X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView_pimpl.C;h=8eff02dd2c0f27e06b89f4ed3a589e32d47b81c5;hb=fd836612cb8540458e0952026c30ade6e0bd56bb;hp=421bb8b25f62c7bb3d647b4d7a1cf6e44893325a;hpb=f1d829a18584fe8c787c7ea428f10cc7a82d6083;p=lyx.git diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C index 421bb8b25f..8eff02dd2c 100644 --- a/src/BufferView_pimpl.C +++ b/src/BufferView_pimpl.C @@ -16,6 +16,8 @@ #include "lyxrow.h" #include "LyXView.h" #include "commandtags.h" +#include "lyxfunc.h" +#include "debug.h" #include "font.h" #include "bufferview_funcs.h" #include "TextCache.h" @@ -24,6 +26,7 @@ #include "lyxrc.h" #include "intl.h" #include "support/LAssert.h" +#include "support/lstrings.h" #include "frontends/Dialogs.h" #include "insets/insetbib.h" #include "insets/insettext.h" @@ -40,7 +43,7 @@ #include "insets/insetref.h" #include "insets/insetparent.h" #include "insets/insetindex.h" -#include "insets/insetinfo.h" +#include "insets/insetnote.h" #include "insets/insetinclude.h" #include "insets/insetcite.h" #include "insets/insetert.h" @@ -50,20 +53,25 @@ #include "insets/insetmarginal.h" #include "insets/insetminipage.h" #include "insets/insetfloat.h" -#include "insets/insetlist.h" #include "insets/insettabular.h" +#if 0 #include "insets/insettheorem.h" +#include "insets/insetlist.h" +#endif #include "insets/insetcaption.h" #include "insets/insetfloatlist.h" #include "insets/insetspecialchar.h" -#include "mathed/formulamacro.h" #include "gettext.h" +#include "ParagraphParameters.h" +#include "undo_funcs.h" +#include "mathed/formulabase.h" extern LyXTextClass::size_type current_layout; extern int greek_kb_flag; using std::vector; using std::find_if; +using std::find; using std::pair; using std::endl; using std::make_pair; @@ -78,13 +86,14 @@ extern BufferList bufferlist; extern char ascii_type; extern bool math_insert_greek(BufferView *, char); -extern void sigchldhandler(pid_t pid, int * status); +extern void sigchldchecker(pid_t pid, int * status); extern int bibitemMaxWidth(BufferView *, LyXFont const &); -const unsigned int saved_positions_num = 20; namespace { +const unsigned int saved_positions_num = 20; + inline void waitForX() { @@ -112,7 +121,8 @@ BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o, int xpos, int ypos, int width, int height) : bv_(b), owner_(o), buffer_(0), current_scrollbar_value(0), cursor_timeout(400), - workarea_(xpos, ypos, width, height), using_xterm_cursor(false) + workarea_(xpos, ypos, width, height), using_xterm_cursor(false), + inset_slept(false) { // Setup the signals workarea_.scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB)); @@ -138,10 +148,8 @@ BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o, cursor_timeout.timeout.connect(slot(this, &BufferView::Pimpl::cursorToggle)); - //current_scrollbar_value = 0; cursor_timeout.start(); workarea_.setFocus(); - //using_xterm_cursor = false; saved_positions.resize(saved_positions_num); } @@ -157,7 +165,7 @@ 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 @@ -195,7 +203,7 @@ void BufferView::Pimpl::buffer(Buffer * b) updateScreen(); updateScrollbar(); } - bv_->text->first = screen_->TopCursorVisible(bv_->text); + bv_->text->first = screen_->topCursorVisible(bv_->text); owner_->updateMenubar(); owner_->updateToolbar(); // Similarly, buffer-dependent dialogs should be updated or @@ -203,7 +211,7 @@ 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(); @@ -251,8 +259,17 @@ void BufferView::Pimpl::redraw() bool BufferView::Pimpl::fitCursor(LyXText * text) { lyx::Assert(screen_.get()); - - bool const ret = screen_->FitCursor(text, bv_); + + bool ret; + + if (bv_->theLockingInset()) { + bv_->theLockingInset()->fitInsetCursor(bv_); + ret = true; + } else { + ret = screen_->fitCursor(text, bv_); + } + + bv_->owner()->getDialogs()->updateParagraph(); if (ret) updateScrollbar(); return ret; @@ -273,18 +290,18 @@ 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; - LyXParagraph::size_type pos = 0; - LyXParagraph::size_type selstartpos = 0; - LyXParagraph::size_type selendpos = 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_->prohibitInput(); owner_->message(_("Formatting document...")); @@ -297,9 +314,10 @@ int BufferView::Pimpl::resizeCurrentBuffer() selendpos = bv_->text->selection.end.pos(); selection = bv_->text->selection.set(); mark_set = bv_->text->selection.mark(); - the_locking_inset = bv_->text->the_locking_inset; + the_locking_inset = bv_->theLockingInset(); delete bv_->text; bv_->text = new LyXText(bv_); + bv_->text->init(bv_); } else { // See if we have a text in TextCache that fits // the new buffer_ with the correct width. @@ -315,6 +333,7 @@ int BufferView::Pimpl::resizeCurrentBuffer() textcache.show(lyxerr, "resizeCurrentBuffer"); } else { bv_->text = new LyXText(bv_); + bv_->text->init(bv_); } } updateScreen(); @@ -325,28 +344,31 @@ int BufferView::Pimpl::resizeCurrentBuffer() * Mechanism when setting the cursor */ bv_->text->selection.mark(mark_set); if (selection) { - bv_->text->SetCursor(bv_, selstartpar, selstartpos); + 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); + 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->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); + bv_->text->first = screen_->topCursorVisible(bv_->text); buffer_->resizeInsets(bv_); // this will scroll the screen such that the cursor becomes visible updateScrollbar(); redraw(); - bv_->setState(); - AllowInput(bv_); + setState(); + owner_->allowInput(); + /// clear the "Formatting Document" message + owner_->message(""); + /// get rid of the splash screen if it's not gone already owner_->getDialogs()->destroySplash(); @@ -366,59 +388,35 @@ void BufferView::Pimpl::updateScrollbar() /* If the text is smaller than the working area, the scrollbar * maximum must be the working area height. No scrolling will * be possible */ - - if (!buffer_) { + 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; + long const text_height = bv_->text->height; - if (bv_->text) { - cbth = bv_->text->height; - cbsf = bv_->text->first; - } + double const lineh = bv_->text->defaultHeight(); + double const slider_size = + (text_height == 0) ? 1.0 : 1.0 / double(text_height); - // check if anything has changed. - if (max2 == cbth && - height2 == workarea_.height() && - current_scrollbar_value == cbsf) - return; // no - max2 = cbth; - height2 = workarea_.height(); - current_scrollbar_value = cbsf; + static long old_text_height = 0; + static double old_lineh = 0; + static double old_slider_size = 0; - if (cbth <= height2) { // text is smaller than screen - workarea_.setScrollbar(0, 1.0); // right? - return; + if (text_height != old_text_height) { + workarea_.setScrollbarBounds(0, text_height - workarea_.height()); + old_text_height = text_height; + } + if (lineh != old_lineh) { + workarea_.setScrollbarIncrements(lineh); + old_lineh = lineh; + } + if (current_scrollbar_value != bv_->text->first + || slider_size != old_slider_size) { + current_scrollbar_value = bv_->text->first; + workarea_.setScrollbar(current_scrollbar_value, slider_size); + old_slider_size = slider_size; } - - long maximum_height = workarea_.height() * 3 / 4 + cbth; - long value = cbsf; - - // 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 const 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()); } @@ -434,7 +432,7 @@ void BufferView::Pimpl::scrollCB(double value) if (!screen_.get()) return; - screen_->Draw(bv_->text, bv_, current_scrollbar_value); + screen_->draw(bv_->text, bv_, current_scrollbar_value); if (!lyxrc.cursor_follows_scrollbar) { waitForX(); @@ -443,14 +441,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)); 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(); } @@ -465,12 +463,12 @@ int BufferView::Pimpl::scrollUp(long time) 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()); + bv_->text->defaultHeight()); value -= add_value; @@ -491,16 +489,16 @@ int BufferView::Pimpl::scrollDown(long time) double value = workarea_.getScrollbarValue(); pair p = workarea_.getScrollbarBounds(); - double max = p.second; + 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()); + bv_->text->defaultHeight()); value += add_value; @@ -531,36 +529,37 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state) // 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(); + screen_->hideCursor(); - bv_->text->SetCursorFromCoordinates(bv_, x, y + bv_->text->first); + bv_->text->setCursorFromCoordinates(bv_, x, y + bv_->text->first); if (!bv_->text->selection.set()) update(bv_->text, BufferView::UPDATE); // Maybe an empty line was deleted - bv_->text->SetSelection(bv_); - screen_->ToggleToggle(bv_->text, bv_); + bv_->text->setSelection(bv_); + screen_->toggleToggle(bv_->text, bv_); fitCursor(bv_->text); - screen_->ShowCursor(bv_->text, bv_); + screen_->showCursor(bv_->text, bv_); } @@ -568,9 +567,6 @@ 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_.get()) return; Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button); @@ -594,7 +590,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; @@ -605,7 +601,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, if (!inset_hit) selection_possible = true; - screen_->HideCursor(); + screen_->hideCursor(); int const screen_first = bv_->text->first; @@ -613,27 +609,27 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, bool paste_internally = false; if (button == 2 && bv_->text->selection.set()) { - owner_->getLyXFunc()->Dispatch(LFUN_COPY); + owner_->getLyXFunc()->dispatch(LFUN_COPY); paste_internally = true; } // Clear the selection - screen_->ToggleSelection(bv_->text, bv_); - bv_->text->ClearSelection(bv_); - bv_->text->FullRebreak(bv_); - screen_->Update(bv_->text, bv_); + screen_->toggleSelection(bv_->text, 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_->message(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; } @@ -644,8 +640,8 @@ 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->setCursorFromCoordinates(bv_, xpos, ypos + screen_first); + finishUndo(); bv_->text->selection.cursor = bv_->text->cursor; bv_->text->cursor.x_fix(bv_->text->cursor.x()); @@ -659,9 +655,9 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos, // insert this if (button == 2) { if (paste_internally) - owner_->getLyXFunc()->Dispatch(LFUN_PASTE); + owner_->getLyXFunc()->dispatch(LFUN_PASTE); else - owner_->getLyXFunc()->Dispatch(LFUN_PASTESELECTION, + owner_->getLyXFunc()->dispatch(LFUN_PASTESELECTION, "paragraph"); selection_possible = false; return; @@ -682,12 +678,12 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button) if (screen_.get() && button == 1) { if (text->bv_owner) { - screen_->HideCursor(); - screen_->ToggleSelection(text, bv_); - text->SelectWord(bv_); - screen_->ToggleSelection(text, bv_, false); + screen_->hideCursor(); + screen_->toggleSelection(text, bv_); + text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT); + screen_->toggleSelection(text, bv_, false); } else { - text->SelectWord(bv_); + text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT); } /* This will fit the cursor on the screen * if necessary */ @@ -708,13 +704,13 @@ void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button) return; if (screen_.get() && (button == 1)) { - screen_->HideCursor(); - screen_->ToggleSelection(text, bv_); - text->CursorHome(bv_); + screen_->hideCursor(); + screen_->toggleSelection(text, bv_); + text->cursorHome(bv_); text->selection.cursor = text->cursor; - text->CursorEnd(bv_); - text->SetSelection(bv_); - screen_->ToggleSelection(text, bv_, false); + text->cursorEnd(bv_); + text->setSelection(bv_); + screen_->toggleSelection(text, bv_, false); /* This will fit the cursor on the screen * if necessary */ update(text, BufferView::SELECT|BufferView::FITCUR); @@ -755,9 +751,9 @@ 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; } @@ -766,7 +762,7 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, if (button == 2) return; - bv_->setState(); + setState(); owner_->showState(); // Did we hit an editable inset? @@ -789,19 +785,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) { + setCursorParUndo(bv_); } - owner_->message(inset_hit->EditMessage()); + owner_->message(inset_hit->editMessage()); - if (inset_hit->Editable()==Inset::HIGHLY_EDITABLE) { + 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; } @@ -813,11 +809,11 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, if (bv_->text->cursor.pos() < bv_->text->cursor.par()->size()) { c = bv_->text->cursor.par()-> - GetChar(bv_->text->cursor.pos()); + getChar(bv_->text->cursor.pos()); } if (bv_->text->cursor.pos() - 1 >= 0) { c = bv_->text->cursor.par()-> - GetChar(bv_->text->cursor.pos() - 1); + getChar(bv_->text->cursor.pos() - 1); } if (hit == true) { selection_possible = false; @@ -830,7 +826,7 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y, 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; @@ -851,18 +847,18 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, int y_tmp = y + text->first; LyXCursor cursor; - text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp); - text->SetCursor(bv_, cursor, cursor.par(),cursor.pos(),true); + text->setCursorFromCoordinates(bv_, cursor, x, y_tmp); + text->setCursor(bv_, cursor, cursor.par(),cursor.pos(),true); if (cursor.pos() < cursor.par()->size() - && cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET - && cursor.par()->GetInset(cursor.pos()) - && cursor.par()->GetInset(cursor.pos())->Editable()) { + && 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 const width = tmpinset->width(bv_, font); int const inset_x = font.isVisibleRightToLeft() @@ -873,7 +869,7 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, 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()); @@ -882,11 +878,11 @@ 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 const width = tmpinset->width(bv_, font); int const inset_x = font.isVisibleRightToLeft() @@ -900,7 +896,7 @@ Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y, #if 0 if (move_cursor && (tmpinset != bv_->theLockingInset())) #endif - text->SetCursor(bv_, cursor.par(), + text->setCursor(bv_, cursor.par(), cursor.pos() - 1, true); x = x - start_x; // The origin of an inset is on the baseline @@ -914,8 +910,8 @@ 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 const widthChange = workarea_.workWidth() != work_area_width; bool const heightChange = workarea_.height() != work_area_height; @@ -925,8 +921,8 @@ void BufferView::Pimpl::workAreaExpose() 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 @@ -948,7 +944,7 @@ void BufferView::Pimpl::workAreaExpose() // The main window size has changed, repaint most stuff redraw(); } else if (screen_.get()) - screen_->Redraw(bv_->text, bv_); + screen_->redraw(bv_->text, bv_); } else { // Grey box when we don't have a buffer workarea_.greyOut(); @@ -963,7 +959,11 @@ void BufferView::Pimpl::workAreaExpose() void BufferView::Pimpl::update() { - if (screen_.get()) screen_->Update(bv_->text, bv_); + if (screen_.get() && + (!bv_->theLockingInset() || !bv_->theLockingInset()->nodraw())) + { + screen_->update(bv_->text, bv_); + } } // Values used when calling update: @@ -1012,17 +1012,18 @@ void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f) 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); - } else + text->inset_owner->setUpdateStatus(bv_, InsetText::NONE); + updateInset(text->inset_owner, true); + } else { update(); - + } + if ((f & FITCUR)) { fitCursor(text); - } + } if ((f & CHANGE)) { buffer_->markDirty(); @@ -1041,11 +1042,11 @@ 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) - sigchldhandler(pid, &status); + sigchldchecker(pid, &status); updatelist.update(bv_); @@ -1055,9 +1056,9 @@ void BufferView::Pimpl::cursorToggle() } if (!bv_->theLockingInset()) { - screen_->CursorToggle(bv_->text, bv_); + screen_->cursorToggle(bv_->text, bv_); } else { - bv_->theLockingInset()->ToggleInsetCursor(bv_); + bv_->theLockingInset()->toggleInsetCursor(bv_); } cursor_timeout.restart(); @@ -1073,15 +1074,15 @@ 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); + 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()) - screen_->Draw(bv_->text, bv_, + screen_->draw(bv_->text, bv_, text->cursor.y() - text->cursor.row()->baseline() + text->cursor.row()->height() @@ -1098,18 +1099,18 @@ void BufferView::Pimpl::cursorNext(LyXText * text) 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()); + 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()) - screen_->Draw(bv_->text, bv_, text->cursor.y() - + screen_->draw(bv_->text, bv_, text->cursor.y() - text->cursor.row()->baseline()); updateScrollbar(); } @@ -1125,7 +1126,7 @@ bool BufferView::Pimpl::available() const void BufferView::Pimpl::beforeChange(LyXText * text) { toggleSelection(); - text->ClearSelection(bv_); + text->clearSelection(bv_); } @@ -1137,8 +1138,9 @@ void BufferView::Pimpl::savePosition(unsigned int i) bv_->text->cursor.par()->id(), bv_->text->cursor.pos()); if (i > 0) { - string const str = _("Saved bookmark") + ' ' + tostr(i); - owner_->message(str); + ostringstream str; + str << _("Saved bookmark") << ' ' << i; + owner_->message(str.str().c_str()); } } @@ -1159,17 +1161,18 @@ void BufferView::Pimpl::restorePosition(unsigned int i) if (b != 0 ) buffer(b); } - LyXParagraph * par = bv_->text->GetParFromID(saved_positions[i].par_id); + Paragraph * par = buffer_->getParFromID(saved_positions[i].par_id); if (!par) return; - bv_->text->SetCursor(bv_, par, + bv_->text->setCursor(bv_, par, min(par->size(), saved_positions[i].par_pos)); update(bv_->text, BufferView::SELECT|BufferView::FITCUR); if (i > 0) { - string const str = _("Moved to bookmark") + ' ' + tostr(i); - owner_->message(str); + ostringstream str; + str << _("Moved to bookmark") << ' ' << i; + owner_->message(str.str().c_str()); } } @@ -1189,8 +1192,12 @@ void BufferView::Pimpl::setState() return; LyXText * text = bv_->getLyXText(); - if (text->real_current_font.isRightToLeft() && - text->real_current_font.latex() != LyXFont::ON) { + 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 { @@ -1202,19 +1209,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; } } @@ -1222,11 +1229,11 @@ 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; + finishUndo(); + inset_slept = false; } } @@ -1257,29 +1264,40 @@ bool BufferView::Pimpl::belowMouse() const void BufferView::Pimpl::showCursor() { - if (screen_.get()) - screen_->ShowCursor(bv_->text, bv_); + if (screen_.get()) { + if (bv_->theLockingInset()) + bv_->theLockingInset()->showInsetCursor(bv_); + else + screen_->showCursor(bv_->text, bv_); + } } void BufferView::Pimpl::hideCursor() { - if (screen_.get()) - screen_->HideCursor(); + if (screen_.get()) { + if (!bv_->theLockingInset()) +// bv_->theLockingInset()->hideInsetCursor(bv_); +// else + screen_->hideCursor(); + } } void BufferView::Pimpl::toggleSelection(bool b) { - if (screen_.get()) - screen_->ToggleSelection(bv_->text, bv_, b); + if (screen_.get()) { + if (bv_->theLockingInset()) + bv_->theLockingInset()->toggleSelection(bv_, b); + screen_->toggleSelection(bv_->text, bv_, b); + } } void BufferView::Pimpl::toggleToggle() { if (screen_.get()) - screen_->ToggleToggle(bv_->text, bv_); + screen_->toggleToggle(bv_->text, bv_); } @@ -1287,9 +1305,9 @@ 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); + screen_->draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_.height() / 2); } else { - screen_->Draw(bv_->text, bv_, 0); + screen_->draw(bv_->text, bv_, 0); } update(bv_->text, BufferView::SELECT|BufferView::FITCUR); redraw(); @@ -1300,7 +1318,7 @@ void BufferView::Pimpl::pasteClipboard(bool asPara) { if (!buffer_) return; - screen_->HideCursor(); + screen_->hideCursor(); beforeChange(bv_->text); string const clip(workarea_.getClipboard()); @@ -1308,9 +1326,9 @@ void BufferView::Pimpl::pasteClipboard(bool asPara) 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); } @@ -1334,9 +1352,9 @@ void BufferView::Pimpl::moveCursorUpdate(bool selecting) LyXText * lt = bv_->getLyXText(); if (selecting || lt->selection.mark()) { - lt->SetSelection(bv_); + lt->setSelection(bv_); if (lt->bv_owner) - bv_->toggleToggle(); + toggleToggle(); } update(lt, BufferView::SELECT|BufferView::FITCUR); showCursor(); @@ -1344,7 +1362,7 @@ void BufferView::Pimpl::moveCursorUpdate(bool selecting) /* ---> Everytime the cursor is moved, show the current font state. */ // should this too me moved out of this func? //owner->showState(); - bv_->setState(); + setState(); } @@ -1355,8 +1373,7 @@ Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code) find_if(Buffer::inset_iterator( cursor.par(), cursor.pos()), buffer_->inset_iterator_end(), - lyx::compare_memfun(&Inset::LyxCode, code) - ); + lyx::compare_memfun(&Inset::lyxCode, code)); return it != buffer_->inset_iterator_end() ? (*it) : 0; } @@ -1400,31 +1417,36 @@ void BufferView::Pimpl::MenuInsertLyXFile(string const & filen) } } - // 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 - string const s1 = _("Inserting document") + ' ' - + MakeDisplayPath(filename) + " ..."; - owner_->message(s1); + 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) { - string const str = _("Document") + ' ' - + MakeDisplayPath(filename) + ' ' + _("inserted."); - owner_->message(str); + ostringstream str; + str << _("Document") << ' ' << disp_fn + << ' ' << _("inserted."); + owner_->message(str.str().c_str()); } else { - string const str = _("Could not insert document") + ' ' - + MakeDisplayPath(filename); - owner_->message(str); + 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: @@ -1445,7 +1467,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) InsetCommandParams p; p.setCmdName("tableofcontents"); Inset * inset = new InsetTOC(p); - if (!bv_->insertInset(inset, "Standard", true)) + if (!insertInset(inset, "Standard")) delete inset; break; } @@ -1460,12 +1482,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_); } break; } @@ -1501,11 +1523,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: @@ -1513,24 +1535,28 @@ 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: - hyphenationPoint(); + specialChar(InsetSpecialChar::HYPHENATION); + break; + + case LFUN_LIGATURE_BREAK: + specialChar(InsetSpecialChar::LIGATURE_BREAK); break; case LFUN_LDOTS: - ldots(); + specialChar(InsetSpecialChar::LDOTS); break; case LFUN_END_OF_SENTENCE: - endOfSentenceDot(); + specialChar(InsetSpecialChar::END_OF_SENTENCE); break; case LFUN_MENU_SEPARATOR: - menuSeparator(); + specialChar(InsetSpecialChar::MENU_SEPARATOR); break; case LFUN_HFILL: @@ -1552,13 +1578,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) 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); @@ -1575,8 +1603,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) 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). */ @@ -1609,7 +1637,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT | BufferView::FITCUR); - lt->SetLayout(bv_, layout.second); + lt->setLayout(bv_, layout.second); owner_->setLayout(layout.second); update(lt, BufferView::SELECT @@ -1682,9 +1710,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT | BufferView::FITCUR); - lt->ChangeWordCase(bv_, LyXText::text_uppercase); + lt->changeCase(bv_, LyXText::text_uppercase); if (lt->inset_owner) - bv_->updateInset(lt->inset_owner, true); + updateInset(lt->inset_owner, true); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -1697,9 +1725,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->ChangeWordCase(bv_, LyXText::text_lowercase); + lt->changeCase(bv_, LyXText::text_lowercase); if (lt->inset_owner) - bv_->updateInset(lt->inset_owner, true); + updateInset(lt->inset_owner, true); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -1712,10 +1740,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->ChangeWordCase(bv_, - LyXText::text_capitalization); + lt->changeCase(bv_, LyXText::text_capitalization); if (lt->inset_owner) - bv_->updateInset(lt->inset_owner, true); + updateInset(lt->inset_owner, true); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -1728,9 +1755,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->TransposeChars(*bv_); + lt->transposeChars(*bv_); if (lt->inset_owner) - bv_->updateInset(lt->inset_owner, true); + updateInset(lt->inset_owner, true); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -1752,10 +1779,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; @@ -1799,28 +1826,23 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); if (is_rtl) - lt->CursorLeft(bv_, false); + lt->cursorLeft(bv_, false); if (lt->cursor.pos() < lt->cursor.par()->size() - && lt->cursor.par()->GetChar(lt->cursor.pos()) - == LyXParagraph::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 const font = - lt->GetFont(buffer_, - lt->cursor.par(), - lt->cursor.pos()); - y = tmpinset->descent(bv_,font); - } - tmpinset->Edit(bv_, 0, y, 0); + && 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()); + if (is_rtl) + tmpinset->edit(bv_, false); + else + tmpinset->edit(bv_); break; } if (!is_rtl) - lt->CursorRight(bv_, false); - lt->FinishUndo(); + lt->cursorRight(bv_, false); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1835,34 +1857,29 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.mark()) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); - LyXCursor const & cur = lt->cursor; + LyXCursor const cur = lt->cursor; if (!is_rtl) - lt->CursorLeft(bv_, false); + 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()) == - LyXParagraph::META_INSET) && - lt->cursor.par()->GetInset(lt->cursor.pos()) && - (lt->cursor.par()->GetInset(lt->cursor.pos())->Editable() + (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()); - 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->x() + - tmpinset->width(bv_,font), - y, 0); + Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos()); + owner_->getLyXFunc()->setMessage(tmpinset->editMessage()); + if (is_rtl) + tmpinset->edit(bv_); + else + tmpinset->edit(bv_, false); break; } if (is_rtl) - lt->CursorRight(bv_, false); + lt->cursorRight(bv_, false); - lt->FinishUndo(); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1875,8 +1892,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.mark()) beforeChange(lt); update(lt, BufferView::UPDATE); - lt->CursorUp(bv_); - lt->FinishUndo(); + lt->cursorUp(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1889,8 +1906,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.mark()) beforeChange(lt); update(lt, BufferView::UPDATE); - lt->CursorDown(bv_); - lt->FinishUndo(); + lt->cursorDown(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1903,8 +1920,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.mark()) beforeChange(lt); update(lt, BufferView::UPDATE); - lt->CursorUpParagraph(bv_); - lt->FinishUndo(); + lt->cursorUpParagraph(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1917,8 +1934,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.mark()) beforeChange(lt); update(lt, BufferView::UPDATE); - lt->CursorDownParagraph(bv_); - lt->FinishUndo(); + lt->cursorDownParagraph(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1932,7 +1949,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::UPDATE); cursorPrevious(lt); - lt->FinishUndo(); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1946,7 +1963,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::UPDATE); cursorNext(lt); - lt->FinishUndo(); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1959,8 +1976,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.mark()) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorHome(bv_); - lt->FinishUndo(); + lt->cursorHome(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1974,8 +1991,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorEnd(bv_); - lt->FinishUndo(); + lt->cursorEnd(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1990,8 +2007,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorTab(bv_); - lt->FinishUndo(); + lt->cursorTab(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -2005,10 +2022,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) - lt->CursorLeftOneWord(bv_); + lt->cursorLeftOneWord(bv_); else - lt->CursorRightOneWord(bv_); - lt->FinishUndo(); + lt->cursorRightOneWord(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -2022,10 +2039,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) - lt->CursorRightOneWord(bv_); + lt->cursorRightOneWord(bv_); else - lt->CursorLeftOneWord(bv_); - lt->FinishUndo(); + lt->cursorLeftOneWord(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -2039,8 +2056,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorTop(bv_); - lt->FinishUndo(); + lt->cursorTop(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -2054,8 +2071,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorBottom(bv_); - lt->FinishUndo(); + lt->cursorBottom(bv_); + finishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -2069,10 +2086,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) - lt->CursorLeft(bv_); + lt->cursorLeft(bv_); else - lt->CursorRight(bv_); - lt->FinishUndo(); + lt->cursorRight(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2085,10 +2102,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) - lt->CursorRight(bv_); + lt->cursorRight(bv_); else - lt->CursorLeft(bv_); - lt->FinishUndo(); + lt->cursorLeft(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2100,8 +2117,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorUp(bv_); - lt->FinishUndo(); + lt->cursorUp(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2113,8 +2130,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorDown(bv_); - lt->FinishUndo(); + lt->cursorDown(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2126,8 +2143,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorUpParagraph(bv_); - lt->FinishUndo(); + lt->cursorUpParagraph(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2139,8 +2156,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorDownParagraph(bv_); - lt->FinishUndo(); + lt->cursorDownParagraph(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2152,7 +2169,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); cursorPrevious(lt); - lt->FinishUndo(); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2164,7 +2181,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); cursorNext(lt); - lt->FinishUndo(); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2175,8 +2192,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorHome(bv_); - lt->FinishUndo(); + lt->cursorHome(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2187,8 +2204,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorEnd(bv_); - lt->FinishUndo(); + lt->cursorEnd(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2200,10 +2217,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) - lt->CursorLeftOneWord(bv_); + lt->cursorLeftOneWord(bv_); else - lt->CursorRightOneWord(bv_); - lt->FinishUndo(); + lt->cursorRightOneWord(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2215,10 +2232,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) update(lt, BufferView::SELECT|BufferView::FITCUR); if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) - lt->CursorRightOneWord(bv_); + lt->cursorRightOneWord(bv_); else - lt->CursorLeftOneWord(bv_); - lt->FinishUndo(); + lt->cursorLeftOneWord(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2231,8 +2248,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (lt->inset_owner) break; update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorTop(bv_); - lt->FinishUndo(); + lt->cursorTop(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2246,8 +2263,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) break; update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->CursorBottom(bv_); - lt->FinishUndo(); + lt->cursorBottom(bv_); + finishUndo(); moveCursorUpdate(true); owner_->showState(); } @@ -2259,7 +2276,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); beforeChange(lt); - lt->InsertChar(bv_, LyXParagraph::META_NEWLINE); + lt->insertChar(bv_, Paragraph::META_NEWLINE); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2274,10 +2291,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXLayout const & style = textclasslist .Style(buffer_->params.textclass, - lt->cursor.par()->GetLayout()); + lt->cursor.par()->getLayout()); if (style.free_spacing) { - lt->InsertChar(bv_, ' '); + lt->insertChar(bv_, ' '); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2344,28 +2361,28 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.set()) { if (cursor.pos() == cursor.par()->size()) { - lt->CursorRight(bv_); + lt->cursorRight(bv_); cursor = lt->cursor; if (cursor.pos() == 0 - && !(cursor.par()->params.spaceTop() + && !(cursor.par()->params().spaceTop() == VSpace (VSpace::NONE))) { - lt->SetParagraph + lt->setParagraph (bv_, - cursor.par()->params.lineTop(), - cursor.par()->params.lineBottom(), - cursor.par()->params.pagebreakTop(), - cursor.par()->params.pagebreakBottom(), + 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); - lt->CursorLeft(bv_); + 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 { - lt->CursorLeft(bv_); + lt->cursorLeft(bv_); lt->Delete(bv_); lt->selection.cursor = lt->cursor; update(lt, @@ -2390,7 +2407,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) /* -------> Delete word forward. */ case LFUN_DELETE_WORD_FORWARD: update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); - bv_->getLyXText()->DeleteWordForward(bv_); + bv_->getLyXText()->deleteWordForward(bv_); update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); moveCursorUpdate(false); owner_->showState(); @@ -2402,7 +2419,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->DeleteWordBackward(bv_); + lt->deleteWordBackward(bv_); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2418,7 +2435,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); update(lt, BufferView::SELECT|BufferView::FITCUR); - lt->DeleteLineForward(bv_); + lt->deleteLineForward(bv_); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2458,7 +2475,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.set()) { if (owner_->getIntl()->getTrans().backspace()) { - lt->Backspace(bv_); + lt->backspace(bv_); lt->selection.cursor = lt->cursor; update(lt, BufferView::SELECT @@ -2485,23 +2502,23 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (!lt->selection.set()) { if (cursor.pos() == 0 - && !(cursor.par()->params.spaceTop() + && !(cursor.par()->params().spaceTop() == VSpace (VSpace::NONE))) { - lt->SetParagraph + lt->setParagraph (bv_, - 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); + 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 { - lt->Backspace(bv_); + lt->backspace(bv_); lt->selection.cursor = cursor; update(lt, BufferView::SELECT @@ -2518,7 +2535,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); beforeChange(lt); - lt->BreakParagraph(bv_, 0); + lt->breakParagraph(bv_, 0); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2534,7 +2551,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); beforeChange(lt); - lt->BreakParagraph(bv_, 1); + lt->breakParagraph(bv_, 1); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2556,21 +2573,21 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) beforeChange(lt); if (cursor.pos() == 0) { - if (cursor.par()->params.spaceTop() == VSpace(VSpace::NONE)) { - lt->SetParagraph + if (cursor.par()->params().spaceTop() == VSpace(VSpace::NONE)) { + lt->setParagraph (bv_, - 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); + 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 { - lt->BreakParagraph(bv_, 0); + lt->breakParagraph(bv_, 0); //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } @@ -2588,11 +2605,11 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { LyXText * lt = bv_->getLyXText(); - LyXParagraph * par = lt->cursor.par(); - Spacing::Space cur_spacing = par->params.spacing().getSpace(); + 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->params.spacing().getValue(); + cur_value = par->params().spacing().getValue(); } istringstream istr(argument.c_str()); @@ -2624,8 +2641,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) << argument << endl; } if (cur_spacing != new_spacing || cur_value != new_value) { - par->params.spacing(Spacing(new_spacing, new_value)); - lt->RedoParagraph(bv_); + par->params().spacing(Spacing(new_spacing, new_value)); + lt->redoParagraph(bv_); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -2634,8 +2651,20 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } break; + case LFUN_INSET_TOGGLE: + { + LyXText * lt = bv_->getLyXText(); + hideCursor(); + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->toggleInset(bv_); + update(lt, BufferView::SELECT|BufferView::FITCUR); + setState(); + } + break; + case LFUN_QUOTE: - bv_->insertCorrectQuote(); + smartQuote(); break; case LFUN_HTMLURL: @@ -2646,90 +2675,69 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) p.setCmdName("htmlurl"); else p.setCmdName("url"); - owner_->getDialogs()->createUrl( p.getAsString() ); + owner_->getDialogs()->createUrl(p.getAsString()); } break; case LFUN_INSERT_URL: { InsetCommandParams p; - p.setFromString( argument ); + p.setFromString(argument); - InsetUrl * inset = new InsetUrl( p ); - if (!bv_->insertInset(inset)) + InsetUrl * inset = new InsetUrl(p); + 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); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetText); + break; case LFUN_INSET_ERT: - { - InsetERT * new_inset = new InsetERT; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetERT); + break; case LFUN_INSET_EXTERNAL: - { - InsetExternal * new_inset = new InsetExternal; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetExternal); + break; case LFUN_INSET_FOOTNOTE: - { - InsetFoot * new_inset = new InsetFoot; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetFoot); + break; case LFUN_INSET_MARGINAL: - { - InsetMarginal * new_inset = new InsetMarginal; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetMarginal); + break; case LFUN_INSET_MINIPAGE: - { - InsetMinipage * new_inset = new InsetMinipage; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetMinipage); + break; + + case LFUN_INSERT_NOTE: + insertAndEditInset(new InsetNote); + break; case LFUN_INSET_FLOAT: + // check if the float type exist + if (floatList.typeExist(argument)) { + insertAndEditInset(new InsetFloat(argument)); + } 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); - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); + new_inset->wide(true); + if (insertInset(new_inset)) + new_inset->edit(bv_); else delete new_inset; } else { @@ -2740,39 +2748,29 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } break; +#if 0 case LFUN_INSET_LIST: - { - InsetList * new_inset = new InsetList; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; + insertAndEditInset(new InsetList); + break; case LFUN_INSET_THEOREM: - { - InsetTheorem * new_inset = new InsetTheorem; - if (bv_->insertInset(new_inset)) - new_inset->Edit(bv_, 0, 0, 0); - else - delete new_inset; - } - break; - + insertAndEditInset(new InsetTheorem); + break; +#endif + case LFUN_INSET_CAPTION: { // 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_); else delete new_inset; } @@ -2781,12 +2779,13 @@ 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 = + bool const rtl = bv_->getLyXText()->real_current_font.isRightToLeft(); if (!open_new_inset(new_inset, rtl)) delete new_inset; @@ -2797,10 +2796,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_CHARATCURSOR: { - LyXParagraph::size_type pos = bv_->getLyXText()->cursor.pos(); + Paragraph::size_type pos = bv_->getLyXText()->cursor.pos(); if (pos < bv_->getLyXText()->cursor.par()->size()) owner_->getLyXFunc()->setMessage( - tostr(bv_->getLyXText()->cursor.par()->GetChar(pos))); + tostr(bv_->getLyXText()->cursor.par()->getChar(pos))); else owner_->getLyXFunc()->setMessage("EOF"); } @@ -2814,10 +2813,13 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_SETXY: { - int x; - int y; - ::sscanf(argument.c_str(), " %d %d", &x, &y); - bv_->getLyXText()->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; @@ -2840,10 +2842,12 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_GETLATEX: { +#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; @@ -2881,71 +2885,44 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } break; - // --- insert characters ---------------------------------------- - + case LFUN_MATH_MACRO: + mathDispatchMathMacro(bv_, argument); + break; + case LFUN_MATH_DELIM: + mathDispatchMathDelim(bv_, argument); + break; + case LFUN_INSERT_MATRIX: - { - if (available()) { - if (open_new_inset(new InsetFormula(false))) { - bv_->theLockingInset() - ->LocalDispatch(bv_, action, argument); - } - } - } - break; - + mathDispatchInsertMatrix(bv_, argument); + break; + case LFUN_INSERT_MATH: - { - if (!available()) - break; - - InsetFormula * f = new InsetFormula(true); - open_new_inset(f); - f->LocalDispatch(bv_, LFUN_INSERT_MATH, argument); - } - break; - - case LFUN_MATH_DISPLAY: - { - if (available()) - open_new_inset(new InsetFormula(true)); + mathDispatchInsertMath(bv_, argument); break; - } - - case LFUN_MATH_MACRO: - { - if (available()) { - string s(argument); - if (s.empty()) - owner_->getLyXFunc()->setErrorMessage(N_("Missing argument")); - else { - string const s1 = token(s, ' ', 1); - int const na = s1.empty() ? 0 : lyx::atoi(s1); - open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na)); - } - } - } - break; - case LFUN_MATH_MODE: // Open or create a math inset - { - if (available()) - open_new_inset(new InsetFormula); - owner_->getLyXFunc()->setMessage(N_("Math editor mode")); - } - break; - + case LFUN_MATH_IMPORT_SELECTION: // Imports LaTeX from the X selection + mathDispatchMathImportSelection(bv_, argument); + break; + + case LFUN_MATH_DISPLAY: // Open or create a displayed math inset + mathDispatchMathDisplay(bv_, argument); + break; + + case LFUN_MATH_MODE: // Open or create an inlined math inset + mathDispatchMathMode(bv_, argument); + break; + case LFUN_CITATION_INSERT: { InsetCommandParams p; 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; @@ -2962,9 +2939,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_); } else delete inset; } @@ -3003,24 +2980,20 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_INDEX_CREATE: { - InsetCommandParams p( "index" ); + InsetCommandParams p("index"); + LyXText * lt = bv_->getLyXText(); if (argument.empty()) { - // Get the word immediately preceding the cursor - LyXParagraph::size_type curpos = - bv_->getLyXText()->cursor.pos() - 1; - - string curstring; - if (curpos >= 0 ) - curstring = bv_->getLyXText() - ->cursor.par()->GetWord(curpos); - - p.setContents( curstring ); + string const idxstring(bv_->getLyXText()->getStringToIndex(bv_)); + if (!idxstring.empty()) + p.setContents(idxstring); + else + break; } else { - p.setContents( argument ); + p.setContents(argument); } - owner_->getDialogs()->createIndex( p.getAsString() ); + owner_->getDialogs()->createIndex(p.getAsString()); } break; @@ -3030,31 +3003,27 @@ 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 = - bv_->getLyXText()->cursor.pos() - 1; - // Can't do that at the beginning of a paragraph - if (curpos < 0) break; - - string const curstring(bv_->getLyXText() - ->cursor.par()->GetWord(curpos)); - - InsetCommandParams p("index", curstring); - InsetIndex * inset = new InsetIndex(p); - - if (!bv_->insertInset(inset)) - delete inset; - else - bv_->updateInset(inset, true); + string const idxstring(bv_->getLyXText()->getStringToIndex(bv_)); + if (!idxstring.empty()) { + owner_->message(_("Word `") + + idxstring + _(("' indexed."))); + InsetCommandParams p("index", idxstring); + InsetIndex * inset = new InsetIndex(p); + + if (!insertInset(inset)) + delete inset; + else + updateInset(inset, true); + } } break; @@ -3062,7 +3031,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; @@ -3072,7 +3041,7 @@ 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; } @@ -3085,10 +3054,10 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) p.masterFilename_ = buffer_->fileName(); InsetInclude * inset = new InsetInclude(p); - if (!bv_->insertInset(inset)) + if (!insertInset(inset)) delete inset; else { - bv_->updateInset(inset, true); + updateInset(inset, true); bv_->owner()->getDialogs()->showInclude(inset); } } @@ -3098,15 +3067,31 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { // We should check the argument for validity. (Lgb) Inset * inset = new InsetFloatList(argument); - if (!bv_->insertInset(inset, "Standard", true)) + if (!insertInset(inset, "Standard")) delete inset; } break; - case LFUN_INSERT_NOTE: - insertNote(); - break; + case LFUN_THESAURUS_ENTRY: + { + string arg = argument; + if (arg.empty()) { + arg = bv_->getLyXText()->selectionAsString(buffer_); + + // FIXME + if (arg.size() > 100 || arg.empty()) { + // Get word or selection + bv_->getLyXText()->selectWordWhenUnderCursor(bv_, LyXText::WHOLE_WORD); + arg = bv_->getLyXText()->selectionAsString(buffer_); + // FIXME: where is getLyXText()->unselect(bv_) ? + } + } + + bv_->owner()->getDialogs()->showThesaurus(arg); + } + break; + case LFUN_SELFINSERT: { if (argument.empty()) break; @@ -3121,7 +3106,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (lyxrc.auto_region_delete) { if (lt->selection.set()) { - lt->CutSelection(bv_, false); + lt->cutSelection(bv_, false); bv_->update(lt, BufferView::SELECT | BufferView::FITCUR @@ -3129,7 +3114,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } } - bv_->beforeChange(lt); + beforeChange(lt); LyXFont const old_font(lt->real_current_font); string::const_iterator cit = argument.begin(); @@ -3175,7 +3160,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) LyXText * lt = bv_->getLyXText(); for (int i = 0; i < datetmp_len; i++) { - lt->InsertChar(bv_, datetmp[i]); + lt->insertChar(bv_, datetmp[i]); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -3188,7 +3173,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) break; case LFUN_UNKNOWN_ACTION: - owner_->getLyXFunc()->setErrorMessage(N_("Unknow function!")); + owner_->getLyXFunc()->setErrorMessage(N_("Unknown function!")); break; default: @@ -3207,7 +3192,7 @@ void BufferView::Pimpl::newline() update(lt, BufferView::SELECT | BufferView::FITCUR); - lt->InsertChar(bv_, LyXParagraph::META_NEWLINE); + lt->insertChar(bv_, Paragraph::META_NEWLINE); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -3224,7 +3209,7 @@ void BufferView::Pimpl::hfill() update(lt, BufferView::SELECT | BufferView::FITCUR); - lt->InsertChar(bv_, LyXParagraph::META_HFILL); + lt->insertChar(bv_, Paragraph::META_HFILL); update(lt, BufferView::SELECT | BufferView::FITCUR @@ -3240,15 +3225,21 @@ void BufferView::Pimpl::protectedBlank(LyXText * lt) update(lt, BufferView::SELECT|BufferView::FITCUR); InsetSpecialChar * new_inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - if (!bv_->insertInset(new_inset)) +#ifdef WITH_WARNINGS +#warning Why is this code different from specialChar() below? (JMarc) +// the code in specialChar is a generic version of what used to exist +// for other special chars. I did not merge this case because of the +// call to updateInset(), but what does it do? +#endif + if (!insertInset(new_inset)) delete new_inset; else - bv_->updateInset(new_inset, true); + updateInset(new_inset, true); } } -void BufferView::Pimpl::menuSeparator() +void BufferView::Pimpl::specialChar(InsetSpecialChar::Kind kind) { if (available()) { LyXText * lt = bv_->getLyXText(); @@ -3256,71 +3247,201 @@ void BufferView::Pimpl::menuSeparator() hideCursor(); update(lt, BufferView::SELECT|BufferView::FITCUR); InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR); - bv_->insertInset(new_inset); + new InsetSpecialChar(kind); + insertInset(new_inset); } } -void BufferView::Pimpl::endOfSentenceDot() +void BufferView::Pimpl::smartQuote() { - if (available()) { - hideCursor(); - update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE); - bv_->insertInset(new_inset); + char c; + LyXText * lt = bv_->getLyXText(); + + if (lt->cursor.pos()) + c = lt->cursor.par()->getChar(lt->cursor.pos() - 1); + else + c = ' '; + + hideCursor(); + if (!insertInset(new InsetQuotes(c, bv_->buffer()->params))) + Dispatch(LFUN_SELFINSERT, "\""); +} + + +void BufferView::Pimpl::insertAndEditInset(Inset * inset) +{ + if (insertInset(inset)) + inset->edit(bv_); + else + delete inset; +} + + +// Open and lock an updatable inset +bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind) +{ + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + finishUndo(); + if (!insertInset(new_inset)) { + delete new_inset; + return false; } + new_inset->edit(bv_, !behind); + return true; } -void BufferView::Pimpl::ldots() +bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout) { - if (available()) { - hideCursor(); - update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::LDOTS); - bv_->insertInset(new_inset); + // 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()->insetAllowed(inset)) + return bv_->theLockingInset()->insertInset(bv_, inset); + return false; } + + // not quite sure if we want this... + setCursorParUndo(bv_); + 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); + } + + 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; + } + + 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); + + unFreezeUndo(); + return true; } -void BufferView::Pimpl::hyphenationPoint() +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; + } + } 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_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::HYPHENATION); - bv_->insertInset(new_inset); + 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; + } } } -void BufferView::Pimpl::insertNote() +void BufferView::Pimpl::gotoInset(vector const & codes, + bool same_content) { - InsetInfo * new_inset = new InsetInfo(); - bv_->insertInset(new_inset); - new_inset->Edit(bv_, 0, 0, 0); + 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 { + bv_->owner()->message(_("No more insets")); + } + } + update(bv_->text, BufferView::SELECT|BufferView::FITCUR); + bv_->text->selection.cursor = bv_->text->cursor; } -// Open and lock an updatable inset -bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind) +void BufferView::Pimpl::gotoInset(Inset::Code code, bool same_content) { - LyXText * lt = bv_->getLyXText(); - - beforeChange(lt); - lt->FinishUndo(); - if (!bv_->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; + gotoInset(vector(1, code), same_content); }