#include "WordLangTuple.h"
#include "insets/InsetBibtex.h"
+#include "insets/InsetCitation.h"
#include "insets/InsetCommand.h" // ChangeRefs
#include "insets/InsetExternal.h"
#include "insets/InsetGraphics.h"
return 0;
}
+
/// Note that comparing contents can only be used for InsetCommand
bool findNextInset(DocIterator & dit, vector<InsetCode> const & codes,
docstring const & contents)
if (tm.contains(bot_pit)) {
ParagraphMetrics const & pm = tm.parMetrics(bot_pit);
- LASSERT(!pm.rows().empty(), /**/);
+ LBUFERR(!pm.rows().empty());
// FIXME: smooth scrolling doesn't work in mathed.
CursorSlice const & cs = dit.innerTextSlice();
int offset = coordOffset(dit).y_;
}
-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));
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: {
- BranchList const & 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;
if (lyxfind(this, req))
dr.screenUpdate(Update::Force | Update::FitCursor);
else
- message(_("String not found!"));
+ message(_("String not found."));
d->search_request_cache_ = req;
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();
d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
true, act == LFUN_SCREEN_UP);
- cur.resetAnchor();
//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_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->layoutName();
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 directly 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 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: {
- BranchList & branch_list = buffer().params().branchlist();
- docstring const branch_name = cmd.argument();
- // the case without a branch name is handled elsewhere
- if (branch_name.empty()) {
- dispatched = false;
- break;
- }
- Branch * branch = branch_list.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;
- if (branch->isSelected() != activate) {
- branch->setSelected(activate);
- cur.recordUndoFullDocument();
- dr.setError(false);
- dr.screenUpdate(Update::Force);
- dr.forceBufferUpdate();
- }
+ 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;
}
{
if (d->last_inset_ != inset) {
LYXERR0("Wrong last_inset!");
- LASSERT(false, /**/);
+ LATTEST(false);
}
d->last_inset_ = 0;
}
// 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();
}
TextMetrics & BufferView::textMetrics(Text const * t)
{
- LASSERT(t, /**/);
+ LBUFERR(t);
TextMetricsCache::iterator tmc_it = d->text_metrics_.find(t);
if (tmc_it == d->text_metrics_.end()) {
tmc_it = d->text_metrics_.insert(
bool BufferView::mouseSetCursor(Cursor & cur, bool select)
{
- LASSERT(&cur.bv() == this, /**/);
+ LASSERT(&cur.bv() == this, return false);
if (!select)
// this event will clear selection so we save selection for
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 const leftinset = (&d->cursor_.inset() != &cur.inset());
void BufferView::insertLyXFile(FileName const & fname)
{
- LASSERT(d->cursor_.inTexted(), /**/);
+ LASSERT(d->cursor_.inTexted(), return);
// Get absolute path of file and add ".lyx"
// to the filename if necessary
CursorSlice const & sl = dit[0];
TextMetrics const & tm = textMetrics(sl.text());
ParagraphMetrics const & pm = tm.parMetrics(sl.pit());
- LASSERT(!pm.rows().empty(), /**/);
+
+ LBUFERR(!pm.rows().empty());
y -= pm.rows()[0].ascent();
#if 1
// FIXME: document this mess
projects / lyx.git / blobdiff