* Copyright 2002 the LyX Team
* Read the file COPYING
*
+ * \author Lars Gullik Bjønnes
* \author various
*/
#include "BufferView_pimpl.h"
#include "bufferlist.h"
+#include "buffer.h"
+#include "buffer_funcs.h"
#include "bufferview_funcs.h"
-#include "commandtags.h"
+#include "lfuns.h"
#include "debug.h"
#include "factory.h"
#include "FloatList.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 "lyxtext.h"
#include "lyxrc.h"
#include "lyxrow.h"
+#include "lastfiles.h"
#include "paragraph.h"
#include "ParagraphParameters.h"
#include "TextCache.h"
#include "graphics/Previews.h"
#include "support/LAssert.h"
-#include "support/lstrings.h"
+#include "support/tostr.h"
#include "support/filetools.h"
+#include "support/path_defines.h"
#include <boost/bind.hpp>
#include <boost/signals/connection.hpp>
-#include "BoostFormat.h"
#include <unistd.h>
#include <sys/wait.h>
using std::min;
using lyx::pos_type;
+using namespace lyx::support;
+using namespace bv_funcs;
extern BufferList bufferlist;
resizecon = workarea().workAreaResize
.connect(boost::bind(&BufferView::Pimpl::workAreaResize, this));
dispatchcon = workarea().dispatch
- .connect(boost::bind(&BufferView::Pimpl::dispatch, this, _1));
+ .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);
+}
+
+
+void BufferView::Pimpl::showReadonly(bool)
+{
+ owner_->updateWindowTitle();
+ owner_->getDialogs().updateBufferDependent(false);
+}
+
+
+void BufferView::Pimpl::connectBuffer(Buffer & buf)
+{
+ if (errorConnection_.connected())
+ disconnectBuffer();
+
+ errorConnection_ = buf.error.connect(boost::bind(&BufferView::Pimpl::addError, this, _1));
+ messageConnection_ = buf.message.connect(boost::bind(&LyXView::message, owner_, _1));
+ busyConnection_ = buf.busy.connect(boost::bind(&LyXView::busy, owner_, _1));
+ titleConnection_ = buf.updateTitles.connect(boost::bind(&LyXView::updateWindowTitle, owner_));
+ timerConnection_ = buf.resetAutosaveTimers.connect(boost::bind(&LyXView::resetAutosaveTimer, owner_));
+ readonlyConnection_ = buf.readonly.connect(boost::bind(&BufferView::Pimpl::showReadonly, this, _1));
+ closingConnection_ = buf.closing.connect(boost::bind(&BufferView::Pimpl::buffer, this, (Buffer *)0));
+}
+
+
+void BufferView::Pimpl::disconnectBuffer()
+{
+ errorConnection_.disconnect();
+ messageConnection_.disconnect();
+ busyConnection_.disconnect();
+ titleConnection_.disconnect();
+ timerConnection_.disconnect();
+ readonlyConnection_.disconnect();
+ closingConnection_.disconnect();
+}
+
+
+bool BufferView::Pimpl::newFile(string const & filename,
+ string const & tname,
+ bool isNamed)
+{
+ Buffer * b = ::newFile(filename, tname, isNamed);
+ buffer(b);
+ return true;
+}
+
+
+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);
+
+ connectBuffer(*b);
+
+ if (! ::loadLyXFile(b, s)) {
+ bufferlist.release(b);
+ string text = bformat(_("The document %1$s does not yet "
+ "exist.\n\nDo you want to create "
+ "a new document?"), s);
+ int const ret = Alert::prompt(_("Create new document?"),
+ text, 0, 1, _("&Create"), _("Cancel"));
+
+ if (ret != 0)
+ return false;
+ }
+
+ buffer(b);
+
+ if (tolastfiles)
+ lastfiles->newFile(b->fileName());
+
+ bv_->showErrorList(_("Parse"));
+
+ return true;
+}
+
+
WorkArea & BufferView::Pimpl::workarea() const
{
return *workarea_.get();
lyxerr[Debug::INFO] << "Setting buffer in BufferView ("
<< b << ')' << endl;
if (buffer_) {
- buffer_->delUser(bv_);
-
+ disconnectBuffer();
// Put the old text into the TextCache, but
// only if the buffer is still loaded.
// Also set the owner of the test to 0
if (buffer_) {
lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl;
- buffer_->addUser(bv_);
+ connectBuffer(*buffer_);
// If we don't have a text object for this, we make one
if (bv_->text == 0) {
}
// FIXME: needed when ?
- bv_->text->top_y(screen().topCursorVisible(bv_->text->cursor, bv_->text->top_y()));
+ bv_->text->top_y(screen().topCursorVisible(bv_->text));
- // 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 (grfx::Previews::activated() && buffer_)
- grfx::Previews::get().generateBufferPreviews(*buffer_);
+ if (buffer_) {
+ // Don't forget to update the Layout
+ string const layoutname =
+ bv_->text->cursor.par()->layout()->name();
+ owner_->setLayout(layoutname);
+ }
+
+ if (lyx::graphics::Previews::activated() && buffer_)
+ lyx::graphics::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;
selection = bv_->text->selection.set();
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)
- delete bv_->text;
- bv_->text = new LyXText(bv_);
- bv_->text->init(bv_);
+ resizeInsets(bv_);
+ bv_->text->fullRebreak();
+ update();
} else {
+ lyxerr << "text not available!\n";
// See if we have a text in TextCache that fits
// the new buffer_ with the correct width.
bv_->text = textcache.findFit(buffer_, workarea().workWidth());
if (bv_->text) {
+ lyxerr << "text in cache!\n";
if (lyxerr.debugging()) {
lyxerr << "Found a LyXText that fits:\n";
textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea().workWidth(), bv_->text)));
if (lyxerr.debugging())
textcache.show(lyxerr, "resizeCurrentBuffer");
- buffer_->resizeInsets(bv_);
+ resizeInsets(bv_);
} else {
+ lyxerr << "no text in cache!\n";
bv_->text = new LyXText(bv_);
+ resizeInsets(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->top_y(screen().topCursorVisible(bv_->text->cursor, bv_->text->top_y()));
+ bv_->text->top_y(screen().topCursorVisible(bv_->text));
switchKeyMap();
owner_->busy(false);
+ // reset the "Formatting..." message
+ owner_->clearMessage();
+
updateScrollbar();
return 0;
if (!buffer_)
return;
+ screen().hideCursor();
+
screen().draw(bv_->text, bv_, value);
if (!lyxrc.cursor_follows_scrollbar)
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);
+ vbt->setCursorFromCoordinates(0, last);
+
+ owner_->updateLayoutChoice();
}
key_modifier::state state)
{
bv_->owner()->getLyXFunc().processKeySym(key, state);
+
+ /* 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);
}
}
textcache.show(lyxerr, "Expose delete all");
textcache.clear();
// FIXME: this is already done in resizeCurrentBuffer() ??
- buffer_->resizeInsets(bv_);
+ resizeInsets(bv_);
} else if (heightChange) {
// fitCursor() ensures we don't jump back
// to the start of the document on vertical
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->partialRebreak();
if (text->inset_owner) {
- text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
- updateInset(text->inset_owner, false);
+ text->inset_owner->setUpdateStatus(InsetText::NONE);
+ 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->partialRebreak();
+
+ if (text->inset_owner) {
+ text->inset_owner->setUpdateStatus(InsetText::NONE);
+ updateInset(text->inset_owner);
+ } else {
+ update();
}
}
return;
}
- if (!bv_->theLockingInset()) {
- screen().cursorToggle(bv_);
- } else {
- bv_->theLockingInset()->toggleInsetCursor(bv_);
- }
+ screen().toggleCursor(*bv_);
cursor_timeout.restart();
}
saved_positions[i] = Position(buffer_->fileName(),
bv_->text->cursor.par()->id(),
bv_->text->cursor.pos());
- if (i > 0) {
- ostringstream str;
-#if USE_BOOST_FORMAT
- str << boost::format(_("Saved bookmark %1$d")) % i;
-#else
- str << _("Saved bookmark ") << i;
-#endif
- owner_->message(STRCONV(str.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;
-#if USE_BOOST_FORMAT
- str << boost::format(_("Moved to bookmark %1$d")) % i;
-#else
- str << _("Moved to bookmark ") << i;
-#endif
- owner_->message(STRCONV(str.str()));
- }
+ update(BufferView::SELECT);
+ if (i > 0)
+ owner_->message(bformat(_("Moved to bookmark %1$s"), tostr(i)));
}
LyXText * text = bv_->getLyXText();
if (text->real_current_font.isRightToLeft()
&& !(bv_->theLockingInset()
- && bv_->theLockingInset()->lyxCode() == Inset::ERT_CODE))
+ && bv_->theLockingInset()->lyxCode() == InsetOld::ERT_CODE))
{
if (owner_->getIntl().keymap == Intl::PRIMARY)
owner_->getIntl().KeyMapSec();
}
-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 top_y() but means the fitCursor() call
// from the update(FITCUR) doesn't realise that we might
// pretty obfuscated way of updating t->top_y()
screen().draw(t, bv_, new_y);
- update(t, BufferView::SELECT | BufferView::FITCUR);
+ update(BufferView::SELECT);
}
*/
-Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code)
+InsetOld * BufferView::Pimpl::getInsetByCode(InsetOld::Code code)
{
#if 0
LyXCursor cursor = bv_->getLyXText()->cursor;
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir, "examples"))));
+ string(AddPath(system_lyxdir(), "examples"))));
FileDialog::Result result =
fileDlg.open(initpath,
// necessary
filename = FileSearch(string(), filename, "lyx");
- string const disp_fn(MakeDisplayPath(filename));
-
- ostringstream s1;
-#if USE_BOOST_FORMAT
- s1 << boost::format(_("Inserting document %1$s...")) % disp_fn;
-#else
- s1 << _("Inserting document ") << disp_fn << _("...");
-#endif
- owner_->message(STRCONV(s1.str()));
- bool const res = bv_->insertLyXFile(filename);
- if (res) {
- ostringstream str;
-#if USE_BOOST_FORMAT
- str << boost::format(_("Document %1$s inserted.")) % disp_fn;
-#else
- str << _("Document ") << disp_fn << _(" inserted.");
-#endif
- owner_->message(STRCONV(str.str()));
- } else {
- ostringstream str;
-#if USE_BOOST_FORMAT
- str << boost::format(_("Could not insert document %1$s")) % disp_fn;
-#else
- str << _("Could not insert document ") << disp_fn;
-#endif
- owner_->message(STRCONV(str.str()));
- }
+ string const disp_fn = MakeDisplayPath(filename);
+ owner_->message(bformat(_("Inserting document %1$s..."), disp_fn));
+ if (bv_->insertLyXFile(filename))
+ owner_->message(bformat(_("Document %1$s inserted."),
+ disp_fn));
+ else
+ owner_->message(bformat(_("Could not insert document %1$s"),
+ disp_fn));
}
if (!tracking) {
ParIterator const end = buf->par_iterator_end();
- for (ParIterator it = buf->par_iterator_begin(); it != end; ++it) {
- (*it)->trackChanges();
- }
+ 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 {
- bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
- bv_->text->setCursor(bv_, &(*buf->paragraphs.begin()), 0);
+ update(BufferView::SELECT);
+ bv_->text->setCursor(buf->paragraphs.begin(), 0);
#warning changes FIXME
//moveCursorUpdate(false);
- bool found = lyxfind::findNextChange(bv_);
+ bool found = lyx::find::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();
- }
+ for (ParIterator it = buf->par_iterator_begin(); it != end; ++it)
+ it->untrackChanges();
buf->params.tracking_changes = false;
}
}
+// Doesn't go through lyxfunc, so we need to update the
+// layout choice etc. ourselves
+bool BufferView::Pimpl::workAreaDispatch(FuncRequest const & ev_in)
+{
+ // e.g. Qt mouse press when no buffer
+ if (!available())
+ return false;
+
+ screen().hideCursor();
+
+ // Make sure that the cached BufferView is correct.
+ FuncRequest ev = ev_in;
+ ev.setView(bv_);
+
+ bool const res = dispatch(ev);
+
+ // see workAreaKeyPress
+ cursor_timeout.restart();
+ screen().showCursor(*bv_);
+
+ // FIXME: we should skip these when selecting
+ bv_->owner()->updateLayoutChoice();
+ bv_->owner()->updateToolbar();
+ bv_->fitCursor();
+
+ // 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();
+
+ return res;
+}
+
+
bool BufferView::Pimpl::dispatch(FuncRequest const & ev_in)
{
// Make sure that the cached BufferView is correct.
<< " button[" << ev.button() << ']'
<< endl;
- // e.g. Qt mouse press when no buffer
- if (!buffer_)
- return false;
-
LyXTextClass const & tclass = buffer_->params.getLyXTextClass();
switch (ev.action) {
// a tabular-inset
break;
- case LFUN_LAYOUT_COPY:
- bv_->copyEnvironment();
- break;
-
- case LFUN_LAYOUT_PASTE:
- bv_->pasteEnvironment();
- switchKeyMap();
- break;
-
- case LFUN_DEPTH_MIN:
- changeDepth(bv_, bv_->getLyXText(), -1);
- break;
-
- case LFUN_DEPTH_PLUS:
- changeDepth(bv_, bv_->getLyXText(), 1);
- break;
-
- case LFUN_FREE:
- owner_->getDialogs().setUserFreeFont();
- break;
-
case LFUN_FILE_INSERT:
MenuInsertLyXFile(ev.argument);
break;
restorePosition(strToUnsignedInt(ev.argument));
break;
- case LFUN_REF_GOTO:
- {
+ case LFUN_REF_GOTO: {
string label = ev.argument;
if (label.empty()) {
InsetRef * inset =
- static_cast<InsetRef*>(getInsetByCode(Inset::REF_CODE));
+ static_cast<InsetRef*>(getInsetByCode(InsetOld::REF_CODE));
if (inset) {
label = inset->getContents();
savePosition(0);
}
}
- 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;
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(ev);
break;
case LFUN_INSET_APPLY: {
string const name = ev.getArg(0);
- InsetBase * base = owner_->getDialogs().getOpenInset(name);
- if (base) {
+ InsetBase * inset = owner_->getDialogs().getOpenInset(name);
+ if (inset) {
// This works both for 'original' and 'mathed' insets.
// Note that the localDispatch performs updateInset
// also.
FuncRequest fr(bv_, LFUN_INSET_MODIFY, ev.argument);
- base->localDispatch(fr);
+ inset->localDispatch(fr);
} else {
- Inset * inset = createInset(ev);
- if (inset && insertInset(inset)) {
- updateInset(inset, true);
- } else {
- delete inset;
- }
+ FuncRequest fr(bv_, LFUN_INSET_INSERT, ev.argument);
+ dispatch(fr);
}
+ }
+ break;
- if (name == "bibitem") {
- // We need to do a redraw because the maximum
- // InsetBibitem width could have changed
+ case LFUN_INSET_INSERT: {
+ InsetOld * 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();
+ bv_->repaint();
+ bv_->fitCursor();
+ }
+ } else {
+ delete inset;
}
}
break;
case LFUN_FLOAT_LIST:
if (tclass.floats().typeExist(ev.argument)) {
- Inset * inset = new InsetFloatList(ev.argument);
+ InsetOld * inset = new InsetFloatList(ev.argument);
if (!insertInset(inset, tclass.defaultLayoutName()))
delete inset;
} else {
}
break;
+ case LFUN_LAYOUT_PARAGRAPH: {
+ Paragraph const * par = &*bv_->getLyXText()->cursor.par();
+ if (!par)
+ break;
+
+ string data;
+ params2string(*par, data);
+
+ data = "show\n" + data;
+ bv_->owner()->getDialogs().show("paragraph", data);
+ break;
+ }
+
+ case LFUN_PARAGRAPH_UPDATE: {
+ if (!bv_->owner()->getDialogs().visible("paragraph"))
+ break;
+ Paragraph const * par = &*bv_->getLyXText()->cursor.par();
+ if (!par)
+ break;
+
+ string data;
+ params2string(*par, data);
+
+ // Will the paragraph accept changes from the dialog?
+ InsetOld * const inset = par->inInset();
+ bool const accept =
+ !(inset && inset->forceDefaultParagraphs(inset));
+
+ data = "update " + tostr(accept) + '\n' + data;
+ bv_->owner()->getDialogs().update("paragraph", data);
+ break;
+ }
+
+ case LFUN_PARAGRAPH_APPLY:
+ setParagraphParams(*bv_, ev.argument);
+ break;
+
case LFUN_THESAURUS_ENTRY:
{
string arg = ev.argument;
// FIXME
if (arg.size() > 100 || arg.empty()) {
// Get word or selection
- bv_->getLyXText()->selectWordWhenUnderCursor(bv_, LyXText::WHOLE_WORD);
+ bv_->getLyXText()->selectWordWhenUnderCursor(lyx::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;
break;
case LFUN_ACCEPT_ALL_CHANGES: {
- bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
- bv_->text->setCursor(bv_, &(*bv_->buffer()->paragraphs.begin()), 0);
+ update(BufferView::SELECT);
+ bv_->text->setCursor(bv_->buffer()->paragraphs.begin(), 0);
#warning FIXME changes
//moveCursorUpdate(false);
- while (lyxfind::findNextChange(bv_)) {
- bv_->getLyXText()->acceptChange(bv_);
+ while (lyx::find::findNextChange(bv_)) {
+ bv_->getLyXText()->acceptChange();
}
- update(bv_->text,
- BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
+ update(BufferView::SELECT);
break;
}
case LFUN_REJECT_ALL_CHANGES: {
- bv_->update(bv_->text, BufferView::SELECT | BufferView::FITCUR);
- bv_->text->setCursor(bv_, &(*bv_->buffer()->paragraphs.begin()), 0);
+ update(BufferView::SELECT);
+ bv_->text->setCursor(bv_->buffer()->paragraphs.begin(), 0);
#warning FIXME changes
//moveCursorUpdate(false);
- while (lyxfind::findNextChange(bv_)) {
- bv_->getLyXText()->rejectChange(bv_);
+ while (lyx::find::findNextChange(bv_)) {
+ bv_->getLyXText()->rejectChange();
}
- update(bv_->text,
- BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
+ update(BufferView::SELECT);
break;
}
case LFUN_ACCEPT_CHANGE: {
- bv_->getLyXText()->acceptChange(bv_);
- update(bv_->text,
- BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
+ bv_->getLyXText()->acceptChange();
+ update(BufferView::SELECT);
break;
}
case LFUN_REJECT_CHANGE: {
- bv_->getLyXText()->rejectChange(bv_);
- update(bv_->text,
- BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE);
+ bv_->getLyXText()->rejectChange();
+ update(BufferView::SELECT);
break;
}
}
-bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
+bool BufferView::Pimpl::insertInset(InsetOld * inset, string const & lout)
{
// if we are in a locking inset we should try to insert the
// inset there otherwise this is a illegal function now
}
// not quite sure if we want this...
- setCursorParUndo(bv_);
+ recordUndo(bv_, Undo::ATOMIC);
freezeUndo();
beforeChange(bv_->text);
if (!lout.empty()) {
- update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
- bv_->text->breakParagraph(bv_, bv_->buffer()->paragraphs);
- 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_, bv_->buffer()->paragraphs);
- 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(InsetOld * 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;
}
// then check if the inset is a top_level inset (has no owner)
// if yes do the update as always otherwise we have to update the
// toplevel inset where this inset is inside
- Inset * tl_inset = inset;
+ InsetOld * 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();
}