use more std::functors add some of my own, some change to fl_display etc. read the...

[lyx.git] / src / BufferView_pimpl.C

diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C
index 53fdc53cc00e35af4315a995fbfb3aa8c31b70e4..993db847162302b2fd132335453cbb49a34305d4 100644 (file)
--- a/src/BufferView_pimpl.C
+++ b/src/BufferView_pimpl.C
@@ -61,12 +61,12 @@ void SetXtermCursor(Window win)
        static Cursor cursor;
        static bool cursor_undefined = true;
        if (cursor_undefined){
-               cursor = XCreateFontCursor(fl_display, XC_xterm);
-               XFlush(fl_display);
+               cursor = XCreateFontCursor(fl_get_display(), XC_xterm);
+               XFlush(fl_get_display());
                cursor_undefined = false;
        }
-       XDefineCursor(fl_display, win, cursor);
-       XFlush(fl_display);
+       XDefineCursor(fl_get_display(), win, cursor);
+       XFlush(fl_get_display());
 }
 
 
@@ -161,13 +161,17 @@ void BufferView::Pimpl::buffer(Buffer * b)
                bv_->text->first = screen_->TopCursorVisible(bv_->text);
                owner_->updateMenubar();
                owner_->updateToolbar();
-               redraw();
+               // Similarly, buffer-dependent dialogs should be updated or
+               // hidden. This should go here because some dialogs (eg ToC)
+               // require bv_->text.
                owner_->getDialogs()->updateBufferDependent();
+               redraw();
                bv_->insetWakeup();
        } else {
                lyxerr[Debug::INFO] << "  No Buffer!" << endl;
                owner_->updateMenubar();
                owner_->updateToolbar();
+               owner_->getDialogs()->hideBufferDependent();
                updateScrollbar();
                workarea_->redraw();
 
@@ -208,12 +212,13 @@ void BufferView::Pimpl::redraw()
 }
 
 
-bool BufferView::Pimpl::fitCursor()
+bool BufferView::Pimpl::fitCursor(LyXText * text)
 {
        Assert(screen_); // it is a programming error to call fitCursor
        // without a valid screen.
-       bool ret = screen_->FitCursor(bv_->text);
-       if (ret) updateScrollbar();
+       bool ret = screen_->FitCursor(text);
+       if (ret)
+           updateScrollbar();
        return ret;
 }
 
@@ -412,8 +417,6 @@ void BufferView::Pimpl::updateScrollbar()
 // Callback for scrollbar slider
 void BufferView::Pimpl::scrollCB(double value)
 {
-       extern bool cursor_follows_scrollbar;
-       
        if (buffer_ == 0) return;
 
        current_scrollbar_value = long(value);
@@ -425,16 +428,17 @@ void BufferView::Pimpl::scrollCB(double value)
 
        screen_->Draw(bv_->text, current_scrollbar_value);
 
-       if (cursor_follows_scrollbar) {
+       if (lyxrc.cursor_follows_scrollbar) {
                LyXText * vbt = bv_->text;
-               unsigned int height = vbt->DefaultHeight();
+               int height = vbt->DefaultHeight();
                
-               if (vbt->cursor.y() < bv_->text->first + height) {
+               if (vbt->cursor.y() < (int)(bv_->text->first + height)) {
                        vbt->SetCursorFromCoordinates(bv_, 0,
                                                      bv_->text->first +
                                                      height);
                } else if (vbt->cursor.y() >
-                          bv_->text->first + workarea_->height() - height) {
+                          (int)(bv_->text->first+workarea_->height()-height))
+               {
                        vbt->SetCursorFromCoordinates(bv_, 0,
                                                      bv_->text->first +
                                                      workarea_->height()  -
@@ -518,12 +522,12 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
        if (buffer_ == 0 || !screen_) return;
 
        // Check for inset locking
-       if (bv_->the_locking_inset) {
+       if (bv_->theLockingInset()) {
                LyXCursor cursor = bv_->text->cursor;
-               bv_->the_locking_inset->
+               bv_->theLockingInset()->
                        InsetMotionNotify(bv_,
                                          x - cursor.x() -
-                                         bv_->the_locking_inset->scroll(),
+                                         bv_->theLockingInset()->scroll(),
                                          y - cursor.y() + bv_->text->first,
                                          state);
                return;
@@ -541,7 +545,7 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
       
                bv_->text->SetSelection();
                screen_->ToggleToggle(bv_->text);
-               fitCursor();
+               fitCursor(bv_->text);
                screen_->ShowCursor(bv_->text);
        }
        return;
@@ -571,19 +575,19 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
                }
        }
        
-       if (bv_->the_locking_inset) {
+       if (bv_->theLockingInset()) {
                // We are in inset locking mode
                
                /* Check whether the inset was hit. If not reset mode,
                   otherwise give the event to the inset */
-               if (inset_hit == bv_->the_locking_inset) {
-                       bv_->the_locking_inset->
+               if (inset_hit == bv_->theLockingInset()) {
+                       bv_->theLockingInset()->
                                InsetButtonPress(bv_,
                                                 xpos, ypos,
                                                 button);
                        return;
                } else {
-                       bv_->unlockInset(bv_->the_locking_inset);
+                       bv_->unlockInset(bv_->theLockingInset());
                }
        }
        
@@ -634,7 +638,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
        bv_->text->cursor.x_fix(bv_->text->cursor.x());
        
        owner_->updateLayoutChoice();
-       if (fitCursor()) {
+       if (fitCursor(bv_->text)) {
                selection_possible = false;
        }
        
@@ -656,7 +660,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button) 
 {
        // select a word
-       if (buffer_ && !bv_->the_locking_inset) {
+       if (buffer_ && !bv_->theLockingInset()) {
                if (screen_ && button == 1) {
                        screen_->HideCursor();
                        screen_->ToggleSelection(bv_->text);
@@ -673,7 +677,7 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button)
 void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
 {
        // select a line
-       if (buffer_ && screen_ && !bv_->the_locking_inset && (button == 1)) {
+       if (buffer_ && screen_ && !bv_->theLockingInset() && (button == 1)) {
                screen_->HideCursor();
                screen_->ToggleSelection(bv_->text);
                bv_->text->CursorHome(bv_);
@@ -700,7 +704,7 @@ void BufferView::Pimpl::enterView()
 void BufferView::Pimpl::leaveView()
 {
        if (using_xterm_cursor) {
-               XUndefineCursor(fl_display, workarea_->getWin());
+               XUndefineCursor(fl_get_display(), workarea_->getWin());
                using_xterm_cursor = false;
        }
 }
@@ -716,13 +720,13 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
        // inset, inset_hit is 0, and inset_x == x, inset_y == y.
        Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
 
-       if (bv_->the_locking_inset) {
+       if (bv_->theLockingInset()) {
                // We are in inset locking mode.
 
                /* LyX does a kind of work-area grabbing for insets.
                   Only a ButtonPress Event outside the inset will 
                   force a InsetUnlock. */
-               bv_->the_locking_inset->
+               bv_->theLockingInset()->
                        InsetButtonRelease(bv_, x, y, button);
                return;
        }
@@ -867,7 +871,7 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
        if (!screen_)
                return 0;
   
-       unsigned int y_tmp = y + text->first;
+       int y_tmp = y + text->first;
   
        LyXCursor cursor;
        text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
@@ -882,7 +886,8 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
                LyXFont font = text->GetFont(bv_->buffer(),
                                                  cursor.par(), cursor.pos());
                bool is_rtl = font.isVisibleRightToLeft();
-               int start_x, end_x;
+               int start_x;
+               int end_x;
 
                if (is_rtl) {
                        start_x = cursor.x() - tmpinset->width(bv_, font) + tmpinset->scroll();
@@ -911,7 +916,8 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
                LyXFont font = text->GetFont(bv_->buffer(), cursor.par(),
                                                  cursor.pos()-1);
                bool is_rtl = font.isVisibleRightToLeft();
-               int start_x, end_x;
+               int start_x;
+               int end_x;
 
                if (!is_rtl) {
                        start_x = cursor.x() - tmpinset->width(bv_, font) +
@@ -926,7 +932,7 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
                    && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
                    && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
 #if 0
-                       if (move_cursor && (tmpinset != bv_->the_locking_inset))
+                       if (move_cursor && (tmpinset != bv_->theLockingInset()))
 #endif
                                text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
                        x = x - start_x;
@@ -976,7 +982,7 @@ void BufferView::Pimpl::workAreaExpose()
                        // fitCursor() ensures we don't jump back
                        // to the start of the document on vertical
                        // resize
-                       fitCursor();
+                       fitCursor(bv_->text);
 
                        // The main window size has changed, repaint most stuff
                        redraw();
@@ -1052,7 +1058,7 @@ void BufferView::Pimpl::update(BufferView::UpdateCodes f)
        update();
 
        if ((f & FITCUR)) {
-               fitCursor();
+               fitCursor(bv_->text);
        }
 
        if ((f & CHANGE)) {
@@ -1118,11 +1124,10 @@ void BufferView::Pimpl::cursorToggle()
                goto set_timer_and_return;
        }
 
-       if (!bv_->the_locking_inset) {
+       if (!bv_->theLockingInset()) {
                screen_->CursorToggle(bv_->text);
        } else {
-               bv_->the_locking_inset->
-                       ToggleInsetCursor(bv_);
+               bv_->theLockingInset()->ToggleInsetCursor(bv_);
        }
        
   set_timer_and_return:
@@ -1131,45 +1136,53 @@ void BufferView::Pimpl::cursorToggle()
 }
 
 
-void BufferView::Pimpl::cursorPrevious()
+void BufferView::Pimpl::cursorPrevious(LyXText * text)
 {
-       if (!bv_->text->cursor.row()->previous()) return;
+       if (!text->cursor.row()->previous())
+               return;
        
-       long y = bv_->text->first;
-       Row * cursorrow = bv_->text->cursor.row();
-       bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
+       int y = text->first;
+       if (text->inset_owner)
+               y += bv_->text->first;
+       Row * cursorrow = text->cursor.row();
+       text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
        bv_->text->FinishUndo();
        // This is to allow jumping over large insets
-       if ((cursorrow == bv_->text->cursor.row()))
-               bv_->text->CursorUp(bv_);
+       if ((cursorrow == text->cursor.row()))
+               text->CursorUp(bv_);
        
-       if (bv_->text->cursor.row()->height() < workarea_->height())
+       if (text->inset_owner ||
+           text->cursor.row()->height() < workarea_->height())
                screen_->Draw(bv_->text,
-                             bv_->text->cursor.y()
-                             - bv_->text->cursor.row()->baseline()
-                             + bv_->text->cursor.row()->height()
+                             text->cursor.y()
+                             - text->cursor.row()->baseline()
+                             + text->cursor.row()->height()
                              - workarea_->height() + 1 );
        updateScrollbar();
 }
 
 
-void BufferView::Pimpl::cursorNext()
+void BufferView::Pimpl::cursorNext(LyXText * text)
 {
-       if (!bv_->text->cursor.row()->next()) return;
+       if (!text->cursor.row()->next())
+               return;
        
-       long y = bv_->text->first;
-       bv_->text->GetRowNearY(y);
-       Row * cursorrow = bv_->text->cursor.row();
-       bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y
+       int y = text->first;
+//     if (text->inset_owner)
+//             y += bv_->text->first;
+       text->GetRowNearY(y);
+       Row * cursorrow = text->cursor.row();
+       text->SetCursorFromCoordinates(bv_, text->cursor.x_fix(), y
                                       + workarea_->height());
        bv_->text->FinishUndo();
        // This is to allow jumping over large insets
        if ((cursorrow == bv_->text->cursor.row()))
-               bv_->text->CursorDown(bv_);
+               text->CursorDown(bv_);
        
-       if (bv_->text->cursor.row()->height() < workarea_->height())
-               screen_->Draw(bv_->text, bv_->text->cursor.y()
-                            - bv_->text->cursor.row()->baseline());
+       if (text->inset_owner ||
+           text->cursor.row()->height() < workarea_->height())
+               screen_->Draw(bv_->text, text->cursor.y() -
+                             text->cursor.row()->baseline());
        updateScrollbar();
 }
 
@@ -1244,9 +1257,9 @@ void BufferView::Pimpl::setState()
 
 void BufferView::Pimpl::insetSleep()
 {
-       if (bv_->the_locking_inset && !bv_->inset_slept) {
-               bv_->the_locking_inset->GetCursorPos(bv_, bv_->slx, bv_->sly);
-               bv_->the_locking_inset->InsetUnlock(bv_);
+       if (bv_->theLockingInset() && !bv_->inset_slept) {
+               bv_->theLockingInset()->GetCursorPos(bv_, bv_->slx, bv_->sly);
+               bv_->theLockingInset()->InsetUnlock(bv_);
                bv_->inset_slept = true;
        }
 }
@@ -1254,8 +1267,8 @@ void BufferView::Pimpl::insetSleep()
 
 void BufferView::Pimpl::insetWakeup()
 {
-       if (bv_->the_locking_inset && bv_->inset_slept) {
-               bv_->the_locking_inset->Edit(bv_, bv_->slx, bv_->sly, 0);
+       if (bv_->theLockingInset() && bv_->inset_slept) {
+               bv_->theLockingInset()->Edit(bv_, bv_->slx, bv_->sly, 0);
                bv_->inset_slept = false;
        }
 }
@@ -1263,9 +1276,10 @@ void BufferView::Pimpl::insetWakeup()
 
 void BufferView::Pimpl::insetUnlock()
 {
-       if (bv_->the_locking_inset) {
-               if (!bv_->inset_slept) bv_->the_locking_inset->InsetUnlock(bv_);
-               bv_->the_locking_inset = 0;
+       if (bv_->theLockingInset()) {
+               if (!bv_->inset_slept)
+                       bv_->theLockingInset()->InsetUnlock(bv_);
+               bv_->theLockingInset(0);
                bv_->text->FinishUndo();
                bv_->inset_slept = false;
        }
@@ -1327,7 +1341,7 @@ void BufferView::Pimpl::toggleToggle()
 void BufferView::Pimpl::center() 
 {
        beforeChange();
-       if (bv_->text->cursor.y() > workarea_->height() / 2) {
+       if (bv_->text->cursor.y() > (int)(workarea_->height() / 2)) {
                screen_->Draw(bv_->text, bv_->text->cursor.y() - workarea_->height() / 2);
        } else {
                screen_->Draw(bv_->text, 0);