]> git.lyx.org Git - lyx.git/blobdiff - src/BufferView_pimpl.C
Fixes to insettabular/text.
[lyx.git] / src / BufferView_pimpl.C
index 8613ee40b5c8d057ec5756a3fb49849f3dfee19f..36dbfa07c3744369fb5bc1e43b0bedd0c5c6fcf6 100644 (file)
 #include "TextCache.h"
 #include "bufferlist.h"
 #include "insets/insetbib.h"
-#include "menus.h"
 #include "lyx_gui_misc.h"
 #include "lyxrc.h"
 #include "intl.h"
 #include "support/LAssert.h"
 #include "frontends/Dialogs.h"
 
+#ifdef SIGC_CXX_NAMESPACES
+using SigC::slot;
+#endif
+
 using std::pair;
 using std::endl;
 using std::vector;
@@ -40,8 +43,9 @@ bool selection_possible = false;
 extern BufferList bufferlist;
 extern char ascii_type;
 
+extern "C" void TimerCB(FL_OBJECT *, long); 
 extern void sigchldhandler(pid_t pid, int * status);
-extern int bibitemMaxWidth(Painter &, LyXFont const &);
+extern int bibitemMaxWidth(BufferView *, LyXFont const &);
 
 
 static inline
@@ -72,14 +76,34 @@ BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o,
 {
        buffer_ = 0;
        workarea_ = new WorkArea(bv_, xpos, ypos, width, height);
-       screen = 0;
+       // Setup the signals
+       workarea_->workAreaExpose
+               .connect(slot(this, &BufferView::Pimpl::workAreaExpose));
+       workarea_->workAreaEnter
+               .connect(slot(this, &BufferView::Pimpl::enterView));
+       workarea_->workAreaLeave
+               .connect(slot(this, &BufferView::Pimpl::leaveView));
+       workarea_->workAreaButtonPress
+               .connect(slot(this, &BufferView::Pimpl::workAreaButtonPress));
+       workarea_->workAreaButtonRelease
+               .connect(slot(this,
+                             &BufferView::Pimpl::workAreaButtonRelease));
+       workarea_->workAreaMotionNotify
+               .connect(slot(this, &BufferView::Pimpl::workAreaMotionNotify));
+       workarea_->workAreaDoubleClick
+               .connect(slot(this, &BufferView::Pimpl::doubleClick));
+       workarea_->workAreaTripleClick
+               .connect(slot(this, &BufferView::Pimpl::tripleClick));
+       workarea_->workAreaKeyPress
+               .connect(slot(this, &BufferView::Pimpl::workAreaKeyPress));
+       
+       screen_ = 0;
 
-       cursor_timeout.callback(BufferView::cursorToggleCB, bv_);
+       cursor_timeout.timeout.connect(slot(this,
+                                           &BufferView::Pimpl::cursorToggle));
        current_scrollbar_value = 0;
        cursor_timeout.start();
        workarea_->setFocus();
-       work_area_focus = true;
-       lyx_focus = false;
        using_xterm_cursor = false;
 }
 
@@ -116,8 +140,8 @@ void BufferView::Pimpl::buffer(Buffer * b)
        
        // Nuke old image
        // screen is always deleted when the buffer is changed.
-       delete screen;
-       screen = 0;
+       delete screen_;
+       screen_ = 0;
 
        // If we are closing the buffer, use the first buffer as current
        if (!buffer_) {
@@ -127,7 +151,6 @@ void BufferView::Pimpl::buffer(Buffer * b)
        if (buffer_) {
                lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl;
                buffer_->addUser(bv_);
-               owner_->getMenus()->showMenus();
                // If we don't have a text object for this, we make one
                if (bv_->text == 0) {
                        resizeCurrentBuffer();
@@ -135,13 +158,16 @@ void BufferView::Pimpl::buffer(Buffer * b)
                        updateScreen();
                        updateScrollbar();
                }
-               screen->first = screen->TopCursorVisible();
+               bv_->text->first = screen_->TopCursorVisible(bv_->text);
+               owner_->updateMenubar();
+               owner_->updateToolbar();
                redraw();
                owner_->getDialogs()->updateBufferDependent();
                bv_->insetWakeup();
        } else {
                lyxerr[Debug::INFO] << "  No Buffer!" << endl;
-               owner_->getMenus()->hideMenus();
+               owner_->updateMenubar();
+               owner_->updateToolbar();
                updateScrollbar();
                workarea_->redraw();
 
@@ -182,12 +208,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
+       Assert(screen_); // it is a programming error to call fitCursor
        // without a valid screen.
-       bool ret = screen->FitCursor();
-       if (ret) updateScrollbar();
+       bool ret = screen_->FitCursor(text);
+       if (ret)
+           updateScrollbar();
        return ret;
 }
 
@@ -266,10 +293,9 @@ int BufferView::Pimpl::resizeCurrentBuffer()
                        bv_->text->selection = false;
                }
        }
-       screen->first = screen->TopCursorVisible(); /* this will scroll the
-                                                    * screen such that the
-                                                    * cursor becomes
-                                                    * visible */ 
+       bv_->text->first = screen_->TopCursorVisible(bv_->text);
+       buffer_->resizeInsets(bv_);
+       // this will scroll the screen such that the cursor becomes visible
        updateScrollbar();
        redraw();
        owner_->getMiniBuffer()->Init();
@@ -285,10 +311,10 @@ int BufferView::Pimpl::resizeCurrentBuffer()
 
 void BufferView::Pimpl::gotoError()
 {
-       if (!screen)
+       if (!screen_)
                return;
    
-       screen->HideCursor();
+       screen_->HideCursor();
        bv_->beforeChange();
        update(BufferView::SELECT|BufferView::FITCUR);
        LyXCursor tmp;
@@ -318,8 +344,8 @@ void BufferView::Pimpl::gotoError()
 void BufferView::Pimpl::updateScreen()
 {
        // Regenerate the screen.
-       delete screen;
-       screen = new LyXScreen(*workarea_, bv_->text);
+       delete screen_;
+       screen_ = new LyXScreen(*workarea_);
 }
 
 
@@ -340,10 +366,10 @@ void BufferView::Pimpl::updateScrollbar()
        unsigned long cbth = 0;
        long cbsf = 0;
 
-       if (bv_->text)
+       if (bv_->text) {
                cbth = bv_->text->height;
-       if (screen)
-               cbsf = screen->first;
+               cbsf = bv_->text->first;
+       }
 
        // check if anything has changed.
        if (max2 == cbth &&
@@ -395,23 +421,23 @@ void BufferView::Pimpl::scrollCB(double value)
        if (current_scrollbar_value < 0)
                current_scrollbar_value = 0;
    
-       if (!screen)
+       if (!screen_)
                return;
 
-       screen->Draw(current_scrollbar_value);
+       screen_->Draw(bv_->text, current_scrollbar_value);
 
        if (cursor_follows_scrollbar) {
                LyXText * vbt = bv_->text;
                unsigned int height = vbt->DefaultHeight();
                
-               if (vbt->cursor.y() < screen->first + height) {
+               if (vbt->cursor.y() < bv_->text->first + height) {
                        vbt->SetCursorFromCoordinates(bv_, 0,
-                                                     screen->first +
+                                                     bv_->text->first +
                                                      height);
                } else if (vbt->cursor.y() >
-                          screen->first + workarea_->height() - height) {
+                          bv_->text->first + workarea_->height() - height) {
                        vbt->SetCursorFromCoordinates(bv_, 0,
-                                                     screen->first +
+                                                     bv_->text->first +
                                                      workarea_->height()  -
                                                      height);
                }
@@ -423,7 +449,7 @@ void BufferView::Pimpl::scrollCB(double value)
 int BufferView::Pimpl::scrollUp(long time)
 {
        if (buffer_ == 0) return 0;
-       if (!screen) return 0;
+       if (!screen_) return 0;
    
        double value = workarea_->getScrollbarValue();
    
@@ -451,7 +477,7 @@ int BufferView::Pimpl::scrollUp(long time)
 int BufferView::Pimpl::scrollDown(long time)
 {
        if (buffer_ == 0) return 0;
-       if (!screen) return 0;
+       if (!screen_) return 0;
    
        double value= workarea_->getScrollbarValue();
        pair<float, float> p = workarea_->getScrollbarBounds();
@@ -478,21 +504,28 @@ int BufferView::Pimpl::scrollDown(long time)
 }
 
 
+void BufferView::Pimpl::workAreaKeyPress(KeySym keysym, unsigned int state)
+{
+       bv_->owner()->getLyXFunc()->processKeySym(keysym, state);
+}
+
+
 void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
 {
        // Only use motion with button 1
        if (!(state & Button1MotionMask))
                return;
 
-       if (buffer_ == 0 || !screen) return;
+       if (buffer_ == 0 || !screen_) return;
 
        // Check for inset locking
        if (bv_->the_locking_inset) {
                LyXCursor cursor = bv_->text->cursor;
                bv_->the_locking_inset->
                        InsetMotionNotify(bv_,
-                                         x - cursor.x(),
-                                         y - cursor.y() + screen->first,
+                                         x - cursor.x() -
+                                         bv_->the_locking_inset->scroll(),
+                                         y - cursor.y() + bv_->text->first,
                                          state);
                return;
        }
@@ -500,17 +533,17 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
        /* The selection possible is needed, that only motion events are 
         * used, where the bottom press event was on the drawing area too */
        if (selection_possible) {
-               screen->HideCursor();
+               screen_->HideCursor();
 
-               bv_->text->SetCursorFromCoordinates(bv_, x, y + screen->first);
+               bv_->text->SetCursorFromCoordinates(bv_, x, y + bv_->text->first);
       
                if (!bv_->text->selection)
                        update(BufferView::UPDATE); // Maybe an empty line was deleted
       
                bv_->text->SetSelection();
-               screen->ToggleToggle();
-               fitCursor();
-               screen->ShowCursor();
+               screen_->ToggleToggle(bv_->text);
+               fitCursor(bv_->text);
+               screen_->ShowCursor(bv_->text);
        }
        return;
 }
@@ -523,18 +556,18 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
        last_click_x = -1;
        last_click_y = -1;
 
-       if (buffer_ == 0 || !screen) return;
+       if (buffer_ == 0 || !screen_) return;
 
-       Inset * inset_hit = checkInsetHit(xpos, ypos, button);
+       Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button);
 
        // ok ok, this is a hack.
        if (button == 4 || button == 5) {
                switch (button) {
                case 4:
-                       scrollUp(100); // This number is only temporary
+                       scrollUp(lyxrc.wheel_jump); // default 100, set in lyxrc
                        break;
                case 5:
-                       scrollDown(100);
+                       scrollDown(lyxrc.wheel_jump);
                        break;
                }
        }
@@ -557,48 +590,9 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
        
        if (!inset_hit)
                selection_possible = true;
-       screen->HideCursor();
-
-#ifndef NEW_TABULAR
-       // Right button mouse click on a table
-       if (button == 3 &&
-           (bv_->text->cursor.par()->table ||
-            bv_->text->MouseHitInTable(bv_, xpos, ypos + screen->first))) {
-               // Set the cursor to the press-position
-               bv_->text->SetCursorFromCoordinates(bv_, xpos, ypos + screen->first);
-               bool doit = true;
-               
-               // Only show the table popup if the hit is in
-               // the table, too
-               if (!bv_->text->HitInTable(bv_,
-                                          bv_->text->cursor.row(), xpos))
-                       doit = false;
-               
-               // Hit above or below the table?
-               if (doit) {
-                       if (!bv_->text->selection) {
-                               screen->ToggleSelection();
-                               bv_->text->ClearSelection();
-                               bv_->text->FullRebreak(bv_);
-                               screen->Update();
-                               updateScrollbar();
-                       }
-                       // Popup table popup when on a table.
-                       // This is obviously temporary, since we
-                       // should be able to popup various
-                       // context-sensitive-menus with the
-                       // the right mouse. So this should be done more
-                       // general in the future. Matthias.
-                       selection_possible = false;
-                       owner_->getLyXFunc()
-                               ->Dispatch(LFUN_LAYOUT_TABLE,
-                                          "true");
-                       return;
-               }
-       }
-#endif
-       
-       int screen_first = screen->first;
+       screen_->HideCursor();
+
+       int const screen_first = bv_->text->first;
        
        // Middle button press pastes if we have a selection
        bool paste_internally = false;
@@ -609,10 +603,10 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
        }
        
        // Clear the selection
-       screen->ToggleSelection();
+       screen_->ToggleSelection(bv_->text);
        bv_->text->ClearSelection();
        bv_->text->FullRebreak(bv_);
-       screen->Update();
+       screen_->Update(bv_->text);
        updateScrollbar();
        
        // Single left click in math inset?
@@ -641,7 +635,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;
        }
        
@@ -664,30 +658,30 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button)
 {
        // select a word
        if (buffer_ && !bv_->the_locking_inset) {
-               if (screen && button == 1) {
-                       screen->HideCursor();
-                       screen->ToggleSelection();
+               if (screen_ && button == 1) {
+                       screen_->HideCursor();
+                       screen_->ToggleSelection(bv_->text);
                        bv_->text->SelectWord(bv_);
-                       screen->ToggleSelection(false);
+                       screen_->ToggleSelection(bv_->text, false);
                        /* This will fit the cursor on the screen
                         * if necessary */
                        update(BufferView::SELECT|BufferView::FITCUR);
                }
-       }            
+       }   
 }
 
 
 void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
 {
        // select a line
-       if (buffer_ && screen && button == 1) {
-               screen->HideCursor();
-               screen->ToggleSelection();
+       if (buffer_ && screen_ && !bv_->the_locking_inset && (button == 1)) {
+               screen_->HideCursor();
+               screen_->ToggleSelection(bv_->text);
                bv_->text->CursorHome(bv_);
                bv_->text->sel_cursor = bv_->text->cursor;
                bv_->text->CursorEnd(bv_);
                bv_->text->SetSelection();
-               screen->ToggleSelection(false);
+               screen_->ToggleSelection(bv_->text, false);
                /* This will fit the cursor on the screen
                 * if necessary */
                update(BufferView::SELECT|BufferView::FITCUR);
@@ -716,12 +710,12 @@ void BufferView::Pimpl::leaveView()
 void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
                                              unsigned int button)
 {
-       if (buffer_ == 0 || screen == 0) return;
+       if (buffer_ == 0 || screen_ == 0) return;
 
        // If we hit an inset, we have the inset coordinates in these
        // and inset_hit points to the inset.  If we do not hit an
        // inset, inset_hit is 0, and inset_x == x, inset_y == y.
-       Inset * inset_hit = checkInsetHit(x, y, button);
+       Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
 
        if (bv_->the_locking_inset) {
                // We are in inset locking mode.
@@ -735,24 +729,11 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
        }
        
        selection_possible = false;
-#ifndef NEW_TABULAR
-       if (bv_->text->cursor.par()->table) {
-                int cell = bv_->text->
-                        NumberOfCell(bv_->text->cursor.par(),
-                                     bv_->text->cursor.pos());
-                if (bv_->text->cursor.par()->table->IsContRow(cell) &&
-                    bv_->text->cursor.par()->table->
-                    CellHasContRow(bv_->text->cursor.par()->table->
-                                   GetCellAbove(cell))<0) {
-                        bv_->text->CursorUp(bv_);
-                }
-        }
-#endif
        
        if (button >= 2) return;
 
        bv_->setState();
-       owner_->getMiniBuffer()->Set(CurrentState(bv_));
+       owner_->showState();
 
        // Did we hit an editable inset?
        if (inset_hit != 0) {
@@ -799,6 +780,7 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
                        c = bv_->text->cursor.par()->
                                GetChar(bv_->text->cursor.pos());
                }
+#ifndef NEW_INSETS
                if (c == LyXParagraph::META_FOOTNOTE
                    || c == LyXParagraph::META_MARGIN
                    || c == LyXParagraph::META_FIG
@@ -807,9 +789,12 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
                    || c == LyXParagraph::META_WIDE_TAB
                     || c == LyXParagraph::META_ALGORITHM){
                        hit = true;
-               } else if (bv_->text->cursor.pos() - 1 >= 0) {
+               } else
+#endif
+                       if (bv_->text->cursor.pos() - 1 >= 0) {
                        c = bv_->text->cursor.par()->
                                GetChar(bv_->text->cursor.pos() - 1);
+#ifndef NEW_INSETS
                        if (c == LyXParagraph::META_FOOTNOTE
                            || c == LyXParagraph::META_MARGIN
                            || c == LyXParagraph::META_FIG
@@ -821,14 +806,18 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
                                bv_->text->CursorLeft(bv_);
                                hit = true;
                        }
+#endif
                }
                if (hit == true) {
+#ifndef NEW_INSETS
                        bv_->toggleFloat();
+#endif
                        selection_possible = false;
                        return;
                }
        }
 
+#ifndef NEW_INSETS
        // Do we want to close a float? (click on the float-label)
        if (bv_->text->cursor.row()->par()->footnoteflag == 
            LyXParagraph::OPEN_FOOTNOTE
@@ -841,7 +830,7 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
                int box_x = 20; // LYX_PAPER_MARGIN;
                box_x += lyxfont::width(" wide-tab ", font);
 
-               unsigned int screen_first = screen->first;
+               unsigned int screen_first = bv_->text->first;
 
                if (x < box_x
                    && y + screen_first > bv_->text->cursor.y() -
@@ -854,13 +843,13 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
                        return;
                }
        }
+#endif
 
        // Maybe we want to edit a bibitem ale970302
        if (bv_->text->cursor.par()->bibkey && x < 20 + 
-           bibitemMaxWidth(bv_->painter(),
-                           textclasslist
-                           .TextClass(buffer_->
-                                      params.textclass).defaultfont())) {
+           bibitemMaxWidth(bv_, textclasslist.
+                           TextClass(buffer_->
+                                     params.textclass).defaultfont())) {
                bv_->text->cursor.par()->bibkey->Edit(bv_, 0, 0, 0);
        }
 
@@ -873,20 +862,17 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
  * If hit, the coordinates are changed relative to the inset. 
  * Otherwise coordinates are not changed, and false is returned.
  */
-Inset * BufferView::Pimpl::checkInsetHit(int & x, int & y,
+Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
                                         unsigned int /* button */)
 {
-       if (!screen)
+       if (!screen_)
                return 0;
   
-       unsigned int y_tmp = y + screen->first;
+       unsigned int y_tmp = y + text->first;
   
        LyXCursor cursor;
-       bv_->text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
-#if 0 // Are you planning to use this Jürgen? (Lgb)
-       bool move_cursor = ((cursor.par != bv_->text->cursor.par) ||
-                           (cursor.pos != bv_->text->cursor.pos()));
-#endif
+       text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
+
        if (cursor.pos() < cursor.par()->Last()
            && cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET
            && cursor.par()->GetInset(cursor.pos())
@@ -894,29 +880,26 @@ Inset * BufferView::Pimpl::checkInsetHit(int & x, int & y,
 
                // Check whether the inset really was hit
                Inset * tmpinset = cursor.par()->GetInset(cursor.pos());
-               LyXFont font = bv_->text->GetFont(bv_->buffer(),
+               LyXFont font = text->GetFont(bv_->buffer(),
                                                  cursor.par(), cursor.pos());
                bool is_rtl = font.isVisibleRightToLeft();
                int start_x, end_x;
 
                if (is_rtl) {
-                       start_x = cursor.x() - tmpinset->width(bv_->painter(), font);
-                       end_x = cursor.x();
+                       start_x = cursor.x() - tmpinset->width(bv_, font) + tmpinset->scroll();
+                       end_x = cursor.x() + tmpinset->scroll();
                } else {
-                       start_x = cursor.x();
-                       end_x = cursor.x() + tmpinset->width(bv_->painter(), font);
+                       start_x = cursor.x() + tmpinset->scroll();
+                       end_x = cursor.x() + tmpinset->width(bv_, font) + tmpinset->scroll();
                }
 
                if (x > start_x && x < end_x
-                   && y_tmp > cursor.y() - tmpinset->ascent(bv_->painter(), font)
-                   && y_tmp < cursor.y() + tmpinset->descent(bv_->painter(), font)) {
-#if 0
-                       if (move_cursor && (tmpinset != bv_->the_locking_inset))
-#endif
-                               bv_->text->SetCursor(bv_, cursor.par(),cursor.pos(),true);
+                   && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
+                   && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
+                       text->SetCursor(bv_, cursor.par(),cursor.pos(),true);
                        x = x - start_x;
                        // The origin of an inset is on the baseline
-                       y = y_tmp - (bv_->text->cursor.y()); 
+                       y = y_tmp - (text->cursor.y()); 
                        return tmpinset;
                }
        }
@@ -926,28 +909,30 @@ Inset * BufferView::Pimpl::checkInsetHit(int & x, int & y,
            (cursor.par()->GetInset(cursor.pos() - 1)) &&
            (cursor.par()->GetInset(cursor.pos() - 1)->Editable())) {
                Inset * tmpinset = cursor.par()->GetInset(cursor.pos()-1);
-               LyXFont font = bv_->text->GetFont(bv_->buffer(), cursor.par(),
+               LyXFont font = text->GetFont(bv_->buffer(), cursor.par(),
                                                  cursor.pos()-1);
                bool is_rtl = font.isVisibleRightToLeft();
                int start_x, end_x;
 
                if (!is_rtl) {
-                       start_x = cursor.x() - tmpinset->width(bv_->painter(), font);
-                       end_x = cursor.x();
+                       start_x = cursor.x() - tmpinset->width(bv_, font) +
+                           tmpinset->scroll();
+                       end_x = cursor.x() + tmpinset->scroll();
                } else {
-                       start_x = cursor.x();
-                       end_x = cursor.x() + tmpinset->width(bv_->painter(), font);
+                       start_x = cursor.x() + tmpinset->scroll();
+                       end_x = cursor.x() + tmpinset->width(bv_, font) +
+                           tmpinset->scroll();
                }
                if (x > start_x && x < end_x
-                   && y_tmp > cursor.y() - tmpinset->ascent(bv_->painter(), font)
-                   && y_tmp < cursor.y() + tmpinset->descent(bv_->painter(), font)) {
+                   && 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))
 #endif
-                               bv_->text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
+                               text->SetCursor(bv_, cursor.par(),cursor.pos()-1,true);
                        x = x - start_x;
                        // The origin of an inset is on the baseline
-                       y = y_tmp - (bv_->text->cursor.y()); 
+                       y = y_tmp - (text->cursor.y()); 
                        return tmpinset;
                }
        }
@@ -992,14 +977,14 @@ 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();
                        // ...including the minibuffer
                        owner_->getMiniBuffer()->Init();
 
-               } else if (screen) screen->Redraw();
+               } else if (screen_) screen_->Redraw(bv_->text);
        } else {
                // Grey box when we don't have a buffer
                workarea_->greyOut();
@@ -1014,7 +999,7 @@ void BufferView::Pimpl::workAreaExpose()
 
 void BufferView::Pimpl::update()
 {
-       if (screen) screen->Update();
+       if (screen_) screen_->Update(bv_->text);
 }
 
 // Values used when calling update:
@@ -1055,7 +1040,6 @@ void BufferView::Pimpl::update()
 // update(1)  -> update(1 + 2 + 4) -> update(7) -> update(SELECT|FITCUR|CHANGE)
 // update(3)  -> update(1)         -> update(1) -> update(SELECT)
 
-//void BufferView::Pimpl::update(signed char f)
 void BufferView::Pimpl::update(BufferView::UpdateCodes f)
 {
        owner_->updateLayoutChoice();
@@ -1069,7 +1053,7 @@ void BufferView::Pimpl::update(BufferView::UpdateCodes f)
        update();
 
        if ((f & FITCUR)) {
-               fitCursor();
+               fitCursor(bv_->text);
        }
 
        if ((f & CHANGE)) {
@@ -1131,57 +1115,19 @@ void BufferView::Pimpl::cursorToggle()
 
        updatelist.update(bv_);
        
-       if (!screen) {
+       if (!screen_) {
                goto set_timer_and_return;
        }
 
-       if (lyx_focus && work_area_focus) {
-               if (!bv_->the_locking_inset) {
-                       screen->CursorToggle();
-               } else {
-                       bv_->the_locking_inset->
-                               ToggleInsetCursor(bv_);
-               }
-               goto set_timer_and_return;
+       if (!bv_->the_locking_inset) {
+               screen_->CursorToggle(bv_->text);
        } else {
-               // Make sure that the cursor is visible.
-               if (!bv_->the_locking_inset) {
-                       screen->ShowCursor();
-               } else {
-                       if (!bv_->the_locking_inset->isCursorVisible())
-                               bv_->the_locking_inset->
-                                       ToggleInsetCursor(bv_);
-               }
-               // This is only run when work_area_focus or lyx_focus is false.
-               Window tmpwin;
-               int tmp;
-               XGetInputFocus(fl_display, &tmpwin, &tmp);
-               // Commenting this out, we have not had problems with this
-               // for a long time. We will probably work on this code later
-               // and we can reenable this debug code then. Now it only
-               // anoying when debugging. (Lgb)
-               //if (lyxerr.debugging(Debug::INFO)) {
-               //      lyxerr << "tmpwin: " << tmpwin
-               //             << "\nwindow: " << view->owner_->getForm()->window
-               //             << "\nwork_area_focus: " << view->work_area_focus
-               //             << "\nlyx_focus      : " << view->lyx_focus
-               //             << endl;
-               //}
-               if (tmpwin != owner_->getForm()->window) {
-                       lyx_focus = false;
-                       goto skip_timer;
-               } else {
-                       lyx_focus = true;
-                       if (!work_area_focus)
-                               goto skip_timer;
-                       else
-                               goto set_timer_and_return;
-               }
+               bv_->the_locking_inset->
+                       ToggleInsetCursor(bv_);
        }
-
+       
   set_timer_and_return:
        cursor_timeout.restart();
-  skip_timer:
        return;
 }
 
@@ -1190,7 +1136,7 @@ void BufferView::Pimpl::cursorPrevious()
 {
        if (!bv_->text->cursor.row()->previous()) return;
        
-       long y = screen->first;
+       int y = bv_->text->first;
        Row * cursorrow = bv_->text->cursor.row();
        bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
        bv_->text->FinishUndo();
@@ -1199,10 +1145,11 @@ void BufferView::Pimpl::cursorPrevious()
                bv_->text->CursorUp(bv_);
        
        if (bv_->text->cursor.row()->height() < workarea_->height())
-               screen->Draw(bv_->text->cursor.y()
-                            - bv_->text->cursor.row()->baseline()
-                            + bv_->text->cursor.row()->height()
-                                 - workarea_->height() + 1 );
+               screen_->Draw(bv_->text,
+                             bv_->text->cursor.y()
+                             - bv_->text->cursor.row()->baseline()
+                             + bv_->text->cursor.row()->height()
+                             - workarea_->height() + 1 );
        updateScrollbar();
 }
 
@@ -1211,7 +1158,7 @@ void BufferView::Pimpl::cursorNext()
 {
        if (!bv_->text->cursor.row()->next()) return;
        
-       long y = screen->first;
+       int y = bv_->text->first;
        bv_->text->GetRowNearY(y);
        Row * cursorrow = bv_->text->cursor.row();
        bv_->text->SetCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y
@@ -1222,7 +1169,7 @@ void BufferView::Pimpl::cursorNext()
                bv_->text->CursorDown(bv_);
        
        if (bv_->text->cursor.row()->height() < workarea_->height())
-               screen->Draw(bv_->text->cursor.y()
+               screen_->Draw(bv_->text, bv_->text->cursor.y()
                             - bv_->text->cursor.row()->baseline());
        updateScrollbar();
 }
@@ -1259,15 +1206,20 @@ void BufferView::Pimpl::restorePosition()
        
        int  x, y;
        string fname = backstack.pop(&x, &y);
-       
+
        beforeChange();
-       Buffer * b = bufferlist.exists(fname) ?
-               bufferlist.getBuffer(fname) :
-               bufferlist.loadLyXFile(fname); // don't ask, just load it
-       buffer(b);
+
+       if( fname != buffer_->fileName() ) {
+               Buffer * b = bufferlist.exists(fname) ?
+                       bufferlist.getBuffer(fname) :
+                       bufferlist.loadLyXFile(fname); // don't ask, just load it
+               if( b != 0 ) buffer(b);
+       }
+
        bv_->text->SetCursorFromCoordinates(bv_, x, y);
        update(BufferView::SELECT|BufferView::FITCUR);
-} 
+}
+
 
 bool BufferView::Pimpl::NoSavedPositions()
 {
@@ -1294,7 +1246,7 @@ void BufferView::Pimpl::setState()
 void BufferView::Pimpl::insetSleep()
 {
        if (bv_->the_locking_inset && !bv_->inset_slept) {
-               bv_->the_locking_inset->GetCursorPos(bv_->slx, bv_->sly);
+               bv_->the_locking_inset->GetCursorPos(bv_, bv_->slx, bv_->sly);
                bv_->the_locking_inset->InsetUnlock(bv_);
                bv_->inset_slept = true;
        }
@@ -1347,29 +1299,29 @@ bool BufferView::Pimpl::belowMouse() const
 
 void BufferView::Pimpl::showCursor()
 {
-       if (screen)
-               screen->ShowCursor();
+       if (screen_)
+               screen_->ShowCursor(bv_->text);
 }
 
 
 void BufferView::Pimpl::hideCursor()
 {
-       if (screen)
-               screen->HideCursor();
+       if (screen_)
+               screen_->HideCursor();
 }
 
 
 void BufferView::Pimpl::toggleSelection(bool b)
 {
-       if (screen)
-               screen->ToggleSelection(b);
+       if (screen_)
+               screen_->ToggleSelection(bv_->text, b);
 }
 
 
 void BufferView::Pimpl::toggleToggle()
 {
-       if (screen)
-               screen->ToggleToggle();
+       if (screen_)
+               screen_->ToggleToggle(bv_->text);
 }
 
 
@@ -1377,9 +1329,9 @@ void BufferView::Pimpl::center()
 {
        beforeChange();
        if (bv_->text->cursor.y() > workarea_->height() / 2) {
-               screen->Draw(bv_->text->cursor.y() - workarea_->height() / 2);
+               screen_->Draw(bv_->text, bv_->text->cursor.y() - workarea_->height() / 2);
        } else {
-               screen->Draw(0);
+               screen_->Draw(bv_->text, 0);
        }
        update(BufferView::SELECT|BufferView::FITCUR);
        redraw();
@@ -1390,7 +1342,7 @@ void BufferView::Pimpl::pasteClipboard(bool asPara)
 {
        if (buffer_ == 0) return;
 
-       screen->HideCursor();
+       screen_->HideCursor();
        bv_->beforeChange();
        
        string clip(workarea_->getClipboard());