move a bit moer stuff from BufferView::dispatch to LyXText::dispatch

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@5117 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C
index 121e8c632776f898a7a7e373085504d261c4fd4d..e4c12469b12294334e67790fc18c114720c25501 100644 (file)
--- a/src/BufferView_pimpl.C
+++ b/src/BufferView_pimpl.C
@@ -885,7 +885,7 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y)
        LyXCursor cursor;
        text->setCursorFromCoordinates(bv_, cursor, x, y_tmp);
 
-       Inset * inset(checkInset(*text, cursor, x, y_tmp));
+       Inset * inset = checkInset(*text, cursor, x, y_tmp);
 
        if (inset) {
                y = y_tmp;
@@ -935,7 +935,7 @@ void BufferView::Pimpl::workAreaResize()
                        if (lyxerr.debugging())
                                textcache.show(lyxerr, "Expose delete all");
                        textcache.clear();
-                       // FIXME: this is aalready done in resizeCurrentBuffer() ??
+                       // FIXME: this is already done in resizeCurrentBuffer() ??
                        buffer_->resizeInsets(bv_);
                } else if (heightChange) {
                        // fitCursor() ensures we don't jump back
@@ -1441,23 +1441,6 @@ bool BufferView::Pimpl::dispatch(FuncRequest const & ev)
                switchKeyMap();
                break;
 
-       case LFUN_GOTOERROR:
-               gotoInset(Inset::ERROR_CODE, false);
-               break;
-
-       case LFUN_GOTONOTE:
-               gotoInset(Inset::NOTE_CODE, false);
-               break;
-
-       case LFUN_REFERENCE_GOTO:
-       {
-               vector<Inset::Code> tmp;
-               tmp.push_back(Inset::LABEL_CODE);
-               tmp.push_back(Inset::REF_CODE);
-               gotoInset(tmp, true);
-               break;
-       }
-
        case LFUN_DEPTH_MIN:
                changeDepth(bv_, bv_->getLyXText(), -1);
                break;
@@ -2092,50 +2075,3 @@ void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
                }
        }
 }
-
-
-void BufferView::Pimpl::gotoInset(vector<Inset::Code> const & codes,
-                                 bool same_content)
-{
-       if (!available()) return;
-
-       hideCursor();
-       beforeChange(bv_->text);
-       update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
-
-       LyXCursor const & cursor = bv_->text->cursor;
-
-       string contents;
-       if (same_content &&
-           cursor.par()->isInset(cursor.pos())) {
-               Inset const * inset = cursor.par()->getInset(cursor.pos());
-               if (find(codes.begin(), codes.end(), inset->lyxCode())
-                   != codes.end())
-                       contents =
-                               static_cast<InsetCommand const *>(inset)->getContents();
-       }
-
-
-       if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
-               if (bv_->text->cursor.pos()
-                   || bv_->text->cursor.par() != bv_->text->ownerParagraph()) {
-                       LyXCursor tmp = bv_->text->cursor;
-                       bv_->text->cursor.par(bv_->text->ownerParagraph());
-                       bv_->text->cursor.pos(0);
-                       if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
-                               bv_->text->cursor = tmp;
-                               bv_->owner()->message(_("No more insets"));
-                       }
-               } else {
-                       bv_->owner()->message(_("No more insets"));
-               }
-       }
-       update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
-       bv_->text->selection.cursor = bv_->text->cursor;
-}
-
-
-void BufferView::Pimpl::gotoInset(Inset::Code code, bool same_content)
-{
-       gotoInset(vector<Inset::Code>(1, code), same_content);
-}

diff --git a/src/BufferView_pimpl.h b/src/BufferView_pimpl.h
index bd0bd26605c84f2564cf8e663d60f3283a76fb52..5fd64aecf9ccc0877f5a0237d5f6d014d333c7ab 100644 (file)
--- a/src/BufferView_pimpl.h
+++ b/src/BufferView_pimpl.h
@@ -144,11 +144,7 @@ private:
        void hfill();
        ///
        void smartQuote();
-       ///
-       void gotoInset(std::vector<Inset::Code> const & codes,
-                      bool same_content);
-       ///
-       void gotoInset(Inset::Code codes, bool same_content);
+
        ///
        BufferView * bv_;
        ///

diff --git a/src/lyxtext.h b/src/lyxtext.h
index 7a42c27739931696ccfd2d4fd3bc2aaeefba357b..3f8dc0569d21ce658129333e3b60d9a617ce5cd9 100644 (file)
--- a/src/lyxtext.h
+++ b/src/lyxtext.h
@@ -432,6 +432,11 @@ public:
        bool gotoNextInset(BufferView *, std::vector<Inset::Code> const & codes,
                           string const & contents = string()) const;
        ///
+       void gotoInset(BufferView * bv, std::vector<Inset::Code> const & codes,
+                                               bool same_content);
+       ///
+       void gotoInset(BufferView * bv, Inset::Code code, bool same_content);
+       ///
 
        /* for the greater insets */
 
@@ -480,18 +485,21 @@ public:
 private:
        ///
        mutable Row * firstrow;
-
        ///
        mutable Row * lastrow;
 
        ///
        void cursorLeftOneWord(LyXCursor &) const;
+       ///
+       void cursorPrevious(BufferView * bv);
+       ///
+       void cursorNext(BufferView * bv);
  
        ///
        float getCursorX(BufferView *, Row *, lyx::pos_type pos,
                                         lyx::pos_type last, bool boundary) const;
        ///
-       void changeRegionCase(BufferView * bview,
+       void changeRegionCase(BufferView * bv,
                                       LyXCursor const & from,
                                       LyXCursor const & to,
                                       LyXText::TextCase action);
@@ -602,7 +610,7 @@ private:
 
        // fix the cursor `cur' after a characters has been deleted at `where'
        // position. Called by deleteEmptyParagraphMechanism
-       void fixCursorAfterDelete(BufferView * bview,
+       void fixCursorAfterDelete(BufferView * bv,
                                  LyXCursor & cur,
                                  LyXCursor const & where) const;
 

diff --git a/src/text2.C b/src/text2.C
index 9d13ee2d5368d90eea5dfd83a7c6fa13e3ca76b7..91097ed2781685ff590249566c2c0d54b276818c 100644 (file)
--- a/src/text2.C
+++ b/src/text2.C
@@ -1667,37 +1667,6 @@ void LyXText::insertStringAsParagraphs(BufferView * bview, string const & str)
 }
 
 
-bool LyXText::gotoNextInset(BufferView * bview,
-                           vector<Inset::Code> const & codes,
-                           string const & contents) const
-{
-       LyXCursor res = cursor;
-       Inset * inset;
-       do {
-               if (res.pos() < res.par()->size() - 1) {
-                       res.pos(res.pos() + 1);
-               } else  {
-                       res.par(res.par()->next());
-                       res.pos(0);
-               }
-
-       } while (res.par() &&
-                !(res.par()->isInset(res.pos())
-                  && (inset = res.par()->getInset(res.pos())) != 0
-                  && find(codes.begin(), codes.end(), inset->lyxCode())
-                  != codes.end()
-                  && (contents.empty() ||
-                      static_cast<InsetCommand *>(res.par()->getInset(res.pos()))->getContents()
-                      == contents)));
-
-       if (res.par()) {
-               setCursor(bview, res.par(), res.pos(), false);
-               return true;
-       }
-       return false;
-}
-
-
 void LyXText::checkParagraph(BufferView * bview, Paragraph * par,
                             pos_type pos)
 {

diff --git a/src/text3.C b/src/text3.C
index e59ac3bd0a981b52b6740d7822ba5a68ad60f713..ed93cc2abe78d8c1c552a8b033802407e3ab2011 100644 (file)
--- a/src/text3.C
+++ b/src/text3.C
@@ -28,6 +28,7 @@
 #include "frontends/WorkArea.h"
 #include "insets/insetspecialchar.h"
 #include "insets/insettext.h"
+#include "insets/insetcommand.h"
 #include "undo_funcs.h"
 
 using std::endl;
@@ -35,12 +36,80 @@ using std::endl;
 extern string current_layout;
 
 
-namespace {
+bool LyXText::gotoNextInset(BufferView * bv,
+       vector<Inset::Code> const & codes, string const & contents) const
+{
+       LyXCursor res = cursor;
+       Inset * inset;
+       do {
+               if (res.pos() < res.par()->size() - 1) {
+                       res.pos(res.pos() + 1);
+               } else  {
+                       res.par(res.par()->next());
+                       res.pos(0);
+               }
+
+       } while (res.par() &&
+                !(res.par()->isInset(res.pos())
+                  && (inset = res.par()->getInset(res.pos())) != 0
+                  && find(codes.begin(), codes.end(), inset->lyxCode())
+                  != codes.end()
+                  && (contents.empty() ||
+                      static_cast<InsetCommand *>(
+                                                       res.par()->getInset(res.pos()))->getContents()
+                      == contents)));
+
+       if (res.par()) {
+               setCursor(bv, res.par(), res.pos(), false);
+               return true;
+       }
+       return false;
+}
+
+
+void LyXText::gotoInset(BufferView * bv, vector<Inset::Code> const & codes,
+                                 bool same_content)
+{
+       bv->hideCursor();
+       bv->beforeChange(this);
+       update(bv, false);
+
+       string contents;
+       if (same_content && cursor.par()->isInset(cursor.pos())) {
+               Inset const * inset = cursor.par()->getInset(cursor.pos());
+               if (find(codes.begin(), codes.end(), inset->lyxCode())
+                   != codes.end())
+                       contents = static_cast<InsetCommand const *>(inset)->getContents();
+       }
+
+       if (!gotoNextInset(bv, codes, contents)) {
+               if (cursor.pos() || cursor.par() != ownerParagraph()) {
+                       LyXCursor tmp = cursor;
+                       cursor.par(ownerParagraph());
+                       cursor.pos(0);
+                       if (!gotoNextInset(bv, codes, contents)) {
+                               cursor = tmp;
+                               bv->owner()->message(_("No more insets"));
+                       }
+               } else {
+                       bv->owner()->message(_("No more insets"));
+               }
+       }
+       update(bv, false);
+       selection.cursor = cursor;
+}
+
+
+void LyXText::gotoInset(BufferView * bv, Inset::Code code, bool same_content)
+{
+       gotoInset(bv, vector<Inset::Code>(1, code), same_content);
+}
+
 
-void cursorPrevious(LyXText * text, BufferView * bv)
+void LyXText::cursorPrevious(BufferView * bv)
 {
-       if (!text->cursor.row()->previous()) {
-               if (text->first_y > 0) {
+       if (!cursor.row()->previous()) {
+               if (first_y > 0) {
                        int new_y = bv->text->first_y - bv->workarea().workHeight();
                        bv->screen().draw(bv->text, bv, new_y < 0 ? 0 : new_y);
                        bv->updateScrollbar();
@@ -48,10 +117,10 @@ void cursorPrevious(LyXText * text, BufferView * bv)
                return;
        }
 
-       int y = text->first_y;
-       Row * cursorrow = text->cursor.row();
+       int y = first_y;
+       Row * cursorrow = cursor.row();
 
-       text->setCursorFromCoordinates(bv, text->cursor.x_fix(), y);
+       setCursorFromCoordinates(bv, cursor.x_fix(), y);
        finishUndo();
 
        int new_y;
@@ -63,37 +132,37 @@ void cursorPrevious(LyXText * text, BufferView * bv)
                // is better than just jump down and only display part of the row.
                new_y = bv->text->first_y - bv->workarea().workHeight();
        } else {
-               if (text->inset_owner) {
+               if (inset_owner) {
                        new_y = bv->text->cursor.iy()
                                + bv->theLockingInset()->insetInInsetY() + y
-                               + text->cursor.row()->height()
+                               + cursor.row()->height()
                                - bv->workarea().workHeight() + 1;
                } else {
-                       new_y = text->cursor.y()
-                               - text->cursor.row()->baseline()
-                               + text->cursor.row()->height()
+                       new_y = cursor.y()
+                               - cursor.row()->baseline()
+                               + cursor.row()->height()
                                - bv->workarea().workHeight() + 1;
                }
        }
        bv->screen().draw(bv->text, bv, new_y < 0 ? 0 : new_y);
-       if (text->cursor.row()->previous()) {
+       if (cursor.row()->previous()) {
                LyXCursor cur;
-               text->setCursor(bv, cur, text->cursor.row()->previous()->par(),
-                                               text->cursor.row()->previous()->pos(), false);
-               if (cur.y() > text->first_y) {
-                       text->cursorUp(bv, true);
+               setCursor(bv, cur, cursor.row()->previous()->par(),
+                                               cursor.row()->previous()->pos(), false);
+               if (cur.y() > first_y) {
+                       cursorUp(bv, true);
                }
        }
        bv->updateScrollbar();
 }
 
 
-void cursorNext(LyXText * text, BufferView * bv)
+void LyXText::cursorNext(BufferView * bv)
 {
-       if (!text->cursor.row()->next()) {
-               int y = text->cursor.y() - text->cursor.row()->baseline() +
-                       text->cursor.row()->height();
-               if (y > int(text->first_y + bv->workarea().workHeight())) {
+       if (!cursor.row()->next()) {
+               int y = cursor.y() - cursor.row()->baseline() +
+                       cursor.row()->height();
+               if (y > int(first_y + bv->workarea().workHeight())) {
                        bv->screen().draw(bv->text, bv,
                                                  bv->text->first_y + bv->workarea().workHeight());
                        bv->updateScrollbar();
@@ -101,17 +170,17 @@ void cursorNext(LyXText * text, BufferView * bv)
                return;
        }
 
-       int y = text->first_y + bv->workarea().workHeight();
-       if (text->inset_owner && !text->first_y) {
+       int y = first_y + bv->workarea().workHeight();
+       if (inset_owner && !first_y) {
                y -= (bv->text->cursor.iy()
                          - bv->text->first_y
                          + bv->theLockingInset()->insetInInsetY());
        }
 
-       text->getRowNearY(y);
+       getRowNearY(y);
 
-       Row * cursorrow = text->cursor.row();
-       text->setCursorFromCoordinates(bv, text->cursor.x_fix(), y);
+       Row * cursorrow = cursor.row();
+       setCursorFromCoordinates(bv, cursor.x_fix(), y);
        // + workarea().workHeight());
        finishUndo();
 
@@ -124,28 +193,26 @@ void cursorNext(LyXText * text, BufferView * bv)
                // is better than just jump down and only display part of the row.
                new_y = bv->text->first_y + bv->workarea().workHeight();
        } else {
-               if (text->inset_owner) {
+               if (inset_owner) {
                        new_y = bv->text->cursor.iy()
                                + bv->theLockingInset()->insetInInsetY()
-                               + y - text->cursor.row()->baseline();
+                               + y - cursor.row()->baseline();
                } else {
-                       new_y =  text->cursor.y() - text->cursor.row()->baseline();
+                       new_y =  cursor.y() - cursor.row()->baseline();
                }
        }
        bv->screen().draw(bv->text, bv, new_y);
-       if (text->cursor.row()->next()) {
+       if (cursor.row()->next()) {
                LyXCursor cur;
-               text->setCursor(bv, cur, text->cursor.row()->next()->par(),
-                                               text->cursor.row()->next()->pos(), false);
-               if (cur.y() < int(text->first_y + bv->workarea().workHeight())) {
-                       text->cursorDown(bv, true);
+               setCursor(bv, cur, cursor.row()->next()->par(),
+                                               cursor.row()->next()->pos(), false);
+               if (cur.y() < int(first_y + bv->workarea().workHeight())) {
+                       cursorDown(bv, true);
                }
        }
        bv->updateScrollbar();
 }
 
-}
-
 
 void LyXText::update(BufferView * bv, bool changed)
 {
@@ -314,13 +381,13 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 
        case LFUN_PRIORSEL:
                update(bv, false);
-               cursorPrevious(this, bv);
+               cursorPrevious(bv);
                bv->finishChange(true);
                break;
 
        case LFUN_NEXTSEL:
                update(bv, false);
-               cursorNext(this, bv);
+               cursorNext(bv);
                bv->finishChange();
                break;
 
@@ -436,7 +503,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
                if (!selection.mark())
                        bv->beforeChange(this);
                bv->update(this, BufferView::UPDATE);
-               cursorPrevious(this, bv);
+               cursorPrevious(bv);
                bv->finishChange(false);
                // was:
                // finishUndo();
@@ -448,7 +515,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
                if (!selection.mark())
                        bv->beforeChange(this);
                bv->update(this, BufferView::UPDATE);
-               cursorNext(this, bv);
+               cursorNext(bv);
                bv->finishChange(false);
                break;
 
@@ -926,6 +993,23 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
                break;
        }
 
+       case LFUN_GOTOERROR:
+               gotoInset(bv, Inset::ERROR_CODE, false);
+               break;
+
+       case LFUN_GOTONOTE:
+               gotoInset(bv, Inset::NOTE_CODE, false);
+               break;
+
+       case LFUN_REFERENCE_GOTO:
+       {
+               vector<Inset::Code> tmp;
+               tmp.push_back(Inset::LABEL_CODE);
+               tmp.push_back(Inset::REF_CODE);
+               gotoInset(bv, tmp, true);
+               break;
+       }
+
        case LFUN_SELFINSERT: {
                if (cmd.argument.empty())
                        break;