#include "Text.h"
+#include "Bidi.h"
#include "BranchList.h"
#include "FloatList.h"
#include "FuncStatus.h"
#include "buffer_funcs.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "bufferview_funcs.h"
#include "Cursor.h"
-#include "CoordCache.h"
#include "CutAndPaste.h"
-#include "debug.h"
+#include "support/debug.h"
#include "DispatchResult.h"
#include "ErrorList.h"
#include "factory.h"
#include "FuncRequest.h"
-#include "gettext.h"
+#include "support/gettext.h"
+#include "InsetList.h"
#include "Intl.h"
#include "Language.h"
+#include "Layout.h"
#include "LyXAction.h"
#include "LyXFunc.h"
#include "Lexer.h"
#include "LyXRC.h"
-#include "Row.h"
#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "Undo.h"
-#include "VSpace.h"
#include "ParIterator.h"
+#include "TextClass.h"
+#include "TextMetrics.h"
+#include "VSpace.h"
#include "frontends/Clipboard.h"
#include "frontends/Selection.h"
+#include "insets/InsetCollapsable.h"
#include "insets/InsetCommand.h"
#include "insets/InsetFloatList.h"
#include "insets/InsetNewline.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"
#include "mathed/InsetMathHull.h"
#include "mathed/MathMacroTemplate.h"
-#include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
#include <clocale>
#include <sstream>
+using std::endl;
+using std::string;
+using std::istringstream;
+using std::ostringstream;
namespace lyx {
using support::isStrUnsignedInt;
using support::token;
-using std::endl;
-using std::string;
-using std::istringstream;
-using std::ostringstream;
-
-
-extern docstring current_layout;
-
-
-namespace {
-
- // globals...
- Font freefont(Font::ALL_IGNORE);
- bool toggleall = false;
+// globals...
+static Font freefont(ignore_font, ignore_language);
+static bool toggleall = false;
- void toggleAndShow(Cursor & cur, Text * text,
- Font const & font, bool toggleall = true)
- {
- text->toggleFree(cur, font, toggleall);
-
- if (font.language() != ignore_language ||
- font.number() != Font::IGNORE) {
- Paragraph & par = cur.paragraph();
- if (cur.boundary() != text->isRTLBoundary(cur.buffer(), par,
- cur.pos(), text->real_current_font))
- text->setCursor(cur, cur.pit(), cur.pos(),
- false, !cur.boundary());
- }
- }
-
-
- void moveCursor(Cursor & cur, bool selecting)
- {
- if (selecting || cur.mark())
- cur.setSelection();
- }
-
-
- void finishChange(Cursor & cur, bool selecting)
- {
- finishUndo();
- moveCursor(cur, selecting);
- }
-
-
- void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
- {
- recordUndo(cur);
- docstring sel = cur.selectionAsString(false);
-
- // It may happen that sel is empty but there is a selection
- replaceSelection(cur);
-
- if (sel.empty()) {
-#ifdef ENABLE_ASSERTIONS
- const int old_pos = cur.pos();
-#endif
- cur.insert(new InsetMathHull(hullSimple));
- BOOST_ASSERT(old_pos == cur.pos());
- cur.nextInset()->edit(cur, true);
- // don't do that also for LFUN_MATH_MODE
- // unless you want end up with always changing
- // to mathrm when opening an inlined inset --
- // I really hate "LyXfunc overloading"...
- if (display)
- cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
- // Avoid an unnecessary undo step if cmd.argument
- // is empty
- if (!cmd.argument().empty())
- cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
- cmd.argument()));
- } else {
- // create a macro if we see "\\newcommand"
- // somewhere, and an ordinary formula
- // otherwise
- if (sel.find(from_ascii("\\newcommand")) == string::npos
- && sel.find(from_ascii("\\def")) == string::npos)
- {
- InsetMathHull * formula = new InsetMathHull;
- istringstream is(to_utf8(sel));
- Lexer lex(0, 0);
- lex.setStream(is);
- formula->read(cur.buffer(), lex);
- if (formula->getType() == hullNone)
- // Don't create pseudo formulas if
- // delimiters are left out
- formula->mutate(hullSimple);
- cur.insert(formula);
- } else {
- cur.insert(new MathMacroTemplate(sel));
- }
- }
- cur.message(from_utf8(N_("Math editor mode")));
+static void toggleAndShow(Cursor & cur, Text * text,
+ Font const & font, bool toggleall = true)
+{
+ text->toggleFree(cur, font, toggleall);
+
+ if (font.language() != ignore_language ||
+ font.fontInfo().number() != FONT_IGNORE) {
+ TextMetrics const & tm = cur.bv().textMetrics(text);
+ if (cur.boundary() != tm.isRTLBoundary(cur.pit(), cur.pos(),
+ cur.real_current_font))
+ text->setCursor(cur, cur.pit(), cur.pos(),
+ false, !cur.boundary());
}
+}
-} // namespace anon
-
-
-
-namespace bv_funcs {
-string const freefont2string()
+static void moveCursor(Cursor & cur, bool selecting)
{
- string data;
- if (font2string(freefont, toggleall, data))
- return data;
- return string();
+ if (selecting || cur.mark())
+ cur.setSelection();
}
-}
-void Text::cursorPrevious(Cursor & cur)
+static void finishChange(Cursor & cur, bool selecting)
{
- pos_type cpos = cur.pos();
- pit_type cpar = cur.pit();
-
- int x = cur.x_target();
- setCursorFromCoordinates(cur, x, 0);
- cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP));
-
- if (cpar == cur.pit() && cpos == cur.pos())
- // we have a row which is taller than the workarea. The
- // simplest solution is to move to the previous row instead.
- cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP));
-
- finishUndo();
- cur.updateFlags(Update::Force | Update::FitCursor);
+ cur.finishUndo();
+ moveCursor(cur, selecting);
}
-void Text::cursorNext(Cursor & cur)
+static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
{
- pos_type cpos = cur.pos();
- pit_type cpar = cur.pit();
+ cur.recordUndo();
+ docstring sel = cur.selectionAsString(false);
- int x = cur.x_target();
- setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1);
- cur.dispatch(FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN));
+ // It may happen that sel is empty but there is a selection
+ replaceSelection(cur);
- if (cpar == cur.pit() && cpos == cur.pos())
- // we have a row which is taller than the workarea. The
- // simplest solution is to move to the next row instead.
- cur.dispatch(
- FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN));
-
- finishUndo();
- cur.updateFlags(Update::Force | Update::FitCursor);
+ if (sel.empty()) {
+#ifdef ENABLE_ASSERTIONS
+ const int old_pos = cur.pos();
+#endif
+ cur.insert(new InsetMathHull(hullSimple));
+ BOOST_ASSERT(old_pos == cur.pos());
+ cur.nextInset()->edit(cur, true);
+ // don't do that also for LFUN_MATH_MODE
+ // unless you want end up with always changing
+ // to mathrm when opening an inlined inset --
+ // I really hate "LyXfunc overloading"...
+ if (display)
+ cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
+ // Avoid an unnecessary undo step if cmd.argument
+ // is empty
+ if (!cmd.argument().empty())
+ cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
+ cmd.argument()));
+ } else {
+ // create a macro if we see "\\newcommand"
+ // somewhere, and an ordinary formula
+ // otherwise
+ if (sel.find(from_ascii("\\newcommand")) == string::npos
+ && sel.find(from_ascii("\\def")) == string::npos)
+ {
+ InsetMathHull * formula = new InsetMathHull;
+ istringstream is(to_utf8(sel));
+ Lexer lex(0, 0);
+ lex.setStream(is);
+ formula->read(cur.buffer(), lex);
+ if (formula->getType() == hullNone)
+ // Don't create pseudo formulas if
+ // delimiters are left out
+ formula->mutate(hullSimple);
+ cur.insert(formula);
+ } else {
+ cur.insert(new MathMacroTemplate(sel));
+ }
+ }
+ cur.message(from_utf8(N_("Math editor mode")));
}
-namespace {
-
-void specialChar(Cursor & cur, InsetSpecialChar::Kind kind)
+static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind)
{
- recordUndo(cur);
+ cur.recordUndo();
cap::replaceSelection(cur);
cur.insert(new InsetSpecialChar(kind));
- cur.posRight();
+ cur.posForward();
}
-bool doInsertInset(Cursor & cur, Text * text,
+static bool doInsertInset(Cursor & cur, Text * text,
FuncRequest const & cmd, bool edit, bool pastesel)
{
- Inset * inset = createInset(&cur.bv(), cmd);
+ Inset * inset = createInset(cur.bv().buffer(), cmd);
if (!inset)
return false;
- recordUndo(cur);
- bool gotsel = false;
- if (cur.selection()) {
- lyx::dispatch(FuncRequest(LFUN_CUT));
- gotsel = true;
- }
- text->insertInset(cur, inset);
-
- if (edit)
- inset->edit(cur, true);
-
- if (gotsel && pastesel) {
- lyx::dispatch(FuncRequest(LFUN_PASTE, "0"));
- // reset first par to default
- if (cur.lastpit() != 0 || cur.lastpos() != 0) {
- Layout_ptr const layout =
- cur.buffer().params().getTextClass().defaultLayout();
- cur.text()->paragraphs().begin()->layout(layout);
+ if (InsetCollapsable * ci = inset->asInsetCollapsable())
+ ci->setLayout(cur.bv().buffer().params());
+
+ cur.recordUndo();
+ if (cmd.action == LFUN_INDEX_INSERT) {
+ docstring ds = support::subst(text->getStringToIndex(cur), '\n', ' ');
+ text->insertInset(cur, inset);
+ if (edit)
+ inset->edit(cur, true);
+ // Now put this into inset
+ static_cast<InsetCollapsable *>(inset)->text_.insertStringAsParagraphs(cur, ds);
+ } else {
+ bool gotsel = false;
+ if (cur.selection()) {
+ lyx::dispatch(FuncRequest(LFUN_CUT));
+ gotsel = true;
+ }
+ text->insertInset(cur, inset);
+
+ if (edit)
+ inset->edit(cur, true);
+
+ if (gotsel && pastesel) {
+ lyx::dispatch(FuncRequest(LFUN_PASTE, "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);
+ }
}
}
return true;
}
-} // anon namespace
-
-
-void Text::number(Cursor & cur)
+string const freefont2string()
{
- Font font(Font::ALL_IGNORE);
- font.setNumber(Font::TOGGLE);
- toggleAndShow(cur, this, font);
+ return freefont.toString(toggleall);
}
-bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const
-{
- return par.isRightToLeftPar(buffer.params());
-}
+/// the type of outline operation
+enum OutlineOp {
+ OutlineUp, // Move this header with text down
+ OutlineDown, // Move this header with text up
+ OutlineIn, // Make this header deeper
+ OutlineOut // Make this header shallower
+};
-bool Text::isRTL(Buffer const & buffer, CursorSlice const & sl, bool boundary) const
+static void outline(OutlineOp mode, Cursor & cur)
{
- if (!lyxrc.rtl_support && !sl.text())
- return false;
-
- int correction = 0;
- if (boundary && sl.pos() > 0)
- correction = -1;
-
- Paragraph const & par = getPar(sl.pit());
- return getFont(buffer, par, sl.pos() + correction).isVisibleRightToLeft();
+ Buffer & buf = cur.buffer();
+ pit_type & pit = cur.pit();
+ ParagraphList & pars = buf.text().paragraphs();
+ ParagraphList::iterator bgn = pars.begin();
+ // The first paragraph of the area to be copied:
+ ParagraphList::iterator start = boost::next(bgn, pit);
+ // The final paragraph of area to be copied:
+ ParagraphList::iterator finish = start;
+ ParagraphList::iterator end = pars.end();
+
+ TextClass::const_iterator lit =
+ buf.params().getTextClass().begin();
+ TextClass::const_iterator const lend =
+ buf.params().getTextClass().end();
+
+ int const thistoclevel = start->layout()->toclevel;
+ int toclevel;
+ switch (mode) {
+ case OutlineUp: {
+ // Move out (down) from this section header
+ if (finish != end)
+ ++finish;
+ // Seek the one (on same level) below
+ for (; finish != end; ++finish) {
+ toclevel = finish->layout()->toclevel;
+ if (toclevel != Layout::NOT_IN_TOC
+ && toclevel <= thistoclevel) {
+ break;
+ }
+ }
+ ParagraphList::iterator dest = start;
+ // Move out (up) from this header
+ if (dest == bgn)
+ break;
+ // Search previous same-level header above
+ do {
+ --dest;
+ toclevel = dest->layout()->toclevel;
+ } while(dest != bgn
+ && (toclevel == Layout::NOT_IN_TOC
+ || toclevel > thistoclevel));
+ // Not found; do nothing
+ if (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel)
+ break;
+ pit_type const newpit = std::distance(bgn, dest);
+ pit_type const len = std::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);
+ break;
+ }
+ case OutlineDown: {
+ // Go down out of current header:
+ if (finish != end)
+ ++finish;
+ // Find next same-level header:
+ for (; finish != end; ++finish) {
+ toclevel = finish->layout()->toclevel;
+ if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel)
+ break;
+ }
+ ParagraphList::iterator dest = finish;
+ // Go one down from *this* header:
+ if (dest != end)
+ ++dest;
+ else
+ break;
+ // 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 = std::distance(bgn, dest);
+ pit_type const len = std::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);
+ break;
+ }
+ case OutlineIn:
+ buf.undo().recordUndo(cur);
+ for (; lit != lend; ++lit) {
+ if ((*lit)->toclevel == thistoclevel + 1 &&
+ start->layout()->labeltype == (*lit)->labeltype) {
+ start->layout((*lit));
+ break;
+ }
+ }
+ break;
+ case OutlineOut:
+ buf.undo().recordUndo(cur);
+ for (; lit != lend; ++lit) {
+ if ((*lit)->toclevel == thistoclevel - 1 &&
+ start->layout()->labeltype == (*lit)->labeltype) {
+ start->layout((*lit));
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
}
-bool Text::isRTLBoundary(Buffer const & buffer, Paragraph const & par,
- pos_type pos) const
+void Text::number(Cursor & cur)
{
- if (!lyxrc.rtl_support)
- return false;
-
- // no RTL boundary at line start
- if (pos == 0)
- return false;
-
- bool left = getFont(buffer, par, pos - 1).isVisibleRightToLeft();
- bool right;
- if (pos == par.size())
- right = par.isRightToLeftPar(buffer.params());
- else
- right = getFont(buffer, par, pos).isVisibleRightToLeft();
- return left != right;
+ FontInfo font = ignore_font;
+ font.setNumber(FONT_TOGGLE);
+ toggleAndShow(cur, this, Font(font));
}
-bool Text::isRTLBoundary(Buffer const & buffer, Paragraph const & par,
- pos_type pos, Font const & font) const
+bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const
{
- if (!lyxrc.rtl_support)
- return false;
-
- bool left = font.isVisibleRightToLeft();
- bool right;
- if (pos == par.size())
- right = par.isRightToLeftPar(buffer.params());
- else
- right = getFont(buffer, par, pos).isVisibleRightToLeft();
- return left != right;
+ return par.isRTL(buffer.params());
}
void Text::dispatch(Cursor & cur, FuncRequest & cmd)
{
- LYXERR(Debug::ACTION) << "Text::dispatch: cmd: " << cmd << endl;
+ LYXERR(Debug::ACTION, "Text::dispatch: cmd: " << cmd);
// FIXME: We use the update flag to indicates wether a singlePar or a
// full screen update is needed. We reset it here but shall we restore it
BOOST_ASSERT(cur.text() == this);
BufferView * bv = &cur.bv();
+ TextMetrics & tm = cur.bv().textMetrics(this);
CursorSlice oldTopSlice = cur.top();
bool oldBoundary = cur.boundary();
bool sel = cur.selection();
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();
Paragraph & par = cur.paragraph();
bool start = !par.params().startOfAppendix();
-#ifdef WITH_WARNINGS
-#warning The code below only makes sense at top level.
+// FIXME: The code below only makes sense at top level.
// Should LFUN_APPENDIX be restricted to top-level paragraphs?
-#endif
// ensure that we have only one start_of_appendix in this document
// FIXME: this don't work for multipart document!
for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) {
}
}
- recordUndo(cur);
+ cur.recordUndo();
par.params().startOfAppendix(start);
// we can set the refreshing parameters now
if (cur.selection()) {
cutSelection(cur, true, false);
} else
- deleteLineForward(cur);
+ tm.deleteLineForward(cur);
finishChange(cur, false);
break;
case LFUN_CHAR_FORWARD:
case LFUN_CHAR_FORWARD_SELECT:
- //lyxerr << BOOST_CURRENT_FUNCTION
- // << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl;
+ //LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur);
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)) {
+ cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ?
+ LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
+ } else {
+ cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ?
+ LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
+ }
+ dispatch(cur, cmd);
+ return;
+
+ case LFUN_CHAR_RIGHT:
+ case LFUN_CHAR_RIGHT_SELECT:
+ //FIXME: for visual cursor, really move right
+ if (reverseDirectionNeeded(cur)) {
+ cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ?
+ LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
+ } else {
+ cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ?
+ LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
+ }
+ dispatch(cur, cmd);
+ return;
+
case LFUN_UP_SELECT:
case LFUN_DOWN_SELECT:
case LFUN_UP:
needsUpdate |= cursorDownParagraph(cur);
break;
- case LFUN_SCREEN_UP:
case LFUN_SCREEN_UP_SELECT:
- needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_UP_SELECT);
+ needsUpdate |= cur.selHandle(true);
if (cur.pit() == 0 && cur.textRow().pos() == 0)
cur.undispatched();
else {
- cursorPrevious(cur);
+ tm.cursorPrevious(cur);
}
break;
- case LFUN_SCREEN_DOWN:
case LFUN_SCREEN_DOWN_SELECT:
- needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_DOWN_SELECT);
+ needsUpdate |= cur.selHandle(true);
if (cur.pit() == cur.lastpit()
&& cur.textRow().endpos() == cur.lastpos())
cur.undispatched();
else {
- cursorNext(cur);
+ tm.cursorNext(cur);
}
break;
case LFUN_LINE_BEGIN:
case LFUN_LINE_BEGIN_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT);
- needsUpdate |= cursorHome(cur);
+ needsUpdate |= tm.cursorHome(cur);
break;
case LFUN_LINE_END:
case LFUN_LINE_END_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT);
- needsUpdate |= cursorEnd(cur);
+ needsUpdate |= tm.cursorEnd(cur);
break;
+ 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;
+ } else {
+ cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
+ LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+ }
+ dispatch(cur, cmd);
+ return;
+
case LFUN_WORD_FORWARD:
case LFUN_WORD_FORWARD_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT);
- if (reverseDirectionNeeded(cur))
- needsUpdate |= cursorLeftOneWord(cur);
- else
- needsUpdate |= cursorRightOneWord(cur);
+ needsUpdate |= cursorForwardOneWord(cur);
break;
+ 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;
+ } else {
+ cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
+ LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+ }
+ dispatch(cur, cmd);
+ return;
+
case LFUN_WORD_BACKWARD:
case LFUN_WORD_BACKWARD_SELECT:
needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT);
- if (reverseDirectionNeeded(cur))
- needsUpdate |= cursorRightOneWord(cur);
- else
- needsUpdate |= cursorLeftOneWord(cur);
+ needsUpdate |= cursorBackwardOneWord(cur);
break;
case LFUN_WORD_SELECT: {
break;
}
- case LFUN_BREAK_LINE: {
+ 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())
- recordUndo(cur);
+ cur.recordUndo();
cap::replaceSelection(cur);
cur.insert(new InsetNewline);
- cur.posRight();
+ 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;
// 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_DELETE_BACKWARD_SKIP:
// Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
if (!cur.selection()) {
-#ifdef WITH_WARNINGS
-#warning look here
-#endif
+ // FIXME: look here
//CursorSlice cur = cursor();
backspace(cur);
//anchor() = cur;
case LFUN_BREAK_PARAGRAPH:
cap::replaceSelection(cur);
- breakParagraph(cur, 0);
- cur.resetAnchor();
- break;
-
- case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT:
- cap::replaceSelection(cur);
- breakParagraph(cur, 1);
+ breakParagraph(cur, cmd.argument() == "inverse");
cur.resetAnchor();
break;
if (cur.pos() == 0)
cur.paragraph().params().labelWidthString(docstring());
else
- breakParagraph(cur, 0);
+ 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??
+ // 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();
}
case LFUN_INSET_INSERT: {
- recordUndo(cur);
- Inset * inset = createInset(bv, cmd);
+ cur.recordUndo();
+ Inset * inset = createInset(bv->buffer(), cmd);
if (inset) {
// FIXME (Abdel 01/02/2006):
// What follows would be a partial fix for bug 2154:
// 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
dispatch(cur, fr);
}
*/
+ if (cur.selection())
+ cutSelection(cur, true, false);
insertInset(cur, inset);
- cur.posRight();
+ cur.posForward();
}
break;
}
insertChar(cur, ' ');
else {
doInsertInset(cur, this, cmd, false, false);
- cur.posRight();
+ cur.posForward();
}
moveCursor(cur, false);
break;
- case LFUN_HYPHENATION_POINT_INSERT:
- specialChar(cur, InsetSpecialChar::HYPHENATION);
- break;
-
- case LFUN_LIGATURE_BREAK_INSERT:
- specialChar(cur, InsetSpecialChar::LIGATURE_BREAK);
- break;
-
- case LFUN_DOTS_INSERT:
- specialChar(cur, InsetSpecialChar::LDOTS);
- break;
-
- case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
- specialChar(cur, InsetSpecialChar::END_OF_SENTENCE);
- break;
-
- case LFUN_MENU_SEPARATOR_INSERT:
- specialChar(cur, InsetSpecialChar::MENU_SEPARATOR);
+ case LFUN_SPECIALCHAR_INSERT: {
+ string const name = to_utf8(cmd.argument());
+ if (name == "hyphenation")
+ specialChar(cur, InsetSpecialChar::HYPHENATION);
+ else if (name == "ligature-break")
+ specialChar(cur, InsetSpecialChar::LIGATURE_BREAK);
+ else if (name == "slash")
+ specialChar(cur, InsetSpecialChar::SLASH);
+ else if (name == "nobreakdash")
+ specialChar(cur, InsetSpecialChar::NOBREAKDASH);
+ else if (name == "dots")
+ specialChar(cur, InsetSpecialChar::LDOTS);
+ else if (name == "end-of-sentence")
+ specialChar(cur, InsetSpecialChar::END_OF_SENTENCE);
+ else if (name == "menu-separator")
+ specialChar(cur, InsetSpecialChar::MENU_SEPARATOR);
+ else if (name.empty())
+ lyxerr << "LyX function 'specialchar-insert' needs an argument." << endl;
+ else
+ lyxerr << "Wrong argument for LyX function 'specialchar-insert'." << endl;
break;
+ }
case LFUN_WORD_UPCASE:
- changeCase(cur, Text::text_uppercase);
+ changeCase(cur, text_uppercase);
break;
case LFUN_WORD_LOWCASE:
- changeCase(cur, Text::text_lowercase);
+ changeCase(cur, text_lowercase);
break;
case LFUN_WORD_CAPITALIZE:
- changeCase(cur, Text::text_capitalization);
+ changeCase(cur, text_capitalization);
break;
case LFUN_CHARS_TRANSPOSE:
cur.message(_("Paste"));
cap::replaceSelection(cur);
if (cmd.argument().empty() && !theClipboard().isInternal())
- pasteClipboard(cur, bv->buffer()->errorList("Paste"));
+ pasteClipboard(cur, bv->buffer().errorList("Paste"));
else {
string const arg(to_utf8(cmd.argument()));
- pasteFromStack(cur, bv->buffer()->errorList("Paste"),
+ pasteFromStack(cur, bv->buffer().errorList("Paste"),
isStrUnsignedInt(arg) ?
convert<unsigned int>(arg) :
0);
}
- bv->buffer()->errors("Paste");
+ bv->buffer().errors("Paste");
cur.clearSelection(); // bug 393
- finishUndo();
+ cur.finishUndo();
break;
case LFUN_CUT:
case LFUN_SERVER_GET_XY:
cur.message(from_utf8(
- convert<string>(cursorX(cur.bv(), cur.top(), cur.boundary()))
- + ' ' + convert<string>(cursorY(cur.bv(), cur.top(), cur.boundary()))));
+ convert<string>(tm.cursorX(cur.top(), cur.boundary()))
+ + ' ' + convert<string>(tm.cursorY(cur.top(), cur.boundary()))));
break;
case LFUN_SERVER_SET_XY: {
lyxerr << "SETXY: Could not parse coordinates in '"
<< to_utf8(cmd.argument()) << std::endl;
else
- setCursorFromCoordinates(cur, x, y);
+ tm.setCursorFromCoordinates(cur, x, y);
break;
}
case LFUN_SERVER_GET_FONT:
- if (current_font.shape() == Font::ITALIC_SHAPE)
+ if (cur.current_font.fontInfo().shape() == ITALIC_SHAPE)
cur.message(from_ascii("E"));
- else if (current_font.shape() == Font::SMALLCAPS_SHAPE)
+ else if (cur.current_font.fontInfo().shape() == SMALLCAPS_SHAPE)
cur.message(from_ascii("N"));
else
cur.message(from_ascii("0"));
case LFUN_LAYOUT: {
docstring layout = cmd.argument();
- LYXERR(Debug::INFO) << "LFUN_LAYOUT: (arg) " << to_utf8(layout) << endl;
+ LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout));
+
+ docstring const old_layout = cur.paragraph().layout()->name();
// Derive layout number from given argument (string)
// and current buffer's textclass (number)
- TextClass const & tclass = bv->buffer()->params().getTextClass();
+ TextClass const & tclass = bv->buffer().params().getTextClass();
if (layout.empty())
layout = tclass.defaultLayoutName();
bool hasLayout = tclass.hasLayout(layout);
break;
}
- bool change_layout = (current_layout != layout);
+ bool change_layout = (old_layout != layout);
if (!change_layout && cur.selection() &&
cur.selBegin().pit() != cur.selEnd().pit())
pit_type spit = cur.selBegin().pit();
pit_type epit = cur.selEnd().pit() + 1;
while (spit != epit) {
- if (pars_[spit].layout()->name() != current_layout) {
+ if (pars_[spit].layout()->name() != old_layout) {
change_layout = true;
break;
}
}
}
- if (change_layout) {
+ if (change_layout)
setLayout(cur, layout);
- // inform the GUI that the layout has changed.
- bv->layoutChanged(layout);
- }
+
break;
}
case LFUN_CLIPBOARD_PASTE:
cur.clearSelection();
- pasteClipboard(cur, bv->buffer()->errorList("Paste"),
+ pasteClipboard(cur, bv->buffer().errorList("Paste"),
cmd.argument() == "paragraph");
- bv->buffer()->errors("Paste");
+ bv->buffer().errors("Paste");
break;
case LFUN_PRIMARY_SELECTION_PASTE:
case LFUN_QUOTE_INSERT: {
Paragraph & par = cur.paragraph();
pos_type pos = cur.pos();
- BufferParams const & bufparams = bv->buffer()->params();
- Layout_ptr const & style = par.layout();
+ BufferParams const & bufparams = bv->buffer().params();
+ LayoutPtr const & style = par.layout();
if (!style->pass_thru
&& par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") {
// 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;
cur.insert(new InsetQuotes(c,
bufparams.quotes_language,
InsetQuotes::DoubleQ));
- cur.posRight();
+ cur.posForward();
}
else
lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\""));
break;
}
- case LFUN_DATE_INSERT:
- if (cmd.argument().empty())
- lyx::dispatch(FuncRequest(LFUN_SELF_INSERT,
- formatted_time(current_time())));
- else
- lyx::dispatch(FuncRequest(LFUN_SELF_INSERT,
- formatted_time(current_time(), to_utf8(cmd.argument()))));
+ case LFUN_DATE_INSERT: {
+ string const format = cmd.argument().empty()
+ ? lyxrc.date_insert_format : to_utf8(cmd.argument());
+ string const time = formatted_time(current_time(), format);
+ lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, time));
break;
+ }
case LFUN_MOUSE_TRIPLE:
if (cmd.button() == mouse_button::button1) {
- cursorHome(cur);
+ tm.cursorHome(cur);
cur.resetAnchor();
- cursorEnd(cur);
+ tm.cursorEnd(cur);
cur.setSelection();
bv->cursor() = cur;
}
// 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();
- // Middle button press pastes if we have a selection
- // We do this here as if the selection was inside an inset
- // it could get cleared on the unlocking of the inset so
- // we have to check this first
- bool paste_internally = false;
- if (cmd.button() == mouse_button::button2 && cap::selection()) {
- // Copy the selection buffer to the clipboard
- // stack, because we want it to appear in the
- // "Edit->Paste recent" menu.
- cap::copySelectionToStack();
- paste_internally = true;
- }
+ bool do_selection = cmd.button() == mouse_button::button1
+ && cmd.argument() == "region-select";
+ // Set the cursor
+ bool update = bv->mouseSetCursor(cur, do_selection);
// Insert primary selection with middle mouse
// if there is a local selection in the current buffer,
// insert this
if (cmd.button() == mouse_button::button2) {
- if (paste_internally) {
- cap::pasteSelection(cur, bv->buffer()->errorList("Paste"));
- bv->buffer()->errors("Paste");
- cur.clearSelection(); // bug 393
- bv->buffer()->markDirty();
- finishUndo();
+ if (cap::selection()) {
+ // Copy the selection buffer to the clipboard
+ // stack, because we want it to appear in the
+ // "Edit->Paste recent" menu.
+ cap::copySelectionToStack();
+
+ cap::pasteSelection(bv->cursor(),
+ bv->buffer().errorList("Paste"));
+ bv->buffer().errors("Paste");
+ bv->buffer().markDirty();
+ bv->cursor().finishUndo();
} else {
- bv->mouseSetCursor(cur);
lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph"));
}
}
- // we have to update after dePM triggered
- bool update = bv->mouseSetCursor(cur);
-
+ // we have to update after dEPM triggered
if (!update && cmd.button() == mouse_button::button1) {
needsUpdate = false;
cur.noUpdate();
// ignore motions deeper nested than the real anchor
Cursor & bvcur = cur.bv().cursor();
- if (bvcur.anchor_.hasPart(cur)) {
- CursorSlice old = bvcur.top();
-
- int const wh = bv->workHeight();
- int const y = std::max(0, std::min(wh - 1, cmd.y));
-
- setCursorFromCoordinates(cur, cmd.x, y);
- cur.setTargetX(cmd.x);
+ if (!bvcur.anchor_.hasPart(cur)) {
+ cur.undispatched();
+ break;
+ }
+ CursorSlice old = bvcur.top();
+
+ int const wh = bv->workHeight();
+ int const y = std::max(0, std::min(wh - 1, cmd.y));
+
+ tm.setCursorFromCoordinates(cur, cmd.x, y);
+ cur.setTargetX(cmd.x);
+ if (cmd.y >= wh)
+ lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
+ else if (cmd.y < 0)
+ lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
+ // This is to allow jumping over large insets
+ if (cur.top() == old) {
if (cmd.y >= wh)
lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
else if (cmd.y < 0)
lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
- // This is to allow jumping over large insets
- if (cur.top() == old) {
- if (cmd.y >= wh)
- lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
- else if (cmd.y < 0)
- lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
- }
-
- if (cur.top() == old)
- cur.noUpdate();
- else {
- // don't set anchor_
- bvcur.setCursor(cur);
- bvcur.selection() = true;
- //lyxerr << "MOTION: " << bv->cursor() << endl;
- }
+ }
- } else
- cur.undispatched();
+ if (cur.top() == old)
+ cur.noUpdate();
+ else {
+ // FIXME: This is brute force! But without it the selected
+ // area is not corrected updated while moving the mouse.
+ cur.updateFlags(Update::Force | Update::FitCursor);
+ // don't set anchor_
+ bvcur.setCursor(cur);
+ bvcur.selection() = true;
+ //lyxerr << "MOTION: " << bv->cursor() << endl;
+ }
break;
}
// "auto_region_delete", which defaults to
// true (on).
- if (lyxrc.auto_region_delete && cur.selection()) {
+ if (lyxrc.auto_region_delete && cur.selection())
cutSelection(cur, false, false);
- // When change tracking is set to off, the metrics update
- // mechanism correctly detects if a full update is needed or not.
- // This detection fails when a selection spans multiple rows and
- // change tracking is enabled because the paragraph metrics stays
- // the same. In this case, we force the full update:
- // (see http://bugzilla.lyx.org/show_bug.cgi?id=3992)
- if (cur.buffer().params().trackChanges)
- cur.updateFlags(Update::Force);
- }
cur.clearSelection();
- Font const old_font = real_current_font;
+ Font const old_font = cur.real_current_font;
docstring::const_iterator cit = cmd.argument().begin();
docstring::const_iterator end = cmd.argument().end();
break;
}
- case LFUN_URL_INSERT: {
- InsetCommandParams p("url");
- string const data = InsetCommandMailer::params2string("url", p);
- bv->showInsetDialog("url", data, 0);
- break;
- }
-
- case LFUN_HTML_INSERT: {
- InsetCommandParams p("htmlurl");
- string const data = InsetCommandMailer::params2string("url", p);
- bv->showInsetDialog("url", data, 0);
+ case LFUN_HYPERLINK_INSERT: {
+ InsetCommandParams p(HYPERLINK_CODE);
+ 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("href", p);
+ if (p["target"].empty()) {
+ bv->showDialog("href", data);
+ } else {
+ FuncRequest fr(LFUN_INSET_INSERT, data);
+ dispatch(cur, fr);
+ }
break;
}
case LFUN_LABEL_INSERT: {
- InsetCommandParams p("label");
+ InsetCommandParams p(LABEL_CODE);
// Try to generate a valid label
p["name"] = (cmd.argument().empty()) ?
cur.getPossibleLabel() :
string const data = InsetCommandMailer::params2string("label", p);
if (cmd.argument().empty()) {
- bv->showInsetDialog("label", data, 0);
+ bv->showDialog("label", data);
} else {
FuncRequest fr(LFUN_INSET_INSERT, data);
dispatch(cur, fr);
break;
}
-
+ 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.
+ 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.posForward();
+ break;
+ }
#if 0
case LFUN_LIST_INSERT:
case LFUN_THEOREM_INSERT:
#endif
case LFUN_CAPTION_INSERT:
+ case LFUN_FOOTNOTE_INSERT:
// Open the inset, and move the current selection
// inside it.
doInsertInset(cur, this, cmd, true, true);
- cur.posRight();
- updateLabels(*bv->buffer());
+ cur.posForward();
+ // These insets are numbered.
+ updateLabels(bv->buffer());
break;
case LFUN_NOTE_INSERT:
- case LFUN_CHARSTYLE_INSERT:
+ case LFUN_FLEX_INSERT:
case LFUN_BOX_INSERT:
case LFUN_BRANCH_INSERT:
case LFUN_BIBITEM_INSERT:
case LFUN_ERT_INSERT:
case LFUN_LISTING_INSERT:
- case LFUN_FOOTNOTE_INSERT:
case LFUN_MARGINALNOTE_INSERT:
case LFUN_OPTIONAL_INSERT:
case LFUN_ENVIRONMENT_INSERT:
// Open the inset, and move the current selection
// inside it.
doInsertInset(cur, this, cmd, true, true);
- cur.posRight();
+ cur.posForward();
break;
case LFUN_TABULAR_INSERT:
// if there were no arguments, just open the dialog
if (doInsertInset(cur, this, cmd, false, true))
- cur.posRight();
+ cur.posForward();
else
bv->showDialog("tabularcreate");
bool content = cur.selection(); // will some text be moved into the inset?
doInsertInset(cur, this, cmd, true, true);
- cur.posRight();
+ cur.posForward();
ParagraphList & pars = cur.text()->paragraphs();
- TextClass const & tclass = bv->buffer()->params().getTextClass();
+ TextClass const & tclass = bv->buffer().params().getTextClass();
// add a separate paragraph for the caption inset
pars.push_back(Paragraph());
// reposition the cursor to the caption
cur.pit() = cap_pit;
cur.pos() = 0;
- cur.dispatch(FuncRequest(LFUN_CAPTION_INSERT));
+ // FIXME: This Text/Cursor dispatch handling is a mess!
+ // We cannot use Cursor::dispatch here it needs access to up to
+ // date metrics.
+ FuncRequest cmd_caption(LFUN_CAPTION_INSERT);
+ cur.text()->dispatch(cur, cmd_caption);
+ cur.updateFlags(Update::Force);
// FIXME: When leaving the Float (or Wrap) inset we should
// delete any empty paragraph left above or below the
// caption.
}
case LFUN_INDEX_INSERT:
+ doInsertInset(cur, this, cmd, true, true);
+ cur.posForward();
+ break;
+
case LFUN_NOMENCL_INSERT: {
- Inset * inset = createInset(&cur.bv(), cmd);
+ FuncRequest cmd1 = cmd;
+ if (cmd.argument().empty())
+ cmd1 = FuncRequest(cmd,
+ bv->cursor().innerText()->getStringToIndex(bv->cursor()));
+ Inset * inset = createInset(cur.bv().buffer(), cmd1);
if (!inset)
break;
- recordUndo(cur);
+ cur.recordUndo();
cur.clearSelection();
insertInset(cur, inset);
- inset->edit(cur, true);
// Show the dialog for the nomenclature entry, since the
// description entry still needs to be filled in.
if (cmd.action == LFUN_NOMENCL_INSERT)
- InsetCommandMailer("nomenclature",
- *reinterpret_cast<InsetCommand *>(inset)).showDialog(&cur.bv());
- cur.posRight();
+ inset->edit(cur, true);
+ cur.posForward();
break;
}
case LFUN_TOC_INSERT:
case LFUN_HFILL_INSERT:
case LFUN_LINE_INSERT:
+ case LFUN_NEWPAGE_INSERT:
case LFUN_PAGEBREAK_INSERT:
case LFUN_CLEARPAGE_INSERT:
case LFUN_CLEARDOUBLEPAGE_INSERT:
// do nothing fancy
doInsertInset(cur, this, cmd, false, false);
- cur.posRight();
+ cur.posForward();
break;
case LFUN_DEPTH_DECREMENT:
int const nargs = s1.empty() ? 0 : convert<int>(s1);
string const s2 = token(s, ' ', 2);
string const type = s2.empty() ? "newcommand" : s2;
- cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, from_utf8(type)));
+ cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, false, from_utf8(type)));
//cur.nextInset()->edit(cur, true);
}
break;
case LFUN_MATH_MATRIX:
case LFUN_MATH_DELIM:
case LFUN_MATH_BIGDELIM: {
+ if (cur.selection())
+ cur.clearSelection();
+ // FIXME: instead of the above, this one
+ // should be used (but it asserts with Bidi enabled)
+ // cf. http://bugzilla.lyx.org/show_bug.cgi?id=4055
+ // cap::replaceSelection(cur);
cur.insert(new InsetMathHull(hullSimple));
checkAndActivateInset(cur, true);
BOOST_ASSERT(cur.inMathed());
}
case LFUN_FONT_EMPH: {
- Font font(Font::ALL_IGNORE);
- font.setEmph(Font::TOGGLE);
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setEmph(FONT_TOGGLE);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_BOLD: {
- Font font(Font::ALL_IGNORE);
- font.setSeries(Font::BOLD_SERIES);
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setSeries(BOLD_SERIES);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_NOUN: {
- Font font(Font::ALL_IGNORE);
- font.setNoun(Font::TOGGLE);
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setNoun(FONT_TOGGLE);
toggleAndShow(cur, this, font);
break;
}
- case LFUN_FONT_CODE: {
- Font font(Font::ALL_IGNORE);
- font.setFamily(Font::TYPEWRITER_FAMILY); // no good
+ case LFUN_FONT_TYPEWRITER: {
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setFamily(TYPEWRITER_FAMILY); // no good
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_SANS: {
- Font font(Font::ALL_IGNORE);
- font.setFamily(Font::SANS_FAMILY);
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setFamily(SANS_FAMILY);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_ROMAN: {
- Font font(Font::ALL_IGNORE);
- font.setFamily(Font::ROMAN_FAMILY);
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setFamily(ROMAN_FAMILY);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_DEFAULT: {
- Font font(Font::ALL_INHERIT, ignore_language);
+ Font font(inherit_font, ignore_language);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_UNDERLINE: {
- Font font(Font::ALL_IGNORE);
- font.setUnderbar(Font::TOGGLE);
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setUnderbar(FONT_TOGGLE);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_SIZE: {
- Font font(Font::ALL_IGNORE);
- font.setLyXSize(to_utf8(cmd.argument()));
+ Font font(ignore_font, ignore_language);
+ setLyXSize(to_utf8(cmd.argument()), font.fontInfo());
toggleAndShow(cur, this, font);
break;
}
Language const * lang = languages.getLanguage(to_utf8(cmd.argument()));
if (!lang)
break;
- Font font(Font::ALL_IGNORE);
- font.setLanguage(lang);
+ Font font(ignore_font, lang);
toggleAndShow(cur, this, font);
break;
}
case LFUN_FONT_FREE_UPDATE: {
Font font;
bool toggle;
- if (bv_funcs::string2font(to_utf8(cmd.argument()), font, toggle)) {
+ if (font.fromString(to_utf8(cmd.argument()), toggle)) {
freefont = font;
toggleall = toggle;
toggleAndShow(cur, this, freefont, toggleall);
cur.message(_("Character set"));
+ } else {
+ lyxerr << "Argument not ok";
}
break;
}
case LFUN_FINISHED_LEFT:
- LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_LEFT:\n" << cur << endl;
- if (reverseDirectionNeeded(cur))
+ LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_LEFT:\n" << cur);
+ if (reverseDirectionNeeded(cur)) {
++cur.pos();
+ cur.setCurrentFont();
+ }
break;
case LFUN_FINISHED_RIGHT:
- LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_RIGHT:\n" << cur << endl;
- if (!reverseDirectionNeeded(cur))
+ LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_RIGHT:\n" << cur);
+ if (!reverseDirectionNeeded(cur)) {
++cur.pos();
+ cur.setCurrentFont();
+ }
+ break;
+
+ case LFUN_FINISHED_BACKWARD:
+ LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur);
+ break;
+
+ case LFUN_FINISHED_FORWARD:
+ LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_FORWARD:\n" << cur);
+ ++cur.pos();
+ cur.setCurrentFont();
break;
case LFUN_LAYOUT_PARAGRAPH: {
string data;
params2string(cur.paragraph(), data);
data = "show\n" + data;
- bv->showDialogWithData("paragraph", data);
+ bv->showDialog("paragraph", data);
break;
}
break;
case LFUN_FLOAT_LIST: {
- TextClass const & tclass = bv->buffer()->params().getTextClass();
+ TextClass const & tclass = bv->buffer().params().getTextClass();
if (tclass.floats().typeExist(to_utf8(cmd.argument()))) {
- // not quite sure if we want this...
- recordUndo(cur);
- cur.clearSelection();
+ cur.recordUndo();
+ if (cur.selection())
+ cutSelection(cur, true, false);
breakParagraph(cur);
if (cur.lastpos() != 0) {
- cursorLeft(cur);
+ cursorBackward(cur);
breakParagraph(cur);
}
setLayout(cur, tclass.defaultLayoutName());
- setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, docstring(), 0);
+ ParagraphParameters p;
+ setParagraphs(cur, p);
insertInset(cur, new InsetFloatList(to_utf8(cmd.argument())));
- cur.posRight();
+ cur.posForward();
} else {
lyxerr << "Non-existent float type: "
<< to_utf8(cmd.argument()) << endl;
arg = cur.selectionAsString(false);
}
}
- bv->showDialogWithData("thesaurus", to_utf8(arg));
+ bv->showDialog("thesaurus", to_utf8(arg));
break;
}
case LFUN_PARAGRAPH_PARAMS_APPLY: {
// Given data, an encoding of the ParagraphParameters
// generated in the Paragraph dialog, this function sets
- // the current paragraph appropriately.
- istringstream is(to_utf8(cmd.argument()));
- Lexer lex(0, 0);
- lex.setStream(is);
- ParagraphParameters params;
- params.read(lex);
- setParagraph(cur,
- params.spacing(),
- params.align(),
- params.labelWidthString(),
- params.noindent());
+ // the current paragraph, or currently selected paragraphs,
+ // appropriately.
+ // NOTE: This function overrides all existing settings.
+ setParagraphs(cur, cmd.argument());
+ cur.message(_("Paragraph layout set"));
+ break;
+ }
+
+ case LFUN_PARAGRAPH_PARAMS: {
+ // Given data, an encoding of the ParagraphParameters as we'd
+ // find them in a LyX file, this function modifies the current paragraph,
+ // or currently selected paragraphs.
+ // NOTE: This function only modifies, and does not override, existing
+ // settings.
+ setParagraphs(cur, cmd.argument(), true);
cur.message(_("Paragraph layout set"));
break;
}
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;
+ case LFUN_OUTLINE_UP:
+ outline(OutlineUp, cur);
+ setCursor(cur, cur.pit(), 0);
+ updateLabels(cur.buffer());
+ needsUpdate = true;
+ break;
+
+ case LFUN_OUTLINE_DOWN:
+ outline(OutlineDown, cur);
+ setCursor(cur, cur.pit(), 0);
+ updateLabels(cur.buffer());
+ needsUpdate = true;
+ break;
+
+ case LFUN_OUTLINE_IN:
+ outline(OutlineIn, cur);
+ updateLabels(cur.buffer());
+ needsUpdate = true;
+ break;
+
+ case LFUN_OUTLINE_OUT:
+ outline(OutlineOut, cur);
+ updateLabels(cur.buffer());
+ needsUpdate = true;
+ break;
+
default:
- LYXERR(Debug::ACTION)
- << BOOST_CURRENT_FUNCTION
- << ": Command " << cmd
- << " not DISPATCHED by Text" << endl;
+ LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text");
cur.undispatched();
break;
}
// Inserting characters does not change par height
ParagraphMetrics const & pms
= cur.bv().parMetrics(cur.bottom().text(), cur.bottom().pit());
- if (pms.dim().height()
- == olddim.height()) {
+ if (pms.dim().height() == olddim.height()) {
// if so, update _only_ this paragraph
cur.updateFlags(Update::SinglePar |
- Update::FitCursor |
- Update::MultiParSel);
+ Update::FitCursor);
return;
- } else
- needsUpdate = true;
+ }
+ needsUpdate = true;
}
if (!needsUpdate
{
BOOST_ASSERT(cur.text() == this);
- Font const & font = real_current_font;
+ Font const & font = cur.real_current_font;
+ FontInfo const & fontinfo = font.fontInfo();
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;
- break;
- case LFUN_CHARSTYLE_INSERT:
- code = Inset::CHARSTYLE_CODE;
- if (cur.buffer().params().getTextClass().charstyles().empty())
+ code = NOTE_CODE;
+ break;
+ case LFUN_FLEX_INSERT: {
+ code = FLEX_CODE;
+ string s = cmd.getArg(0);
+ InsetLayout il = cur.buffer().params().getTextClass().insetlayout(from_utf8(s));
+ if (il.lyxtype != "charstyle" &&
+ il.lyxtype != "custom" &&
+ il.lyxtype != "element" &&
+ il.lyxtype != "standard")
enable = false;
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().insetList().count(OPTARG_CODE)
< 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
// if an inset is not allowed.
break;
- case LFUN_HYPHENATION_POINT_INSERT:
- case LFUN_LIGATURE_BREAK_INSERT:
case LFUN_HFILL_INSERT:
- case LFUN_MENU_SEPARATOR_INSERT:
- case LFUN_DOTS_INSERT:
- case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
- code = Inset::SPECIALCHAR_CODE;
+ case LFUN_SPECIALCHAR_INSERT:
+ 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_FONT_EMPH:
- flag.setOnOff(font.emph() == Font::ON);
+ flag.setOnOff(fontinfo.emph() == FONT_ON);
return true;
case LFUN_FONT_NOUN:
- flag.setOnOff(font.noun() == Font::ON);
+ flag.setOnOff(fontinfo.noun() == FONT_ON);
return true;
case LFUN_FONT_BOLD:
- flag.setOnOff(font.series() == Font::BOLD_SERIES);
+ flag.setOnOff(fontinfo.series() == BOLD_SERIES);
return true;
case LFUN_FONT_SANS:
- flag.setOnOff(font.family() == Font::SANS_FAMILY);
+ flag.setOnOff(fontinfo.family() == SANS_FAMILY);
return true;
case LFUN_FONT_ROMAN:
- flag.setOnOff(font.family() == Font::ROMAN_FAMILY);
+ flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
return true;
- case LFUN_FONT_CODE:
- flag.setOnOff(font.family() == Font::TYPEWRITER_FAMILY);
+ case LFUN_FONT_TYPEWRITER:
+ flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
return true;
case LFUN_CUT:
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:
enable = true;
break;
+ case LFUN_OUTLINE_UP:
+ case LFUN_OUTLINE_DOWN:
+ case LFUN_OUTLINE_IN:
+ case LFUN_OUTLINE_OUT:
+ enable = (cur.paragraph().layout()->toclevel != Layout::NOT_IN_TOC);
+ break;
+
case LFUN_WORD_DELETE_FORWARD:
case LFUN_WORD_DELETE_BACKWARD:
case LFUN_LINE_DELETE:
case LFUN_WORD_FORWARD:
case LFUN_WORD_BACKWARD:
+ case LFUN_WORD_RIGHT:
+ case LFUN_WORD_LEFT:
case LFUN_CHAR_FORWARD:
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_LINE_END_SELECT:
case LFUN_WORD_FORWARD_SELECT:
case LFUN_WORD_BACKWARD_SELECT:
+ case LFUN_WORD_RIGHT_SELECT:
+ case LFUN_WORD_LEFT_SELECT:
case LFUN_WORD_SELECT:
case LFUN_PARAGRAPH_UP:
case LFUN_PARAGRAPH_DOWN:
- case LFUN_SCREEN_UP:
- case LFUN_SCREEN_DOWN:
case LFUN_LINE_BEGIN:
+ case LFUN_LINE_BREAK:
case LFUN_LINE_END:
- case LFUN_BREAK_LINE:
+ 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_KEEP_LAYOUT:
case LFUN_BREAK_PARAGRAPH_SKIP:
case LFUN_PARAGRAPH_SPACING:
case LFUN_INSET_INSERT:
case LFUN_DATE_INSERT:
case LFUN_SELF_INSERT:
case LFUN_LINE_INSERT:
+ case LFUN_NEWPAGE_INSERT:
case LFUN_PAGEBREAK_INSERT:
case LFUN_CLEARPAGE_INSERT:
case LFUN_CLEARDOUBLEPAGE_INSERT:
case LFUN_ACCENT_OGONEK:
case LFUN_THESAURUS_ENTRY:
case LFUN_PARAGRAPH_PARAMS_APPLY:
+ case LFUN_PARAGRAPH_PARAMS:
case LFUN_ESCAPE:
case LFUN_BUFFER_END:
case LFUN_BUFFER_BEGIN:
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
projects / lyx.git / blobdiff