#include <config.h>
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
#include "BufferView_pimpl.h"
-#include "frontends/WorkArea.h"
-#include "frontends/screen.h"
-#include "frontends/LyXScreenFactory.h"
-#include "frontends/WorkAreaFactory.h"
-#include "frontends/Dialogs.h"
-#include "frontends/Alert.h"
-#include "frontends/FileDialog.h"
-#include "lyxtext.h"
-#include "lyxrow.h"
-#include "paragraph.h"
-#include "frontends/LyXView.h"
-#include "commandtags.h"
-#include "lyxfunc.h"
-#include "debug.h"
-#include "bufferview_funcs.h"
-#include "TextCache.h"
#include "bufferlist.h"
-#include "lyxrc.h"
-#include "intl.h"
-// added for Dispatch functions
-#include "lyx_cb.h"
-#include "lyx_main.h"
+#include "buffer.h"
+#include "buffer_funcs.h"
+#include "bufferview_funcs.h"
+#include "lfuns.h"
+#include "debug.h"
+#include "factory.h"
#include "FloatList.h"
+#include "funcrequest.h"
#include "gettext.h"
+#include "intl.h"
+#include "iterators.h"
+#include "Lsstream.h"
+#include "lyx_cb.h" // added for Dispatch functions
+#include "lyx_main.h"
+#include "lyxfind.h"
+#include "lyxfunc.h"
+#include "lyxtext.h"
+#include "lyxrc.h"
+#include "lyxrow.h"
+#include "lastfiles.h"
+#include "paragraph.h"
#include "ParagraphParameters.h"
+#include "TextCache.h"
#include "undo_funcs.h"
-#include "funcrequest.h"
-#include "factory.h"
-#include "insets/insetbib.h"
-#include "insets/insettext.h"
-#include "insets/inseturl.h"
-#include "insets/insetlatexaccent.h"
-#include "insets/insettoc.h"
-#include "insets/insetref.h"
-#include "insets/insetparent.h"
-#include "insets/insetindex.h"
-#include "insets/insetinclude.h"
-#include "insets/insetcite.h"
-#include "insets/insetgraphics.h"
-#include "insets/insetmarginal.h"
-#include "insets/insettabular.h"
-#include "insets/insetcaption.h"
#include "insets/insetfloatlist.h"
+#include "insets/insetgraphics.h"
+#include "insets/insetinclude.h"
+#include "insets/insetref.h"
+#include "insets/insettext.h"
+
+#include "frontends/Alert.h"
+#include "frontends/Dialogs.h"
+#include "frontends/FileDialog.h"
+#include "frontends/LyXView.h"
+#include "frontends/LyXScreenFactory.h"
+#include "frontends/mouse_state.h"
+#include "frontends/screen.h"
+#include "frontends/WorkArea.h"
+#include "frontends/WorkAreaFactory.h"
#include "mathed/formulabase.h"
#include "graphics/Previews.h"
#include "support/LAssert.h"
-#include "support/lstrings.h"
+#include "support/tostr.h"
#include "support/filetools.h"
#include <boost/bind.hpp>
#include <boost/signals/connection.hpp>
-#include <cstdio>
#include <unistd.h>
#include <sys/wait.h>
using std::min;
using lyx::pos_type;
-
-/* the selection possible is needed, that only motion events are
- * used, where the bottom press event was on the drawing area too */
-bool selection_possible = false;
+using namespace bv_funcs;
extern BufferList bufferlist;
-extern int bibitemMaxWidth(BufferView *, LyXFont const &);
namespace {
// to these connections we avoid a segfault upon startup, and also at exit.
// (Lgb)
+boost::signals::connection dispatchcon;
boost::signals::connection timecon;
boost::signals::connection doccon;
boost::signals::connection resizecon;
-boost::signals::connection bpresscon;
-boost::signals::connection breleasecon;
-boost::signals::connection motioncon;
-boost::signals::connection doublecon;
-boost::signals::connection triplecon;
boost::signals::connection kpresscon;
boost::signals::connection selectioncon;
boost::signals::connection lostcon;
+
} // anon namespace
.connect(boost::bind(&BufferView::Pimpl::scrollDocView, this, _1));
resizecon = workarea().workAreaResize
.connect(boost::bind(&BufferView::Pimpl::workAreaResize, this));
- bpresscon = workarea().workAreaButtonPress
- .connect(boost::bind(&BufferView::Pimpl::workAreaButtonPress, this, _1, _2, _3));
- breleasecon = workarea().workAreaButtonRelease
- .connect(boost::bind(&BufferView::Pimpl::workAreaButtonRelease, this, _1, _2, _3));
- motioncon = workarea().workAreaMotionNotify
- .connect(boost::bind(&BufferView::Pimpl::workAreaMotionNotify, this, _1, _2, _3));
- doublecon = workarea().workAreaDoubleClick
- .connect(boost::bind(&BufferView::Pimpl::doubleClick, this, _1, _2, _3));
- triplecon = workarea().workAreaTripleClick
- .connect(boost::bind(&BufferView::Pimpl::tripleClick, this, _1, _2, _3));
+ dispatchcon = workarea().dispatch
+ .connect(boost::bind(&BufferView::Pimpl::workAreaDispatch, this, _1));
kpresscon = workarea().workAreaKeyPress
.connect(boost::bind(&BufferView::Pimpl::workAreaKeyPress, this, _1, _2));
selectioncon = workarea().selectionRequested
}
+void BufferView::Pimpl::addError(ErrorItem const & ei)
+{
+ errorlist_.push_back(ei);
+
+}
+
+
+bool BufferView::Pimpl::loadLyXFile(string const & filename, bool tolastfiles)
+{
+ // get absolute path of file and add ".lyx" to the filename if
+ // necessary
+ string s = FileSearch(string(), filename, "lyx");
+ if (s.empty()) {
+ s = filename;
+ }
+
+ // file already open?
+ if (bufferlist.exists(s)) {
+ string const file = MakeDisplayPath(s, 20);
+ string text = bformat(_("The document %1$s is already "
+ "loaded.\n\nDo you want to revert "
+ "to the saved version?"), file);
+ int const ret = Alert::prompt(_("Revert to saved document?"),
+ text, 0, 1, _("&Revert"), _("&Switch to document"));
+
+ if (ret != 0) {
+ buffer(bufferlist.getBuffer(s));
+ return true;
+ } else {
+ // FIXME: should be LFUN_REVERT
+ if (!bufferlist.close(bufferlist.getBuffer(s), false))
+ return false;
+ // Fall through to new load. (Asger)
+ }
+ }
+ Buffer * b = bufferlist.newBuffer(s);
+
+ bv_->resetErrorList();
+ //attach to the error signal in the buffer
+ b->parseError.connect(boost::bind(&BufferView::Pimpl::addError,
+ this, _1));
+
+ bool loaded = true;
+
+ if (! ::loadLyXFile(b, s)) {
+ bufferlist.release(b);
+ string text = bformat(_("The document %1$s does "
+ "not yet exist.\n\n"
+ "Do you want to create "
+ "a new document?"), s);
+ int const ret = Alert::prompt(_("Create new document?"),
+ text, 0, 1, _("&Create"), _("Cancel"));
+
+ if (ret == 0) {
+ bufferlist.close(buffer_, false);
+ buffer(newFile(s, string(), true));
+ }
+
+ loaded = false;
+ }
+
+ buffer(b);
+
+ if (tolastfiles)
+ lastfiles->newFile(b->fileName());
+
+ if (loaded)
+ bv_->showErrorList(_("Parse"));
+
+ return true;
+}
+
WorkArea & BufferView::Pimpl::workarea() const
{
return *workarea_.get();
void BufferView::Pimpl::buffer(Buffer * b)
{
lyxerr[Debug::INFO] << "Setting buffer in BufferView ("
- << b << ")" << endl;
+ << b << ')' << endl;
if (buffer_) {
buffer_->delUser(bv_);
// set current buffer
buffer_ = b;
- if (bufferlist.getState() == BufferList::CLOSING) return;
+ // if we're quitting lyx, don't bother updating stuff
+ if (quitting)
+ return;
// if we are closing the buffer, use the first buffer as current
if (!buffer_) {
}
// FIXME: needed when ?
- bv_->text->first_y =
- screen().topCursorVisible(bv_->text->cursor, bv_->text->first_y);
+ bv_->text->top_y(screen().topCursorVisible(bv_->text->cursor, bv_->text->top_y()));
- // Similarly, buffer-dependent dialogs should be updated or
+ // Buffer-dependent dialogs should be updated or
// hidden. This should go here because some dialogs (eg ToC)
// require bv_->text.
owner_->getDialogs().updateBufferDependent(true);
owner_->updateLayoutChoice();
owner_->updateWindowTitle();
+ if (buffer_) {
+ // Don't forget to update the Layout
+ string const layoutname =
+ bv_->text->cursor.par()->layout()->name();
+ owner_->setLayout(layoutname);
+ }
+
if (grfx::Previews::activated() && buffer_)
grfx::Previews::get().generateBufferPreviews(*buffer_);
}
ret = screen().fitCursor(bv_->text, bv_);
}
- bv_->owner()->getDialogs().updateParagraph();
- if (ret)
- updateScrollbar();
+ dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
+
+ // We need to always update, in case we did a
+ // paste and we stayed anchored to a row, but
+ // the actual height of the doc changed ...
+ updateScrollbar();
return ret;
}
{
lyxerr[Debug::INFO] << "resizeCurrentBuffer" << endl;
- Paragraph * par = 0;
- Paragraph * selstartpar = 0;
- Paragraph * selendpar = 0;
+ ParagraphList::iterator par;
+ ParagraphList::iterator selstartpar;
+ ParagraphList::iterator selendpar;
UpdatableInset * the_locking_inset = 0;
pos_type pos = 0;
bool selection = false;
bool mark_set = false;
- owner_->prohibitInput();
+ owner_->busy(true);
owner_->message(_("Formatting document..."));
mark_set = bv_->text->selection.mark();
the_locking_inset = bv_->theLockingInset();
buffer_->resizeInsets(bv_);
- // I don't think the delete and new are necessary here we just could
- // call only init! (Jug 20020419)
+ // I don't think the delete and new are necessary here we
+ // just could call only init! (Jug 20020419)
delete bv_->text;
bv_->text = new LyXText(bv_);
bv_->text->init(bv_);
// bv_->text->owner(bv_);
if (lyxerr.debugging())
textcache.show(lyxerr, "resizeCurrentBuffer");
+
+ buffer_->resizeInsets(bv_);
} else {
bv_->text = new LyXText(bv_);
bv_->text->init(bv_);
//buffer_->resizeInsets(bv_);
}
+
+ par = bv_->text->ownerParagraphs().end();
+ selstartpar = bv_->text->ownerParagraphs().end();
+ selendpar = bv_->text->ownerParagraphs().end();
}
- if (par) {
+ if (par != bv_->text->ownerParagraphs().end()) {
bv_->text->selection.set(true);
// At this point just to avoid the Delete-Empty-Paragraph-
// Mechanism when setting the cursor.
bv_->text->selection.mark(mark_set);
if (selection) {
- bv_->text->setCursor(bv_, selstartpar, selstartpos);
+ bv_->text->setCursor(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(selendpar, selendpos);
+ bv_->text->setSelection();
+ bv_->text->setCursor(par, pos);
} else {
- bv_->text->setCursor(bv_, par, pos);
+ bv_->text->setCursor(par, pos);
bv_->text->selection.cursor = bv_->text->cursor;
bv_->text->selection.set(false);
}
bv_->theLockingInset(the_locking_inset);
}
- bv_->text->first_y = screen().topCursorVisible(bv_->text->cursor, bv_->text->first_y);
+ bv_->text->top_y(screen().topCursorVisible(bv_->text->cursor, bv_->text->top_y()));
switchKeyMap();
- owner_->allowInput();
+ owner_->busy(false);
+
+ // reset the "Formatting..." message
+ owner_->clearMessage();
updateScrollbar();
LyXText const & t = *bv_->text;
- lyxerr[Debug::GUI] << "Updating scrollbar: h " << t.height << ", first_y "
- << t.first_y << ", default height " << t.defaultHeight() << endl;
+ lyxerr[Debug::GUI] << "Updating scrollbar: h " << t.height << ", top_y() "
+ << t.top_y() << ", default height " << defaultRowHeight() << endl;
- workarea().setScrollbarParams(t.height, t.first_y, t.defaultHeight());
+ workarea().setScrollbarParams(t.height, t.top_y(), defaultRowHeight());
}
{
lyxerr[Debug::GUI] << "scrollDocView of " << value << endl;
- if (!buffer_) return;
+ if (!buffer_)
+ return;
+
+ screen().hideCursor();
screen().draw(bv_->text, bv_, value);
- if (!lyxrc.cursor_follows_scrollbar) {
+ if (!lyxrc.cursor_follows_scrollbar)
return;
- }
LyXText * vbt = bv_->text;
- int const height = vbt->defaultHeight();
- int const first = static_cast<int>((bv_->text->first_y + height));
- int const last = static_cast<int>((bv_->text->first_y + workarea().workHeight() - height));
+ int const height = defaultRowHeight();
+ int const first = static_cast<int>((bv_->text->top_y() + height));
+ int const last = static_cast<int>((bv_->text->top_y() + workarea().workHeight() - height));
if (vbt->cursor.y() < first)
- vbt->setCursorFromCoordinates(bv_, 0, first);
+ vbt->setCursorFromCoordinates(0, first);
else if (vbt->cursor.y() > last)
- vbt->setCursorFromCoordinates(bv_, 0, last);
-}
-
-
-int BufferView::Pimpl::scroll(long time)
-{
- if (!buffer_)
- return 0;
-
- LyXText const * t = bv_->text;
-
- double const diff = t->defaultHeight()
- + double(time) * double(time) * 0.125;
-
- scrollDocView(int(diff));
- workarea().setScrollbarParams(t->height, t->first_y, t->defaultHeight());
- return 0;
-}
-
-
-void BufferView::Pimpl::workAreaKeyPress(LyXKeySymPtr key,
- key_modifier::state state)
-{
- bv_->owner()->getLyXFunc().processKeySym(key, state);
-}
-
-
-void BufferView::Pimpl::workAreaMotionNotify(int x, int y, mouse_button::state state)
-{
- // Only use motion with button 1
- if (!(state & mouse_button::button1))
- return;
-
- if (!buffer_)
- return;
-
- // Check for inset locking
- if (bv_->theLockingInset()) {
- LyXCursor cursor = bv_->text->cursor;
- LyXFont font = bv_->text->getFont(buffer_,
- cursor.par(), cursor.pos());
- int width = bv_->theLockingInset()->width(bv_, font);
- int inset_x = font.isVisibleRightToLeft()
- ? cursor.ix() - width : cursor.ix();
- int start_x = inset_x + bv_->theLockingInset()->scroll();
-
- FuncRequest cmd(bv_, LFUN_MOUSE_MOTION,
- x - start_x, y - cursor.iy() + bv_->text->first_y, state);
- bv_->theLockingInset()->localDispatch(cmd);
- 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
- if (!selection_possible)
- return;
-
- screen().hideCursor();
+ vbt->setCursorFromCoordinates(0, last);
- Row * cursorrow = bv_->text->cursor.row();
- bv_->text->setCursorFromCoordinates(bv_, x, y + bv_->text->first_y);
-#if 0
- // sorry for this but I have a strange error that the y value jumps at
- // a certain point. This seems like an error in my xforms library or
- // in some other local environment, but I would like to leave this here
- // for the moment until I can remove this (Jug 20020418)
- if (y_before < bv_->text->cursor.y())
- lyxerr << y_before << ":" << bv_->text->cursor.y() << endl;
-#endif
- // This is to allow jumping over large insets
- if (cursorrow == bv_->text->cursor.row()) {
- if (y >= int(workarea().workHeight())) {
- bv_->text->cursorDown(bv_, false);
- } else if (y < 0) {
- bv_->text->cursorUp(bv_, false);
- }
- }
-
- 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_);
- fitCursor();
- showCursor();
+ owner_->updateLayoutChoice();
}
-// Single-click on work area
-void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
- mouse_button::state button)
+void BufferView::Pimpl::scroll(int lines)
{
- if (!buffer_)
- return;
-
- // ok ok, this is a hack (for xforms)
- if (button == mouse_button::button4) {
- scroll(-lyxrc.wheel_jump);
- // We shouldn't go further down as we really should only do the
- // scrolling and be done with this. Otherwise we may open some
- // dialogs (Jug 20020424).
- return;
- } else if (button == mouse_button::button5) {
- scroll(lyxrc.wheel_jump);
- // We shouldn't go further down as we really should only do the
- // scrolling and be done with this. Otherwise we may open some
- // dialogs (Jug 20020424).
- return;
- }
-
- Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos);
-
- // Middle button press pastes if we have a selection
- // We do this here as if the selection was inside an inset
- // it could get cleared on the unlocking of the inset so
- // we have to check this first
- bool paste_internally = false;
- if (button == mouse_button::button2 && bv_->getLyXText()->selection.set()) {
- owner_->dispatch(FuncRequest(LFUN_COPY));
- paste_internally = true;
- }
-
- int const screen_first = bv_->text->first_y;
-
- if (bv_->theLockingInset()) {
- // We are in inset locking mode
-
- // Check whether the inset was hit. If not reset mode,
- // otherwise give the event to the inset
- if (inset_hit == bv_->theLockingInset()) {
- FuncRequest cmd(bv_, LFUN_MOUSE_PRESS, xpos, ypos, button);
- bv_->theLockingInset()->localDispatch(cmd);
- return;
- }
- bv_->unlockInset(bv_->theLockingInset());
- }
-
- if (!inset_hit)
- selection_possible = true;
- screen().hideCursor();
-
- // Clear the selection
- screen().toggleSelection(bv_->text, bv_);
- bv_->text->clearSelection();
- bv_->text->fullRebreak(bv_);
- update();
- updateScrollbar();
-
- // Single left click in math inset?
- if (isHighlyEditableInset(inset_hit)) {
- // Highly editable inset, like math
- UpdatableInset * inset = static_cast<UpdatableInset *>(inset_hit);
- selection_possible = false;
- owner_->updateLayoutChoice();
- owner_->message(inset->editMessage());
- //inset->edit(bv_, xpos, ypos, button);
- // We just have to lock the inset before calling a PressEvent on it!
- // we don't need the edit() call here! (Jug20020329)
- if (!bv_->lockInset(inset)) {
- lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
- }
- FuncRequest cmd(bv_, LFUN_MOUSE_PRESS, xpos, ypos, button);
- inset->localDispatch(cmd);
- return;
- }
- // I'm not sure we should continue here if we hit an inset (Jug20020403)
-
- // Right click on a footnote flag opens float menu
- if (button == mouse_button::button3) {
- selection_possible = false;
+ if (!buffer_) {
return;
}
- if (!inset_hit) // otherwise it was already set in checkInsetHit(...)
- 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());
-
- owner_->updateLayoutChoice();
- if (fitCursor()) {
- selection_possible = false;
- }
-
- // Insert primary selection with middle mouse
- // if there is a local selection in the current buffer,
- // insert this
- if (button == mouse_button::button2) {
- if (paste_internally)
- owner_->dispatch(FuncRequest(LFUN_PASTE));
- else
- owner_->dispatch(FuncRequest(LFUN_PASTESELECTION, "paragraph"));
- selection_possible = false;
- return;
- }
-}
+ LyXText const * t = bv_->text;
+ int const line_height = defaultRowHeight();
+ // The new absolute coordinate
+ int new_top_y = t->top_y() + lines * line_height;
-void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, mouse_button::state button)
-{
- if (!buffer_)
- return;
+ // Restrict to a valid value
+ new_top_y = std::min(t->height - 4 * line_height, new_top_y);
+ new_top_y = std::max(0, new_top_y);
- LyXText * text = bv_->getLyXText();
+ scrollDocView(new_top_y);
- if (text->bv_owner && bv_->theLockingInset())
- return;
-
- if (button == mouse_button::button1) {
- if (text->bv_owner) {
- screen().hideCursor();
- screen().toggleSelection(text, bv_);
- text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
- screen().toggleSelection(text, bv_, false);
- } else {
- text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
- }
- // This will fit the cursor on the screen if necessary
- update(text, BufferView::SELECT|BufferView::FITCUR);
- workarea().haveSelection(bv_->getLyXText()->selection.set());
- }
+ // Update the scrollbar.
+ workarea().setScrollbarParams(t->height, t->top_y(), defaultRowHeight());
}
-void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, mouse_button::state button)
+void BufferView::Pimpl::workAreaKeyPress(LyXKeySymPtr key,
+ key_modifier::state state)
{
- if (!buffer_)
- return;
-
- LyXText * text = bv_->getLyXText();
-
- if (text->bv_owner && bv_->theLockingInset())
- return;
+ bv_->owner()->getLyXFunc().processKeySym(key, state);
- if (button == mouse_button::button1) {
- if (text->bv_owner) {
- screen().hideCursor();
- screen().toggleSelection(text, bv_);
- }
- text->cursorHome(bv_);
- text->selection.cursor = text->cursor;
- text->cursorEnd(bv_);
- text->setSelection(bv_);
- if (text->bv_owner) {
- screen().toggleSelection(text, bv_, false);
- }
- // This will fit the cursor on the screen if necessary
- update(text, BufferView::SELECT|BufferView::FITCUR);
- workarea().haveSelection(bv_->getLyXText()->selection.set());
+ /* This is perhaps a bit of a hack. When we move
+ * around, or type, it's nice to be able to see
+ * the cursor immediately after the keypress. So
+ * we reset the toggle timeout and force the visibility
+ * of the cursor. Note we cannot do this inside
+ * dispatch() itself, because that's called recursively.
+ */
+ if (available()) {
+ cursor_timeout.restart();
+ screen().showCursor(*bv_);
}
}
void BufferView::Pimpl::selectionLost()
{
if (available()) {
- hideCursor();
+ screen().hideCursor();
toggleSelection();
bv_->getLyXText()->clearSelection();
- showCursor();
bv_->text->xsel_cache.set(false);
}
}
-void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
- mouse_button::state button)
-{
- // do nothing if we used the mouse wheel
- if (!buffer_ || button == mouse_button::button4 || button == mouse_button::button5)
- return;
-
- // If we hit an inset, we have the inset coordinates in these
- // and inset_hit points to the inset. If we do not hit an
- // inset, inset_hit is 0, and inset_x == x, inset_y == y.
- Inset * inset_hit = checkInsetHit(bv_->text, x, y);
-
- if (bv_->theLockingInset()) {
- // We are in inset locking mode.
-
- // LyX does a kind of work-area grabbing for insets.
- // Only a ButtonPress FuncRequest outside the inset will
- // force a insetUnlock.
- FuncRequest cmd(bv_, LFUN_MOUSE_RELEASE, x, y, button);
- bv_->theLockingInset()->localDispatch(cmd);
- return;
- }
-
- selection_possible = false;
-
- if (button == mouse_button::button2)
- return;
-
- // finish selection
- if (button == mouse_button::button1) {
- workarea().haveSelection(bv_->getLyXText()->selection.set());
- }
-
- switchKeyMap();
- owner_->view_state_changed();
- owner_->updateMenubar();
- owner_->updateToolbar();
-
- // Did we hit an editable inset?
- if (inset_hit) {
- selection_possible = false;
-
- // if we reach this point with a selection, it
- // must mean we are currently selecting.
- // But we don't want to open the inset
- // because that is annoying for the user.
- // So just pretend we didn't hit it.
- // this is OK because a "kosher" ButtonRelease
- // will follow a ButtonPress that clears
- // the selection.
- // Note this also fixes selection drawing
- // problems if we end up opening an inset
- if (bv_->getLyXText()->selection.set())
- return;
-
- // CHECK fix this proper in 0.13
- // well, maybe 13.0 !!!!!!!!!
-
- // Following a ref shouldn't issue
- // a push on the undo-stack
- // anylonger, now that we have
- // keybindings for following
- // references and returning from
- // references. IMHO though, it
- // should be the inset's own business
- // to push or not push on the undo
- // stack. They don't *have* to
- // alter the document...
- // (Joacim)
- // ...or maybe the SetCursorParUndo()
- // below isn't necessary at all anylonger?
- if (inset_hit->lyxCode() == Inset::REF_CODE) {
- setCursorParUndo(bv_);
- }
-
- owner_->message(inset_hit->editMessage());
-
- if (isHighlyEditableInset(inset_hit)) {
- // Highly editable inset, like math
- UpdatableInset *inset = (UpdatableInset *)inset_hit;
- FuncRequest cmd(bv_, LFUN_MOUSE_RELEASE, x, y, button);
- inset->localDispatch(cmd);
- } else {
- FuncRequest cmd(bv_, LFUN_MOUSE_RELEASE, x, y, button);
- inset_hit->localDispatch(cmd);
- // IMO this is a grosshack! Inset's should be changed so that
- // they call the actions they have to do with the insetButtonRel.
- // function and not in the edit(). This should be changed
- // (Jug 20020329)
-#ifdef WITH_WARNINGS
-#warning Please remove donot call inset->edit() here (Jug 20020812)
-#endif
- inset_hit->edit(bv_, x, y, button);
- }
- return;
- }
-
- // Maybe we want to edit a bibitem ale970302
- if (bv_->text->cursor.par()->bibkey) {
- bool const is_rtl = bv_->text->cursor.par()->isRightToLeftPar(buffer_->params);
- int const width = bibitemMaxWidth(bv_, buffer_->params.getLyXTextClass().defaultfont());
- if ((is_rtl && x > bv_->text->workWidth(bv_)-20-width) ||
- (!is_rtl && x < 20+width)) {
- bv_->text->cursor.par()->bibkey->edit(bv_, 0, 0, mouse_button::none);
- }
- }
-
- return;
-}
-
-
-Box BufferView::Pimpl::insetDimensions(LyXText const & text,
- LyXCursor const & cursor) const
-{
- Paragraph /*const*/ & par = *cursor.par();
- pos_type const pos = cursor.pos();
-
- lyx::Assert(par.getInset(pos));
-
- Inset const & inset(*par.getInset(pos));
-
- LyXFont const & font = text.getFont(buffer_, &par, pos);
-
- int const width = inset.width(bv_, font);
- int const inset_x = font.isVisibleRightToLeft()
- ? (cursor.ix() - width) : cursor.ix();
-
- return Box(
- inset_x + inset.scroll(),
- inset_x + width,
- cursor.iy() - inset.ascent(bv_, font),
- cursor.iy() + inset.descent(bv_, font));
-}
-
-
-Inset * BufferView::Pimpl::checkInset(LyXText const & text,
- LyXCursor const & cursor,
- int & x, int & y) const
-{
- pos_type const pos(cursor.pos());
- Paragraph /*const*/ & par(*cursor.par());
-
- if (pos >= par.size() || !par.isInset(pos)) {
- return 0;
- }
-
- Inset /*const*/ * inset = par.getInset(pos);
-
- if (!isEditableInset(inset)) {
- return 0;
- }
-
- Box b(insetDimensions(text, cursor));
-
- if (!b.contained(x, y)) {
- lyxerr[Debug::GUI] << "Missed inset at x,y " << x << "," << y
- << " box " << b << endl;
- return 0;
- }
-
- text.setCursor(bv_, &par, pos, true);
-
- x -= b.x1;
- // The origin of an inset is on the baseline
- y -= text.cursor.iy();
-
- return inset;
-}
-
-
-Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y)
-{
- int y_tmp = y + text->first_y;
-
- LyXCursor cursor;
- text->setCursorFromCoordinates(bv_, cursor, x, y_tmp);
-
- Inset * inset = checkInset(*text, cursor, x, y_tmp);
-
- if (inset) {
- y = y_tmp;
- return inset;
- }
-
- // look at previous position
- if (cursor.pos() == 0) {
- return 0;
- }
-
- // move back one
- text->setCursor(bv_, cursor, cursor.par(), cursor.pos() - 1, true);
-
- inset = checkInset(*text, cursor, x, y_tmp);
- if (inset) {
- y = y_tmp;
- }
- return inset;
-}
-
-
void BufferView::Pimpl::workAreaResize()
{
static int work_area_width;
void BufferView::Pimpl::update()
{
if (!bv_->theLockingInset() || !bv_->theLockingInset()->nodraw()) {
- LyXText::text_status st = bv_->text->status();
- screen().update(bv_->text, bv_);
- bool fitc = false;
- while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
- bv_->text->fullRebreak(bv_);
- st = LyXText::NEED_MORE_REFRESH;
- bv_->text->setCursor(bv_, bv_->text->cursor.par(),
- bv_->text->cursor.pos());
- if (bv_->text->selection.set()) {
- bv_->text->setCursor(bv_, bv_->text->selection.start,
- bv_->text->selection.start.par(),
- bv_->text->selection.start.pos());
- bv_->text->setCursor(bv_, bv_->text->selection.end,
- bv_->text->selection.end.par(),
- bv_->text->selection.end.pos());
- }
- fitc = true;
- bv_->text->status(bv_, st);
- screen().update(bv_->text, bv_);
- }
- // do this here instead of in the screen::update because of
- // the above loop!
- bv_->text->status(bv_, LyXText::UNCHANGED);
- if (fitc)
- fitCursor();
+ screen().update(*bv_);
+ bv_->text->clearPaint();
}
}
-// Values used when calling update:
-// -3 - update
-// -2 - update, move sel_cursor if selection, fitcursor
-// -1 - update, move sel_cursor if selection, fitcursor, mark dirty
-// 0 - update, move sel_cursor if selection, fitcursor
-// 1 - update, move sel_cursor if selection, fitcursor, mark dirty
-// 3 - update, move sel_cursor if selection
-//
-// update -
-// a simple redraw of the parts that need refresh
-//
-// move sel_cursor if selection -
-// the text's sel_cursor is moved if there is selection is progress
-//
-// fitcursor -
-// fitCursor() is called and the scrollbar updated
-//
-// mark dirty -
-// the buffer is marked dirty.
-//
-// enum {
-// UPDATE = 0,
-// SELECT = 1,
-// FITCUR = 2,
-// CHANGE = 4
-// };
-//
-// UPDATE_ONLY = UPDATE;
-// UPDATE_SELECT = UPDATE | SELECT;
-// UPDATE_SELECT_MOVE = UPDATE | SELECT | FITCUR;
-// UPDATE_SELECT_MOVE_AFTER_CHANGE = UPDATE | SELECT | FITCUR | CHANGE;
-//
-// update(-3) -> update(0) -> update(0) -> update(UPDATE)
-// update(-2) -> update(1 + 2) -> update(3) -> update(SELECT|FITCUR)
-// update(-1) -> update(1 + 2 + 4) -> update(7) -> update(SELECT|FITCUR|CHANGE)
-// update(1) -> update(1 + 2 + 4) -> update(7) -> update(SELECT|FITCUR|CHANGE)
-// update(3) -> update(1) -> update(1) -> update(SELECT)
void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f)
{
- owner_->updateLayoutChoice();
-
if (!text->selection.set() && (f & SELECT)) {
text->selection.cursor = text->cursor;
}
- text->fullRebreak(bv_);
+ text->fullRebreak();
if (text->inset_owner) {
text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
- updateInset(text->inset_owner, false);
+ updateInset(text->inset_owner);
} else {
update();
}
+}
- if ((f & FITCUR)) {
- fitCursor();
+
+void BufferView::Pimpl::update(BufferView::UpdateCodes f)
+{
+ LyXText * text = bv_->text;
+
+ if (!text->selection.set() && (f & SELECT)) {
+ text->selection.cursor = text->cursor;
}
- if ((f & CHANGE)) {
- buffer_->markDirty();
+ text->fullRebreak();
+
+ if (text->inset_owner) {
+ text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
+ updateInset(text->inset_owner);
+ } else {
+ update();
}
}
return;
}
- /* FIXME */
- extern void reapSpellchecker(void);
- reapSpellchecker();
-
- if (!bv_->theLockingInset()) {
- screen().cursorToggle(bv_);
- } else {
- bv_->theLockingInset()->toggleInsetCursor(bv_);
- }
+ screen().toggleCursor(*bv_);
cursor_timeout.restart();
}
}
+Change const BufferView::Pimpl::getCurrentChange()
+{
+ if (!bv_->buffer()->params.tracking_changes)
+ return Change(Change::UNCHANGED);
+
+ LyXText * t(bv_->getLyXText());
+
+ if (!t->selection.set())
+ return Change(Change::UNCHANGED);
+
+ LyXCursor const & cur(t->selection.start);
+ return cur.par()->lookupChangeFull(cur.pos());
+}
+
+
void BufferView::Pimpl::beforeChange(LyXText * text)
{
toggleSelection();
saved_positions[i] = Position(buffer_->fileName(),
bv_->text->cursor.par()->id(),
bv_->text->cursor.pos());
- if (i > 0) {
- ostringstream str;
- str << _("Saved bookmark") << ' ' << i;
- owner_->message(str.str().c_str());
- }
+ if (i > 0)
+ owner_->message(bformat(_("Saved bookmark %1$s"), tostr(i)));
}
beforeChange(bv_->text);
if (fname != buffer_->fileName()) {
- Buffer * b = bufferlist.exists(fname) ?
- bufferlist.getBuffer(fname) :
- bufferlist.loadLyXFile(fname); // don't ask, just load it
- if (b != 0) buffer(b);
+ Buffer * b;
+ if (bufferlist.exists(fname))
+ b = bufferlist.getBuffer(fname);
+ else {
+ b = bufferlist.newBuffer(fname);
+ ::loadLyXFile(b, fname); // don't ask, just load it
+ }
+ if (b != 0)
+ buffer(b);
}
- Paragraph * par = buffer_->getParFromID(saved_positions[i].par_id);
- if (!par)
+ ParIterator par = buffer_->getParFromID(saved_positions[i].par_id);
+ if (par == buffer_->par_iterator_end())
return;
- bv_->text->setCursor(bv_, par,
+ bv_->text->setCursor(par.pit(),
min(par->size(), saved_positions[i].par_pos));
- update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
- if (i > 0) {
- ostringstream str;
- str << _("Moved to bookmark") << ' ' << i;
- owner_->message(str.str().c_str());
- }
+ update(BufferView::SELECT);
+ if (i > 0)
+ owner_->message(bformat(_("Moved to bookmark %1$s"), tostr(i)));
}
}
-void BufferView::Pimpl::showCursor()
-{
- if (bv_->theLockingInset())
- bv_->theLockingInset()->showInsetCursor(bv_);
- else
- screen().showCursor(bv_->text, bv_);
-}
-
-
-void BufferView::Pimpl::hideCursor()
-{
- if (!bv_->theLockingInset())
- screen().hideCursor();
-}
-
-
void BufferView::Pimpl::toggleSelection(bool b)
{
if (bv_->theLockingInset())
new_y = t->cursor.y() - half_height;
}
+ // FIXME: look at this comment again ...
+
// FIXME: can we do this w/o calling screen directly ?
- // This updates first_y but means the fitCursor() call
+ // This updates top_y() but means the fitCursor() call
// from the update(FITCUR) doesn't realise that we might
// have moved (e.g. from GOTOPARAGRAPH), so doesn't cause
// the scrollbar to be updated as it should, so we have
// to do it manually. Any operation that does a center()
- // and also might have moved first_y must make sure to call
+ // and also might have moved top_y() must make sure to call
// updateScrollbar() currently. Never mind that this is a
- // pretty obfuscated way of updating t->first_y
+ // pretty obfuscated way of updating t->top_y()
screen().draw(t, bv_, new_y);
- update(t, BufferView::SELECT | BufferView::FITCUR);
+ update(BufferView::SELECT);
}
*/
-void BufferView::Pimpl::moveCursorUpdate(bool selecting, bool fitcur)
-{
- LyXText * lt = bv_->getLyXText();
-
- if (selecting || lt->selection.mark()) {
- lt->setSelection(bv_);
- if (lt->bv_owner)
- toggleToggle();
- else
- updateInset(lt->inset_owner, false);
- }
- if (lt->bv_owner) {
- if (fitcur)
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- else
- update(lt, BufferView::SELECT);
- showCursor();
- } else if (bv_->text->status() != LyXText::UNCHANGED) {
- bv_->theLockingInset()->hideInsetCursor(bv_);
- update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
- showCursor();
- }
-
- if (!lt->selection.set())
- workarea().haveSelection(false);
-
- switchKeyMap();
-}
-
-
Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code)
{
#if 0
initpath = trypath;
}
- FileDialog fileDlg(bv_->owner(),
- _("Select LyX document to insert"),
+ FileDialog fileDlg(_("Select LyX document to insert"),
LFUN_FILE_INSERT,
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
string(AddPath(system_lyxdir, "examples"))));
FileDialog::Result result =
- fileDlg.Select(initpath,
+ fileDlg.open(initpath,
_("*.lyx| LyX Documents (*.lyx)"));
if (result.first == FileDialog::Later)
// necessary
filename = FileSearch(string(), filename, "lyx");
- string const disp_fn(MakeDisplayPath(filename));
-
- ostringstream s1;
- s1 << _("Inserting document") << ' '
- << disp_fn << " ...";
- owner_->message(s1.str().c_str());
+ string const disp_fn = MakeDisplayPath(filename);
+ owner_->message(bformat(_("Inserting document %1$s..."), disp_fn));
bool const res = bv_->insertLyXFile(filename);
- if (res) {
- ostringstream str;
- str << _("Document") << ' ' << disp_fn
- << ' ' << _("inserted.");
- owner_->message(str.str().c_str());
+ if (res)
+ owner_->message(bformat(_("Document %1$s inserted."), disp_fn));
+ else
+ owner_->message(bformat(_("Could not insert document %1$s"), disp_fn));
+}
+
+
+void BufferView::Pimpl::trackChanges()
+{
+ Buffer * buf(bv_->buffer());
+ bool const tracking(buf->params.tracking_changes);
+
+ if (!tracking) {
+ ParIterator const end = buf->par_iterator_end();
+ for (ParIterator it = buf->par_iterator_begin(); it != end; ++it)
+ it->trackChanges();
+ buf->params.tracking_changes = true;
+
+ // we cannot allow undos beyond the freeze point
+ buf->undostack.clear();
} else {
- ostringstream str;
- str << _("Could not insert document") << ' '
- << disp_fn;
- owner_->message(str.str().c_str());
+ update(BufferView::SELECT);
+ bv_->text->setCursor(buf->paragraphs.begin(), 0);
+#warning changes FIXME
+ //moveCursorUpdate(false);
+
+ bool found = lyxfind::findNextChange(bv_);
+ if (found) {
+ owner_->getDialogs().show("changes");
+ return;
+ }
+
+ ParIterator const end = buf->par_iterator_end();
+ for (ParIterator it = buf->par_iterator_begin(); it != end; ++it)
+ it->untrackChanges();
+ buf->params.tracking_changes = false;
}
+
+ buf->redostack.clear();
}
-bool BufferView::Pimpl::dispatch(FuncRequest const & ev)
+// Doesn't go through lyxfunc, so we need to update the
+// layout choice etc. ourselves
+bool BufferView::Pimpl::workAreaDispatch(FuncRequest const & ev_in)
{
- lyxerr[Debug::ACTION] << "BufferView::Pimpl::Dispatch: action["
- << ev.action <<"] arg[" << ev.argument << "]" << endl;
+ // e.g. Qt mouse press when no buffer
+ if (!available())
+ return false;
- LyXTextClass const & tclass = buffer_->params.getLyXTextClass();
+ screen().hideCursor();
- switch (ev.action) {
+ bool const res = dispatch(ev_in);
- case LFUN_TOC_INSERT:
- {
- InsetCommandParams p;
- p.setCmdName("tableofcontents");
- Inset * inset = new InsetTOC(p);
- if (!insertInset(inset, tclass.defaultLayoutName()))
- delete inset;
- break;
- }
+ // see workAreaKeyPress
+ cursor_timeout.restart();
+ screen().showCursor(*bv_);
- case LFUN_SCROLL_INSET:
- // this is not handled here as this function is only active
- // if we have a locking_inset and that one is (or contains)
- // a tabular-inset
- break;
+ // FIXME: we should skip these when selecting
+ bv_->owner()->updateLayoutChoice();
+ bv_->owner()->updateToolbar();
+ bv_->fitCursor();
- case LFUN_INSET_GRAPHICS:
- {
- Inset * new_inset = new InsetGraphics;
- if (!insertInset(new_inset)) {
- delete new_inset;
- } else {
- // this is need because you don't use a inset->Edit()
- updateInset(new_inset, true);
- new_inset->edit(bv_);
- }
- break;
- }
+ // slight hack: this is only called currently when
+ // we clicked somewhere, so we force through the display
+ // of the new status here.
+ bv_->owner()->clearMessage();
- case LFUN_LAYOUT_COPY:
- bv_->copyEnvironment();
- break;
+ return res;
+}
- case LFUN_LAYOUT_PASTE:
- bv_->pasteEnvironment();
- switchKeyMap();
- break;
- case LFUN_DEPTH_MIN:
- changeDepth(bv_, bv_->getLyXText(), -1);
- break;
+bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
+{
+ // Make sure that the cached BufferView is correct.
+ FuncRequest ev = ev_in;
+ ev.setView(bv_);
+
+ lyxerr[Debug::ACTION] << "BufferView::Pimpl::Dispatch:"
+ << " action[" << ev.action << ']'
+ << " arg[" << ev.argument << ']'
+ << " x[" << ev.x << ']'
+ << " y[" << ev.y << ']'
+ << " button[" << ev.button() << ']'
+ << endl;
- case LFUN_DEPTH_PLUS:
- changeDepth(bv_, bv_->getLyXText(), 1);
- break;
+ LyXTextClass const & tclass = buffer_->params.getLyXTextClass();
+
+ switch (ev.action) {
- case LFUN_FREE:
- owner_->getDialogs().setUserFreeFont();
+ case LFUN_SCROLL_INSET:
+ // this is not handled here as this function is only active
+ // if we have a locking_inset and that one is (or contains)
+ // a tabular-inset
break;
case LFUN_FILE_INSERT:
owner_->getLyXFunc().setMessage(currentState(bv_));
break;
- case LFUN_INSERT_LABEL:
- MenuInsertLabel(bv_, ev.argument);
- break;
-
- case LFUN_REF_INSERT:
- if (ev.argument.empty()) {
- InsetCommandParams p("ref");
- owner_->getDialogs().createRef(p.getAsString());
- } else {
- InsetCommandParams p;
- p.setFromString(ev.argument);
-
- InsetRef * inset = new InsetRef(p, *buffer_);
- if (!insertInset(inset))
- delete inset;
- else
- updateInset(inset, true);
- }
- break;
+ case LFUN_INSERT_LABEL: {
+ // Try and generate a valid label
+ string const contents = ev.argument.empty() ?
+ getPossibleLabel(*bv_) : ev.argument;
+ InsetCommandParams icp("label", contents);
+ string data = InsetCommandMailer::params2string("label", icp);
+ owner_->getDialogs().show("label", data, 0);
+ }
+ break;
case LFUN_BOOKMARK_SAVE:
savePosition(strToUnsignedInt(ev.argument));
restorePosition(strToUnsignedInt(ev.argument));
break;
- case LFUN_REF_GOTO:
- {
+ case LFUN_REF_GOTO: {
string label = ev.argument;
if (label.empty()) {
InsetRef * inset =
}
}
- if (!label.empty()) {
- //bv_->savePosition(0);
- if (!bv_->gotoLabel(label))
- Alert::alert(_("Error"),
- _("Couldn't find this label"),
- _("in current document."));
- }
+ if (!label.empty())
+ bv_->gotoLabel(label);
}
break;
- case LFUN_HTMLURL:
- case LFUN_URL:
- {
- InsetCommandParams p;
- if (ev.action == LFUN_HTMLURL)
- p.setCmdName("htmlurl");
- else
- p.setCmdName("url");
- owner_->getDialogs().createUrl(p.getAsString());
- }
- break;
-
- case LFUN_INSERT_URL:
- {
- InsetCommandParams p;
- p.setFromString(ev.argument);
-
- InsetUrl * inset = new InsetUrl(p);
- if (!insertInset(inset))
- delete inset;
- else
- updateInset(inset, true);
- }
- break;
-
-#if 0
- case LFUN_INSET_LIST:
- case LFUN_INSET_THEOREM:
-#endif
- case LFUN_INSERT_NOTE:
- case LFUN_INSET_ERT:
- case LFUN_INSET_EXTERNAL:
- case LFUN_INSET_FLOAT:
- case LFUN_INSET_FOOTNOTE:
- case LFUN_INSET_MARGINAL:
- case LFUN_INSET_MINIPAGE:
- case LFUN_INSET_OPTARG:
- case LFUN_INSET_WIDE_FLOAT:
- {
- FuncRequest cmd = ev;
- cmd.setView(bv_);
- Inset * inset = createInset(cmd);
- if (inset) {
- bool gotsel = false;
-
- if (bv_->getLyXText()->selection.set()) {
- bv_->getLyXText()->cutSelection(bv_, true, false);
- gotsel = true;
- }
-
- if (insertInset(inset)) {
- inset->edit(bv_);
- if (gotsel)
- owner_->dispatch(FuncRequest(LFUN_PASTESELECTION));
- }
- else
- delete inset;
- }
- break;
- }
-
- case LFUN_INSET_CAPTION:
- {
- // Do we have a locking inset...
- if (bv_->theLockingInset()) {
- lyxerr << "Locking inset code: "
- << static_cast<int>(bv_->theLockingInset()->lyxCode());
- InsetCaption * new_inset =
- new InsetCaption(buffer_->params);
- new_inset->setOwner(bv_->theLockingInset());
- 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;
- }
- }
- break;
-
- case LFUN_TABULAR_INSERT:
- {
- if (ev.argument.empty()) {
- owner_->getDialogs().showTabularCreate();
- break;
- }
-
- int r = 2;
- int c = 2;
- ::sscanf(ev.argument.c_str(),"%d%d", &r, &c);
- InsetTabular * new_inset =
- new InsetTabular(*buffer_, r, c);
- bool const rtl =
- bv_->getLyXText()->real_current_font.isRightToLeft();
- if (!open_new_inset(new_inset, rtl))
- delete new_inset;
- }
- break;
-
-
// --- accented characters ---------------------------
case LFUN_UMLAUT:
owner_->getLyXFunc().handleKeyFunc(ev.action);
owner_->getIntl().getTransManager()
.TranslateAndInsert(ev.argument[0], bv_->getLyXText());
- update(bv_->getLyXText(),
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
+ update(bv_->getLyXText(), BufferView::SELECT);
}
break;
case LFUN_MATH_IMPORT_SELECTION: // Imports LaTeX from the X selection
case LFUN_MATH_DISPLAY: // Open or create a displayed math inset
case LFUN_MATH_MODE: // Open or create an inlined math inset
- case LFUN_GREEK: // Insert a single greek letter
- mathDispatch(FuncRequest(bv_, ev.action, ev.argument));
+ mathDispatch(ev);
break;
- case LFUN_CITATION_INSERT:
- {
- InsetCommandParams p;
- p.setFromString(ev.argument);
-
- InsetCitation * inset = new InsetCitation(p);
- if (!insertInset(inset))
- delete inset;
- else
- updateInset(inset, true);
- }
- break;
-
- case LFUN_INSERT_BIBTEX:
- {
- // ale970405+lasgoutt970425
- // The argument can be up to two tokens separated
- // by a space. The first one is the bibstyle.
- string const db = token(ev.argument, ' ', 0);
- string bibstyle = token(ev.argument, ' ', 1);
- if (bibstyle.empty())
- bibstyle = "plain";
-
- InsetCommandParams p("BibTeX", db, bibstyle);
- InsetBibtex * inset = new InsetBibtex(p);
-
- if (insertInset(inset)) {
- if (ev.argument.empty())
- inset->edit(bv_);
- } else
- delete inset;
- }
- break;
+ case LFUN_INSET_APPLY: {
+ string const name = ev.getArg(0);
- // BibTeX data bases
- case LFUN_BIBDB_ADD:
- {
- InsetBibtex * inset =
- static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
+ InsetBase * inset = owner_->getDialogs().getOpenInset(name);
if (inset) {
- inset->addDatabase(ev.argument);
+ // This works both for 'original' and 'mathed' insets.
+ // Note that the localDispatch performs updateInset
+ // also.
+ FuncRequest fr(bv_, LFUN_INSET_MODIFY, ev.argument);
+ inset->localDispatch(fr);
+ } else {
+ FuncRequest fr(bv_, LFUN_INSET_INSERT, ev.argument);
+ dispatch(fr);
}
}
break;
- case LFUN_BIBDB_DEL:
- {
- InsetBibtex * inset =
- static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
- if (inset) {
- inset->delDatabase(ev.argument);
+ case LFUN_INSET_INSERT: {
+ Inset * inset = createInset(ev);
+ if (inset && insertInset(inset)) {
+ updateInset(inset);
+
+ string const name = ev.getArg(0);
+ if (name == "bibitem") {
+ // We need to do a redraw because the maximum
+ // InsetBibitem width could have changed
+#warning please check you mean repaint() not update(),
+#warning and whether the repaint() is needed at all
+ bv_->repaint();
+ bv_->fitCursor();
+ }
+ } else {
+ delete inset;
}
}
break;
- case LFUN_BIBTEX_STYLE:
- {
- InsetBibtex * inset =
- static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
- if (inset) {
- inset->setOptions(ev.argument);
+ case LFUN_FLOAT_LIST:
+ if (tclass.floats().typeExist(ev.argument)) {
+ Inset * inset = new InsetFloatList(ev.argument);
+ if (!insertInset(inset, tclass.defaultLayoutName()))
+ delete inset;
+ } else {
+ lyxerr << "Non-existent float type: "
+ << ev.argument << endl;
}
- }
- break;
-
- case LFUN_INDEX_INSERT:
- {
- string entry = ev.argument;
- if (entry.empty())
- entry = bv_->getLyXText()->getStringToIndex(bv_);
+ break;
- if (entry.empty()) {
- owner_->getDialogs().createIndex();
+ case LFUN_LAYOUT_PARAGRAPH: {
+ Paragraph const * par = &*bv_->getLyXText()->cursor.par();
+ if (!par)
break;
- }
-
- InsetIndex * inset = new InsetIndex(InsetCommandParams("index", entry));
- if (!insertInset(inset)) {
- delete inset;
- } else {
- updateInset(inset, true);
- }
- }
- break;
+ string data;
+ params2string(*par, data);
- case LFUN_INDEX_PRINT:
- {
- InsetCommandParams p("printindex");
- Inset * inset = new InsetPrintIndex(p);
- if (!insertInset(inset, tclass.defaultLayoutName()))
- delete inset;
+ data = "show\n" + data;
+ bv_->owner()->getDialogs().show("paragraph", data);
+ break;
}
- break;
- case LFUN_PARENTINSERT:
- {
- InsetCommandParams p("lyxparent", ev.argument);
- Inset * inset = new InsetParent(p, *buffer_);
- if (!insertInset(inset, tclass.defaultLayoutName()))
- delete inset;
- }
+ case LFUN_PARAGRAPH_UPDATE: {
+ if (!bv_->owner()->getDialogs().visible("paragraph"))
+ break;
+ Paragraph const * par = &*bv_->getLyXText()->cursor.par();
+ if (!par)
+ break;
- break;
+ string data;
+ params2string(*par, data);
- case LFUN_CHILD_INSERT:
- {
- InsetInclude::Params p;
- p.cparams.setFromString(ev.argument);
- p.masterFilename_ = buffer_->fileName();
+ // Will the paragraph accept changes from the dialog?
+ Inset * const inset = par->inInset();
+ bool const accept =
+ !(inset && inset->forceDefaultParagraphs(inset));
- InsetInclude * inset = new InsetInclude(p);
- if (!insertInset(inset))
- delete inset;
- else {
- updateInset(inset, true);
- bv_->owner()->getDialogs().showInclude(inset);
- }
+ data = "update " + tostr(accept) + '\n' + data;
+ bv_->owner()->getDialogs().update("paragraph", data);
+ break;
}
- break;
- case LFUN_FLOAT_LIST:
- if (floatList.typeExist(ev.argument)) {
- Inset * inset = new InsetFloatList(ev.argument);
- if (!insertInset(inset, tclass.defaultLayoutName()))
- delete inset;
- } else {
- lyxerr << "Non-existent float type: "
- << ev.argument << endl;
- }
+ case LFUN_PARAGRAPH_APPLY:
+ setParagraphParams(*bv_, ev.argument);
break;
case LFUN_THESAURUS_ENTRY:
// FIXME
if (arg.size() > 100 || arg.empty()) {
// Get word or selection
- bv_->getLyXText()->selectWordWhenUnderCursor(bv_, LyXText::WHOLE_WORD);
+ bv_->getLyXText()->selectWordWhenUnderCursor(LyXText::WHOLE_WORD);
arg = bv_->getLyXText()->selectionAsString(buffer_, false);
// FIXME: where is getLyXText()->unselect(bv_) ?
}
}
- bv_->owner()->getDialogs().showThesaurus(arg);
+ bv_->owner()->getDialogs().show("thesaurus", arg);
}
break;
- case LFUN_UNKNOWN_ACTION:
- ev.errorMessage(N_("Unknown function!"));
+ case LFUN_TRACK_CHANGES:
+ trackChanges();
break;
- default:
- FuncRequest cmd = ev;
- cmd.setView(bv_);
- return bv_->getLyXText()->dispatch(cmd);
- } // end of switch
+ case LFUN_MERGE_CHANGES:
+ owner_->getDialogs().show("changes");
+ break;
- return true;
-}
+ case LFUN_ACCEPT_ALL_CHANGES: {
+ update(BufferView::SELECT);
+ bv_->text->setCursor(bv_->buffer()->paragraphs.begin(), 0);
+#warning FIXME changes
+ //moveCursorUpdate(false);
+ while (lyxfind::findNextChange(bv_)) {
+ bv_->getLyXText()->acceptChange();
+ }
+ update(BufferView::SELECT);
+ break;
+ }
-// Open and lock an updatable inset
-bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind)
-{
- LyXText * lt = bv_->getLyXText();
+ case LFUN_REJECT_ALL_CHANGES: {
+ update(BufferView::SELECT);
+ bv_->text->setCursor(bv_->buffer()->paragraphs.begin(), 0);
+#warning FIXME changes
+ //moveCursorUpdate(false);
- beforeChange(lt);
- finishUndo();
- if (!insertInset(new_inset)) {
- delete new_inset;
- return false;
+ while (lyxfind::findNextChange(bv_)) {
+ bv_->getLyXText()->rejectChange();
+ }
+ update(BufferView::SELECT);
+ break;
}
- new_inset->edit(bv_, !behind);
+
+ case LFUN_ACCEPT_CHANGE: {
+ bv_->getLyXText()->acceptChange();
+ update(BufferView::SELECT);
+ break;
+ }
+
+ case LFUN_REJECT_CHANGE: {
+ bv_->getLyXText()->rejectChange();
+ update(BufferView::SELECT);
+ break;
+ }
+
+ case LFUN_UNKNOWN_ACTION:
+ ev.errorMessage(N_("Unknown function!"));
+ break;
+
+ default:
+ return bv_->getLyXText()->dispatch(FuncRequest(ev, bv_));
+ } // end of switch
+
return true;
}
// inset there otherwise this is a illegal function now
if (bv_->theLockingInset()) {
if (bv_->theLockingInset()->insetAllowed(inset))
- return bv_->theLockingInset()->insertInset(bv_, inset);
+ return bv_->theLockingInset()->insertInset(bv_, inset);
return false;
}
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);
+ update(BufferView::SELECT);
+ bv_->text->breakParagraph(bv_->buffer()->paragraphs);
+ update(BufferView::SELECT);
if (!bv_->text->cursor.par()->empty()) {
bv_->text->cursorLeft(bv_);
- bv_->text->breakParagraph(bv_);
- update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ bv_->text->breakParagraph(bv_->buffer()->paragraphs);
+ update(BufferView::SELECT);
}
string lres = lout;
lay = tclass.defaultLayoutName();
}
- bv_->text->setLayout(bv_, lay);
+ bv_->text->setLayout(lay);
- bv_->text->setParagraph(bv_, 0, 0,
+ bv_->text->setParagraph(0, 0,
0, 0,
VSpace(VSpace::NONE), VSpace(VSpace::NONE),
Spacing(),
LYX_ALIGN_LAYOUT,
string(),
0);
- update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ update(BufferView::SELECT);
}
- bv_->text->insertInset(bv_, inset);
- update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ bv_->text->insertInset(inset);
+ update(BufferView::SELECT);
unFreezeUndo();
return true;
}
-void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
+void BufferView::Pimpl::updateInset(Inset * inset)
{
if (!inset || !available())
return;
// first check for locking insets
if (bv_->theLockingInset()) {
if (bv_->theLockingInset() == inset) {
- if (bv_->text->updateInset(bv_, inset)) {
+ if (bv_->text->updateInset(inset)) {
update();
- if (mark_dirty) {
- buffer_->markDirty();
- }
updateScrollbar();
return;
}
} else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) {
- if (bv_->text->updateInset(bv_, bv_->theLockingInset())) {
+ if (bv_->text->updateInset(bv_->theLockingInset())) {
update();
- if (mark_dirty) {
- buffer_->markDirty();
- }
updateScrollbar();
return;
}
Inset * tl_inset = inset;
while (tl_inset->owner())
tl_inset = tl_inset->owner();
- hideCursor();
if (tl_inset == 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);
- }
+ update(BufferView::UPDATE);
+ if (bv_->text->updateInset(inset)) {
+ update(BufferView::SELECT);
return;
}
} else if (static_cast<UpdatableInset *>(tl_inset)
->updateInsetInInset(bv_, inset))
{
- if (bv_->text->updateInset(bv_, tl_inset)) {
+ if (bv_->text->updateInset(tl_inset)) {
update();
updateScrollbar();
}