#include "insets/InsetCommand.h" // ChangeRefs
#include "insets/InsetExternal.h"
#include "insets/InsetGraphics.h"
+#include "insets/InsetNote.h"
#include "insets/InsetRef.h"
#include "insets/InsetText.h"
-#include "insets/InsetNote.h"
#include "frontends/alert.h"
#include "frontends/Application.h"
return 0;
}
-
-bool findInset(DocIterator & dit, vector<InsetCode> const & codes,
- bool same_content);
-
+/// Note that comparing contents can only be used for InsetCommand
bool findNextInset(DocIterator & dit, vector<InsetCode> const & codes,
docstring const & contents)
{
while (tmpdit) {
Inset const * inset = tmpdit.nextInset();
- if (inset
- && std::find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end()
- && (contents.empty() ||
- static_cast<InsetCommand const *>(inset)->getFirstNonOptParam() == contents)) {
- dit = tmpdit;
- return true;
+ if (inset) {
+ bool const valid_code = std::find(codes.begin(), codes.end(),
+ inset->lyxCode()) != codes.end();
+ InsetCommand const * ic = inset->asInsetCommand();
+ bool const same_or_no_contents = contents.empty()
+ || (ic && (ic->getFirstNonOptParam() == contents));
+
+ if (valid_code && same_or_no_contents) {
+ dit = tmpdit;
+ return true;
+ }
}
tmpdit.forwardInset();
}
/// Looks for next inset with one of the given codes.
+/// Note that same_content can only be used for InsetCommand
bool findInset(DocIterator & dit, vector<InsetCode> const & codes,
bool same_content)
{
if (!tmpdit)
return false;
- if (same_content) {
- Inset const * inset = tmpdit.nextInset();
- if (inset
- && std::find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end()) {
- contents = static_cast<InsetCommand const *>(inset)->getFirstNonOptParam();
+ Inset const * inset = tmpdit.nextInset();
+ if (same_content && inset) {
+ InsetCommand const * ic = inset->asInsetCommand();
+ if (ic) {
+ bool const valid_code = std::find(codes.begin(), codes.end(),
+ ic->lyxCode()) != codes.end();
+ if (valid_code)
+ contents = ic->getFirstNonOptParam();
}
}
Private(BufferView & bv): wh_(0), cursor_(bv),
anchor_pit_(0), anchor_ypos_(0),
inlineCompletionUniqueChars_(0),
- last_inset_(0), mouse_position_cache_(),
- bookmark_edit_position_(0), gui_(0)
+ last_inset_(0), clickable_inset_(false),
+ mouse_position_cache_(),
+ bookmark_edit_position_(-1), gui_(0)
{}
///
/** 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_;
/// position of the mouse at the time of the last mouse move
/// This is used to update the hovering status of inset in
d->cursor_.resetAnchor();
d->cursor_.setCurrentFont();
- if (graphics::Previews::status() != LyXRC::PREVIEW_OFF)
- thePreviews().generateBufferPreviews(buffer_);
+ buffer_.updatePreviews();
}
<< ", singlepar = " << (flags & Update::SinglePar)
<< "] buffer: " << &buffer_);
+ // FIXME Does this really need doing here? It's done in updateBuffer, and
+ // if the Buffer doesn't need updating, then do the macros?
buffer_.updateMacros();
// Now do the first drawing step if needed. This consists on updating
}
-void BufferView::scrollDocView(int value)
+void BufferView::scrollDocView(int value, bool update)
{
int const offset = value - d->scrollbarParameters_.position;
// cut off at the top
if (value <= d->scrollbarParameters_.min) {
DocIterator dit = doc_iterator_begin(&buffer_);
- showCursor(dit, false);
+ showCursor(dit, false, update);
LYXERR(Debug::SCROLLING, "scroll to top");
return;
}
if (value >= d->scrollbarParameters_.max) {
DocIterator dit = doc_iterator_end(&buffer_);
dit.backwardPos();
- showCursor(dit, false);
+ showCursor(dit, false, update);
LYXERR(Debug::SCROLLING, "scroll to bottom");
return;
}
// It seems we didn't find the correct pit so stay on the safe side and
// scroll to bottom.
LYXERR0("scrolling position not found!");
- scrollDocView(d->scrollbarParameters_.max);
+ scrollDocView(d->scrollbarParameters_.max, update);
return;
}
DocIterator dit = doc_iterator_begin(&buffer_);
dit.pit() = i;
LYXERR(Debug::SCROLLING, "value = " << value << " -> scroll to pit " << i);
- showCursor(dit, false);
+ showCursor(dit, false, update);
}
void BufferView::bookmarkEditPosition()
{
+ d->cursor_.markEditPosition();
// Don't eat cpu time for each keystroke
if (d->cursor_.paragraph().id() == d->bookmark_edit_position_)
return;
void BufferView::recenter()
{
- showCursor(d->cursor_, true);
+ showCursor(d->cursor_, true, true);
}
void BufferView::showCursor()
{
- showCursor(d->cursor_, false);
+ showCursor(d->cursor_, false, true);
}
-void BufferView::showCursor(DocIterator const & dit, bool recenter)
+void BufferView::showCursor(DocIterator const & dit,
+ bool recenter, bool update)
{
- if (scrollToCursor(dit, recenter)) {
+ if (scrollToCursor(dit, recenter) && update) {
buffer_.changed(true);
updateHoveredInset();
}
setCursor(backcur.asDocIterator(&buffer_));
buffer_.errors("Class Switch");
- buffer_.updateBuffer();
}
/** Return the change status at cursor position, taking in account the
// FIXME: This is a bit problematic because we don't check if this is
// a document BufferView or not for these LFUNs. We probably have to
// dispatch both to currentBufferView() and, if that fails,
- // to documentBufferView(); same as we do know for current Buffer and
- // document Buffer. Ideally those LFUN should go to Buffer as they*
+ // to documentBufferView(); same as we do now for current Buffer and
+ // document Buffer. Ideally those LFUN should go to Buffer as they
// operate on the full Buffer and the cursor is only needed either for
// an Undo record or to restore a cursor position. But we don't know
// how to do that inside Buffer of course.
break;
case LFUN_UNDO:
- flag.setEnabled(buffer_.undo().hasUndoStack());
+ // We do not use the LyXAction flag for readonly because Undo sets the
+ // buffer clean/dirty status by itself.
+ flag.setEnabled(!buffer_.isReadonly() && buffer_.undo().hasUndoStack());
break;
case LFUN_REDO:
- flag.setEnabled(buffer_.undo().hasRedoStack());
+ // We do not use the LyXAction flag for readonly because Redo sets the
+ // buffer clean/dirty status by itself.
+ flag.setEnabled(!buffer_.isReadonly() && buffer_.undo().hasRedoStack());
break;
case LFUN_FILE_INSERT:
case LFUN_FILE_INSERT_PLAINTEXT_PARA:
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: {
// 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
// current document settings.
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
break;
}
buffer_.params().clearLayoutModules();
buffer_.params().makeDocumentClass();
updateDocumentClass(oldClass);
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force);
+ dr.forceBufferUpdate();
break;
}
buffer_.params().addLayoutModule(argument);
buffer_.params().makeDocumentClass();
updateDocumentClass(oldClass);
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force);
+ dr.forceBufferUpdate();
break;
}
case LFUN_TEXTCLASS_APPLY: {
- if (!LayoutFileList::get().load(argument, buffer_.temppath()) &&
- !LayoutFileList::get().load(argument, buffer_.filePath()))
+ // since this shortcircuits, the second call is made only if
+ // the first fails
+ bool const success =
+ LayoutFileList::get().load(argument, buffer_.temppath()) ||
+ LayoutFileList::get().load(argument, buffer_.filePath());
+ if (!success) {
+ docstring s = bformat(_("The document class `%1$s' "
+ "could not be loaded."), from_utf8(argument));
+ frontend::Alert::error(_("Could not load class"), s);
break;
+ }
LayoutFile const * old_layout = buffer_.params().baseClass();
LayoutFile const * new_layout = &(LayoutFileList::get()[argument]);
// nothing to do
break;
- //Save the old, possibly modular, layout for use in conversion.
+ // 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);
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force);
+ dr.forceBufferUpdate();
break;
}
- case LFUN_TEXTCLASS_LOAD:
- LayoutFileList::get().load(argument, buffer_.temppath()) ||
- LayoutFileList::get().load(argument, buffer_.filePath());
+ case LFUN_TEXTCLASS_LOAD: {
+ // since this shortcircuits, the second call is made only if
+ // the first fails
+ bool const success =
+ LayoutFileList::get().load(argument, buffer_.temppath()) ||
+ LayoutFileList::get().load(argument, buffer_.filePath());
+ if (!success) {
+ docstring s = bformat(_("The document class `%1$s' "
+ "could not be loaded."), from_utf8(argument));
+ frontend::Alert::error(_("Could not load class"), s);
+ }
break;
+ }
case LFUN_LAYOUT_RELOAD: {
DocumentClass const * const oldClass = buffer_.params().documentClassPtr();
buffer_.params().setBaseClass(bc);
buffer_.params().makeDocumentClass();
updateDocumentClass(oldClass);
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force);
+ dr.forceBufferUpdate();
break;
}
if (!cur.textUndo())
dr.setMessage(_("No further undo information"));
else
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
break;
case LFUN_REDO:
if (!cur.textRedo())
dr.setMessage(_("No further redo information"));
else
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
break;
case LFUN_FONT_STATE:
saveBookmark(0);
}
}
- if (!label.empty())
+ if (!label.empty()) {
gotoLabel(label);
+ // at the moment, this is redundant, since gotoLabel will
+ // eventually call LFUN_PARAGRAPH_GOTO, but it seems best
+ // to have it here.
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ }
break;
}
// Set the cursor
dit.pos() = pos;
setCursor(dit);
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
} else {
// Switch to other buffer view and resend cmd
lyx::dispatch(FuncRequest(
case LFUN_CHANGE_NEXT:
findNextChange(this);
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
break;
case LFUN_CHANGE_PREVIOUS:
findPreviousChange(this);
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
break;
case LFUN_CHANGES_MERGE:
if (findNextChange(this) || findPreviousChange(this)) {
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
showDialog("changes");
}
break;
// accept everything in a single step to support atomic undo
buffer_.text().acceptOrRejectChanges(cur, Text::ACCEPT);
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
break;
case LFUN_ALL_CHANGES_REJECT:
// Note: reject does not work recursively; the user may have to repeat the operation
buffer_.text().acceptOrRejectChanges(cur, Text::REJECT);
// FIXME: Move this LFUN to Buffer so that we don't have to do this:
- dr.update(Update::Force | Update::FitCursor);
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
break;
case LFUN_WORD_FIND_FORWARD:
bool const fw = act == LFUN_WORD_FIND_FORWARD;
docstring const data =
find2string(searched_string, true, false, fw);
- find(this, FuncRequest(LFUN_WORD_FIND, data));
+ bool found = lyxfind(this, FuncRequest(LFUN_WORD_FIND, data));
+ if (found)
+ dr.screenUpdate(Update::Force | Update::FitCursor);
break;
}
lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, "findreplace"));
break;
}
- if (find(this, req))
- showCursor();
+ if (lyxfind(this, req))
+ dr.screenUpdate(Update::Force | Update::FitCursor);
else
message(_("String not found!"));
d->search_request_cache_ = req;
DocIterator end = cur.selectionEnd();
if (beg.pit() == end.pit()) {
for (pos_type p = beg.pos() ; p < end.pos() ; ++p) {
- if (!cur.inMathed()
- && cur.paragraph().isDeleted(p))
+ if (!cur.inMathed() && cur.paragraph().isDeleted(p)) {
has_deleted = true;
+ break;
+ }
}
}
}
- replace(this, cmd, has_deleted);
+ if (lyxreplace(this, cmd, has_deleted)) {
+ dr.forceBufferUpdate();
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ }
break;
}
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();
- else
+ dispatched = true;
+ } else {
cur.undispatched();
+ dispatched = false;
+ }
break;
}
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
BIBTEX_CODE);
if (inset) {
- if (inset->addDatabase(cmd.argument()))
- buffer_.updateBibfilesCache();
+ if (inset->addDatabase(cmd.argument())) {
+ buffer_.invalidateBibfileCache();
+ dr.forceBufferUpdate();
+ }
}
break;
}
InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
BIBTEX_CODE);
if (inset) {
- if (inset->delDatabase(cmd.argument()))
- buffer_.updateBibfilesCache();
+ if (inset->delDatabase(cmd.argument())) {
+ buffer_.invalidateBibfileCache();
+ dr.forceBufferUpdate();
+ }
}
break;
}
//FIXME: what to do with cur.x_target()?
bool update = in_texted && cur.bv().checkDepm(cur, old);
cur.finishUndo();
- if (update)
- dr.update(Update::Force | Update::FitCursor);
+ if (update) {
+ dr.screenUpdate(Update::Force | Update::FitCursor);
+ dr.forceBufferUpdate();
+ }
break;
}
case LFUN_SCROLL:
lfunScroll(cmd);
+ dr.forceBufferUpdate();
break;
case LFUN_SCREEN_UP_SELECT: {
y = getPos(cur).y_;
cur.finishUndo();
- dr.update(Update::SinglePar | Update::FitCursor);
+ dr.screenUpdate(Update::SinglePar | Update::FitCursor);
break;
}
y = getPos(cur).y_;
cur.finishUndo();
- dr.update(Update::SinglePar | Update::FitCursor);
+ dr.screenUpdate(Update::SinglePar | Update::FitCursor);
break;
}
cur.endUndoGroup();
cur = savecur;
cur.fixIfBroken();
- dr.update(Update::Force);
+ dr.screenUpdate(Update::Force);
+ dr.forceBufferUpdate();
if (iterations >= max_iter) {
dr.setError(true);
icp["key"] = from_utf8(arg);
if (!opt1.empty())
icp["before"] = from_utf8(opt1);
- string icstr = InsetCommand::params2string("citation", icp);
+ string icstr = InsetCommand::params2string(icp);
FuncRequest fr(LFUN_INSET_INSERT, icstr);
lyx::dispatch(fr);
break;
cur.recordUndo();
FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument());
inset->dispatch(cur, fr);
- dr.update(Update::SinglePar | Update::FitCursor);
+ dr.screenUpdate(cur.result().screenUpdate());
+ if (cur.result().needBufferUpdate())
+ 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;
}
void BufferView::updateHoveredInset() const
{
// Get inset under mouse, if there is one.
- Inset const * covering_inset = getCoveringInset(buffer_.text(),
- d->mouse_position_cache_.x_, d->mouse_position_cache_.y_);
+ int const x = d->mouse_position_cache_.x_;
+ int const y = d->mouse_position_cache_.y_;
+ Inset const * covering_inset = getCoveringInset(buffer_.text(), x, y);
+
+ d->clickable_inset_ = covering_inset && covering_inset->clickable(x, y);
+
if (covering_inset == d->last_inset_)
// Same inset, no need to do anything...
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) {
theSelection().haveSelection(cursor().selection());
// If the command has been dispatched,
- if (cur.result().dispatched() || cur.result().update())
- processUpdateFlags(cur.result().update());
+ if (cur.result().dispatched() || cur.result().screenUpdate())
+ processUpdateFlags(cur.result().screenUpdate());
}
void BufferView::gotoLabel(docstring const & label)
{
- std::vector<Buffer const *> bufs = buffer().allRelatives();
- std::vector<Buffer const *>::iterator it = bufs.begin();
+ ListOfBuffers bufs = buffer().allRelatives();
+ ListOfBuffers::iterator it = bufs.begin();
for (; it != bufs.end(); ++it) {
Buffer const * buf = *it;
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_ = cur;
- buffer_.updateBuffer();
+ cur.forceBufferUpdate();
buffer_.changed(true);
return true;
}
d->cursor_.finishUndo();
d->cursor_.setCurrentFont();
+ if (update)
+ cur.forceBufferUpdate();
return update;
}
} else
d->cursor_.setSelection(d->cursor_, length);
}
- // Ensure a redraw happens in any case because the new selection could
- // possibly be on the same screen as the previous selection.
- processUpdateFlags(Update::Force | Update::FitCursor);
+}
+
+
+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;
}
message(bformat(_("Inserting document %1$s..."), disp_fn));
docstring res;
- Buffer buf("", false);
- if (buf.loadLyXFile(filename)) {
+ 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");
buffer_.changed(true);
// emit message signal.
message(bformat(res, disp_fn));
- buffer_.errors("Parse");
}
}
+void BufferView::resetInlineCompletionPos()
+{
+ d->inlineCompletionPos_ = DocIterator();
+}
+
+
bool samePar(DocIterator const & a, DocIterator const & b)
{
if (a.empty() && b.empty())
// set update flags
if (changed) {
- if (singlePar && !(cur.result().update() & Update::Force))
- cur.updateFlags(cur.result().update() | Update::SinglePar);
+ if (singlePar && !(cur.result().screenUpdate() & Update::Force))
+ cur.screenUpdateFlags(cur.result().screenUpdate() | Update::SinglePar);
else
- cur.updateFlags(cur.result().update() | Update::Force);
+ cur.screenUpdateFlags(cur.result().screenUpdate() | Update::Force);
}
}
+
+bool BufferView::clickableInset() const
+{
+ return d->clickable_inset_;
+}
+
} // namespace lyx