#include "TextMetrics.h"
#include "TexRow.h"
#include "TocBackend.h"
-#include "VSpace.h"
#include "WordLangTuple.h"
#include "insets/InsetBibtex.h"
+#include "insets/InsetCitation.h"
#include "insets/InsetCommand.h" // ChangeRefs
#include "insets/InsetExternal.h"
#include "insets/InsetGraphics.h"
#include "frontends/Painter.h"
#include "frontends/Selection.h"
-#include "graphics/Previews.h"
-
#include "support/convert.h"
#include "support/debug.h"
#include "support/ExceptionMessage.h"
#include "support/filetools.h"
#include "support/gettext.h"
+#include "support/lassert.h"
#include "support/lstrings.h"
#include "support/Package.h"
#include "support/types.h"
return 0;
}
+
/// Note that comparing contents can only be used for InsetCommand
bool findNextInset(DocIterator & dit, vector<InsetCode> const & codes,
docstring const & contents)
/** kept to send setMouseHover(false).
* Not owned, so don't delete.
*/
- Inset * last_inset_;
+ Inset const * last_inset_;
/// are we hovering something that we can click
bool clickable_inset_;
d->cursor_.resetAnchor();
d->cursor_.setCurrentFont();
- if (graphics::Previews::status() != LyXRC::PREVIEW_OFF)
- thePreviews().generateBufferPreviews(buffer_);
+ buffer_.updatePreviews();
}
}
-docstring BufferView::contextMenu(int x, int y) const
+string BufferView::contextMenu(int x, int y) const
{
//If there is a selection, return the containing inset menu
if (d->cursor_.selection())
// FIXME: Care about the d->cursor_ flags to redraw if needed
Cursor old = d->cursor_;
mouseSetCursor(cur);
- bool badcursor = notifyCursorLeavesOrEnters(old, d->cursor_);
+ // the DEPM call in mouseSetCursor() might have destroyed the
+ // paragraph the cursor is in.
+ bool badcursor = old.fixIfBroken();
+ badcursor |= notifyCursorLeavesOrEnters(old, d->cursor_);
if (badcursor)
d->cursor_.fixIfBroken();
}
if (recenter)
scrolled = scroll(ypos - height_/2);
+ // We try to visualize the whole row, if the row height is larger than
+ // the screen height, we scroll to a heuristic value of height_ / 4.
+ // FIXME: This heuristic value should be replaced by a recursive search
+ // for a row in the inset that can be visualized completely.
+ else if (row_dim.height() > height_) {
+ if (ypos < defaultRowHeight())
+ scrolled = scroll(ypos - height_ / 4);
+ else if (ypos > height_ - defaultRowHeight())
+ scrolled = scroll(ypos - 3 * height_ / 4);
+ }
+
// If the top part of the row falls of the screen, we scroll
// up to align the top of the row with the top of the screen.
- else if (ypos - row_dim.ascent() < 0)
- scrolled = scrollUp(-ypos + row_dim.ascent());
+ else if (ypos - row_dim.ascent() < 0 && ypos < height_) {
+ int ynew = row_dim.ascent();
+ scrolled = scrollUp(ynew - ypos);
+ }
// If the bottom of the row falls of the screen, we scroll down.
- // However, we have to be careful not to scroll that much that
- // the top falls of the screen.
- else if (ypos + row_dim.descent() > height_) {
+ else if (ypos + row_dim.descent() > height_ && ypos > 0) {
int ynew = height_ - row_dim.descent();
- if (ynew < row_dim.ascent())
- ynew = row_dim.ascent();
- int const scroll = ypos - ynew;
- scrolled = scrollDown(scroll);
+ scrolled = scrollDown(ypos - ynew);
}
// else, nothing to do, the cursor is already visible so we just return.
}
-void BufferView::updateDocumentClass(DocumentClass const * const olddc)
+void BufferView::makeDocumentClass()
+{
+ DocumentClassConstPtr olddc = buffer_.params().documentClassPtr();
+ buffer_.params().makeDocumentClass();
+ updateDocumentClass(olddc);
+}
+
+
+void BufferView::updateDocumentClass(DocumentClassConstPtr olddc)
{
message(_("Converting document to new document class..."));
buffer_.errors("Class Switch");
}
+
/** Return the change status at cursor position, taking in account the
* status at each level of the document iterator (a table in a deleted
* footnote is deleted).
// buffer clean/dirty status by itself.
flag.setEnabled(!buffer_.isReadonly() && buffer_.undo().hasRedoStack());
break;
- case LFUN_FILE_INSERT:
case LFUN_FILE_INSERT_PLAINTEXT_PARA:
- case LFUN_FILE_INSERT_PLAINTEXT:
+ case LFUN_FILE_INSERT_PLAINTEXT: {
+ docstring const fname = cmd.argument();
+ if (!FileName::isAbsolute(to_utf8(fname))) {
+ flag.message(_("Absolute filename expected."));
+ return false;
+ }
+ flag.setEnabled(cur.inTexted());
+ break;
+ }
+ case LFUN_FILE_INSERT:
case LFUN_BOOKMARK_SAVE:
// FIXME: Actually, these LFUNS should be moved to Text
flag.setEnabled(cur.inTexted());
case LFUN_WORD_FIND:
case LFUN_WORD_FIND_FORWARD:
case LFUN_WORD_FIND_BACKWARD:
- case LFUN_WORD_FINDADV:
case LFUN_WORD_REPLACE:
case LFUN_MARK_OFF:
case LFUN_MARK_ON:
flag.setEnabled(true);
break;
+ case LFUN_WORD_FINDADV: {
+ FindAndReplaceOptions opt;
+ istringstream iss(to_utf8(cmd.argument()));
+ iss >> opt;
+ flag.setEnabled(opt.repl_buf_name.empty()
+ || !buffer_.isReadonly());
+ }
+
case LFUN_LABEL_GOTO: {
flag.setEnabled(!cmd.argument().empty()
|| getInsetByCode<InsetRef>(cur, REF_CODE));
if (cur.inset().lyxCode() == CAPTION_CODE)
return cur.inset().getStatus(cur, cmd, flag);
// FIXME we should consider passthru paragraphs too.
- flag.setEnabled(!cur.inset().getLayout().isPassThru());
+ flag.setEnabled(!(cur.inTexted() && cur.paragraph().isPassThru()));
break;
case LFUN_CITATION_INSERT: {
break;
}
+ // FIXME We do not really want this here, but at present we need to
+ // handle their dispatch here, for reasons explained there, so we'll
+ // handle this here, too, for consistency.
+ case LFUN_BRANCH_ACTIVATE:
+ case LFUN_BRANCH_DEACTIVATE:
+ case LFUN_BRANCH_MASTER_ACTIVATE:
+ case LFUN_BRANCH_MASTER_DEACTIVATE: {
+ bool const master = (cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE
+ || cmd.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
+ BranchList const & branchList = master ? buffer().masterBuffer()->params().branchlist()
+ : buffer().params().branchlist();
+ docstring const branchName = cmd.argument();
+ flag.setEnabled(!branchName.empty() && branchList.find(branchName));
+ break;
+ }
+
default:
return false;
}
void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
{
- //lyxerr << [ cmd = " << cmd << "]" << endl;
-
- // Make sure that the cached BufferView is correct.
- LYXERR(Debug::ACTION, " action[" << cmd.action() << ']'
- << " arg[" << to_utf8(cmd.argument()) << ']'
- << " x[" << cmd.x() << ']'
- << " y[" << cmd.y() << ']'
- << " button[" << cmd.button() << ']');
+ LYXERR(Debug::ACTION, "BufferView::dispatch: cmd: " << cmd);
string const argument = to_utf8(cmd.argument());
Cursor & cur = d->cursor_;
switch (act) {
case LFUN_BUFFER_PARAMS_APPLY: {
- DocumentClass const * const oldClass = buffer_.params().documentClassPtr();
+ DocumentClassConstPtr olddc = buffer_.params().documentClassPtr();
cur.recordUndoFullDocument();
istringstream ss(to_utf8(cmd.argument()));
Lexer lex;
<< unknown_tokens << " unknown token"
<< (unknown_tokens == 1 ? "" : "s"));
}
- updateDocumentClass(oldClass);
+ updateDocumentClass(olddc);
// We are most certainly here because of a change in the document
// It is then better to make sure that all dialogs are in sync with
}
case LFUN_LAYOUT_MODULES_CLEAR: {
- DocumentClass const * const oldClass =
- buffer_.params().documentClassPtr();
cur.recordUndoFullDocument();
buffer_.params().clearLayoutModules();
- buffer_.params().makeDocumentClass();
- updateDocumentClass(oldClass);
+ makeDocumentClass();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
break;
case LFUN_LAYOUT_MODULE_ADD: {
BufferParams const & params = buffer_.params();
- if (!params.moduleCanBeAdded(argument)) {
+ if (!params.layoutModuleCanBeAdded(argument)) {
LYXERR0("Module `" << argument <<
"' cannot be added due to failed requirements or "
"conflicts with installed modules.");
break;
}
- DocumentClass const * const oldClass = params.documentClassPtr();
cur.recordUndoFullDocument();
buffer_.params().addLayoutModule(argument);
- buffer_.params().makeDocumentClass();
- updateDocumentClass(oldClass);
+ makeDocumentClass();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
break;
break;
// Save the old, possibly modular, layout for use in conversion.
- DocumentClass const * const oldDocClass =
- buffer_.params().documentClassPtr();
cur.recordUndoFullDocument();
buffer_.params().setBaseClass(argument);
- buffer_.params().makeDocumentClass();
- updateDocumentClass(oldDocClass);
+ makeDocumentClass();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
break;
}
case LFUN_LAYOUT_RELOAD: {
- DocumentClass const * const oldClass = buffer_.params().documentClassPtr();
LayoutFileIndex bc = buffer_.params().baseClassID();
LayoutFileList::get().reset(bc);
buffer_.params().setBaseClass(bc);
- buffer_.params().makeDocumentClass();
- updateDocumentClass(oldClass);
+ makeDocumentClass();
dr.screenUpdate(Update::Force);
dr.forceBufferUpdate();
break;
buffer_.text().cursorBottom(cur);
// accept everything in a single step to support atomic undo
buffer_.text().acceptOrRejectChanges(cur, Text::ACCEPT);
+ cur.resetAnchor();
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
dr.screenUpdate(Update::Force | Update::FitCursor);
dr.forceBufferUpdate();
// reject everything in a single step to support atomic undo
// Note: reject does not work recursively; the user may have to repeat the operation
buffer_.text().acceptOrRejectChanges(cur, Text::REJECT);
+ cur.resetAnchor();
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
dr.screenUpdate(Update::Force | Update::FitCursor);
dr.forceBufferUpdate();
FindAndReplaceOptions opt;
istringstream iss(to_utf8(cmd.argument()));
iss >> opt;
- if (findAdv(this, opt))
+ if (findAdv(this, opt)) {
dr.screenUpdate(Update::Force | Update::FitCursor);
+ cur.dispatched();
+ dispatched = true;
+ } else {
+ cur.undispatched();
+ dispatched = false;
+ }
break;
}
from = doc_iterator_begin(&buffer_);
to = doc_iterator_end(&buffer_);
}
- int const words = countWords(from, to);
- int const chars = countChars(from, to, false);
- int const chars_blanks = countChars(from, to, true);
+ buffer_.updateStatistics(from, to);
+ int const words = buffer_.wordCount();
+ int const chars = buffer_.charCount(false);
+ int const chars_blanks = buffer_.charCount(true);
docstring message;
if (cur.selection())
message = _("Statistics for the selection:");
p = Point(width_, height_);
Cursor old = cur;
bool const in_texted = cur.inTexted();
- cur.reset();
+ cur.setCursor(doc_iterator_begin(cur.buffer()));
+ cur.selHandle(false);
buffer_.changed(true);
updateHoveredInset();
//FIXME: what to do with cur.x_target()?
bool update = in_texted && cur.bv().checkDepm(cur, old);
cur.finishUndo();
- if (update) {
- dr.screenUpdate(Update::Force | Update::FitCursor);
+
+ if (update || cur.mark())
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ if (update)
dr.forceBufferUpdate();
- }
break;
}
- case LFUN_SCROLL:
- lfunScroll(cmd);
+ case LFUN_SCROLL: {
+ string const scroll_type = cmd.getArg(0);
+ int scroll_step = 0;
+ if (scroll_type == "line")
+ scroll_step = d->scrollbarParameters_.single_step;
+ else if (scroll_type == "page")
+ scroll_step = d->scrollbarParameters_.page_step;
+ else
+ return;
+ string const scroll_quantity = cmd.getArg(1);
+ if (scroll_quantity == "up")
+ scrollUp(scroll_step);
+ else if (scroll_quantity == "down")
+ scrollDown(scroll_step);
+ else {
+ int const scroll_value = convert<int>(scroll_quantity);
+ if (scroll_value)
+ scroll(scroll_step * scroll_value);
+ }
+ buffer_.changed(true);
+ updateHoveredInset();
dr.forceBufferUpdate();
break;
+ }
case LFUN_SCREEN_UP_SELECT: {
+ // FIXME: why is the algorithm different from LFUN_SCREEN_UP?
cur.selHandle(true);
if (isTopScreen()) {
lyx::dispatch(FuncRequest(LFUN_BUFFER_BEGIN_SELECT));
}
case LFUN_SCREEN_DOWN_SELECT: {
+ // FIXME: why is the algorithm different from LFUN_SCREEN_DOWN?
cur.selHandle(true);
if (isBottomScreen()) {
lyx::dispatch(FuncRequest(LFUN_BUFFER_END_SELECT));
FuncRequest const fr = lyxaction.lookupFunc(commandstr);
// an arbitrary number to limit number of iterations
- const int max_iter = 10000;
+ const int max_iter = 100000;
int iterations = 0;
Cursor & cur = d->cursor_;
Cursor const savecur = cur;
cur.forwardInset();
cur.beginUndoGroup();
while(cur && iterations < max_iter) {
- Inset * ins = cur.nextInset();
+ Inset * const ins = cur.nextInset();
if (!ins)
break;
- docstring insname = ins->name();
+ docstring insname = ins->layoutName();
while (!insname.empty()) {
if (insname == name || name == from_utf8("*")) {
cur.recordUndo();
break;
insname = insname.substr(0, i);
}
- cur.forwardInset();
+ // if we did not delete the inset, skip it
+ if (!cur.nextInset() || cur.nextInset() == ins)
+ cur.forwardInset();
}
cur.endUndoGroup();
cur = savecur;
arg = token(argument, '|', 0);
opt1 = token(argument, '|', 1);
}
+
+ // if our cursor is direclty in front of or behind a citation inset,
+ // we will instead add the new key to it.
+ Inset * inset = cur.nextInset();
+ if (!inset || inset->lyxCode() != CITE_CODE)
+ inset = cur.prevInset();
+ if (inset && inset->lyxCode() == CITE_CODE) {
+ InsetCitation * icite = static_cast<InsetCitation *>(inset);
+ if (icite->addKey(arg)) {
+ dr.forceBufferUpdate();
+ dr.screenUpdate(Update::FitCursor | Update::SinglePar);
+ if (!opt1.empty())
+ LYXERR0("Discarding optional argument to citation-insert.");
+ }
+ dispatched = true;
+ break;
+ }
InsetCommandParams icp(CITE_CODE);
icp["key"] = from_utf8(arg);
if (!opt1.empty())
break;
}
+ // FIXME:
+ // The change of language of buffer belongs to the Buffer class.
+ // We have to do it here because we need a cursor for Undo.
+ // When Undo::recordUndoBufferParams() is implemented someday
+ // LFUN_BUFFER_LANGUAGE should be handled by the Buffer class.
+ case LFUN_BUFFER_LANGUAGE: {
+ Language const * oldL = buffer_.params().language;
+ Language const * newL = languages.getLanguage(argument);
+ if (!newL || oldL == newL)
+ break;
+ if (oldL->rightToLeft() == newL->rightToLeft()) {
+ cur.recordUndoFullDocument();
+ buffer_.changeLanguage(oldL, newL);
+ cur.setCurrentFont();
+ dr.forceBufferUpdate();
+ }
+ break;
+ }
+
+ case LFUN_FILE_INSERT_PLAINTEXT_PARA:
+ case LFUN_FILE_INSERT_PLAINTEXT: {
+ bool const as_paragraph = (act == LFUN_FILE_INSERT_PLAINTEXT_PARA);
+ string const fname = to_utf8(cmd.argument());
+ if (!FileName::isAbsolute(fname))
+ dr.setMessage(_("Absolute filename expected."));
+ else
+ insertPlaintextFile(FileName(fname), as_paragraph);
+ break;
+ }
+
+ // FIXME We do not really want this here, but it has to be at present
+ // because we need a cursor for the recordUndoFullDocument call. What
+ // we would really like is a recordUndoBufferParams call that did not
+ // need a cursor, but we do not have that yet.
+ // So, if this does get fixed, this code can be moved back to Buffer.cpp,
+ // and the corresponding code in getStatus() should be moved back, too.
+ case LFUN_BRANCH_ACTIVATE:
+ case LFUN_BRANCH_DEACTIVATE:
+ case LFUN_BRANCH_MASTER_ACTIVATE:
+ case LFUN_BRANCH_MASTER_DEACTIVATE: {
+ bool const master = (cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE
+ || cmd.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
+ Buffer * buf = master ? const_cast<Buffer *>(buffer().masterBuffer())
+ : &buffer();
+
+ docstring const branch_name = cmd.argument();
+ // the case without a branch name is handled elsewhere
+ if (branch_name.empty()) {
+ dispatched = false;
+ break;
+ }
+ Branch * branch = buf->params().branchlist().find(branch_name);
+ if (!branch) {
+ LYXERR0("Branch " << branch_name << " does not exist.");
+ dr.setError(true);
+ docstring const msg =
+ bformat(_("Branch \"%1$s\" does not exist."), branch_name);
+ dr.setMessage(msg);
+ break;
+ }
+ bool activate = (cmd.action() == LFUN_BRANCH_ACTIVATE
+ || cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE);
+ if (branch->isSelected() != activate) {
+ branch->setSelected(activate);
+ cur.recordUndoFullDocument();
+ dr.setError(false);
+ dr.screenUpdate(Update::Force);
+ dr.forceBufferUpdate();
+ }
+ break;
+ }
+
default:
- dispatched = false;
+ // OK, so try the Buffer itself...
+ buffer_.dispatch(cmd, dr);
+ dispatched = dr.dispatched();
break;
}
buffer_.undo().endUndoGroup();
dr.dispatched(dispatched);
- return;
}
d->last_inset_ = 0;
}
- // const_cast because of setMouseHover().
- Inset * inset = const_cast<Inset *>(covering_inset);
- if (inset && inset->setMouseHover(this, true)) {
+ if (covering_inset && covering_inset->setMouseHover(this, true)) {
need_redraw = true;
// Only the insets that accept the hover state, do
// clear the last_inset_, so only set the last_inset_
// member if the hovered setting is accepted.
- d->last_inset_ = inset;
+ d->last_inset_ = covering_inset;
}
if (need_redraw) {
// Notify left insets
if (cur != old) {
- old.fixIfBroken();
- bool badcursor = notifyCursorLeavesOrEnters(old, cur);
+ bool badcursor = old.fixIfBroken() | cur.fixIfBroken();
+ badcursor |= notifyCursorLeavesOrEnters(old, cur);
if (badcursor)
cursor().fixIfBroken();
}
// Do we have a selection?
theSelection().haveSelection(cursor().selection());
+ if (cur.needBufferUpdate()) {
+ cur.clearBufferUpdate();
+ buffer().updateBuffer();
+ }
+
// If the command has been dispatched,
if (cur.result().dispatched() || cur.result().screenUpdate())
processUpdateFlags(cur.result().screenUpdate());
}
-void BufferView::lfunScroll(FuncRequest const & cmd)
-{
- string const scroll_type = cmd.getArg(0);
- int scroll_step = 0;
- if (scroll_type == "line")
- scroll_step = d->scrollbarParameters_.single_step;
- else if (scroll_type == "page")
- scroll_step = d->scrollbarParameters_.page_step;
- else
- return;
- string const scroll_quantity = cmd.getArg(1);
- if (scroll_quantity == "up")
- scrollUp(scroll_step);
- else if (scroll_quantity == "down")
- scrollDown(scroll_step);
- else {
- int const scroll_value = convert<int>(scroll_quantity);
- if (scroll_value)
- scroll(scroll_step * scroll_value);
- }
- buffer_.changed(true);
- updateHoveredInset();
-}
-
-
int BufferView::minVisiblePart()
{
return 2 * defaultRowHeight();
void BufferView::setCursorFromRow(int row)
{
- int tmpid = -1;
- int tmppos = -1;
+ int tmpid;
+ int tmppos;
+ pit_type newpit = 0;
+ pos_type newpos = 0;
buffer_.texrow().getIdFromRow(row, tmpid, tmppos);
+ bool posvalid = (tmpid != -1);
+ if (posvalid) {
+ // we need to make sure that the row and position
+ // we got back are valid, because the buffer may well
+ // have changed since we last generated the LaTeX.
+ DocIterator const dit = buffer_.getParFromID(tmpid);
+ if (dit == doc_iterator_end(&buffer_))
+ posvalid = false;
+ else {
+ newpit = dit.pit();
+ // now have to check pos.
+ newpos = tmppos;
+ Paragraph const & par = buffer_.text().getPar(newpit);
+ if (newpos > par.size()) {
+ LYXERR0("Requested position no longer valid.");
+ newpos = par.size() - 1;
+ }
+ }
+ }
+ if (!posvalid) {
+ frontend::Alert::error(_("Inverse Search Failed"),
+ _("Invalid position requested by inverse search.\n"
+ "You need to update the viewed document."));
+ return;
+ }
d->cursor_.reset();
- if (tmpid == -1)
- buffer_.text().setCursor(d->cursor_, 0, 0);
- else
- buffer_.text().setCursor(d->cursor_, buffer_.getParFromID(tmpid).pit(), tmppos);
+ buffer_.text().setCursor(d->cursor_, newpit, newpos);
+ d->cursor_.setSelection(false);
+ d->cursor_.resetAnchor();
recenter();
}
TextMetrics & BufferView::textMetrics(Text const * t)
{
+ LASSERT(t, /**/);
TextMetricsCache::iterator tmc_it = d->text_metrics_.find(t);
if (tmc_it == d->text_metrics_.end()) {
tmc_it = d->text_metrics_.insert(
d->cursor_.setCursor(dit);
d->cursor_.setSelection(false);
+ // FIXME
+ // It seems on general grounds as if this is probably needed, but
+ // it is not yet clear.
+ // See bug #7394 and r38388.
+ // d->cursor.resetAnchor();
}
d->cursor_ = cur;
cur.forceBufferUpdate();
- buffer_.changed(true);
+ cur.screenUpdateFlags(Update::Force);
return true;
}
cap::saveSelection(cursor());
d->cursor_.macroModeClose();
+ // If a macro has been finalized, the cursor might have been broken
+ cur.fixIfBroken();
// Has the cursor just left the inset?
- bool leftinset = (&d->cursor_.inset() != &cur.inset());
+ bool const leftinset = (&d->cursor_.inset() != &cur.inset());
if (leftinset)
d->cursor_.fixIfBroken();
// FIXME: shift-mouse selection doesn't work well across insets.
- bool do_selection = select && &d->cursor_.normalAnchor().inset() == &cur.inset();
+ bool const do_selection =
+ select && &d->cursor_.normalAnchor().inset() == &cur.inset();
// do the dEPM magic if needed
// FIXME: (1) move this to InsetText::notifyCursorLeaves?
}
+bool BufferView::selectIfEmpty(DocIterator & cur)
+{
+ if (!cur.paragraph().empty())
+ return false;
+
+ pit_type const beg_pit = cur.pit();
+ if (beg_pit > 0) {
+ // The paragraph associated to this item isn't
+ // the first one, so it can be selected
+ cur.backwardPos();
+ } else {
+ // We have to resort to select the space between the
+ // end of this item and the begin of the next one
+ cur.forwardPos();
+ }
+ if (cur.empty()) {
+ // If it is the only item in the document,
+ // nothing can be selected
+ return false;
+ }
+ pit_type const end_pit = cur.pit();
+ pos_type const end_pos = cur.pos();
+ d->cursor_.clearSelection();
+ d->cursor_.reset();
+ d->cursor_.setCursor(cur);
+ d->cursor_.pit() = beg_pit;
+ d->cursor_.pos() = 0;
+ d->cursor_.setSelection(false);
+ d->cursor_.resetAnchor();
+ d->cursor_.pit() = end_pit;
+ d->cursor_.pos() = end_pos;
+ d->cursor_.setSelection();
+ return true;
+}
+
+
Cursor & BufferView::cursor()
{
return d->cursor_;
message(bformat(_("Inserting document %1$s..."), disp_fn));
docstring res;
- Buffer buf("", false);
- if (buf.loadLyXFile(filename) == Buffer::ReadSuccess) {
+ Buffer buf(filename.absFileName(), false);
+ if (buf.loadLyXFile() == Buffer::ReadSuccess) {
ErrorList & el = buffer_.errorList("Parse");
// Copy the inserted document error list into the current buffer one.
el = buf.errorList("Parse");
}
+void BufferView::resetInlineCompletionPos()
+{
+ d->inlineCompletionPos_ = DocIterator();
+}
+
+
bool samePar(DocIterator const & a, DocIterator const & b)
{
if (a.empty() && b.empty())
}
-void BufferView::setInlineCompletion(Cursor & cur, DocIterator const & pos,
+void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos,
docstring const & completion, size_t uniqueChars)
{
uniqueChars = min(completion.size(), uniqueChars);
projects / lyx.git / blobdiff