Minipage is no more (long live the box inset)

[lyx.git] / src / frontends / screen.C

diff --git a/src/frontends/screen.C b/src/frontends/screen.C
index 10dab24a2c3b1c45b55384088e6f9b1482e00a70..68da7ca38d9d6d22a7618964b4b69808e3db0a1f 100644 (file)
--- a/src/frontends/screen.C
+++ b/src/frontends/screen.C
@@ -21,6 +21,7 @@
 #include "BufferView.h"
 #include "buffer.h"
 #include "bufferparams.h"
+#include "cursor.h"
 #include "debug.h"
 #include "language.h"
 #include "LColor.h"
@@ -171,34 +172,9 @@ void LyXScreen::showCursor(BufferView & bv)
        int h = ascent + descent;
        int x = 0;
        int y = 0;
-       int const top_y = bv.top_y();
-
-       if (bv.theLockingInset()) {
-               // Would be nice to clean this up to make some understandable sense...
-               UpdatableInset * inset = bv.theLockingInset();
-               inset->getCursor(bv, x, y);
-
-               // Non-obvious. The reason we have to have these
-               // extra checks is that the ->getCursor() calls rely
-               // on the inset's own knowledge of its screen position.
-               // If we scroll up or down in a big enough increment, the
-               // inset->draw() is not called: this doesn't update
-               // inset.top_baseline, so getCursor() returns an old value.
-               // Ugly as you like.
-               int bx, by;
-               inset->getCursorPos(&bv, bx, by);
-               by += inset->insetInInsetY() + bv.text->cursor.y();
-               if (by < top_y)
-                       return;
-               if (by > top_y + workarea().workHeight())
-                       return;
-       } else {
-               x = bv.text->cursor.x();
-               y = bv.text->cursor.y();
-               y -= top_y;
-       }
-
-       y -= ascent;
+       bv.cursor().getPos(x, y);
+       y -= ascent + bv.top_y();
+       //lyxerr << "LyXScreen::showCursor x: " << x << " y: " << y << endl;
 
        // if it doesn't fit entirely on the screen, don't try to show it
        if (y < 0 || y + h > workarea().workHeight())
@@ -228,76 +204,45 @@ void LyXScreen::toggleCursor(BufferView & bv)
 }
 
 
-bool LyXScreen::fitManualCursor(BufferView * bv, LyXText *,
-       int /*x*/, int y, int asc, int desc)
+bool LyXScreen::fitCursor(BufferView * bv)
 {
-       int const vheight = workarea().workHeight();
-       int const topy = bv->top_y();
-       int newtop = topy;
-
-
-       if (y + desc - topy >= vheight)
-               newtop = y - 3 * vheight / 4;  // the scroll region must be so big!!
-       else if (y - asc < topy && topy > 0)
-               newtop = y - vheight / 4;
-
-       newtop = max(newtop, 0); // can newtop ever be < 0? (Lgb)
-
-       if (newtop == topy)
-               return false;
-
-       bv->top_y(newtop);
-       return true;
-}
-
-
-unsigned int LyXScreen::topCursorVisible(LyXText * text)
-{
-       LyXCursor const & cursor = text->cursor;
-       int top_y = text->bv()->top_y();
+       int const top_y = bv->top_y();
+       int const h = workarea().workHeight();
        int newtop = top_y;
-       unsigned int const vheight = workarea().workHeight();
-
-       Row & row = *text->cursorPar()->getRow(cursor.pos());
-
-       if (int(cursor.y() - row.baseline() + row.height() - top_y) >= vheight) {
-               if (row.height() < vheight
-                   && row.height() > vheight / 4) {
-                       newtop = cursor.y()
-                               + row.height()
-                               - row.baseline() - vheight;
-               } else {
-                       // scroll down, the scroll region must be so big!!
-                       newtop = cursor.y() - vheight / 2;
-               }
-
-       } else if (int(cursor.y() - row.baseline()) < top_y && top_y > 0) {
-               if (row.height() < vheight && row.height() > vheight / 4) {
-                       newtop = cursor.y() - row.baseline();
-               } else {
-                       // scroll up
-                       newtop = cursor.y() - vheight / 2;
+       int x, y, asc, desc;
+
+       bv->cursor().getPos(x, y);
+       bv->cursor().getDim(asc, desc);
+       
+       bool const big_row = h / 4 < asc + desc && asc + desc < h;
+
+       if (y + desc - top_y >= h) {
+               if (big_row)
+                       newtop = y + desc - h;
+               else
+                       newtop = y - h / 2;
+
+       } else if (top_y > max(y - asc, 0)) {
+               if (big_row)
+                       newtop = y - asc;
+               else {
+                       newtop = y - h / 2;
                        newtop = min(newtop, top_y);
                }
        }
 
-       return max(newtop, 0);
-}
-
+       newtop = max(newtop, 0);
+       if (newtop == top_y)
+               return false;
 
-bool LyXScreen::fitCursor(LyXText * text, BufferView * bv)
-{
-       // Is a change necessary?
-       int const newtop = topCursorVisible(text);
-       bool const result = (newtop != bv->top_y());
        bv->top_y(newtop);
-       return result;
+       return true;
 }
 
 
 void LyXScreen::redraw(BufferView & bv)
 {
-       greyed_out_ = !bv.text;
+       greyed_out_ = !bv.text();
 
        if (greyed_out_) {
                greyOut();
@@ -312,7 +257,7 @@ void LyXScreen::redraw(BufferView & bv)
 
        // maybe we have to clear the screen at the bottom
        int const y2 = workarea().workHeight();
-       if (y < y2 && !bv.text->isInInset()) {
+       if (y < y2 && !bv.text()->isInInset()) {
                workarea().getPainter().fillRectangle(0, y,
                        workarea().workWidth(), y2 - y,
                        LColor::bottomarea);