X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView_pimpl.C;h=7fb0cc1c1ac9246d6f129b559454fd73e84cf937;hb=ab254289c832cd045c56e6012d14b048618cb833;hp=48c36c73c772edf3938608ed23666eaaa75dfb0b;hpb=7f6bd7f12d1f084a3b7435b811ceb0020309c3cd;p=lyx.git diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C index 48c36c73c7..7fb0cc1c1a 100644 --- a/src/BufferView_pimpl.C +++ b/src/BufferView_pimpl.C @@ -3,6 +3,7 @@ #include #include #include +#include #ifdef __GNUG__ #pragma implementation @@ -16,7 +17,6 @@ #include "LyXView.h" #include "commandtags.h" #include "lyxfunc.h" -#include "minibuffer.h" #include "font.h" #include "bufferview_funcs.h" #include "TextCache.h" @@ -30,7 +30,7 @@ #include "insets/insettext.h" /// added for Dispatch functions #include "lyx_cb.h" -#include "filedlg.h" +#include "frontends/FileDialog.h" #include "lyx_main.h" #include "FloatList.h" #include "support/filetools.h" @@ -41,6 +41,7 @@ #include "insets/insetref.h" #include "insets/insetparent.h" #include "insets/insetindex.h" +#include "insets/insetinfo.h" #include "insets/insetinclude.h" #include "insets/insetcite.h" #include "insets/insetert.h" @@ -54,21 +55,24 @@ #include "insets/insettabular.h" #include "insets/insettheorem.h" #include "insets/insetcaption.h" +#include "insets/insetfloatlist.h" +#include "insets/insetspecialchar.h" #include "mathed/formulamacro.h" +#include "mathed/formula.h" +#include "gettext.h" +#include "ParagraphParameters.h" + extern LyXTextClass::size_type current_layout; -extern void math_insert_symbol(BufferView *, string const &); -extern bool math_insert_greek(BufferView *, char); extern int greek_kb_flag; -#ifdef SIGC_CXX_NAMESPACES -using SigC::slot; -#endif - +using std::vector; using std::find_if; +using std::find; using std::pair; using std::endl; using std::make_pair; using std::min; +using SigC::slot; /* the selection possible is needed, that only motion events are * used, where the bottom press event was on the drawing area too */ @@ -77,19 +81,21 @@ bool selection_possible = false; extern BufferList bufferlist; extern char ascii_type; +extern bool math_insert_greek(BufferView *, char); extern void sigchldhandler(pid_t pid, int * status); extern int bibitemMaxWidth(BufferView *, LyXFont const &); +namespace { + const unsigned int saved_positions_num = 20; -static inline +inline void waitForX() { XSync(fl_get_display(), 0); } -static void SetXtermCursor(Window win) { static Cursor cursor; @@ -103,50 +109,49 @@ void SetXtermCursor(Window win) XFlush(fl_get_display()); } +} // anon namespace + BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o, int xpos, int ypos, int width, int height) - : bv_(b), owner_(o), cursor_timeout(400) + : bv_(b), owner_(o), buffer_(0), + current_scrollbar_value(0), cursor_timeout(400), + workarea_(xpos, ypos, width, height), using_xterm_cursor(false), + inset_slept(false) { - buffer_ = 0; - workarea_ = new WorkArea(xpos, ypos, width, height); // Setup the signals - workarea_->scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB)); - workarea_->workAreaExpose + workarea_.scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB)); + workarea_.workAreaExpose .connect(slot(this, &BufferView::Pimpl::workAreaExpose)); - workarea_->workAreaEnter + workarea_.workAreaEnter .connect(slot(this, &BufferView::Pimpl::enterView)); - workarea_->workAreaLeave + workarea_.workAreaLeave .connect(slot(this, &BufferView::Pimpl::leaveView)); - workarea_->workAreaButtonPress + workarea_.workAreaButtonPress .connect(slot(this, &BufferView::Pimpl::workAreaButtonPress)); - workarea_->workAreaButtonRelease + workarea_.workAreaButtonRelease .connect(slot(this, &BufferView::Pimpl::workAreaButtonRelease)); - workarea_->workAreaMotionNotify + workarea_.workAreaMotionNotify .connect(slot(this, &BufferView::Pimpl::workAreaMotionNotify)); - workarea_->workAreaDoubleClick + workarea_.workAreaDoubleClick .connect(slot(this, &BufferView::Pimpl::doubleClick)); - workarea_->workAreaTripleClick + workarea_.workAreaTripleClick .connect(slot(this, &BufferView::Pimpl::tripleClick)); - workarea_->workAreaKeyPress + workarea_.workAreaKeyPress .connect(slot(this, &BufferView::Pimpl::workAreaKeyPress)); - screen_ = 0; - cursor_timeout.timeout.connect(slot(this, &BufferView::Pimpl::cursorToggle)); - current_scrollbar_value = 0; cursor_timeout.start(); - workarea_->setFocus(); - using_xterm_cursor = false; + workarea_.setFocus(); saved_positions.resize(saved_positions_num); } Painter & BufferView::Pimpl::painter() { - return workarea_->getPainter(); + return workarea_.getPainter(); } @@ -155,14 +160,14 @@ void BufferView::Pimpl::buffer(Buffer * b) lyxerr[Debug::INFO] << "Setting buffer in BufferView (" << b << ")" << endl; if (buffer_) { - bv_->insetSleep(); + insetSleep(); buffer_->delUser(bv_); // Put the old text into the TextCache, but // only if the buffer is still loaded. // Also set the owner of the test to 0 // bv_->text->owner(0); - textcache.add(buffer_, workarea_->workWidth(), bv_->text); + textcache.add(buffer_, workarea_.workWidth(), bv_->text); if (lyxerr.debugging()) textcache.show(lyxerr, "BufferView::buffer"); @@ -176,8 +181,7 @@ void BufferView::Pimpl::buffer(Buffer * b) // Nuke old image // screen is always deleted when the buffer is changed. - delete screen_; - screen_ = 0; + screen_.reset(0); // If we are closing the buffer, use the first buffer as current if (!buffer_) { @@ -202,14 +206,14 @@ void BufferView::Pimpl::buffer(Buffer * b) // require bv_->text. owner_->getDialogs()->updateBufferDependent(true); redraw(); - bv_->insetWakeup(); + insetWakeup(); } else { lyxerr[Debug::INFO] << " No Buffer!" << endl; owner_->updateMenubar(); owner_->updateToolbar(); owner_->getDialogs()->hideBufferDependent(); updateScrollbar(); - workarea_->redraw(); + workarea_.redraw(); // Also remove all remaining text's from the testcache. // (there should not be any!) (if there is any it is a @@ -220,14 +224,14 @@ void BufferView::Pimpl::buffer(Buffer * b) } // should update layoutchoice even if we don't have a buffer. owner_->updateLayoutChoice(); - owner_->getMiniBuffer()->Init(); + owner_->updateWindowTitle(); } void BufferView::Pimpl::resize(int xpos, int ypos, int width, int height) { - workarea_->resize(xpos, ypos, width, height); + workarea_.resize(xpos, ypos, width, height); update(bv_->text, SELECT); redraw(); } @@ -243,15 +247,17 @@ void BufferView::Pimpl::resize() void BufferView::Pimpl::redraw() { lyxerr[Debug::INFO] << "BufferView::redraw()" << endl; - workarea_->redraw(); + workarea_.redraw(); } bool BufferView::Pimpl::fitCursor(LyXText * text) { - Assert(screen_); - - bool ret = screen_->FitCursor(text, bv_); + lyx::Assert(screen_.get()); + + bv_->owner()->getDialogs()->updateParagraph(); + + bool const ret = screen_->FitCursor(text, bv_); if (ret) updateScrollbar(); return ret; @@ -272,41 +278,41 @@ int BufferView::Pimpl::resizeCurrentBuffer() { lyxerr[Debug::INFO] << "resizeCurrentBuffer" << endl; - LyXParagraph * par = 0; - LyXParagraph * selstartpar = 0; - LyXParagraph * selendpar = 0; + Paragraph * par = 0; + Paragraph * selstartpar = 0; + Paragraph * selendpar = 0; UpdatableInset * the_locking_inset = 0; - int pos = 0; - int selstartpos = 0; - int selendpos = 0; - int selection = 0; - int mark_set = 0; + Paragraph::size_type pos = 0; + Paragraph::size_type selstartpos = 0; + Paragraph::size_type selendpos = 0; + bool selection = false; + bool mark_set = false; ProhibitInput(bv_); - owner_->getMiniBuffer()->Set(_("Formatting document...")); + owner_->message(_("Formatting document...")); if (bv_->text) { par = bv_->text->cursor.par(); pos = bv_->text->cursor.pos(); - selstartpar = bv_->text->sel_start_cursor.par(); - selstartpos = bv_->text->sel_start_cursor.pos(); - selendpar = bv_->text->sel_end_cursor.par(); - selendpos = bv_->text->sel_end_cursor.pos(); - selection = bv_->text->selection; - mark_set = bv_->text->mark_set; - the_locking_inset = bv_->text->the_locking_inset; + selstartpar = bv_->text->selection.start.par(); + selstartpos = bv_->text->selection.start.pos(); + selendpar = bv_->text->selection.end.par(); + selendpos = bv_->text->selection.end.pos(); + selection = bv_->text->selection.set(); + mark_set = bv_->text->selection.mark(); + the_locking_inset = bv_->theLockingInset(); delete bv_->text; bv_->text = new LyXText(bv_); } else { // See if we have a text in TextCache that fits // the new buffer_ with the correct width. - bv_->text = textcache.findFit(buffer_, workarea_->workWidth()); + bv_->text = textcache.findFit(buffer_, workarea_.workWidth()); if (bv_->text) { if (lyxerr.debugging()) { lyxerr << "Found a LyXText that fits:\n"; - textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea_->workWidth(), bv_->text))); + textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea_.workWidth(), bv_->text))); } // Set the owner of the newly found text // bv_->text->owner(bv_); @@ -319,34 +325,38 @@ int BufferView::Pimpl::resizeCurrentBuffer() updateScreen(); if (par) { - bv_->text->selection = true; + bv_->text->selection.set(true); /* at this point just to avoid the Delete-Empty-Paragraph * Mechanism when setting the cursor */ - bv_->text->mark_set = mark_set; + bv_->text->selection.mark(mark_set); if (selection) { - bv_->text->SetCursor(bv_, selstartpar, selstartpos); - bv_->text->sel_cursor = bv_->text->cursor; - bv_->text->SetCursor(bv_, selendpar, selendpos); - bv_->text->SetSelection(bv_); - bv_->text->SetCursor(bv_, par, pos); + bv_->text->setCursor(bv_, selstartpar, selstartpos); + bv_->text->selection.cursor = bv_->text->cursor; + bv_->text->setCursor(bv_, selendpar, selendpos); + bv_->text->setSelection(bv_); + bv_->text->setCursor(bv_, par, pos); } else { - bv_->text->SetCursor(bv_, par, pos); - bv_->text->sel_cursor = bv_->text->cursor; - bv_->text->selection = false; + bv_->text->setCursor(bv_, par, pos); + bv_->text->selection.cursor = bv_->text->cursor; + bv_->text->selection.set(false); } // remake the inset locking - bv_->text->the_locking_inset = the_locking_inset; + bv_->theLockingInset(the_locking_inset); } 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(); - bv_->setState(); + + setState(); AllowInput(bv_); - owner_->getDialogs()->hideSplash(); + /// clear the "Formatting Document" message + owner_->message(""); + + /// get rid of the splash screen if it's not gone already + owner_->getDialogs()->destroySplash(); return 0; } @@ -355,8 +365,7 @@ int BufferView::Pimpl::resizeCurrentBuffer() void BufferView::Pimpl::updateScreen() { // Regenerate the screen. - delete screen_; - screen_ = new LyXScreen(*workarea_); + screen_.reset(new LyXScreen(workarea_)); } @@ -366,58 +375,40 @@ void BufferView::Pimpl::updateScrollbar() * maximum must be the working area height. No scrolling will * be possible */ - if (!buffer_) { - workarea_->setScrollbar(0, 1.0); + if (!bv_->text) { + workarea_.setScrollbar(0, 1.0); return; } - - static unsigned long max2 = 0; - static unsigned long height2 = 0; - - unsigned long cbth = 0; - long cbsf = 0; - if (bv_->text) { - cbth = bv_->text->height; - cbsf = bv_->text->first; - } + static unsigned long text_height; + static unsigned long work_height; + unsigned long const tmp_text_height = bv_->text->height; + long const tmp_scrollbar_value = bv_->text->first; + // check if anything has changed. - if (max2 == cbth && - height2 == workarea_->height() && - current_scrollbar_value == cbsf) + if (text_height == tmp_text_height + && work_height == workarea_.height() + && current_scrollbar_value == tmp_scrollbar_value) return; // no - max2 = cbth; - height2 = workarea_->height(); - current_scrollbar_value = cbsf; - if (cbth <= height2) { // text is smaller than screen - workarea_->setScrollbar(0, 1.0); // right? - return; - } + // update values + text_height = tmp_text_height; + work_height = workarea_.height(); + current_scrollbar_value = tmp_scrollbar_value; - long maximum_height = workarea_->height() * 3 / 4 + cbth; - long value = cbsf; + long const height_diff = text_height - work_height; - // set the scrollbar - double hfloat = workarea_->height(); - double maxfloat = maximum_height; - - float slider_size = 0.0; - int slider_value = value; - - workarea_->setScrollbarBounds(0, bv_->text->height - workarea_->height()); - double lineh = bv_->text->DefaultHeight(); - workarea_->setScrollbarIncrements(lineh); - if (maxfloat > 0.0) { - if ((hfloat / maxfloat) * float(height2) < 3) - slider_size = 3.0/float(height2); - else - slider_size = hfloat / maxfloat; - } else - slider_size = hfloat; - - workarea_->setScrollbar(slider_value, slider_size / workarea_->height()); + if (height_diff <= 0) { + workarea_.setScrollbar(0, 1.0); + return; + } + + workarea_.setScrollbarBounds(0, height_diff); + double const lineh = bv_->text->defaultHeight(); + workarea_.setScrollbarIncrements(lineh); + double const slider_size = 1.0 / (double(height_diff) + work_height); + workarea_.setScrollbar(current_scrollbar_value, slider_size); } @@ -430,7 +421,7 @@ void BufferView::Pimpl::scrollCB(double value) if (current_scrollbar_value < 0) current_scrollbar_value = 0; - if (!screen_) + if (!screen_.get()) return; screen_->Draw(bv_->text, bv_, current_scrollbar_value); @@ -442,14 +433,14 @@ void BufferView::Pimpl::scrollCB(double value) LyXText * vbt = bv_->text; - int const height = vbt->DefaultHeight(); + int const height = vbt->defaultHeight(); int const first = static_cast((bv_->text->first + height)); - int const last = static_cast((bv_->text->first + workarea_->height() - height)); + int const last = static_cast((bv_->text->first + workarea_.height() - height)); if (vbt->cursor.y() < first) - vbt->SetCursorFromCoordinates(bv_, 0, first); + vbt->setCursorFromCoordinates(bv_, 0, first); else if (vbt->cursor.y() > last) - vbt->SetCursorFromCoordinates(bv_, 0, last); + vbt->setCursorFromCoordinates(bv_, 0, last); waitForX(); } @@ -458,25 +449,25 @@ void BufferView::Pimpl::scrollCB(double value) int BufferView::Pimpl::scrollUp(long time) { if (!buffer_) return 0; - if (!screen_) return 0; + if (!screen_.get()) return 0; - double value = workarea_->getScrollbarValue(); + double value = workarea_.getScrollbarValue(); if (value == 0) return 0; - float add_value = (bv_->text->DefaultHeight() + float add_value = (bv_->text->defaultHeight() + float(time) * float(time) * 0.125); - if (add_value > workarea_->height()) - add_value = float(workarea_->height() - - bv_->text->DefaultHeight()); + if (add_value > workarea_.height()) + add_value = float(workarea_.height() - + bv_->text->defaultHeight()); value -= add_value; if (value < 0) value = 0; - workarea_->setScrollbarValue(value); + workarea_.setScrollbarValue(value); scrollCB(value); return 0; @@ -486,27 +477,27 @@ int BufferView::Pimpl::scrollUp(long time) int BufferView::Pimpl::scrollDown(long time) { if (!buffer_) return 0; - if (!screen_) return 0; + if (!screen_.get()) return 0; - double value= workarea_->getScrollbarValue(); - pair p = workarea_->getScrollbarBounds(); - double max = p.second; + double value = workarea_.getScrollbarValue(); + pair p = workarea_.getScrollbarBounds(); + double const max = p.second; if (value == max) return 0; - float add_value = (bv_->text->DefaultHeight() + float add_value = (bv_->text->defaultHeight() + float(time) * float(time) * 0.125); - if (add_value > workarea_->height()) - add_value = float(workarea_->height() - - bv_->text->DefaultHeight()); + if (add_value > workarea_.height()) + add_value = float(workarea_.height() - + bv_->text->defaultHeight()); value += add_value; if (value > max) value = max; - workarea_->setScrollbarValue(value); + workarea_.setScrollbarValue(value); scrollCB(value); return 0; @@ -525,38 +516,39 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state) if (!(state & Button1MotionMask)) return; - if (!buffer_ || !screen_) return; + if (!buffer_ || !screen_.get()) return; // Check for inset locking if (bv_->theLockingInset()) { LyXCursor cursor = bv_->text->cursor; - LyXFont font = bv_->text->GetFont(bv_->buffer(), + LyXFont font = bv_->text->getFont(buffer_, cursor.par(), cursor.pos()); int width = bv_->theLockingInset()->width(bv_, font); int inset_x = font.isVisibleRightToLeft() ? cursor.x() - width : cursor.x(); int start_x = inset_x + bv_->theLockingInset()->scroll(); bv_->theLockingInset()-> - InsetMotionNotify(bv_, + insetMotionNotify(bv_, x - start_x, y - cursor.y() + bv_->text->first, state); return; } - /* The test for not selection possible is needed, that only motion events are - * used, where the bottom press event was on the drawing area too */ + /* The test for not selection possible is needed, that only motion + events are used, where the bottom press event was on + the drawing area too */ if (!selection_possible) return; screen_->HideCursor(); - bv_->text->SetCursorFromCoordinates(bv_, x, y + bv_->text->first); + bv_->text->setCursorFromCoordinates(bv_, x, y + bv_->text->first); - if (!bv_->text->selection) + if (!bv_->text->selection.set()) update(bv_->text, BufferView::UPDATE); // Maybe an empty line was deleted - bv_->text->SetSelection(bv_); + bv_->text->setSelection(bv_); screen_->ToggleToggle(bv_->text, bv_); fitCursor(bv_->text); screen_->ShowCursor(bv_->text, bv_); @@ -567,10 +559,7 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state) void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, unsigned int button) { - last_click_x = -1; - last_click_y = -1; - - if (!buffer_ || !screen_) return; + if (!buffer_ || !screen_.get()) return; Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button); @@ -593,7 +582,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, otherwise give the event to the inset */ if (inset_hit == bv_->theLockingInset()) { bv_->theLockingInset()-> - InsetButtonPress(bv_, + insetButtonPress(bv_, xpos, ypos, button); return; @@ -611,28 +600,28 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, // Middle button press pastes if we have a selection bool paste_internally = false; if (button == 2 - && bv_->text->selection) { + && bv_->text->selection.set()) { owner_->getLyXFunc()->Dispatch(LFUN_COPY); paste_internally = true; } // Clear the selection screen_->ToggleSelection(bv_->text, bv_); - bv_->text->ClearSelection(bv_); - bv_->text->FullRebreak(bv_); + bv_->text->clearSelection(bv_); + bv_->text->fullRebreak(bv_); screen_->Update(bv_->text, bv_); updateScrollbar(); // Single left click in math inset? if ((inset_hit != 0) && - (inset_hit->Editable()==Inset::HIGHLY_EDITABLE)) { + (inset_hit->editable()==Inset::HIGHLY_EDITABLE)) { // Highly editable inset, like math UpdatableInset * inset = static_cast(inset_hit); selection_possible = false; owner_->updateLayoutChoice(); - owner_->getMiniBuffer()->Set(inset->EditMessage()); - inset->InsetButtonPress(bv_, xpos, ypos, button); - inset->Edit(bv_, xpos, ypos, button); + owner_->message(inset->editMessage()); + inset->insetButtonPress(bv_, xpos, ypos, button); + inset->edit(bv_, xpos, ypos, button); return; } @@ -643,9 +632,9 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, } if (!inset_hit) // otherwise it was already set in checkInsetHit(...) - bv_->text->SetCursorFromCoordinates(bv_, xpos, ypos + screen_first); - bv_->text->FinishUndo(); - bv_->text->sel_cursor = bv_->text->cursor; + bv_->text->setCursorFromCoordinates(bv_, xpos, ypos + screen_first); + bv_->text->finishUndo(); + bv_->text->selection.cursor = bv_->text->cursor; bv_->text->cursor.x_fix(bv_->text->cursor.x()); owner_->updateLayoutChoice(); @@ -679,14 +668,14 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button) if (text->bv_owner && bv_->theLockingInset()) return; - if (screen_ && button == 1) { + if (screen_.get() && button == 1) { if (text->bv_owner) { screen_->HideCursor(); screen_->ToggleSelection(text, bv_); - text->SelectWord(bv_); + text->selectWord(bv_); screen_->ToggleSelection(text, bv_, false); } else { - text->SelectWord(bv_); + text->selectWord(bv_); } /* This will fit the cursor on the screen * if necessary */ @@ -706,13 +695,13 @@ void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button) if (text->bv_owner && bv_->theLockingInset()) return; - if (screen_ && (button == 1)) { + if (screen_.get() && (button == 1)) { screen_->HideCursor(); screen_->ToggleSelection(text, bv_); - text->CursorHome(bv_); - text->sel_cursor = text->cursor; - text->CursorEnd(bv_); - text->SetSelection(bv_); + text->cursorHome(bv_); + text->selection.cursor = text->cursor; + text->cursorEnd(bv_); + text->setSelection(bv_); screen_->ToggleSelection(text, bv_, false); /* This will fit the cursor on the screen * if necessary */ @@ -724,7 +713,7 @@ void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button) void BufferView::Pimpl::enterView() { if (active() && available()) { - SetXtermCursor(workarea_->getWin()); + SetXtermCursor(workarea_.getWin()); using_xterm_cursor = true; } } @@ -733,7 +722,7 @@ void BufferView::Pimpl::enterView() void BufferView::Pimpl::leaveView() { if (using_xterm_cursor) { - XUndefineCursor(fl_get_display(), workarea_->getWin()); + XUndefineCursor(fl_get_display(), workarea_.getWin()); using_xterm_cursor = false; } } @@ -742,7 +731,7 @@ void BufferView::Pimpl::leaveView() void BufferView::Pimpl::workAreaButtonRelease(int x, int y, unsigned int button) { - if (!buffer_ || !screen_) return; + if (!buffer_ || !screen_.get()) 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 @@ -754,17 +743,18 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, /* LyX does a kind of work-area grabbing for insets. Only a ButtonPress Event outside the inset will - force a InsetUnlock. */ + force a insetUnlock. */ bv_->theLockingInset()-> - InsetButtonRelease(bv_, x, y, button); + insetButtonRelease(bv_, x, y, button); return; } selection_possible = false; - if (button >= 2) return; + if (button == 2) + return; - bv_->setState(); + setState(); owner_->showState(); // Did we hit an editable inset? @@ -787,18 +777,19 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, // (Joacim) // ...or maybe the SetCursorParUndo() // below isn't necessary at all anylonger? - if (inset_hit->LyxCode() == Inset::REF_CODE) { - bv_->text->SetCursorParUndo(bv_->buffer()); + if (inset_hit->lyxCode() == Inset::REF_CODE) { + bv_->text->setCursorParUndo(buffer_); } - owner_->getMiniBuffer()->Set(inset_hit->EditMessage()); - if (inset_hit->Editable()==Inset::HIGHLY_EDITABLE) { + owner_->message(inset_hit->editMessage()); + + if (inset_hit->editable()==Inset::HIGHLY_EDITABLE) { // Highly editable inset, like math UpdatableInset *inset = (UpdatableInset *)inset_hit; - inset->InsetButtonRelease(bv_, x, y, button); + inset->insetButtonRelease(bv_, x, y, button); } else { - inset_hit->InsetButtonRelease(bv_, x, y, button); - inset_hit->Edit(bv_, x, y, button); + inset_hit->insetButtonRelease(bv_, x, y, button); + inset_hit->edit(bv_, x, y, button); } return; } @@ -808,82 +799,26 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, bool hit = false; char c = ' '; if (bv_->text->cursor.pos() < - bv_->text->cursor.par()->Last()) { + bv_->text->cursor.par()->size()) { c = bv_->text->cursor.par()-> - GetChar(bv_->text->cursor.pos()); + getChar(bv_->text->cursor.pos()); } -#ifndef NEW_INSETS - if(!bv_->text->selection) - if (c == LyXParagraph::META_FOOTNOTE - || c == LyXParagraph::META_MARGIN - || c == LyXParagraph::META_FIG - || c == LyXParagraph::META_TAB - || c == LyXParagraph::META_WIDE_FIG - || c == LyXParagraph::META_WIDE_TAB - || c == LyXParagraph::META_ALGORITHM){ - hit = true; - } 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 - || c == LyXParagraph::META_TAB - || c == LyXParagraph::META_WIDE_FIG - || c == LyXParagraph::META_WIDE_TAB - || c == LyXParagraph::META_ALGORITHM){ - // We are one step too far to the right - bv_->text->CursorLeft(bv_); - hit = true; - } -#endif + getChar(bv_->text->cursor.pos() - 1); } 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 - && bv_->text->cursor.row()->previous() && - bv_->text->cursor.row()->previous()->par()-> - footnoteflag != LyXParagraph::OPEN_FOOTNOTE){ - LyXFont font(LyXFont::ALL_SANE); - font.setSize(LyXFont::SIZE_FOOTNOTE); - - int box_x = 20; // LYX_PAPER_MARGIN; - box_x += lyxfont::width(" wide-tab ", font); - - unsigned int screen_first = bv_->text->first; - - if (x < box_x - && y + screen_first > bv_->text->cursor.y() - - bv_->text->cursor.row()->baseline() - && y + screen_first < bv_->text->cursor.y() - - bv_->text->cursor.row()->baseline() - + lyxfont::maxAscent(font) * 1.2 + lyxfont::maxDescent(font) * 1.2) { - bv_->toggleFloat(); - selection_possible = false; - return; - } - } -#endif - // Maybe we want to edit a bibitem ale970302 if (bv_->text->cursor.par()->bibkey && x < 20 + bibitemMaxWidth(bv_, textclasslist. TextClass(buffer_-> params.textclass).defaultfont())) { - bv_->text->cursor.par()->bibkey->Edit(bv_, 0, 0, 0); + bv_->text->cursor.par()->bibkey->edit(bv_, 0, 0, 0); } return; @@ -898,33 +833,35 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, unsigned int /* button */) { - if (!screen_) + if (!screen_.get()) return 0; int y_tmp = y + text->first; LyXCursor cursor; - text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp); + text->setCursorFromCoordinates(bv_, cursor, x, y_tmp); + text->setCursor(bv_, cursor, cursor.par(),cursor.pos(),true); + - if (cursor.pos() < cursor.par()->Last() - && cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET - && cursor.par()->GetInset(cursor.pos()) - && cursor.par()->GetInset(cursor.pos())->Editable()) { + if (cursor.pos() < cursor.par()->size() + && cursor.par()->getChar(cursor.pos()) == Paragraph::META_INSET + && cursor.par()->getInset(cursor.pos()) + && cursor.par()->getInset(cursor.pos())->editable()) { // Check whether the inset really was hit - Inset * tmpinset = cursor.par()->GetInset(cursor.pos()); - LyXFont font = text->GetFont(bv_->buffer(), + Inset * tmpinset = cursor.par()->getInset(cursor.pos()); + LyXFont font = text->getFont(buffer_, cursor.par(), cursor.pos()); - int width = tmpinset->width(bv_, font); - int inset_x = font.isVisibleRightToLeft() + int const width = tmpinset->width(bv_, font); + int const inset_x = font.isVisibleRightToLeft() ? cursor.x() - width : cursor.x(); - int start_x = inset_x + tmpinset->scroll(); - int end_x = inset_x + width; + int const start_x = inset_x + tmpinset->scroll(); + int const end_x = inset_x + width; if (x > start_x && x < end_x && y_tmp > cursor.y() - tmpinset->ascent(bv_, font) && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) { - text->SetCursor(bv_, cursor.par(),cursor.pos(),true); + text->setCursor(bv_, cursor.par(),cursor.pos(), true); x = x - start_x; // The origin of an inset is on the baseline y = y_tmp - (text->cursor.y()); @@ -933,17 +870,17 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, } if ((cursor.pos() - 1 >= 0) && - (cursor.par()->GetChar(cursor.pos()-1) == LyXParagraph::META_INSET) && - (cursor.par()->GetInset(cursor.pos() - 1)) && - (cursor.par()->GetInset(cursor.pos() - 1)->Editable())) { - Inset * tmpinset = cursor.par()->GetInset(cursor.pos()-1); - LyXFont font = text->GetFont(bv_->buffer(), cursor.par(), + (cursor.par()->getChar(cursor.pos()-1) == Paragraph::META_INSET) && + (cursor.par()->getInset(cursor.pos() - 1)) && + (cursor.par()->getInset(cursor.pos() - 1)->editable())) { + Inset * tmpinset = cursor.par()->getInset(cursor.pos()-1); + LyXFont font = text->getFont(buffer_, cursor.par(), cursor.pos()-1); - int width = tmpinset->width(bv_, font); - int inset_x = font.isVisibleRightToLeft() + int const width = tmpinset->width(bv_, font); + int const inset_x = font.isVisibleRightToLeft() ? cursor.x() : cursor.x() - width; - int start_x = inset_x + tmpinset->scroll(); - int end_x = inset_x + width; + int const start_x = inset_x + tmpinset->scroll(); + int const end_x = inset_x + width; if (x > start_x && x < end_x && y_tmp > cursor.y() - tmpinset->ascent(bv_, font) @@ -951,7 +888,8 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, #if 0 if (move_cursor && (tmpinset != bv_->theLockingInset())) #endif - 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 - (text->cursor.y()); @@ -964,19 +902,19 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, void BufferView::Pimpl::workAreaExpose() { - static int work_area_width = 0; - static unsigned int work_area_height = 0; + static int work_area_width; + static unsigned int work_area_height; - bool widthChange = workarea_->workWidth() != work_area_width; - bool heightChange = workarea_->height() != work_area_height; + bool const widthChange = workarea_.workWidth() != work_area_width; + bool const heightChange = workarea_.height() != work_area_height; // update from work area - work_area_width = workarea_->workWidth(); - work_area_height = workarea_->height(); + work_area_width = workarea_.workWidth(); + work_area_height = workarea_.height(); if (buffer_ != 0) { if (widthChange) { - // All buffers need a resize - bufferlist.resize(); + // The visible LyXView need a resize + owner_->resize(); // Remove all texts from the textcache // This is not _really_ what we want to do. What @@ -997,14 +935,11 @@ void BufferView::Pimpl::workAreaExpose() // The main window size has changed, repaint most stuff redraw(); - // ...including the minibuffer - owner_->getMiniBuffer()->Init(); - - } else if (screen_) + } else if (screen_.get()) screen_->Redraw(bv_->text, bv_); } else { // Grey box when we don't have a buffer - workarea_->greyOut(); + workarea_.greyOut(); } // always make sure that the scrollbar is sane. @@ -1016,7 +951,11 @@ void BufferView::Pimpl::workAreaExpose() void BufferView::Pimpl::update() { - if (screen_) screen_->Update(bv_->text, bv_); + if (screen_.get() && + (!bv_->theLockingInset() || !bv_->theLockingInset()->nodraw())) + { + screen_->Update(bv_->text, bv_); + } } // Values used when calling update: @@ -1061,15 +1000,15 @@ void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f) { owner_->updateLayoutChoice(); - if (!text->selection && (f & SELECT)) { - text->sel_cursor = text->cursor; + if (!text->selection.set() && (f & SELECT)) { + text->selection.cursor = text->cursor; } - text->FullRebreak(bv_); + text->fullRebreak(bv_); if (text->inset_owner) { - text->inset_owner->SetUpdateStatus(bv_, InsetText::NONE); - bv_->updateInset(text->inset_owner, true); + text->inset_owner->setUpdateStatus(bv_, InsetText::NONE); + updateInset(text->inset_owner, true); } else update(); @@ -1078,12 +1017,7 @@ void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f) } if ((f & CHANGE)) { - if (buffer_->isLyxClean()) { - buffer_->markDirty(); - owner_->getMiniBuffer()->setTimer(4); - } else { - buffer_->markDirty(); - } + buffer_->markDirty(); } } @@ -1099,7 +1033,7 @@ void BufferView::Pimpl::cursorToggle() } int status = 1; - int pid = waitpid(static_cast(0), &status, WNOHANG); + int const pid = waitpid(static_cast(0), &status, WNOHANG); if (pid == -1) // error find out what is wrong ; // ignore it for now. else if (pid > 0) @@ -1107,7 +1041,7 @@ void BufferView::Pimpl::cursorToggle() updatelist.update(bv_); - if (!screen_) { + if (!screen_.get()) { cursor_timeout.restart(); return; } @@ -1115,7 +1049,7 @@ void BufferView::Pimpl::cursorToggle() if (!bv_->theLockingInset()) { screen_->CursorToggle(bv_->text, bv_); } else { - bv_->theLockingInset()->ToggleInsetCursor(bv_); + bv_->theLockingInset()->toggleInsetCursor(bv_); } cursor_timeout.restart(); @@ -1131,19 +1065,19 @@ void BufferView::Pimpl::cursorPrevious(LyXText * text) 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(); + text->setCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y); + bv_->text->finishUndo(); // This is to allow jumping over large insets if ((cursorrow == text->cursor.row())) - text->CursorUp(bv_); + text->cursorUp(bv_); if (text->inset_owner || - text->cursor.row()->height() < workarea_->height()) + text->cursor.row()->height() < workarea_.height()) screen_->Draw(bv_->text, bv_, text->cursor.y() - text->cursor.row()->baseline() + text->cursor.row()->height() - - workarea_->height() + 1 ); + - workarea_.height() + 1 ); updateScrollbar(); } @@ -1153,20 +1087,20 @@ void BufferView::Pimpl::cursorNext(LyXText * text) if (!text->cursor.row()->next()) return; - int y = text->first + workarea_->height(); + int y = text->first + workarea_.height(); // if (text->inset_owner) // y += bv_->text->first; - text->GetRowNearY(y); + text->getRowNearY(y); Row * cursorrow = text->cursor.row(); - text->SetCursorFromCoordinates(bv_, text->cursor.x_fix(), y); // + workarea_->height()); - bv_->text->FinishUndo(); + 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())) - text->CursorDown(bv_); + text->cursorDown(bv_); if (text->inset_owner || - text->cursor.row()->height() < workarea_->height()) + text->cursor.row()->height() < workarea_.height()) screen_->Draw(bv_->text, bv_, text->cursor.y() - text->cursor.row()->baseline()); updateScrollbar(); @@ -1183,7 +1117,7 @@ bool BufferView::Pimpl::available() const void BufferView::Pimpl::beforeChange(LyXText * text) { toggleSelection(); - text->ClearSelection(bv_); + text->clearSelection(bv_); } @@ -1194,8 +1128,11 @@ void BufferView::Pimpl::savePosition(unsigned int i) saved_positions[i] = Position(buffer_->fileName(), bv_->text->cursor.par()->id(), bv_->text->cursor.pos()); - if (i > 0) - owner_->getMiniBuffer()->Set(_("Saved bookmark ") + tostr(i)); + if (i > 0) { + ostringstream str; + str << _("Saved bookmark") << ' ' << i; + owner_->message(str.str().c_str()); + } } @@ -1204,7 +1141,7 @@ void BufferView::Pimpl::restorePosition(unsigned int i) if (i >= saved_positions_num) return; - string fname = saved_positions[i].filename; + string const fname = saved_positions[i].filename; beforeChange(bv_->text); @@ -1215,15 +1152,19 @@ void BufferView::Pimpl::restorePosition(unsigned int i) if (b != 0 ) buffer(b); } - LyXParagraph * par = bv_->text->GetParFromID(saved_positions[i].par_id); + Paragraph * par = bv_->text->getParFromID(saved_positions[i].par_id); if (!par) return; - bv_->text->SetCursor(bv_, par, - min(par->Last(), saved_positions[i].par_pos)); + bv_->text->setCursor(bv_, par, + min(par->size(), saved_positions[i].par_pos)); + update(bv_->text, BufferView::SELECT|BufferView::FITCUR); - if (i > 0) - owner_->getMiniBuffer()->Set(_("Moved to bookmark ") + tostr(i)); + if (i > 0) { + ostringstream str; + str << _("Moved to bookmark") << ' ' << i; + owner_->message(str.str().c_str()); + } } @@ -1242,12 +1183,16 @@ void BufferView::Pimpl::setState() return; LyXText * text = bv_->getLyXText(); - if (text->real_current_font.isRightToLeft() && - text->real_current_font.latex() != LyXFont::ON) { - if (owner_->getIntl()->primarykeymap) + if (text->real_current_font.isRightToLeft() +#ifndef NO_LATEX + && + text->real_current_font.latex() != LyXFont::ON +#endif + ) { + if (owner_->getIntl()->keymap == Intl::PRIMARY) owner_->getIntl()->KeyMapSec(); } else { - if (!owner_->getIntl()->primarykeymap) + if (owner_->getIntl()->keymap == Intl::SECONDARY) owner_->getIntl()->KeyMapPrim(); } } @@ -1255,19 +1200,19 @@ void BufferView::Pimpl::setState() void BufferView::Pimpl::insetSleep() { - if (bv_->theLockingInset() && !bv_->inset_slept) { - bv_->theLockingInset()->GetCursorPos(bv_, bv_->slx, bv_->sly); - bv_->theLockingInset()->InsetUnlock(bv_); - bv_->inset_slept = true; + if (bv_->theLockingInset() && !inset_slept) { + bv_->theLockingInset()->getCursorPos(bv_, bv_->slx, bv_->sly); + bv_->theLockingInset()->insetUnlock(bv_); + inset_slept = true; } } void BufferView::Pimpl::insetWakeup() { - if (bv_->theLockingInset() && bv_->inset_slept) { - bv_->theLockingInset()->Edit(bv_, bv_->slx, bv_->sly, 0); - bv_->inset_slept = false; + if (bv_->theLockingInset() && inset_slept) { + bv_->theLockingInset()->edit(bv_, bv_->slx, bv_->sly, 0); + inset_slept = false; } } @@ -1275,63 +1220,63 @@ void BufferView::Pimpl::insetWakeup() void BufferView::Pimpl::insetUnlock() { if (bv_->theLockingInset()) { - if (!bv_->inset_slept) - bv_->theLockingInset()->InsetUnlock(bv_); + if (!inset_slept) + bv_->theLockingInset()->insetUnlock(bv_); bv_->theLockingInset(0); - bv_->text->FinishUndo(); - bv_->inset_slept = false; + bv_->text->finishUndo(); + inset_slept = false; } } bool BufferView::Pimpl::focus() const { - return workarea_->hasFocus(); + return workarea_.hasFocus(); } void BufferView::Pimpl::focus(bool f) { - if (f) workarea_->setFocus(); + if (f) workarea_.setFocus(); } bool BufferView::Pimpl::active() const { - return workarea_->active(); + return workarea_.active(); } bool BufferView::Pimpl::belowMouse() const { - return workarea_->belowMouse(); + return workarea_.belowMouse(); } void BufferView::Pimpl::showCursor() { - if (screen_) + if (screen_.get()) screen_->ShowCursor(bv_->text, bv_); } void BufferView::Pimpl::hideCursor() { - if (screen_) + if (screen_.get()) screen_->HideCursor(); } void BufferView::Pimpl::toggleSelection(bool b) { - if (screen_) + if (screen_.get()) screen_->ToggleSelection(bv_->text, bv_, b); } void BufferView::Pimpl::toggleToggle() { - if (screen_) + if (screen_.get()) screen_->ToggleToggle(bv_->text, bv_); } @@ -1339,8 +1284,8 @@ void BufferView::Pimpl::toggleToggle() void BufferView::Pimpl::center() { beforeChange(bv_->text); - if (bv_->text->cursor.y() > static_cast((workarea_->height() / 2))) { - screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_->height() / 2); + if (bv_->text->cursor.y() > static_cast((workarea_.height() / 2))) { + screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_.height() / 2); } else { screen_->Draw(bv_->text, bv_, 0); } @@ -1356,14 +1301,14 @@ void BufferView::Pimpl::pasteClipboard(bool asPara) screen_->HideCursor(); beforeChange(bv_->text); - string const clip(workarea_->getClipboard()); + string const clip(workarea_.getClipboard()); if (clip.empty()) return; if (asPara) { - bv_->text->InsertStringB(bv_, clip); + bv_->text->insertStringAsParagraphs(bv_, clip); } else { - bv_->text->InsertStringA(bv_, clip); + bv_->text->insertStringAsLines(bv_, clip); } update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } @@ -1371,7 +1316,7 @@ void BufferView::Pimpl::pasteClipboard(bool asPara) void BufferView::Pimpl::stuffClipboard(string const & stuff) const { - workarea_->putClipboard(stuff); + workarea_.putClipboard(stuff); } @@ -1379,35 +1324,36 @@ void BufferView::Pimpl::stuffClipboard(string const & stuff) const * Dispatch functions for actions which can be valid for BufferView->text * and/or InsetText->text!!! */ -static LyXText * TEXT(BufferView * bv) { return bv->getLyXText(); } + inline void BufferView::Pimpl::moveCursorUpdate(bool selecting) { - if (selecting || TEXT(bv_)->mark_set) { - TEXT(bv_)->SetSelection(bv_); - if (TEXT(bv_)->bv_owner) - bv_->toggleToggle(); + LyXText * lt = bv_->getLyXText(); + + if (selecting || lt->selection.mark()) { + lt->setSelection(bv_); + if (lt->bv_owner) + toggleToggle(); } - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); + update(lt, BufferView::SELECT|BufferView::FITCUR); showCursor(); /* ---> Everytime the cursor is moved, show the current font state. */ // should this too me moved out of this func? //owner->showState(); - bv_->setState(); + setState(); } Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code) { - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = bv_->getLyXText()->cursor; Buffer::inset_iterator it = find_if(Buffer::inset_iterator( cursor.par(), cursor.pos()), buffer_->inset_iterator_end(), - compare_memfun(&Inset::LyxCode, code) - ); + lyx::compare_memfun(&Inset::lyxCode, code)); return it != buffer_->inset_iterator_end() ? (*it) : 0; } @@ -1419,7 +1365,6 @@ void BufferView::Pimpl::MenuInsertLyXFile(string const & filen) if (filename.empty()) { // Launch a file browser string initpath = lyxrc.document_path; - LyXFileDlg fileDlg; if (available()) { string const trypath = owner_->buffer()->filepath; @@ -1428,72 +1373,81 @@ void BufferView::Pimpl::MenuInsertLyXFile(string const & filen) initpath = trypath; } - // launches dialog - ProhibitInput(bv_); - fileDlg.SetButton(0, _("Documents"), lyxrc.document_path); - fileDlg.SetButton(1, _("Examples"), - AddPath(system_lyxdir, "examples")); - filename = fileDlg.Select(_("Select Document to Insert"), - initpath, "*.lyx"); - AllowInput(bv_); + FileDialog fileDlg(bv_->owner(), + _("Select LyX document to insert"), + LFUN_FILE_INSERT, + make_pair(string(_("Documents")), + string(lyxrc.document_path)), + make_pair(string(_("Examples")), + string(AddPath(system_lyxdir, "examples")))); + + FileDialog::Result result = + fileDlg.Select(initpath, + _("*.lyx| LyX Documents (*.lyx)")); + + if (result.first == FileDialog::Later) + return; + + filename = result.second; // check selected filename if (filename.empty()) { - owner_->getMiniBuffer()->Set(_("Canceled.")); + owner_->message(_("Canceled.")); return; } - } + } - // get absolute path of file and make sure the filename ends - // with .lyx - filename = MakeAbsPath(filename); - if (!IsLyXFilename(filename)) - filename += ".lyx"; + // get absolute path of file and add ".lyx" to the filename if + // necessary + filename = FileSearch(string(), filename, "lyx"); - // Inserts document - owner_->getMiniBuffer()->Set(_("Inserting document"), - MakeDisplayPath(filename), "..."); + string const disp_fn(MakeDisplayPath(filename)); + + ostringstream s1; + s1 << _("Inserting document") << ' ' + << disp_fn << " ..."; + owner_->message(s1.str().c_str()); bool const res = bv_->insertLyXFile(filename); if (res) { - owner_->getMiniBuffer()->Set(_("Document"), - MakeDisplayPath(filename), - _("inserted.")); + ostringstream str; + str << _("Document") << ' ' << disp_fn + << ' ' << _("inserted."); + owner_->message(str.str().c_str()); } else { - owner_->getMiniBuffer()->Set(_("Could not insert document"), - MakeDisplayPath(filename)); + ostringstream str; + str << _("Could not insert document") << ' ' + << disp_fn; + owner_->message(str.str().c_str()); } } bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { + lyxerr[Debug::ACTION] << "BufferView::Pimpl::Dispatch: action[" + << action <<"] arg[" << argument << "]" << endl; + switch (action) { // --- Misc ------------------------------------------- case LFUN_APPENDIX: + { if (available()) { - TEXT(bv_)->toggleAppendix(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + LyXText * lt = bv_->getLyXText(); + lt->toggleAppendix(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } - break; + } + break; case LFUN_TOC_INSERT: - case LFUN_LOA_INSERT: - case LFUN_LOF_INSERT: - case LFUN_LOT_INSERT: { InsetCommandParams p; - - if (action == LFUN_TOC_INSERT ) - p.setCmdName( "tableofcontents" ); - else if (action == LFUN_LOA_INSERT ) - p.setCmdName( "listofalgorithms" ); - else if (action == LFUN_LOF_INSERT ) - p.setCmdName( "listoffigures" ); - else - p.setCmdName( "listoftables" ); - - Inset * inset = new InsetTOC( p ); - if (!bv_->insertInset( inset, "Standard", true ) ) + p.setCmdName("tableofcontents"); + Inset * inset = new InsetTOC(p); + if (!insertInset(inset, "Standard")) delete inset; break; } @@ -1508,12 +1462,12 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_GRAPHICS: { Inset * new_inset = new InsetGraphics; - if (!bv_->insertInset(new_inset)) { + if (!insertInset(new_inset)) { delete new_inset; } else { // this is need because you don't use a inset->Edit() - bv_->updateInset(new_inset, true); - new_inset->Edit(bv_, 0, 0, 0); + updateInset(new_inset, true); + new_inset->edit(bv_, 0, 0, 0); } break; } @@ -1549,11 +1503,11 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) break; case LFUN_GOTOERROR: - bv_->gotoInset(Inset::ERROR_CODE, false); + gotoInset(Inset::ERROR_CODE, false); break; case LFUN_GOTONOTE: - bv_->gotoInset(Inset::IGNORE_CODE, false); + gotoInset(Inset::IGNORE_CODE, false); break; case LFUN_REFERENCE_GOTO: @@ -1561,69 +1515,72 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) vector tmp; tmp.push_back(Inset::LABEL_CODE); tmp.push_back(Inset::REF_CODE); - bv_->gotoInset(tmp, true); + gotoInset(tmp, true); break; } case LFUN_HYPHENATION: - bv_->hyphenationPoint(); + hyphenationPoint(); break; case LFUN_LDOTS: - bv_->ldots(); + ldots(); break; case LFUN_END_OF_SENTENCE: - bv_->endOfSentenceDot(); + endOfSentenceDot(); break; case LFUN_MENU_SEPARATOR: - bv_->menuSeparator(); + menuSeparator(); break; case LFUN_HFILL: - bv_->hfill(); + hfill(); break; case LFUN_DEPTH: - changeDepth(bv_, TEXT(bv_), 0); + changeDepth(bv_, bv_->getLyXText(), 0); break; case LFUN_DEPTH_MIN: - changeDepth(bv_, TEXT(bv_), -1); + changeDepth(bv_, bv_->getLyXText(), -1); break; case LFUN_DEPTH_PLUS: - changeDepth(bv_, TEXT(bv_), 1); + changeDepth(bv_, bv_->getLyXText(), 1); break; case LFUN_FREE: owner_->getDialogs()->setUserFreeFont(); break; - + +#ifndef NO_LATEX case LFUN_TEX: Tex(bv_); setState(); owner_->showState(); break; - +#endif + case LFUN_FILE_INSERT: { MenuInsertLyXFile(argument); } break; + case LFUN_FILE_INSERT_ASCII_PARA: + InsertAsciiFile(bv_, argument, true); + break; + case LFUN_FILE_INSERT_ASCII: - { - bool asPara = (argument == "paragraph"); - InsertAsciiFile(bv_, string(), asPara); - } - break; + InsertAsciiFile(bv_, argument, false); + break; case LFUN_LAYOUT: { - lyxerr.debug() << "LFUN_LAYOUT: (arg) " - << argument << endl; + lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) " + << argument << endl; // Derive layout number from given argument (string) // and current buffer's textclass (number). */ @@ -1650,14 +1607,18 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } if (current_layout != layout.second) { + LyXText * lt = bv_->getLyXText(); hideCursor(); current_layout = layout.second; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->SetLayout(bv_, layout.second); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->setLayout(bv_, layout.second); owner_->setLayout(layout.second); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); setState(); } } @@ -1719,30 +1680,68 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) break; case LFUN_UPCASE_WORD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_uppercase); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->changeCase(bv_, LyXText::text_uppercase); + if (lt->inset_owner) + updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; case LFUN_LOWCASE_WORD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_lowercase); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->changeCase(bv_, LyXText::text_lowercase); + if (lt->inset_owner) + updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; case LFUN_CAPITALIZE_WORD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->ChangeWordCase(bv_, - LyXText::text_capitalization); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->changeCase(bv_, LyXText::text_capitalization); + if (lt->inset_owner) + updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; + + case LFUN_TRANSPOSE_CHARS: + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->transposeChars(*bv_); + if (lt->inset_owner) + updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; + + case LFUN_INSERT_LABEL: MenuInsertLabel(bv_, argument); break; @@ -1756,10 +1755,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) p.setFromString(argument); InsetRef * inset = new InsetRef(p, *buffer_); - if (!bv_->insertInset(inset)) + if (!insertInset(inset)) delete inset; else - bv_->updateInset(inset, true); + updateInset(inset, true); } break; @@ -1796,33 +1795,35 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) // --- Cursor Movements ----------------------------- case LFUN_RIGHT: { - bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params); - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); + LyXText * lt = bv_->getLyXText(); + + bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params); + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); if (is_rtl) - TEXT(bv_)->CursorLeft(bv_, false); - if (TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last() - && TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) - == LyXParagraph::META_INSET - && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) - && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){ - Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()); - owner_->getLyXFunc()->setMessage(tmpinset->EditMessage()); + lt->cursorLeft(bv_, false); + if (lt->cursor.pos() < lt->cursor.par()->size() + && lt->cursor.par()->getChar(lt->cursor.pos()) + == Paragraph::META_INSET + && lt->cursor.par()->getInset(lt->cursor.pos()) + && lt->cursor.par()->getInset(lt->cursor.pos())->editable() == Inset::HIGHLY_EDITABLE){ + Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos()); + owner_->getLyXFunc()->setMessage(tmpinset->editMessage()); int y = 0; if (is_rtl) { - LyXFont font = - TEXT(bv_)->GetFont(buffer_, - TEXT(bv_)->cursor.par(), - TEXT(bv_)->cursor.pos()); + LyXFont const font = + lt->getFont(buffer_, + lt->cursor.par(), + lt->cursor.pos()); y = tmpinset->descent(bv_,font); } - tmpinset->Edit(bv_, 0, y, 0); + tmpinset->edit(bv_, 0, y, 0); break; } if (!is_rtl) - TEXT(bv_)->CursorRight(bv_, false); - TEXT(bv_)->FinishUndo(); + lt->cursorRight(bv_, false); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1832,367 +1833,498 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { // This is soooo ugly. Isn`t it possible to make // it simpler? (Lgb) - bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params); - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - LyXCursor cur = TEXT(bv_)->cursor; + LyXText * lt = bv_->getLyXText(); + bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params); + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + LyXCursor const cur = lt->cursor; if (!is_rtl) - TEXT(bv_)->CursorLeft(bv_, false); - if ((is_rtl || cur != TEXT(bv_)->cursor) && // only if really moved! - TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last() && - (TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) == - LyXParagraph::META_INSET) && - TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) && - (TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable() + lt->cursorLeft(bv_, false); + if ((is_rtl || cur != lt->cursor) && // only if really moved! + lt->cursor.pos() < lt->cursor.par()->size() && + (lt->cursor.par()->getChar(lt->cursor.pos()) == + Paragraph::META_INSET) && + lt->cursor.par()->getInset(lt->cursor.pos()) && + (lt->cursor.par()->getInset(lt->cursor.pos())->editable() == Inset::HIGHLY_EDITABLE)) { - Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()); - owner_->getLyXFunc()->setMessage(tmpinset->EditMessage()); - LyXFont font = TEXT(bv_)->GetFont(buffer_, - TEXT(bv_)->cursor.par(), - TEXT(bv_)->cursor.pos()); + Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos()); + owner_->getLyXFunc()->setMessage(tmpinset->editMessage()); + LyXFont const font = lt->getFont(buffer_, + lt->cursor.par(), + lt->cursor.pos()); int y = is_rtl ? 0 : tmpinset->descent(bv_,font); - tmpinset->Edit(bv_, + tmpinset->edit(bv_, tmpinset->x() + tmpinset->width(bv_,font), y, 0); break; } if (is_rtl) - TEXT(bv_)->CursorRight(bv_, false); + lt->cursorRight(bv_, false); - TEXT(bv_)->FinishUndo(); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); } break; case LFUN_UP: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorUp(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->cursorUp(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_DOWN: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorDown(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->cursorDown(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_UP_PARAGRAPH: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorUpParagraph(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->cursorUpParagraph(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_DOWN_PARAGRAPH: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorDownParagraph(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->cursorDownParagraph(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_PRIOR: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - cursorPrevious(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::UPDATE); + cursorPrevious(lt); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_NEXT: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - cursorNext(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::UPDATE); + cursorNext(lt); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_HOME: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorHome(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->cursorHome(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_END: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorEnd(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorEnd(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_SHIFT_TAB: case LFUN_TAB: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorTab(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorTab(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_WORDRIGHT: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorLeftOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->cursorLeftOneWord(bv_); else - TEXT(bv_)->CursorRightOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorRightOneWord(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_WORDLEFT: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorRightOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->cursorRightOneWord(bv_); else - TEXT(bv_)->CursorLeftOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorLeftOneWord(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_BEGINNINGBUF: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorTop(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorTop(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_ENDBUF: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.mark()) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorBottom(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorBottom(bv_); + lt->finishUndo(); moveCursorUpdate(false); owner_->showState(); - break; - + } + break; /* cursor selection ---------------------------- */ case LFUN_RIGHTSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorLeft(bv_); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->cursorLeft(bv_); else - TEXT(bv_)->CursorRight(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorRight(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_LEFTSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorRight(bv_); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->cursorRight(bv_); else - TEXT(bv_)->CursorLeft(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorLeft(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_UPSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorUp(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorUp(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_DOWNSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorDown(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorDown(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_UP_PARAGRAPHSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorUpParagraph(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorUpParagraph(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_DOWN_PARAGRAPHSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorDownParagraph(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorDownParagraph(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_PRIORSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - cursorPrevious(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + cursorPrevious(lt); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_NEXTSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - cursorNext(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + cursorNext(lt); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_HOMESEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorHome(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->cursorHome(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_ENDSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorEnd(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->cursorEnd(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_WORDRIGHTSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorLeftOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->cursorLeftOneWord(bv_); else - TEXT(bv_)->CursorRightOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorRightOneWord(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_WORDLEFTSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorRightOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->cursorRightOneWord(bv_); else - TEXT(bv_)->CursorLeftOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorLeftOneWord(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_BEGINNINGBUFSEL: - if (TEXT(bv_)->inset_owner) + { + LyXText * lt = bv_->getLyXText(); + + if (lt->inset_owner) break; - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorTop(bv_); - TEXT(bv_)->FinishUndo(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->cursorTop(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_ENDBUFSEL: - if (TEXT(bv_)->inset_owner) + { + LyXText * lt = bv_->getLyXText(); + + if (lt->inset_owner) break; - update(TEXT(bv_), + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorBottom(bv_); - TEXT(bv_)->FinishUndo(); + lt->cursorBottom(bv_); + lt->finishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; // --- text changing commands ------------------------ case LFUN_BREAKLINE: - beforeChange(TEXT(bv_)); - TEXT(bv_)->InsertChar(bv_, LyXParagraph::META_NEWLINE); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + { + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->insertChar(bv_, Paragraph::META_NEWLINE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); moveCursorUpdate(false); - break; + } + break; case LFUN_PROTECTEDSPACE: { - LyXLayout const & style = - textclasslist.Style(buffer_->params.textclass, - TEXT(bv_)->cursor.par()->GetLayout()); + LyXText * lt = bv_->getLyXText(); + + LyXLayout const & style = textclasslist + .Style(buffer_->params.textclass, + lt->cursor.par()->getLayout()); if (style.free_spacing) { - TEXT(bv_)->InsertChar(bv_, ' '); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->insertChar(bv_, ' '); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } else { - bv_->protectedBlank(TEXT(bv_)); + protectedBlank(lt); } moveCursorUpdate(false); } break; case LFUN_SETMARK: - if (TEXT(bv_)->mark_set) { - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); + { + LyXText * lt = bv_->getLyXText(); + + if (lt->selection.mark()) { + beforeChange(lt); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); owner_->getLyXFunc()->setMessage(N_("Mark removed")); } else { - beforeChange(TEXT(bv_)); - TEXT(bv_)->mark_set = 1; - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); + beforeChange(lt); + lt->selection.mark(true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); owner_->getLyXFunc()->setMessage(N_("Mark set")); } - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; - break; + lt->selection.cursor = lt->cursor; + } + break; case LFUN_DELETE: - if (!TEXT(bv_)->selection) { - TEXT(bv_)->Delete(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.set()) { + lt->Delete(bv_); + lt->selection.cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); // It is possible to make it a lot faster still // just comment out the line below... showCursor(); @@ -2202,48 +2334,55 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) moveCursorUpdate(false); owner_->showState(); setState(); - break; + } + break; case LFUN_DELETE_SKIP: { + LyXText * lt = bv_->getLyXText(); + // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = lt->cursor; - if (!TEXT(bv_)->selection) { - if (cursor.pos() == cursor.par()->Last()) { - TEXT(bv_)->CursorRight(bv_); - cursor = TEXT(bv_)->cursor; + if (!lt->selection.set()) { + if (cursor.pos() == cursor.par()->size()) { + lt->cursorRight(bv_); + cursor = lt->cursor; if (cursor.pos() == 0 - && !(cursor.par()->added_space_top + && !(cursor.par()->params().spaceTop() == VSpace (VSpace::NONE))) { - TEXT(bv_)->SetParagraph + lt->setParagraph (bv_, - cursor.par()->line_top, - cursor.par()->line_bottom, - cursor.par()->pagebreak_top, - cursor.par()->pagebreak_bottom, + cursor.par()->params().lineTop(), + cursor.par()->params().lineBottom(), + cursor.par()->params().pagebreakTop(), + cursor.par()->params().pagebreakBottom(), VSpace(VSpace::NONE), - cursor.par()->added_space_bottom, - cursor.par()->align, - cursor.par()->labelwidthstring, 0); - TEXT(bv_)->CursorLeft(bv_); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + cursor.par()->params().spaceBottom(), + cursor.par()->params().align(), + cursor.par()->params().labelWidthString(), 0); + lt->cursorLeft(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } else { - TEXT(bv_)->CursorLeft(bv_); - TEXT(bv_)->Delete(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->cursorLeft(bv_); + lt->Delete(bv_); + lt->selection.cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } else { - TEXT(bv_)->Delete(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->Delete(bv_); + lt->selection.cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } else { bv_->cut(); @@ -2253,56 +2392,81 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) /* -------> Delete word forward. */ case LFUN_DELETE_WORD_FORWARD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->DeleteWordForward(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + bv_->getLyXText()->deleteWordForward(bv_); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); moveCursorUpdate(false); owner_->showState(); break; /* -------> Delete word backward. */ case LFUN_DELETE_WORD_BACKWARD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->DeleteWordBackward(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->deleteWordBackward(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); moveCursorUpdate(false); owner_->showState(); - break; + } + break; /* -------> Kill to end of line. */ case LFUN_DELETE_LINE_FORWARD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->DeleteLineForward(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->deleteLineForward(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); moveCursorUpdate(false); - break; + } + break; /* -------> Set mark off. */ case LFUN_MARK_OFF: - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + { + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->selection.cursor = lt->cursor; owner_->getLyXFunc()->setMessage(N_("Mark off")); - break; + } + break; /* -------> Set mark on. */ case LFUN_MARK_ON: - beforeChange(TEXT(bv_)); - TEXT(bv_)->mark_set = 1; - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + { + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->selection.mark(true); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->selection.cursor = lt->cursor; owner_->getLyXFunc()->setMessage(N_("Mark on")); - break; + } + break; case LFUN_BACKSPACE: { - if (!TEXT(bv_)->selection) { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection.set()) { if (owner_->getIntl()->getTrans().backspace()) { - TEXT(bv_)->Backspace(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->backspace(bv_); + lt->selection.cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); // It is possible to make it a lot faster still // just comment out the line below... showCursor(); @@ -2318,30 +2482,34 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_BACKSPACE_SKIP: { // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. + LyXText * lt = bv_->getLyXText(); - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = lt->cursor; - if (!TEXT(bv_)->selection) { + if (!lt->selection.set()) { if (cursor.pos() == 0 - && !(cursor.par()->added_space_top + && !(cursor.par()->params().spaceTop() == VSpace (VSpace::NONE))) { - TEXT(bv_)->SetParagraph + lt->setParagraph (bv_, - cursor.par()->line_top, - cursor.par()->line_bottom, - cursor.par()->pagebreak_top, - cursor.par()->pagebreak_bottom, - VSpace(VSpace::NONE), cursor.par()->added_space_bottom, - cursor.par()->align, - cursor.par()->labelwidthstring, 0); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + cursor.par()->params().lineTop(), + cursor.par()->params().lineBottom(), + cursor.par()->params().pagebreakTop(), + cursor.par()->params().pagebreakBottom(), + VSpace(VSpace::NONE), cursor.par()->params().spaceBottom(), + cursor.par()->params().align(), + cursor.par()->params().labelWidthString(), 0); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } else { - TEXT(bv_)->Backspace(bv_); - TEXT(bv_)->sel_cursor - = cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->backspace(bv_); + lt->selection.cursor = cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } else bv_->cut(); @@ -2350,11 +2518,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_BREAKPARAGRAPH: { - beforeChange(TEXT(bv_)); - TEXT(bv_)->BreakParagraph(bv_, 0); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->breakParagraph(bv_, 0); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + lt->selection.cursor = lt->cursor; setState(); owner_->showState(); break; @@ -2362,11 +2534,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_BREAKPARAGRAPHKEEPLAYOUT: { - beforeChange(TEXT(bv_)); - TEXT(bv_)->BreakParagraph(bv_, 1); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->breakParagraph(bv_, 1); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + lt->selection.cursor = lt->cursor; setState(); owner_->showState(); break; @@ -2377,32 +2553,35 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) // When at the beginning of a paragraph, remove // indentation and add a "defskip" at the top. // Otherwise, do the same as LFUN_BREAKPARAGRAPH. + LyXText * lt = bv_->getLyXText(); - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = lt->cursor; - beforeChange(TEXT(bv_)); + beforeChange(lt); if (cursor.pos() == 0) { - if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) { - TEXT(bv_)->SetParagraph + if (cursor.par()->params().spaceTop() == VSpace(VSpace::NONE)) { + lt->setParagraph (bv_, - cursor.par()->line_top, - cursor.par()->line_bottom, - cursor.par()->pagebreak_top, - cursor.par()->pagebreak_bottom, - VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom, - cursor.par()->align, - cursor.par()->labelwidthstring, 1); + cursor.par()->params().lineTop(), + cursor.par()->params().lineBottom(), + cursor.par()->params().pagebreakTop(), + cursor.par()->params().pagebreakBottom(), + VSpace(VSpace::DEFSKIP), cursor.par()->params().spaceBottom(), + cursor.par()->params().align(), + cursor.par()->params().labelWidthString(), 1); //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } } else { - TEXT(bv_)->BreakParagraph(bv_, 0); + lt->breakParagraph(bv_, 0); //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(bv_)->sel_cursor = cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + lt->selection.cursor = cursor; setState(); owner_->showState(); } @@ -2410,11 +2589,13 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_PARAGRAPH_SPACING: { - LyXParagraph * par = TEXT(bv_)->cursor.par(); - Spacing::Space cur_spacing = par->spacing.getSpace(); + LyXText * lt = bv_->getLyXText(); + + Paragraph * par = lt->cursor.par(); + Spacing::Space cur_spacing = par->params().spacing().getSpace(); float cur_value = 1.0; if (cur_spacing == Spacing::Other) { - cur_value = par->spacing.getValue(); + cur_value = par->params().spacing().getValue(); } istringstream istr(argument.c_str()); @@ -2446,19 +2627,18 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) << argument << endl; } if (cur_spacing != new_spacing || cur_value != new_value) { - par->spacing.set(new_spacing, new_value); - TEXT(bv_)->RedoParagraph(bv_); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + par->params().spacing(Spacing(new_spacing, new_value)); + lt->redoParagraph(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } break; case LFUN_QUOTE: - beforeChange(TEXT(bv_)); - TEXT(bv_)->InsertChar(bv_, '\"'); // This " matches the single quote in the code - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - moveCursorUpdate(false); + bv_->insertCorrectQuote(); break; case LFUN_HTMLURL: @@ -2472,25 +2652,25 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) owner_->getDialogs()->createUrl( p.getAsString() ); } break; - + case LFUN_INSERT_URL: { InsetCommandParams p; p.setFromString( argument ); InsetUrl * inset = new InsetUrl( p ); - if (!bv_->insertInset(inset)) + if (!insertInset(inset)) delete inset; else - bv_->updateInset( inset, true ); + updateInset( inset, true ); } break; - + case LFUN_INSET_TEXT: { InsetText * new_inset = new InsetText; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2499,8 +2679,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_ERT: { InsetERT * new_inset = new InsetERT; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2509,8 +2689,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_EXTERNAL: { InsetExternal * new_inset = new InsetExternal; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2519,8 +2699,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_FOOTNOTE: { InsetFoot * new_inset = new InsetFoot; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2529,8 +2709,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_MARGINAL: { InsetMarginal * new_inset = new InsetMarginal; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2539,8 +2719,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_MINIPAGE: { InsetMinipage * new_inset = new InsetMinipage; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2551,8 +2731,26 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) // check if the float type exist if (floatList.typeExist(argument)) { InsetFloat * new_inset = new InsetFloat(argument); - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); + else + delete new_inset; + } else { + lyxerr << "Non-existant float type: " + << argument << endl; + } + + } + break; + + case LFUN_INSET_WIDE_FLOAT: + { + // check if the float type exist + if (floatList.typeExist(argument)) { + InsetFloat * new_inset = new InsetFloat(argument); + new_inset->wide(true); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } else { @@ -2566,8 +2764,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_LIST: { InsetList * new_inset = new InsetList; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2576,8 +2774,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_THEOREM: { InsetTheorem * new_inset = new InsetTheorem; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2588,14 +2786,14 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) // Do we have a locking inset... if (bv_->theLockingInset()) { lyxerr << "Locking inset code: " - << static_cast(bv_->theLockingInset()->LyxCode()); + << static_cast(bv_->theLockingInset()->lyxCode()); InsetCaption * new_inset = new InsetCaption; new_inset->setOwner(bv_->theLockingInset()); - new_inset->SetAutoBreakRows(true); - new_inset->SetDrawFrame(0, InsetText::LOCKED); - new_inset->SetFrameColor(0, LColor::footnoteframe); - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + new_inset->setAutoBreakRows(true); + new_inset->setDrawFrame(0, InsetText::LOCKED); + new_inset->setFrameColor(0, LColor::captionframe); + if (insertInset(new_inset)) + new_inset->edit(bv_, 0, 0, 0); else delete new_inset; } @@ -2604,14 +2802,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSET_TABULAR: { - int r = 2, c = 2; + int r = 2; + int c = 2; if (!argument.empty()) ::sscanf(argument.c_str(),"%d%d", &r, &c); InsetTabular * new_inset = new InsetTabular(*buffer_, r, c); - bool rtl = - TEXT(bv_)->real_current_font.isRightToLeft(); - if (!bv_->open_new_inset(new_inset, rtl)) + bool const rtl = + bv_->getLyXText()->real_current_font.isRightToLeft(); + if (!open_new_inset(new_inset, rtl)) delete new_inset; } break; @@ -2620,37 +2819,40 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_CHARATCURSOR: { - LyXParagraph::size_type pos = TEXT(bv_)->cursor.pos(); - if (pos < TEXT(bv_)->cursor.par()->size()) + Paragraph::size_type pos = bv_->getLyXText()->cursor.pos(); + if (pos < bv_->getLyXText()->cursor.par()->size()) owner_->getLyXFunc()->setMessage( - tostr(TEXT(bv_)->cursor.par()->GetChar(pos))); + tostr(bv_->getLyXText()->cursor.par()->getChar(pos))); else owner_->getLyXFunc()->setMessage("EOF"); } break; case LFUN_GETXY: - owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.x()) + owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.x()) + ' ' - + tostr(TEXT(bv_)->cursor.y())); + + tostr(bv_->getLyXText()->cursor.y())); break; case LFUN_SETXY: { - int x; - int y; - ::sscanf(argument.c_str(), " %d %d", &x, &y); - TEXT(bv_)->SetCursorFromCoordinates(bv_, x, y); + int x = 0; + int y = 0; + if (::sscanf(argument.c_str(), " %d %d", &x, &y) != 2) { + lyxerr << "SETXY: Could not parse coordinates in '" + << argument << std::endl; + } + bv_->getLyXText()->setCursorFromCoordinates(bv_, x, y); } break; case LFUN_GETLAYOUT: - owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.par()->layout)); + owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.par()->layout)); break; case LFUN_GETFONT: { - LyXFont & font = TEXT(bv_)->current_font; + LyXFont & font = bv_->getLyXText()->current_font; if (font.shape() == LyXFont::ITALIC_SHAPE) owner_->getLyXFunc()->setMessage("E"); else if (font.shape() == LyXFont::SMALLCAPS_SHAPE) @@ -2663,10 +2865,12 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_GETLATEX: { - LyXFont & font = TEXT(bv_)->current_font; +#ifndef NO_LATEX + LyXFont & font = bv_->getLyXText()->current_font; if (font.latex() == LyXFont::ON) owner_->getLyXFunc()->setMessage("L"); else +#endif owner_->getLyXFunc()->setMessage("0"); } break; @@ -2690,7 +2894,18 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_HUNG_UMLAUT: case LFUN_CIRCLE: case LFUN_OGONEK: - owner_->getLyXFunc()->handleKeyFunc(action); + if (argument.empty()) { + // As always... + owner_->getLyXFunc()->handleKeyFunc(action); + } else { + owner_->getLyXFunc()->handleKeyFunc(action); + owner_->getIntl()->getTrans() + .TranslateAndInsert(argument[0], bv_->getLyXText()); + update(bv_->getLyXText(), + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } break; // --- insert characters ---------------------------------------- @@ -2699,10 +2914,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSERT_MATRIX: { if (available()) { - if (bv_->open_new_inset(new InsetFormula(false))) - { + if (open_new_inset(new InsetFormula, false)) { bv_->theLockingInset() - ->LocalDispatch(bv_, action, argument); + ->localDispatch(bv_, action, argument); } } } @@ -2710,14 +2924,19 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INSERT_MATH: { - math_insert_symbol(bv_, argument); + if (!available()) + break; + + InsetFormula * f = new InsetFormula(LM_OT_EQUATION); + open_new_inset(f); + f->localDispatch(bv_, LFUN_INSERT_MATH, argument); } break; case LFUN_MATH_DISPLAY: - { + { if (available()) - bv_->open_new_inset(new InsetFormula(true)); + open_new_inset(new InsetFormula(LM_OT_EQUATION), false); break; } @@ -2730,7 +2949,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) else { string const s1 = token(s, ' ', 1); int const na = s1.empty() ? 0 : lyx::atoi(s1); - bv_->open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na)); + open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na), false); } } } @@ -2739,7 +2958,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_MATH_MODE: // Open or create a math inset { if (available()) - bv_->open_new_inset(new InsetFormula); + open_new_inset(new InsetFormula, false); owner_->getLyXFunc()->setMessage(N_("Math editor mode")); } break; @@ -2750,10 +2969,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) p.setFromString( argument ); InsetCitation * inset = new InsetCitation( p ); - if (!bv_->insertInset(inset)) + if (!insertInset(inset)) delete inset; else - bv_->updateInset( inset, true ); + updateInset( inset, true ); } break; @@ -2770,9 +2989,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) InsetCommandParams p( "BibTeX", db, bibstyle ); InsetBibtex * inset = new InsetBibtex(p); - if (bv_->insertInset(inset)) { + if (insertInset(inset)) { if (argument.empty()) - inset->Edit(bv_, 0, 0, 0); + inset->edit(bv_, 0, 0, 0); } else delete inset; } @@ -2815,13 +3034,13 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (argument.empty()) { // Get the word immediately preceding the cursor - LyXParagraph::size_type curpos = - TEXT(bv_)->cursor.pos() - 1; + Paragraph::size_type curpos = + bv_->getLyXText()->cursor.pos() - 1; string curstring; if (curpos >= 0 ) - curstring = TEXT(bv_) - ->cursor.par()->GetWord(curpos); + curstring = bv_->getLyXText() + ->cursor.par()->getWord(curpos); p.setContents( curstring ); } else { @@ -2838,31 +3057,31 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) p.setFromString(argument); InsetIndex * inset = new InsetIndex(p); - if (!bv_->insertInset(inset)) + if (!insertInset(inset)) delete inset; else - bv_->updateInset(inset, true); + updateInset(inset, true); } break; case LFUN_INDEX_INSERT_LAST: { // Get word immediately preceding the cursor - LyXParagraph::size_type curpos = - TEXT(bv_)->cursor.pos() - 1; + Paragraph::size_type curpos = + bv_->getLyXText()->cursor.pos() - 1; // Can't do that at the beginning of a paragraph if (curpos < 0) break; - string const curstring(TEXT(bv_) - ->cursor.par()->GetWord(curpos)); + string const curstring(bv_->getLyXText() + ->cursor.par()->getWord(curpos)); InsetCommandParams p("index", curstring); InsetIndex * inset = new InsetIndex(p); - if (!bv_->insertInset(inset)) + if (!insertInset(inset)) delete inset; else - bv_->updateInset(inset, true); + updateInset(inset, true); } break; @@ -2870,7 +3089,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { InsetCommandParams p("printindex"); Inset * inset = new InsetPrintIndex(p); - if (!bv_->insertInset(inset, "Standard", true)) + if (!insertInset(inset, "Standard")) delete inset; } break; @@ -2880,54 +3099,96 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) lyxerr << "arg " << argument << endl; InsetCommandParams p( "lyxparent", argument ); Inset * inset = new InsetParent(p, *buffer_); - if (!bv_->insertInset(inset, "Standard", true)) + if (!insertInset(inset, "Standard")) delete inset; } + break; case LFUN_CHILD_INSERT: { - InsetCommandParams p; - p.setFromString(argument); + InsetInclude::Params p; + p.cparams.setFromString(argument); + p.masterFilename_ = buffer_->fileName(); - InsetInclude * inset = new InsetInclude(p, *buffer_); - if (!bv_->insertInset(inset)) + InsetInclude * inset = new InsetInclude(p); + if (!insertInset(inset)) delete inset; - else - bv_->updateInset(inset, true); + else { + updateInset(inset, true); + bv_->owner()->getDialogs()->showInclude(inset); + } } break; + case LFUN_FLOAT_LIST: + { + // We should check the argument for validity. (Lgb) + Inset * inset = new InsetFloatList(argument); + if (!insertInset(inset, "Standard")) + delete inset; + } + break; + case LFUN_INSERT_NOTE: - bv_->insertNote(); + insertNote(); break; case LFUN_SELFINSERT: { - LyXFont const old_font(TEXT(bv_)->real_current_font); - for (string::size_type i = 0; i < argument.length(); ++i) { - TEXT(bv_)->InsertChar(bv_, argument[i]); - // This needs to be in the loop, or else we - // won't break lines correctly. (Asger) - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + if (argument.empty()) break; + + /* Automatically delete the currently selected + * text and replace it with what is being + * typed in now. Depends on lyxrc settings + * "auto_region_delete", which defaults to + * true (on). */ + + LyXText * lt = bv_->getLyXText(); + + if (lyxrc.auto_region_delete) { + if (lt->selection.set()) { + lt->cutSelection(bv_, false); + bv_->update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + } + + bv_->beforeChange(lt); + LyXFont const old_font(lt->real_current_font); + + string::const_iterator cit = argument.begin(); + string::const_iterator end = argument.end(); + for (; cit != end; ++cit) { + if (greek_kb_flag) { + if (!math_insert_greek(bv_, *cit)) + owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt); + } else + owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt); } - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + + bv_->update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + + lt->selection.cursor = lt->cursor; moveCursorUpdate(false); - - // real_current_font.number can change so we need to + + // real_current_font.number can change so we need to // update the minibuffer - if (old_font != TEXT(bv_)->real_current_font) + if (old_font != lt->real_current_font) owner_->showState(); + //return string(); } break; case LFUN_DATE_INSERT: // jdblair: date-insert cmd { - struct tm * now_tm; - time_t now_time_t = time(NULL); - now_tm = localtime(&now_time_t); + struct tm * now_tm = localtime(&now_time_t); setlocale(LC_TIME, ""); string arg; if (!argument.empty()) @@ -2937,74 +3198,309 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) char datetmp[32]; int const datetmp_len = ::strftime(datetmp, 32, arg.c_str(), now_tm); + + LyXText * lt = bv_->getLyXText(); + for (int i = 0; i < datetmp_len; i++) { - TEXT(bv_)->InsertChar(bv_, datetmp[i]); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->insertChar(bv_, datetmp[i]); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + lt->selection.cursor = lt->cursor; moveCursorUpdate(false); } break; case LFUN_UNKNOWN_ACTION: - { - if (!buffer_) { - owner_->getLyXFunc()->setErrorMessage(N_("No document open")); - break; + owner_->getLyXFunc()->setErrorMessage(N_("Unknown function!")); + break; + + default: + return false; + } // end of switch + + return true; +} + + +void BufferView::Pimpl::newline() +{ + if (available()) { + LyXText * lt = bv_->getLyXText(); + hideCursor(); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->insertChar(bv_, Paragraph::META_NEWLINE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } +} + + +void BufferView::Pimpl::hfill() +{ + if (available()) { + LyXText * lt = bv_->getLyXText(); + hideCursor(); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->insertChar(bv_, Paragraph::META_HFILL); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } +} + + +void BufferView::Pimpl::protectedBlank(LyXText * lt) +{ + if (available()) { + hideCursor(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); + if (!insertInset(new_inset)) + delete new_inset; + else + updateInset(new_inset, true); + } +} + + +void BufferView::Pimpl::menuSeparator() +{ + if (available()) { + LyXText * lt = bv_->getLyXText(); + + hideCursor(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR); + insertInset(new_inset); + } +} + + +void BufferView::Pimpl::endOfSentenceDot() +{ + if (available()) { + hideCursor(); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE); + insertInset(new_inset); + } +} + + +void BufferView::Pimpl::ldots() +{ + if (available()) { + hideCursor(); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::LDOTS); + insertInset(new_inset); + } +} + + +void BufferView::Pimpl::hyphenationPoint() +{ + if (available()) { + hideCursor(); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::HYPHENATION); + insertInset(new_inset); + } +} + + +void BufferView::Pimpl::insertNote() +{ + InsetInfo * new_inset = new InsetInfo(); + insertInset(new_inset); + new_inset->edit(bv_, 0, 0, 0); +} + + +// Open and lock an updatable inset +bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind) +{ + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->finishUndo(); + if (!insertInset(new_inset)) { + delete new_inset; + return false; + } + if (behind) { + LyXFont & font = lt->real_current_font; + new_inset->edit(bv_, new_inset->width(bv_, font), 0, 0); + } else + new_inset->edit(bv_, 0, 0, 0); + return true; +} + + +bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout) +{ + // if we are in a locking inset we should try to insert the + // inset there otherwise this is a illegal function now + if (bv_->theLockingInset()) { + if (bv_->theLockingInset()->insertInsetAllowed(inset)) + return bv_->theLockingInset()->insertInset(bv_, inset); + return false; + } + + // not quite sure if we want this... + bv_->text->setCursorParUndo(buffer_); + bv_->text->freezeUndo(); + + beforeChange(bv_->text); + if (!lout.empty()) { + update(bv_->text, BufferView::SELECT|BufferView::FITCUR); + bv_->text->breakParagraph(bv_); + update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + + if (bv_->text->cursor.par()->size()) { + bv_->text->cursorLeft(bv_); + + bv_->text->breakParagraph(bv_); + update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } - if (buffer_->isReadonly()) { - owner_->getLyXFunc()->setErrorMessage(N_("Document is read only")); - break; + pair lres = + textclasslist.NumberOfLayout(buffer_->params + .textclass, lout); + LyXTextClass::size_type lay; + if (lres.first != false) { + // layout found + lay = lres.second; + } else { + // layout not fount using default "Standard" (0) + lay = 0; } - if (!argument.empty()) { - /* Automatically delete the currently selected - * text and replace it with what is being - * typed in now. Depends on lyxrc settings - * "auto_region_delete", which defaults to - * true (on). */ - - if (lyxrc.auto_region_delete) { - if (TEXT(bv_)->selection){ - TEXT(bv_)->CutSelection(bv_, false); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + + bv_->text->setLayout(bv_, lay); + + bv_->text->setParagraph(bv_, 0, 0, + 0, 0, + VSpace(VSpace::NONE), VSpace(VSpace::NONE), + LYX_ALIGN_LAYOUT, + string(), + 0); + update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); +#ifndef NO_LATEX + bv_->text->current_font.setLatex(LyXFont::OFF); +#endif + } + + bv_->text->insertInset(bv_, inset); + update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + + bv_->text->unFreezeUndo(); + return true; +} + + +void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty) +{ + if (!inset) + return; + + // first check for locking insets + if (bv_->theLockingInset()) { + if (bv_->theLockingInset() == inset) { + if (bv_->text->updateInset(bv_, inset)) { + update(); + if (mark_dirty) { + buffer_->markDirty(); } + updateScrollbar(); + return; } - - beforeChange(TEXT(bv_)); - LyXFont const old_font(TEXT(bv_)->real_current_font); - for (string::size_type i = 0; - i < argument.length(); ++i) { - if (greek_kb_flag) { - if (!math_insert_greek(bv_, - argument[i])) - owner_->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT(bv_)); - } else - owner_->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT(bv_)); + } else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) { + if (bv_->text->updateInset(bv_, + bv_->theLockingInset())) { + update(); + if (mark_dirty){ + buffer_->markDirty(); + } + updateScrollbar(); + return; } + } + } + + // then check the current buffer + if (available()) { + hideCursor(); + update(bv_->text, BufferView::UPDATE); + if (bv_->text->updateInset(bv_, inset)) { + if (mark_dirty) { + update(bv_->text, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } else { + update(bv_->text, SELECT); + } + return; + } + } +} - update(TEXT(bv_),BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; - moveCursorUpdate(false); - // real_current_font.number can change so we need to - // update the minibuffer - if (old_font != TEXT(bv_)->real_current_font) - owner_->showState(); +void BufferView::Pimpl::gotoInset(vector const & codes, + bool same_content) +{ + if (!available()) return; + + hideCursor(); + beforeChange(bv_->text); + update(bv_->text, BufferView::SELECT|BufferView::FITCUR); + + string contents; + if (same_content && + bv_->text->cursor.par()->getChar(bv_->text->cursor.pos()) == Paragraph::META_INSET) { + Inset const * inset = bv_->text->cursor.par()->getInset(bv_->text->cursor.pos()); + if (find(codes.begin(), codes.end(), inset->lyxCode()) + != codes.end()) + contents = + static_cast(inset)->getContents(); + } + + if (!bv_->text->gotoNextInset(bv_, codes, contents)) { + if (bv_->text->cursor.pos() + || bv_->text->cursor.par() != bv_->text->firstParagraph()) { + LyXCursor tmp = bv_->text->cursor; + bv_->text->cursor.par(bv_->text->firstParagraph()); + bv_->text->cursor.pos(0); + if (!bv_->text->gotoNextInset(bv_, codes, contents)) { + bv_->text->cursor = tmp; + bv_->owner()->message(_("No more insets")); + } } else { - // if we don't have an argument there was something - // strange going on so we just tell this to someone! - owner_->getLyXFunc()->setErrorMessage(N_("No argument givven")); + bv_->owner()->message(_("No more insets")); } - break; } - default: - return false; - } // end of switch + update(bv_->text, BufferView::SELECT|BufferView::FITCUR); + bv_->text->selection.cursor = bv_->text->cursor; +} - return true; + +void BufferView::Pimpl::gotoInset(Inset::Code code, bool same_content) +{ + gotoInset(vector(1, code), same_content); }