#include "Lexer.h"
#include "LyXRC.h"
#include "Paragraph.h"
-#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
#include "TextClass.h"
#include "TextMetrics.h"
#include "frontends/Application.h"
#include "frontends/Clipboard.h"
-#include "frontends/LyXView.h"
#include "frontends/Selection.h"
-#include "frontends/WorkArea.h"
#include "insets/InsetCollapsable.h"
#include "insets/InsetCommand.h"
#include "insets/InsetExternal.h"
+#include "insets/InsetFloat.h"
#include "insets/InsetFloatList.h"
#include "insets/InsetGraphics.h"
#include "insets/InsetGraphicsParams.h"
#include "insets/InsetQuotes.h"
#include "insets/InsetSpecialChar.h"
#include "insets/InsetText.h"
+#include "insets/InsetWrap.h"
#include "support/convert.h"
#include "support/debug.h"
#ifdef ENABLE_ASSERTIONS
const int old_pos = cur.pos();
#endif
- cur.insert(new InsetMathHull(hullSimple));
+ cur.insert(new InsetMathHull(cur.buffer(), hullSimple));
#ifdef ENABLE_ASSERTIONS
LASSERT(old_pos == cur.pos(), /**/);
#endif
&& sel.find(from_ascii("\\newlyxcommand")) == string::npos
&& sel.find(from_ascii("\\def")) == string::npos)
{
- InsetMathHull * formula = new InsetMathHull;
+ InsetMathHull * formula = new InsetMathHull(cur.buffer());
string const selstr = to_utf8(sel);
istringstream is(selstr);
Lexer lex;
} else
cur.insert(formula);
} else {
- cur.insert(new MathMacroTemplate(sel));
+ cur.insert(new MathMacroTemplate(cur.buffer(), sel));
}
}
if (valid)
return;
}
cur.recordUndo();
- docstring const save_selection = grabAndEraseSelection(cur);
- selClearOrDel(cur);
- // replaceSelection(cur);
+ docstring sel = cur.selectionAsString(false);
+
+ // It may happen that sel is empty but there is a selection
+ replaceSelection(cur);
- cur.insert(new InsetMathHull(hullRegexp));
+ cur.insert(new InsetMathHull(cur.buffer(), hullRegexp));
cur.nextInset()->edit(cur, true);
- cur.niceInsert(save_selection);
+ cur.niceInsert(sel);
cur.message(_("Regexp editor mode"));
}
{
Buffer & buffer = cur.bv().buffer();
BufferParams const & bparams = buffer.params();
- Inset * inset = createInset(buffer, cmd);
+ Inset * inset = createInset(&buffer, cmd);
if (!inset)
return false;
+ if (InsetCollapsable * ci = inset->asInsetCollapsable())
+ ci->setButtonLabel();
+
cur.recordUndo();
if (cmd.action == LFUN_INDEX_INSERT) {
docstring ds = subst(text->getStringToIndex(cur), '\n', ' ');
if (edit)
inset->edit(cur, true);
// Now put this into inset
- cur.text()->insertStringAsLines(cur, ds);
+ cur.text()->insertStringAsLines(cur, ds, cur.current_font);
cur.leaveInset(*inset);
return true;
}
break;
}
- // Do we need to set insets' buffer_ members, because we copied
- // some stuff? We'll assume we do and reset it otherwise.
- bool set_buffers = true;
-
switch (mode) {
case OutlineUp: {
if (start == pars.begin())
pit_type const len = distance(start, finish);
pit_type const deletepit = pit + len;
buf.undo().recordUndo(cur, ATOMIC_UNDO, newpit, deletepit - 1);
- pars.insert(dest, start, finish);
- start = boost::next(pars.begin(), deletepit);
- pit = newpit;
- pars.erase(start, finish);
+ pars.splice(dest, start, finish);
+ cur.pit() = newpit;
break;
}
case OutlineDown: {
}
// One such was found:
pit_type newpit = distance(bgn, dest);
- pit_type const len = distance(start, finish);
buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, newpit - 1);
- pars.insert(dest, start, finish);
- start = boost::next(bgn, pit);
- pit = newpit - len;
- pars.erase(start, finish);
+ pit_type const len = distance(start, finish);
+ pars.splice(dest, start, finish);
+ cur.pit() = newpit - len;
break;
}
case OutlineIn: {
}
}
}
- set_buffers = false;
break;
}
case OutlineOut: {
}
}
}
- set_buffers = false;
break;
}
}
- if (set_buffers)
- // FIXME This only really needs doing for the newly introduced
- // paragraphs. Something like:
- // pit_type const numpars = distance(start, finish);
- // start = boost::next(bgn, pit);
- // finish = boost::next(start, numpars);
- // for (; start != finish; ++start)
- // start->setBuffer(buf);
- // But while this seems to work, it is kind of fragile.
- buf.inset().setBuffer(buf);
}
}
-bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const
+bool Text::isRTL(Paragraph const & par) const
{
+ Buffer const & buffer = owner_->buffer();
return par.isRTL(buffer.params());
}
pit_type const pit = cur.pit();
recUndo(cur, pit, pit + 1);
cur.finishUndo();
- swap(pars_[pit], pars_[pit + 1]);
+ pars_.swap(pit, pit + 1);
cur.buffer()->updateLabels();
needsUpdate = true;
++cur.pit();
pit_type const pit = cur.pit();
recUndo(cur, pit - 1, pit);
cur.finishUndo();
- swap(pars_[pit], pars_[pit - 1]);
+ pars_.swap(pit, pit - 1);
cur.buffer()->updateLabels();
--cur.pit();
needsUpdate = true;
case LFUN_INSET_BEGIN:
case LFUN_INSET_BEGIN_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_BEGIN_SELECT);
- if (cur.depth() == 1 || cur.pos() > 0)
+ if (cur.depth() == 1 || !cur.top().at_begin())
needsUpdate |= cursorTop(cur);
else
cur.undispatched();
case LFUN_INSET_END:
case LFUN_INSET_END_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_END_SELECT);
- if (cur.depth() == 1 || cur.pos() < cur.lastpos())
+ if (cur.depth() == 1 || !cur.top().at_end())
needsUpdate |= cursorBottom(cur);
else
cur.undispatched();
cur.updateFlags(Update::FitCursor);
break;
+ case LFUN_INSET_SELECT_ALL:
+ if (cur.depth() == 1 || !cur.selection() || !cur.selBegin().at_begin()
+ || !cur.selEnd().at_end()) {
+ needsUpdate |= cur.selHandle(false);
+ needsUpdate |= cursorTop(cur);
+ needsUpdate |= cur.selHandle(true);
+ needsUpdate |= cursorBottom(cur);
+ } else
+ cur.undispatched();
+ cur.updateFlags(Update::FitCursor);
+ break;
+
case LFUN_CHAR_FORWARD:
case LFUN_CHAR_FORWARD_SELECT:
//LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur);
cur.resetAnchor();
break;
- // TODO
- // With the creation of LFUN_PARAGRAPH_PARAMS, this is now redundant,
- // as its duties can be performed there. Should it be removed??
- // FIXME For now, it can just dispatch LFUN_PARAGRAPH_PARAMS...
- case LFUN_PARAGRAPH_SPACING: {
- Paragraph & par = cur.paragraph();
- Spacing::Space cur_spacing = par.params().spacing().getSpace();
- string cur_value = "1.0";
- if (cur_spacing == Spacing::Other)
- cur_value = par.params().spacing().getValueAsString();
-
- istringstream is(to_utf8(cmd.argument()));
- string tmp;
- is >> tmp;
- Spacing::Space new_spacing = cur_spacing;
- string new_value = cur_value;
- if (tmp.empty()) {
- lyxerr << "Missing argument to `paragraph-spacing'"
- << endl;
- } else if (tmp == "single") {
- new_spacing = Spacing::Single;
- } else if (tmp == "onehalf") {
- new_spacing = Spacing::Onehalf;
- } else if (tmp == "double") {
- new_spacing = Spacing::Double;
- } else if (tmp == "other") {
- new_spacing = Spacing::Other;
- string tmpval = "0.0";
- is >> tmpval;
- lyxerr << "new_value = " << tmpval << endl;
- if (tmpval != "0.0")
- new_value = tmpval;
- } else if (tmp == "default") {
- new_spacing = Spacing::Default;
- } else {
- lyxerr << to_utf8(_("Unknown spacing argument: "))
- << to_utf8(cmd.argument()) << endl;
- }
- if (cur_spacing != new_spacing || cur_value != new_value)
- par.params().spacing(Spacing(new_spacing, new_value));
- break;
- }
-
case LFUN_INSET_INSERT: {
cur.recordUndo();
// before inserting into the document. See bug #5626.
bool loaded = bv->buffer().isFullyLoaded();
bv->buffer().setFullyLoaded(false);
- Inset * inset = createInset(bv->buffer(), cmd);
+ Inset * inset = createInset(&bv->buffer(), cmd);
bv->buffer().setFullyLoaded(loaded);
if (inset) {
}
case LFUN_INSET_DISSOLVE: {
- // first, try if there's an inset at cursor
- // FIXME: this first part should be moved to
- // a LFUN_NEXT_INSET_DISSOLVE, or be called via
- // some generic "next-inset inset-dissolve"
- Inset * inset = cur.nextInset();
- if (inset && inset->isActive()) {
- Cursor tmpcur = cur;
- tmpcur.pushBackward(*inset);
- inset->dispatch(tmpcur, cmd);
- if (tmpcur.result().dispatched()) {
- cur.dispatched();
- break;
- }
- }
- // if it did not work, try the underlying inset
- if (dissolveInset(cur)) {
+ if (dissolveInset(cur))
needsUpdate = true;
- break;
- }
- // if it did not work, do nothing.
break;
}
if (layout.empty())
layout = tclass.defaultLayoutName();
- if (para.forcePlainLayout())
+ if (owner_->forcePlainLayout())
// in this case only the empty layout is allowed
layout = tclass.plainLayoutName();
else if (para.usePlainLayout()) {
else
c = par.getChar(pos - 1);
string arg = to_utf8(cmd.argument());
- cur.insert(new InsetQuotes(bv->buffer(), c, (arg == "single")
+ cur.insert(new InsetQuotes(cur.buffer(), c, (arg == "single")
? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes));
cur.posForward();
}
docstring ds = cur.selectionAsString(false);
cutSelection(cur, true, false);
FuncRequest cmd0(cmd, ds);
- inset = createInset(cur.bv().buffer(), cmd0);
+ inset = createInset(cur.buffer(), cmd0);
} else {
- inset = createInset(cur.bv().buffer(), cmd);
+ inset = createInset(cur.buffer(), cmd);
}
if (!inset)
break;
// add a separate paragraph for the caption inset
pars.push_back(Paragraph());
- pars.back().setInsetOwner(&pars[0].inInset());
+ pars.back().setInsetOwner(&cur.text()->inset());
pars.back().setPlainOrDefaultLayout(tclass);
int cap_pit = pars.size() - 1;
// the graphics (or table).
if (!content) {
pars.push_back(Paragraph());
- pars.back().setInsetOwner(&pars[0].inInset());
+ pars.back().setInsetOwner(&cur.text()->inset());
pars.back().setPlainOrDefaultLayout(tclass);
}
MacroType type = MacroTypeNewcommand;
if (s2 == "def")
type = MacroTypeDef;
- MathMacroTemplate * inset = new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, false, type);
+ MathMacroTemplate * inset = new MathMacroTemplate(cur.buffer(),
+ from_utf8(token(s, ' ', 0)), nargs, false, type);
inset->setBuffer(bv->buffer());
insertInset(cur, inset);
case LFUN_MATH_BIGDELIM: {
cur.recordUndo();
cap::replaceSelection(cur);
- cur.insert(new InsetMathHull(hullSimple));
+ cur.insert(new InsetMathHull(cur.buffer(), hullSimple));
checkAndActivateInset(cur, true);
LASSERT(cur.inMathed(), /**/);
cur.dispatch(cmd);
case LFUN_ACCENT_HUNGARIAN_UMLAUT:
case LFUN_ACCENT_CIRCLE:
case LFUN_ACCENT_OGONEK:
- theLyXFunc().handleKeyFunc(cmd.action);
+ theApp()->handleKeyFunc(cmd.action);
if (!cmd.argument().empty())
// FIXME: Are all these characters encoded in one byte in utf8?
bv->translateAndInsert(cmd.argument()[0], this, cur);
setParagraphs(cur, p);
// FIXME This should be simplified when InsetFloatList takes a
// Buffer in its constructor.
- InsetFloatList * ifl = new InsetFloatList(to_utf8(cmd.argument()));
+ InsetFloatList * ifl = new InsetFloatList(cur.buffer(), to_utf8(cmd.argument()));
ifl->setBuffer(bv->buffer());
insertInset(cur, ifl);
cur.posForward();
break;
}
- if (lyxrc.spellcheck_continuously && cur.inTexted())
- // Take this opportunity to spellcheck current word.
- cur.paragraph().isMisspelled(cur.pos());
-
needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection();
// FIXME: The cursor flag is reset two lines below
break;
case LFUN_FLOAT_INSERT:
case LFUN_FLOAT_WIDE_INSERT:
+ // FIXME: If there is a selection, we should check whether there
+ // are floats in the selection, but this has performance issues, see
+ // LFUN_CHANGE_ACCEPT/REJECT.
code = FLOAT_CODE;
- // not allowed in description items
- enable = !inDescriptionItem(cur);
+ if (inDescriptionItem(cur))
+ // not allowed in description items
+ enable = false;
+ else {
+ InsetCode const inset_code = cur.inset().lyxCode();
+
+ // algorithm floats cannot be put in another float
+ if (to_utf8(cmd.argument()) == "algorithm") {
+ enable = inset_code != WRAP_CODE && inset_code != FLOAT_CODE;
+ break;
+ }
+
+ // for figures and tables: only allow in another
+ // float or wrap if it is of the same type and
+ // not a subfloat already
+ if(cur.inset().lyxCode() == code) {
+ InsetFloat const & ins =
+ static_cast<InsetFloat const &>(cur.inset());
+ enable = ins.params().type == to_utf8(cmd.argument())
+ && !ins.params().subfloat;
+ } else if(cur.inset().lyxCode() == WRAP_CODE) {
+ InsetWrap const & ins =
+ static_cast<InsetWrap const &>(cur.inset());
+ enable = ins.params().type == to_utf8(cmd.argument());
+ }
+ }
break;
case LFUN_WRAP_INSERT:
code = WRAP_CODE;
case LFUN_LABEL_INSERT:
code = LABEL_CODE;
break;
+ case LFUN_LINE_INSERT:
+ code = LINE_CODE;
+ break;
case LFUN_INFO_INSERT:
code = INFO_CODE;
break;
code = SPACE_CODE;
break;
+ case LFUN_MATH_INSERT:
+ case LFUN_MATH_AMS_MATRIX:
+ case LFUN_MATH_MATRIX:
+ case LFUN_MATH_DELIM:
+ case LFUN_MATH_BIGDELIM:
+ case LFUN_MATH_DISPLAY:
+ case LFUN_MATH_MODE:
+ case LFUN_MATH_MACRO:
+ case LFUN_MATH_SUBSCRIPT:
+ case LFUN_MATH_SUPERSCRIPT:
+ code = MATH_HULL_CODE;
+ break;
+
case LFUN_INSET_MODIFY:
// We need to disable this, because we may get called for a
// tabular cell via
enable = cur.pit() < cur.lastpit() && !cur.selection();
break;
- case LFUN_INSET_DISSOLVE:
- if (!cmd.argument().empty()) {
- InsetLayout const & il = cur.inset().getLayout();
- InsetLayout::InsetLyXType const type =
- translateLyXType(to_utf8(cmd.argument()));
- enable = cur.inset().lyxCode() == FLEX_CODE
- && il.lyxtype() == type;
- } else {
- enable = ((!isMainText(cur.bv().buffer())
- && cur.inset().nargs() == 1)
- || (cur.nextInset()
- && cur.nextInset()->nargs() == 1));
- }
- break;
-
case LFUN_CHANGE_ACCEPT:
case LFUN_CHANGE_REJECT:
// In principle, these LFUNs should only be enabled if there
// However, without proper optimizations, this will inevitably
// result in unacceptable performance - just imagine a user who
// wants to select the complete content of a long document.
- if (!cur.selection()) {
- Change const & change = cur.paragraph().lookupChange(cur.pos());
- enable = change.changed();
- } else
+ if (!cur.selection())
+ enable = cur.paragraph().isChanged(cur.pos());
+ else
// TODO: context-sensitive enabling of LFUN_CHANGE_ACCEPT/REJECT
// for selections.
enable = true;
case LFUN_OUTLINE_OUT:
case LFUN_OUTLINE_DRAGMOVE:
// FIXME: LyX is not ready for outlining within inset.
- enable = isMainText(cur.bv().buffer())
+ enable = isMainText()
&& cur.paragraph().layout().toclevel != Layout::NOT_IN_TOC;
break;
case LFUN_NEWPAGE_INSERT:
// not allowed in description items
+ code = NEWPAGE_CODE;
enable = !inDescriptionItem(cur);
break;
- case LFUN_MATH_INSERT:
- case LFUN_MATH_AMS_MATRIX:
- case LFUN_MATH_MATRIX:
- case LFUN_MATH_DELIM:
- case LFUN_MATH_BIGDELIM:
- // not allowed in ERT, for example.
- enable = cur.inset().insetAllowed(MATH_CODE);
- break;
-
case LFUN_DATE_INSERT: {
string const format = cmd.argument().empty()
? lyxrc.date_insert_format : to_utf8(cmd.argument());
}
case LFUN_LANGUAGE:
- // FIXME: use isPassThru() here?
- enable = !cur.inset().forceLTR();
+ enable = !cur.inset().getLayout().isPassThru();
+ break;
case LFUN_BREAK_PARAGRAPH:
enable = cur.inset().getLayout().isMultiPar();
+ break;
case LFUN_WORD_DELETE_FORWARD:
case LFUN_WORD_DELETE_BACKWARD:
case LFUN_LINE_END:
case LFUN_CHAR_DELETE_FORWARD:
case LFUN_CHAR_DELETE_BACKWARD:
- case LFUN_PARAGRAPH_SPACING:
case LFUN_INSET_INSERT:
case LFUN_WORD_UPCASE:
case LFUN_WORD_LOWCASE:
case LFUN_SERVER_GET_LAYOUT:
case LFUN_LAYOUT:
case LFUN_SELF_INSERT:
- case LFUN_LINE_INSERT:
- case LFUN_MATH_DISPLAY:
- case LFUN_MATH_MODE:
- case LFUN_MATH_MACRO:
- case LFUN_MATH_SUBSCRIPT:
- case LFUN_MATH_SUPERSCRIPT:
case LFUN_FONT_DEFAULT:
case LFUN_FONT_UNDERLINE:
case LFUN_FONT_STRIKEOUT:
case LFUN_INSET_END:
case LFUN_INSET_BEGIN_SELECT:
case LFUN_INSET_END_SELECT:
+ case LFUN_INSET_SELECT_ALL:
case LFUN_UNICODE_INSERT:
// these are handled in our dispatch()
enable = true;
}
if (code != NO_CODE
- && (cur.empty() || !cur.inset().insetAllowed(code)))
+ && (cur.empty()
+ || !cur.inset().insetAllowed(code)
+ || cur.paragraph().layout().pass_thru))
enable = false;
switch (cmd.action) {
case LFUN_ACCENT_UMLAUT:
case LFUN_ACCENT_UNDERBAR:
case LFUN_ACCENT_UNDERDOT:
- case LFUN_APPENDIX:
- case LFUN_BOX_INSERT:
- case LFUN_BRANCH_INSERT:
- case LFUN_CAPTION_INSERT:
- case LFUN_DEPTH_DECREMENT:
- case LFUN_DEPTH_INCREMENT:
- case LFUN_ERT_INSERT:
- case LFUN_FILE_INSERT:
- case LFUN_FLEX_INSERT:
- case LFUN_FLOAT_INSERT:
- case LFUN_FLOAT_LIST_INSERT:
- case LFUN_FLOAT_WIDE_INSERT:
case LFUN_FONT_BOLD:
case LFUN_FONT_BOLDSYMBOL:
case LFUN_FONT_TYPEWRITER:
case LFUN_FONT_STRIKEOUT:
case LFUN_FONT_UULINE:
case LFUN_FONT_UWAVE:
- case LFUN_FOOTNOTE_INSERT:
- case LFUN_HYPERLINK_INSERT:
- case LFUN_INDEX_INSERT:
- case LFUN_INDEX_PRINT:
- case LFUN_INSET_INSERT:
- case LFUN_LABEL_GOTO:
- case LFUN_LABEL_INSERT:
- case LFUN_LAYOUT_TABULAR:
- case LFUN_LINE_INSERT:
- case LFUN_MARGINALNOTE_INSERT:
- case LFUN_MATH_DISPLAY:
- case LFUN_MATH_INSERT:
- case LFUN_MATH_AMS_MATRIX:
- case LFUN_MATH_MATRIX:
- case LFUN_MATH_MODE:
- case LFUN_MENU_OPEN:
- case LFUN_NEWLINE_INSERT:
- case LFUN_NEWPAGE_INSERT:
- case LFUN_NOACTION:
- case LFUN_NOMENCL_INSERT:
- case LFUN_NOMENCL_PRINT:
- case LFUN_NOTE_INSERT:
- case LFUN_NOTE_NEXT:
- case LFUN_OPTIONAL_INSERT:
- case LFUN_PHANTOM_INSERT:
- case LFUN_REFERENCE_NEXT:
- case LFUN_SERVER_GOTO_FILE_ROW:
- case LFUN_SERVER_NOTIFY:
- case LFUN_SERVER_SET_XY:
- case LFUN_SPACE_INSERT:
- case LFUN_SPECIALCHAR_INSERT:
- case LFUN_TABULAR_INSERT:
case LFUN_TEXTSTYLE_APPLY:
case LFUN_TEXTSTYLE_UPDATE:
- case LFUN_TOC_INSERT:
- case LFUN_WRAP_INSERT:
- if (!cur.inset().getLayout().isPassThru())
+ if (cur.inset().getLayout().isPassThru())
enable = false;
break;
default:
if (!clip.empty()) {
cur.recordUndo();
if (asParagraphs)
- insertStringAsParagraphs(cur, clip);
+ insertStringAsParagraphs(cur, clip, cur.current_font);
else
- insertStringAsLines(cur, clip);
+ insertStringAsLines(cur, clip, cur.current_font);
}
}