#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "Undo.h"
+#include "TextMetrics.h"
#include "VSpace.h"
#include "ParIterator.h"
#include "insets/InsetQuotes.h"
#include "insets/InsetSpecialChar.h"
#include "insets/InsetText.h"
+#include "insets/InsetInfo.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
static void finishChange(Cursor & cur, bool selecting)
{
- finishUndo();
+ cur.finishUndo();
moveCursor(cur, selecting);
}
static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
{
- recordUndo(cur);
+ cur.recordUndo();
docstring sel = cur.selectionAsString(false);
// It may happen that sel is empty but there is a selection
static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind)
{
- recordUndo(cur);
+ cur.recordUndo();
cap::replaceSelection(cur);
cur.insert(new InsetSpecialChar(kind));
cur.posRight();
if (!inset)
return false;
- recordUndo(cur);
+ cur.recordUndo();
if (cmd.action == LFUN_INDEX_INSERT) {
docstring ds = support::subst(text->getStringToIndex(cur), '\n', ' ');
text->insertInset(cur, inset);
if (gotsel && pastesel) {
lyx::dispatch(FuncRequest(LFUN_PASTE, "0"));
- // reset first par to default
- if (cur.lastpit() != 0 || cur.lastpos() != 0) {
+ InsetText * insetText = dynamic_cast<InsetText *>(inset);
+ if (insetText && !insetText->allowMultiPar()
+ || cur.lastpit() == 0) {
+ // reset first par to default
LayoutPtr const layout =
cur.buffer().params().getTextClass().defaultLayout();
cur.text()->paragraphs().begin()->layout(layout);
+ cur.pos() = 0;
+ cur.pit() = 0;
+ // Merge multiple paragraphs -- hack
+ while (cur.lastpit() > 0) {
+ mergeParagraph(cur.buffer().params(),
+ cur.text()->paragraphs(), 0);
+ }
+ } else {
+ // reset surrounding par to default
+ docstring const layoutname =
+ cur.buffer().params().getTextClass().defaultLayoutName();
+ cur.leaveInset(*inset);
+ text->setLayout(cur, layoutname);
}
}
}
case LFUN_PARAGRAPH_MOVE_DOWN: {
pit_type const pit = cur.pit();
recUndo(cur, pit, pit + 1);
- finishUndo();
+ cur.finishUndo();
std::swap(pars_[pit], pars_[pit + 1]);
updateLabels(cur.buffer());
needsUpdate = true;
case LFUN_PARAGRAPH_MOVE_UP: {
pit_type const pit = cur.pit();
recUndo(cur, pit - 1, pit);
- finishUndo();
+ cur.finishUndo();
std::swap(pars_[pit], pars_[pit - 1]);
updateLabels(cur.buffer());
--cur.pit();
}
}
- recordUndo(cur);
+ cur.recordUndo();
par.params().startOfAppendix(start);
// we can set the refreshing parameters now
//lyxerr << BOOST_CURRENT_FUNCTION
// << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl;
needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT);
- if (reverseDirectionNeeded(cur))
- needsUpdate |= cursorLeft(cur);
- else
- needsUpdate |= cursorRight(cur);
+ needsUpdate |= cursorForward(cur);
if (!needsUpdate && oldTopSlice == cur.top()
&& cur.boundary() == oldBoundary) {
cur.undispatched();
- cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_FORWARD);
}
break;
case LFUN_CHAR_BACKWARD_SELECT:
//lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl;
needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT);
- if (reverseDirectionNeeded(cur))
- needsUpdate |= cursorRight(cur);
- else
- needsUpdate |= cursorLeft(cur);
+ needsUpdate |= cursorBackward(cur);
if (!needsUpdate && oldTopSlice == cur.top()
&& cur.boundary() == oldBoundary) {
cur.undispatched();
- cmd = FuncRequest(LFUN_FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
+ }
+ break;
+
+ case LFUN_CHAR_LEFT:
+ case LFUN_CHAR_LEFT_SELECT:
+ //FIXME: for visual cursor, really move left
+ if (reverseDirectionNeeded(cur)) {
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_LEFT_SELECT ?
+ LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD));
+ } else {
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_LEFT_SELECT ?
+ LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD));
+ }
+ break;
+
+ case LFUN_CHAR_RIGHT:
+ case LFUN_CHAR_RIGHT_SELECT:
+ //FIXME: for visual cursor, really move right
+ if (reverseDirectionNeeded(cur)) {
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_RIGHT_SELECT ?
+ LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD));
+ } else {
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_RIGHT_SELECT ?
+ LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD));
}
break;
// this avoids a double undo
// FIXME: should not be needed, ideally
if (!cur.selection())
- recordUndo(cur);
+ cur.recordUndo();
cap::replaceSelection(cur);
cur.insert(new InsetNewline);
cur.posRight();
// Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
if (!cur.selection()) {
if (cur.pos() == cur.lastpos()) {
- cursorRight(cur);
- cursorLeft(cur);
+ cursorForward(cur);
+ cursorBackward(cur);
}
erase(cur);
cur.resetAnchor();
case LFUN_BREAK_PARAGRAPH:
cap::replaceSelection(cur);
- breakParagraph(cur, false);
- cur.resetAnchor();
- break;
-
- case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT:
- cap::replaceSelection(cur);
- breakParagraph(cur, true);
+ breakParagraph(cur, cmd.argument() == "inverse");
cur.resetAnchor();
break;
}
case LFUN_INSET_INSERT: {
- recordUndo(cur);
+ cur.recordUndo();
Inset * inset = createInset(bv, cmd);
if (inset) {
// FIXME (Abdel 01/02/2006):
// other feature like "automatic labelling".
/*
Paragraph & par = pars_[cur.pit()];
- if (inset->lyxCode() == Inset::LABEL_CODE
+ if (inset->lyxCode() == LABEL_CODE
&& par.layout()->labeltype == LABEL_COUNTER) {
// Go to the end of the paragraph
// Warning: Because of Change-Tracking, the last
}
bv->buffer().errors("Paste");
cur.clearSelection(); // bug 393
- finishUndo();
+ cur.finishUndo();
break;
case LFUN_CUT:
// this avoids a double undo
// FIXME: should not be needed, ideally
if (!cur.selection())
- recordUndo(cur);
+ cur.recordUndo();
cap::replaceSelection(cur);
pos = cur.pos();
char_type c;
// Single-click on work area
case LFUN_MOUSE_PRESS: {
// Right click on a footnote flag opens float menu
+ // FIXME: Why should we clear the selection in this case?
if (cmd.button() == mouse_button::button3)
cur.clearSelection();
+ bool do_selection = cmd.button() == mouse_button::button1
+ && cmd.argument() == "region-select";
// Set the cursor
- bool update = bv->mouseSetCursor(cur);
+ bool update = bv->mouseSetCursor(cur, do_selection);
// Insert primary selection with middle mouse
// if there is a local selection in the current buffer,
bv->buffer().errorList("Paste"));
bv->buffer().errors("Paste");
bv->buffer().markDirty();
- finishUndo();
+ bv->cursor().finishUndo();
} else {
lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph"));
}
break;
}
- case LFUN_URL_INSERT: {
- InsetCommandParams p("url");
- docstring content;
- if (cur.selection()) {
- content = cur.selectionAsString(false);
- cutSelection(cur, true, false);
- }
- p["target"] = (cmd.argument().empty()) ?
- content : cmd.argument();
- string const data = InsetCommandMailer::params2string("url", p);
- if (p["target"].empty()) {
- bv->showInsetDialog("url", data, 0);
- } else {
- FuncRequest fr(LFUN_INSET_INSERT, data);
- dispatch(cur, fr);
- }
- break;
- }
-
- case LFUN_HTML_INSERT: {
- InsetCommandParams p("htmlurl");
+ case LFUN_HYPERLINK_INSERT: {
+ InsetCommandParams p(HYPERLINK_CODE);
docstring content;
if (cur.selection()) {
content = cur.selectionAsString(false);
}
p["target"] = (cmd.argument().empty()) ?
content : cmd.argument();
- string const data = InsetCommandMailer::params2string("url", p);
+ string const data = InsetCommandMailer::params2string("href", p);
if (p["target"].empty()) {
- bv->showInsetDialog("url", data, 0);
+ bv->showInsetDialog("href", data, 0);
} else {
FuncRequest fr(LFUN_INSET_INSERT, data);
dispatch(cur, fr);
}
case LFUN_LABEL_INSERT: {
- InsetCommandParams p("label");
+ InsetCommandParams p(LABEL_CODE);
// Try to generate a valid label
p["name"] = (cmd.argument().empty()) ?
cur.getPossibleLabel() :
break;
}
-
+ case LFUN_INFO_INSERT: {
+ Inset * inset = createInset(&cur.bv(), cmd);
+ if (!inset)
+ break;
+ // if an empty inset is created (cmd.argument() is empty)
+ // use current selection as parameter.
+ if (cmd.argument().empty() && cur.selection()) {
+ // use selected text as info to avoid a separate UI
+ docstring ds = cur.selectionAsString(false);
+ cutSelection(cur, true, false);
+ static_cast<InsetInfo *>(inset)->setInfo(to_utf8(ds));
+ }
+ insertInset(cur, inset);
+ cur.posRight();
+ break;
+ }
#if 0
case LFUN_LIST_INSERT:
case LFUN_THEOREM_INSERT:
Inset * inset = createInset(&cur.bv(), cmd);
if (!inset)
break;
- recordUndo(cur);
+ cur.recordUndo();
cur.clearSelection();
insertInset(cur, inset);
// Show the dialog for the nomenclature entry, since the
}
break;
+ case LFUN_FINISHED_BACKWARD:
+ LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_BACKWARD:\n" << cur << endl;
+ break;
+
+ case LFUN_FINISHED_FORWARD:
+ LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_FORWARD:\n" << cur << endl;
+ ++cur.pos();
+ cur.setCurrentFont();
+ break;
+
case LFUN_LAYOUT_PARAGRAPH: {
string data;
params2string(cur.paragraph(), data);
case LFUN_FLOAT_LIST: {
TextClass const & tclass = bv->buffer().params().getTextClass();
if (tclass.floats().typeExist(to_utf8(cmd.argument()))) {
- recordUndo(cur);
+ cur.recordUndo();
if (cur.selection())
cutSelection(cur, true, false);
breakParagraph(cur);
if (cur.lastpos() != 0) {
- cursorLeft(cur);
+ cursorBackward(cur);
breakParagraph(cur);
}
cur.selection() = false;
} else {
cur.undispatched();
- cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+ // This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more
+ // correct, but I'm not 100% sure -- dov, 071019
+ cmd = FuncRequest(LFUN_FINISHED_FORWARD);
}
break;
Font const & font = cur.real_current_font;
bool enable = true;
- Inset::Code code = Inset::NO_CODE;
+ InsetCode code = NO_CODE;
switch (cmd.action) {
case LFUN_DIALOG_SHOW_NEW_INSET:
if (cmd.argument() == "bibitem")
- code = Inset::BIBITEM_CODE;
+ code = BIBITEM_CODE;
else if (cmd.argument() == "bibtex")
- code = Inset::BIBTEX_CODE;
+ code = BIBTEX_CODE;
else if (cmd.argument() == "box")
- code = Inset::BOX_CODE;
+ code = BOX_CODE;
else if (cmd.argument() == "branch")
- code = Inset::BRANCH_CODE;
+ code = BRANCH_CODE;
else if (cmd.argument() == "citation")
- code = Inset::CITE_CODE;
+ code = CITE_CODE;
else if (cmd.argument() == "ert")
- code = Inset::ERT_CODE;
+ code = ERT_CODE;
else if (cmd.argument() == "external")
- code = Inset::EXTERNAL_CODE;
+ code = EXTERNAL_CODE;
else if (cmd.argument() == "float")
- code = Inset::FLOAT_CODE;
+ code = FLOAT_CODE;
else if (cmd.argument() == "graphics")
- code = Inset::GRAPHICS_CODE;
+ code = GRAPHICS_CODE;
+ else if (cmd.argument() == "href")
+ code = HYPERLINK_CODE;
else if (cmd.argument() == "include")
- code = Inset::INCLUDE_CODE;
+ code = INCLUDE_CODE;
else if (cmd.argument() == "index")
- code = Inset::INDEX_CODE;
+ code = INDEX_CODE;
else if (cmd.argument() == "nomenclature")
- code = Inset::NOMENCL_CODE;
+ code = NOMENCL_CODE;
else if (cmd.argument() == "label")
- code = Inset::LABEL_CODE;
+ code = LABEL_CODE;
else if (cmd.argument() == "note")
- code = Inset::NOTE_CODE;
+ code = NOTE_CODE;
else if (cmd.argument() == "ref")
- code = Inset::REF_CODE;
+ code = REF_CODE;
else if (cmd.argument() == "toc")
- code = Inset::TOC_CODE;
- else if (cmd.argument() == "url")
- code = Inset::URL_CODE;
+ code = TOC_CODE;
else if (cmd.argument() == "vspace")
- code = Inset::VSPACE_CODE;
+ code = VSPACE_CODE;
else if (cmd.argument() == "wrap")
- code = Inset::WRAP_CODE;
+ code = WRAP_CODE;
else if (cmd.argument() == "listings")
- code = Inset::LISTINGS_CODE;
+ code = LISTINGS_CODE;
break;
case LFUN_ERT_INSERT:
- code = Inset::ERT_CODE;
+ code = ERT_CODE;
break;
case LFUN_LISTING_INSERT:
- code = Inset::LISTINGS_CODE;
+ code = LISTINGS_CODE;
break;
case LFUN_FOOTNOTE_INSERT:
- code = Inset::FOOT_CODE;
+ code = FOOT_CODE;
break;
case LFUN_TABULAR_INSERT:
- code = Inset::TABULAR_CODE;
+ code = TABULAR_CODE;
break;
case LFUN_MARGINALNOTE_INSERT:
- code = Inset::MARGIN_CODE;
+ code = MARGIN_CODE;
break;
case LFUN_FLOAT_INSERT:
case LFUN_FLOAT_WIDE_INSERT:
- code = Inset::FLOAT_CODE;
+ code = FLOAT_CODE;
break;
case LFUN_WRAP_INSERT:
- code = Inset::WRAP_CODE;
+ code = WRAP_CODE;
break;
case LFUN_FLOAT_LIST:
- code = Inset::FLOAT_LIST_CODE;
+ code = FLOAT_LIST_CODE;
break;
#if 0
case LFUN_LIST_INSERT:
- code = Inset::LIST_CODE;
+ code = LIST_CODE;
break;
case LFUN_THEOREM_INSERT:
- code = Inset::THEOREM_CODE;
+ code = THEOREM_CODE;
break;
#endif
case LFUN_CAPTION_INSERT:
- code = Inset::CAPTION_CODE;
+ code = CAPTION_CODE;
break;
case LFUN_NOTE_INSERT:
- code = Inset::NOTE_CODE;
+ code = NOTE_CODE;
break;
case LFUN_FLEX_INSERT: {
- code = Inset::FLEX_CODE;
+ code = FLEX_CODE;
string s = cmd.getArg(0);
InsetLayout il = cur.buffer().params().getTextClass().insetlayout(from_utf8(s));
if (il.lyxtype != "charstyle" &&
break;
}
case LFUN_BOX_INSERT:
- code = Inset::BOX_CODE;
+ code = BOX_CODE;
break;
case LFUN_BRANCH_INSERT:
- code = Inset::BRANCH_CODE;
- if (cur.buffer().getMasterBuffer()->params().branchlist().empty())
+ code = BRANCH_CODE;
+ if (cur.buffer().masterBuffer()->params().branchlist().empty())
enable = false;
break;
case LFUN_LABEL_INSERT:
- code = Inset::LABEL_CODE;
+ code = LABEL_CODE;
+ break;
+ case LFUN_INFO_INSERT:
+ code = INFO_CODE;
break;
case LFUN_OPTIONAL_INSERT:
- code = Inset::OPTARG_CODE;
- enable = numberOfOptArgs(cur.paragraph())
+ code = OPTARG_CODE;
+ enable = cur.paragraph().numberOfOptArgs()
< cur.paragraph().layout()->optionalargs;
break;
case LFUN_ENVIRONMENT_INSERT:
- code = Inset::BOX_CODE;
+ code = BOX_CODE;
break;
case LFUN_INDEX_INSERT:
- code = Inset::INDEX_CODE;
+ code = INDEX_CODE;
break;
case LFUN_INDEX_PRINT:
- code = Inset::INDEX_PRINT_CODE;
+ code = INDEX_PRINT_CODE;
break;
case LFUN_NOMENCL_INSERT:
- code = Inset::NOMENCL_CODE;
+ code = NOMENCL_CODE;
break;
case LFUN_NOMENCL_PRINT:
- code = Inset::NOMENCL_PRINT_CODE;
+ code = NOMENCL_PRINT_CODE;
break;
case LFUN_TOC_INSERT:
- code = Inset::TOC_CODE;
+ code = TOC_CODE;
break;
- case LFUN_HTML_INSERT:
- case LFUN_URL_INSERT:
- code = Inset::URL_CODE;
+ case LFUN_HYPERLINK_INSERT:
+ code = HYPERLINK_CODE;
break;
case LFUN_QUOTE_INSERT:
// always allow this, since we will inset a raw quote
case LFUN_MENU_SEPARATOR_INSERT:
case LFUN_DOTS_INSERT:
case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
- code = Inset::SPECIALCHAR_CODE;
+ code = SPECIALCHAR_CODE;
break;
case LFUN_SPACE_INSERT:
// slight hack: we know this is allowed in math mode
if (cur.inTexted())
- code = Inset::SPACE_CODE;
+ code = SPACE_CODE;
break;
case LFUN_INSET_MODIFY:
break;
case LFUN_INSET_DISSOLVE:
- enable = !isMainText(cur.bv().buffer()) && cur.inset().nargs() == 1;
+ if (!cmd.argument().empty()) {
+ InsetLayout il = cur.inset().getLayout(cur.buffer().params());
+ enable = cur.inset().lyxCode() == FLEX_CODE
+ && il.lyxtype == to_utf8(cmd.argument());
+ } else {
+ enable = !isMainText(cur.bv().buffer())
+ && cur.inset().nargs() == 1;
+ }
break;
case LFUN_CHANGE_ACCEPT:
case LFUN_CHAR_FORWARD_SELECT:
case LFUN_CHAR_BACKWARD:
case LFUN_CHAR_BACKWARD_SELECT:
+ case LFUN_CHAR_LEFT:
+ case LFUN_CHAR_LEFT_SELECT:
+ case LFUN_CHAR_RIGHT:
+ case LFUN_CHAR_RIGHT_SELECT:
case LFUN_UP:
case LFUN_UP_SELECT:
case LFUN_DOWN:
case LFUN_CHAR_DELETE_BACKWARD:
case LFUN_DELETE_BACKWARD_SKIP:
case LFUN_BREAK_PARAGRAPH:
- case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT:
case LFUN_BREAK_PARAGRAPH_SKIP:
case LFUN_PARAGRAPH_SPACING:
case LFUN_INSET_INSERT:
return false;
}
- if (code != Inset::NO_CODE
+ if (code != NO_CODE
&& (cur.empty() || !cur.inset().insetAllowed(code)))
enable = false;
{
cur.clearSelection();
if (!clip.empty()) {
- recordUndo(cur);
+ cur.recordUndo();
if (asParagraphs)
insertStringAsParagraphs(cur, clip);
else