#include "insets/InsetSpecialChar.h"
#include "insets/InsetText.h"
#include "insets/InsetInfo.h"
+#include "insets/InsetGraphics.h"
+#include "insets/InsetGraphicsParams.h"
#include "support/convert.h"
#include "support/debug.h"
const int old_pos = cur.pos();
#endif
cur.insert(new InsetMathHull(hullSimple));
- BOOST_ASSERT(old_pos == cur.pos());
+#ifdef ENABLE_ASSERTIONS
+ LASSERT(old_pos == cur.pos(), /**/);
+#endif
cur.nextInset()->edit(cur, true);
// don't do that also for LFUN_MATH_MODE
// unless you want end up with always changing
{
InsetMathHull * formula = new InsetMathHull;
istringstream is(to_utf8(sel));
- Lexer lex(0, 0);
+ Lexer lex;
lex.setStream(is);
formula->read(lex);
if (formula->getType() == hullNone)
switch (mode) {
case OutlineUp: {
+ if (start == pars.begin())
+ // Nothing to move.
+ return;
ParagraphList::iterator dest = start;
// Move out (up) from this header
if (dest == bgn)
return;
}
case OutlineDown: {
- ParagraphList::iterator dest = finish;
+ if (finish == end)
+ // Nothing to move.
+ return;
+ // Go one down from *this* header:
+ ParagraphList::iterator dest = boost::next(finish, 1);
+ // Go further down to find header to insert in front of:
+ for (; dest != end; ++dest) {
+ toclevel = dest->layout().toclevel;
+ if (toclevel != Layout::NOT_IN_TOC
+ && toclevel <= thistoclevel) {
+ break;
+ }
+ }
// One such was found:
pit_type newpit = distance(bgn, dest);
pit_type const len = distance(start, finish);
// at the end?
cur.noUpdate();
- BOOST_ASSERT(cur.text() == this);
+ LASSERT(cur.text() == this, /**/);
CursorSlice oldTopSlice = cur.top();
bool oldBoundary = cur.boundary();
bool sel = cur.selection();
case LFUN_WORD_RIGHT:
case LFUN_WORD_RIGHT_SELECT:
- //FIXME: for visual cursor mode, really move right
- if (reverseDirectionNeeded(cur)) {
- cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
- LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+ if (lyxrc.visual_cursor) {
+ needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_RIGHT_SELECT);
+ needsUpdate |= cursorVisRightOneWord(cur);
+ if (!needsUpdate && oldTopSlice == cur.top()
+ && cur.boundary() == oldBoundary) {
+ cur.undispatched();
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+ }
} else {
- cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
- LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+ if (reverseDirectionNeeded(cur)) {
+ cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
+ LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+ } else {
+ cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
+ LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+ }
+ dispatch(cur, cmd);
+ return;
}
- dispatch(cur, cmd);
- return;
+ break;
case LFUN_WORD_FORWARD:
case LFUN_WORD_FORWARD_SELECT:
case LFUN_WORD_LEFT:
case LFUN_WORD_LEFT_SELECT:
- //FIXME: for visual cursor mode, really move left
- if (reverseDirectionNeeded(cur)) {
- cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
- LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+ if (lyxrc.visual_cursor) {
+ needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_LEFT_SELECT);
+ needsUpdate |= cursorVisLeftOneWord(cur);
+ if (!needsUpdate && oldTopSlice == cur.top()
+ && cur.boundary() == oldBoundary) {
+ cur.undispatched();
+ cmd = FuncRequest(LFUN_FINISHED_LEFT);
+ }
} else {
- cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
- LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+ if (reverseDirectionNeeded(cur)) {
+ cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
+ LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+ } else {
+ cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
+ LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+ }
+ dispatch(cur, cmd);
+ return;
}
- dispatch(cur, cmd);
- return;
+ break;
case LFUN_WORD_BACKWARD:
case LFUN_WORD_BACKWARD_SELECT:
break;
}
- case LFUN_NEW_LINE: {
- // Not allowed by LaTeX (labels or empty par)
- if (cur.pos() > cur.paragraph().beginOfBody()) {
- // this avoids a double undo
- // FIXME: should not be needed, ideally
- if (!cur.selection())
- cur.recordUndo();
- cap::replaceSelection(cur);
- cur.insert(new InsetNewline);
- cur.posForward();
- moveCursor(cur, false);
- }
+ case LFUN_NEWLINE_INSERT: {
+ InsetNewlineParams inp;
+ docstring arg = cmd.argument();
+ // this avoids a double undo
+ // FIXME: should not be needed, ideally
+ if (!cur.selection())
+ cur.recordUndo();
+ cap::replaceSelection(cur);
+ if (arg == "linebreak")
+ inp.kind = InsetNewlineParams::LINEBREAK;
+ else
+ inp.kind = InsetNewlineParams::NEWLINE;
+ cur.insert(new InsetNewline(inp));
+ cur.posForward();
+ moveCursor(cur, false);
break;
}
- case LFUN_LINE_BREAK: {
- // Not allowed by LaTeX (labels or empty par)
- if (cur.pos() > cur.paragraph().beginOfBody()) {
- // this avoids a double undo
- // FIXME: should not be needed, ideally
- if (!cur.selection())
- cur.recordUndo();
- cap::replaceSelection(cur);
- cur.insert(new InsetLinebreak);
- cur.posForward();
- moveCursor(cur, false);
- }
- break;
- }
-
case LFUN_CHAR_DELETE_FORWARD:
if (!cur.selection()) {
if (cur.pos() == cur.paragraph().size())
moveCursor(cur, false);
break;
- case LFUN_DELETE_FORWARD_SKIP:
- // Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
- if (!cur.selection()) {
- if (cur.pos() == cur.lastpos()) {
- cursorForward(cur);
- cursorBackward(cur);
- }
- erase(cur);
- cur.resetAnchor();
- } else {
- cutSelection(cur, true, false);
- }
- break;
-
-
case LFUN_CHAR_DELETE_BACKWARD:
if (!cur.selection()) {
if (bv->getIntl().getTransManager().backspace()) {
}
break;
- case LFUN_DELETE_BACKWARD_SKIP:
- // Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
- if (!cur.selection()) {
- // FIXME: look here
- //CursorSlice cur = cursor();
- backspace(cur);
- //anchor() = cur;
- } else {
- cutSelection(cur, true, false);
- }
- break;
-
case LFUN_BREAK_PARAGRAPH:
cap::replaceSelection(cur);
breakParagraph(cur, cmd.argument() == "inverse");
cur.resetAnchor();
break;
- case LFUN_BREAK_PARAGRAPH_SKIP: {
- // When at the beginning of a paragraph, remove
- // indentation. Otherwise, do the same as LFUN_BREAK_PARAGRAPH.
- cap::replaceSelection(cur);
- if (cur.pos() == 0)
- cur.paragraph().params().labelWidthString(docstring());
- else
- breakParagraph(cur, false);
- 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??
break;
case LFUN_INSET_SETTINGS: {
- // if there is an inset at cursor, access this
- Inset * inset = cur.nextInset();
- if (inset) {
- inset->showInsetDialog(bv);
+ Inset & inset = cur.inset();
+ if (cmd.getArg(0) == insetName(inset.lyxCode())) {
+ // This inset dialog has been explicitely requested.
+ inset.showInsetDialog(bv);
+ break;
+ }
+ // else, if there is an inset at the cursor, access this
+ Inset * next_inset = cur.nextInset();
+ if (next_inset) {
+ next_inset->showInsetDialog(bv);
break;
}
- // if not work, access the underlying inset.
- cur.inset().showInsetDialog(bv);
+ // if not then access the underlying inset.
+ inset.showInsetDialog(bv);
break;
}
+ case LFUN_SET_GRAPHICS_GROUP: {
+ InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
+ if (!ins)
+ break;
+
+ cur.recordUndoFullDocument();
+
+ string id = to_utf8(cmd.argument());
+ string grp = graphics::getGroupParams(bv->buffer(), id);
+ InsetGraphicsParams tmp, inspar = ins->getParams();
+
+ if (id.empty())
+ inspar.groupId = to_utf8(cmd.argument());
+ else {
+ InsetGraphics::string2params(grp, bv->buffer(), tmp);
+ tmp.filename = inspar.filename;
+ inspar = tmp;
+ }
+
+ ins->setParams(inspar);
+ }
+
case LFUN_SPACE_INSERT:
if (cur.paragraph().layout().free_spacing)
insertChar(cur, ' ');
else if (arg == "linkback")
type = Clipboard::LinkBackGraphicsType;
else
- BOOST_ASSERT(false);
+ LASSERT(false, /**/);
pasteClipboardGraphics(cur, bv->buffer().errorList("Paste"), type);
}
break;
}
- case LFUN_SERVER_GET_FONT:
- if (cur.current_font.fontInfo().shape() == ITALIC_SHAPE)
- cur.message(from_ascii("E"));
- else if (cur.current_font.fontInfo().shape() == SMALLCAPS_SHAPE)
- cur.message(from_ascii("N"));
- else
- cur.message(from_ascii("0"));
- break;
-
case LFUN_SERVER_GET_LAYOUT:
cur.message(cur.paragraph().layout().name());
break;
}
}
if (!bv->mouseSetCursor(cur, false)) {
- cur.noUpdate();
- return;
+ cur.updateFlags(Update::SinglePar | Update::FitCursor);
+ break;
}
- return;
- }
+ default:
+ break;
+ } // switch (cmd.button())
+ break;
case LFUN_MOUSE_MOTION: {
// Mouse motion with right or middle mouse do nothing for now.
cur.noUpdate();
return;
+ case mouse_button::none:
+ case mouse_button::button4:
+ case mouse_button::button5:
+ break;
} // switch (cmd.button())
break;
}
p["target"] = (cmd.argument().empty()) ?
content : cmd.argument();
- string const data = InsetCommandMailer::params2string("href", p);
+ string const data = InsetCommand::params2string("href", p);
if (p["target"].empty()) {
bv->showDialog("href", data);
} else {
p["name"] = (cmd.argument().empty()) ?
cur.getPossibleLabel() :
cmd.argument();
- string const data = InsetCommandMailer::params2string("label", p);
+ string const data = InsetCommand::params2string("label", p);
if (cmd.argument().empty()) {
bv->showDialog("label", data);
}
case LFUN_INFO_INSERT: {
- Inset * inset = createInset(cur.bv().buffer(), cmd);
- if (!inset)
- break;
- // if an empty inset is created (cmd.argument() is empty)
- // use current selection as parameter.
+ Inset * inset;
if (cmd.argument().empty() && cur.selection()) {
- // use selected text as info to avoid a separate UI
+ // if command argument is empty use current selection as parameter.
docstring ds = cur.selectionAsString(false);
cutSelection(cur, true, false);
- static_cast<InsetInfo *>(inset)->setInfo(to_utf8(ds));
- static_cast<InsetInfo *>(inset)->updateInfo();
+ FuncRequest cmd0(cmd, ds);
+ inset = createInset(cur.bv().buffer(), cmd0);
+ } else {
+ inset = createInset(cur.bv().buffer(), cmd);
}
+ if (!inset)
+ break;
insertInset(cur, inset);
cur.posForward();
break;
}
-#if 0
- case LFUN_LIST_INSERT:
-#endif
case LFUN_CAPTION_INSERT:
case LFUN_FOOTNOTE_INSERT:
case LFUN_NOTE_INSERT:
cap::replaceSelection(cur);
cur.insert(new InsetMathHull(hullSimple));
checkAndActivateInset(cur, true);
- BOOST_ASSERT(cur.inMathed());
+ LASSERT(cur.inMathed(), /**/);
cur.dispatch(cmd);
break;
}
case LFUN_ACCENT_UNDERDOT:
case LFUN_ACCENT_UNDERBAR:
case LFUN_ACCENT_CARON:
- case LFUN_ACCENT_SPECIAL_CARON:
case LFUN_ACCENT_BREVE:
case LFUN_ACCENT_TIE:
case LFUN_ACCENT_HUNGARIAN_UMLAUT:
bv->translateAndInsert(cmd.argument()[0], this, cur);
break;
- case LFUN_FLOAT_LIST: {
+ case LFUN_FLOAT_LIST_INSERT: {
DocumentClass const & tclass = bv->buffer().params().documentClass();
if (tclass.floats().typeExist(to_utf8(cmd.argument()))) {
cur.recordUndo();
breakParagraph(cur);
}
- //FIXME Check if this should be emptyLayout()
- setLayout(cur, tclass.defaultLayoutName());
+ docstring const laystr = cur.inset().useEmptyLayout() ?
+ tclass.emptyLayoutName() :
+ tclass.defaultLayoutName();
+ setLayout(cur, laystr);
ParagraphParameters p;
setParagraphs(cur, p);
- insertInset(cur, new InsetFloatList(to_utf8(cmd.argument())));
+ // FIXME This should be simplified when InsetFloatList takes a
+ // Buffer in its constructor.
+ InsetFloatList * ifl = new InsetFloatList(to_utf8(cmd.argument()));
+ ifl->setBuffer(bv->buffer());
+ insertInset(cur, ifl);
cur.posForward();
} else {
lyxerr << "Non-existent float type: "
bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
- BOOST_ASSERT(cur.text() == this);
+ LASSERT(cur.text() == this, /**/);
Font const & font = cur.real_current_font;
FontInfo const & fontinfo = font.fontInfo();
case LFUN_APPENDIX:
flag.setOnOff(cur.paragraph().params().startOfAppendix());
- return true;
+ break;
case LFUN_BIBITEM_INSERT:
enable = (cur.paragraph().layout().labeltype == LABEL_BIBLIO
case LFUN_WRAP_INSERT:
code = WRAP_CODE;
break;
- case LFUN_FLOAT_LIST:
+ case LFUN_FLOAT_LIST_INSERT:
code = FLOAT_LIST_CODE;
break;
-#if 0
- case LFUN_LIST_INSERT:
- code = LIST_CODE;
- break;
-#endif
case LFUN_CAPTION_INSERT:
code = CAPTION_CODE;
break;
case LFUN_FONT_EMPH:
flag.setOnOff(fontinfo.emph() == FONT_ON);
- return true;
+ break;
case LFUN_FONT_NOUN:
flag.setOnOff(fontinfo.noun() == FONT_ON);
- return true;
+ break;
case LFUN_FONT_BOLD:
flag.setOnOff(fontinfo.series() == BOLD_SERIES);
- return true;
+ break;
case LFUN_FONT_SANS:
flag.setOnOff(fontinfo.family() == SANS_FAMILY);
- return true;
+ break;
case LFUN_FONT_ROMAN:
flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
- return true;
+ break;
case LFUN_FONT_TYPEWRITER:
flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
- return true;
+ break;
case LFUN_CUT:
case LFUN_COPY:
enable = (cur.paragraph().layout().toclevel != Layout::NOT_IN_TOC);
break;
+ case LFUN_NEWLINE_INSERT:
+ // LaTeX restrictions (labels or empty par)
+ enable = (cur.pos() > cur.paragraph().beginOfBody());
+ break;
+
+ case LFUN_SET_GRAPHICS_GROUP: {
+ InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
+ if (!ins)
+ enable = false;
+ else
+ flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
+ break;
+ }
+
case LFUN_WORD_DELETE_FORWARD:
case LFUN_WORD_DELETE_BACKWARD:
case LFUN_LINE_DELETE:
case LFUN_PARAGRAPH_UP:
case LFUN_PARAGRAPH_DOWN:
case LFUN_LINE_BEGIN:
- case LFUN_LINE_BREAK:
case LFUN_LINE_END:
- case LFUN_NEW_LINE:
case LFUN_CHAR_DELETE_FORWARD:
- case LFUN_DELETE_FORWARD_SKIP:
case LFUN_CHAR_DELETE_BACKWARD:
- case LFUN_DELETE_BACKWARD_SKIP:
case LFUN_BREAK_PARAGRAPH:
- case LFUN_BREAK_PARAGRAPH_SKIP:
case LFUN_PARAGRAPH_SPACING:
case LFUN_INSET_INSERT:
case LFUN_WORD_UPCASE:
case LFUN_CHARS_TRANSPOSE:
case LFUN_SERVER_GET_XY:
case LFUN_SERVER_SET_XY:
- case LFUN_SERVER_GET_FONT:
case LFUN_SERVER_GET_LAYOUT:
case LFUN_LAYOUT:
case LFUN_DATE_INSERT:
case LFUN_ACCENT_UNDERDOT:
case LFUN_ACCENT_UNDERBAR:
case LFUN_ACCENT_CARON:
- case LFUN_ACCENT_SPECIAL_CARON:
case LFUN_ACCENT_BREVE:
case LFUN_ACCENT_TIE:
case LFUN_ACCENT_HUNGARIAN_UMLAUT:
&& (cur.empty() || !cur.inset().insetAllowed(code)))
enable = false;
- flag.enabled(enable);
+ flag.setEnabled(enable);
return true;
}