Account for old versions of Pygments

[lyx.git] / src / Cursor.cpp

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index 378a138da6b20c0c3daa7e3883d1aaa7a7d35834..eff32d05769bf650b7f6846c586efdaf19fa5267 100644 (file)
--- a/src/Cursor.cpp
+++ b/src/Cursor.cpp
@@ -551,24 +551,6 @@ void Cursor::checkNewWordPosition()
 }
 
 
-bool Cursor::posBackward()
-{
-       if (pos() == 0)
-               return false;
-       --pos();
-       return true;
-}
-
-
-bool Cursor::posForward()
-{
-       if (pos() == lastpos())
-               return false;
-       ++pos();
-       return true;
-}
-
-
 bool Cursor::posVisRight(bool skip_inset)
 {
        Cursor new_cur = *this; // where we will move to
@@ -1301,7 +1283,7 @@ void Cursor::insert(MathData const & ar)
 }
 
 
-bool Cursor::backspace()
+bool Cursor::backspace(bool const force)
 {
        if (selection()) {
                cap::eraseSelection(*this);
@@ -1337,7 +1319,7 @@ bool Cursor::backspace()
                }
        }
 
-       if (pos() != 0 && prevAtom()->nargs() > 0) {
+       if (pos() != 0 && !force && prevAtom()->confirmDeletion()) {
                // let's require two backspaces for 'big stuff' and
                // highlight on the first
                resetAnchor();
@@ -1351,7 +1333,7 @@ bool Cursor::backspace()
 }
 
 
-bool Cursor::erase()
+bool Cursor::erase(bool const force)
 {
        if (inMacroMode())
                return true;
@@ -1386,7 +1368,7 @@ bool Cursor::erase()
        }
 
        // 'clever' UI hack: only erase large items if previously slected
-       if (pos() != lastpos() && nextAtom()->nargs() > 0) {
+       if (pos() != lastpos() && !force && nextAtom()->confirmDeletion()) {
                resetAnchor();
                selection(true);
                ++pos();
@@ -1756,11 +1738,23 @@ bool Cursor::mathForward(bool word)
        LASSERT(inMathed(), return false);
        if (pos() < lastpos()) {
                if (word) {
-                       // word: skip a group of insets with same math class
+                       // word: skip a group of insets of the form X*(B*|R*|P*) (greedy
+                       // match) where X is any math class, B is mathbin, R is mathrel, and
+                       // P is mathpunct. Make sure that the following remains true:
+                       //   mathForward(true); mathBackward(true); mathForward(true)
+                       // is the same as mathForward(true) and
+                       //   mathBackward(true); mathForward(true); mathBackward(true)
+                       // is the same as mathBackward(true).
                        MathClass mc = nextMath().mathClass();
                        do
                                posForward();
                        while (pos() < lastpos() && mc == nextMath().mathClass());
+                       if (pos() < lastpos() &&
+                           ((mc = nextMath().mathClass()) == MC_BIN ||
+                            mc == MC_REL || mc == MC_PUNCT))
+                               do
+                                       posForward();
+                               while (pos() < lastpos() && mc == nextMath().mathClass());
                } else if (openable(nextAtom())) {
                        // single step: try to enter the next inset
                        pushBackward(nextMath());
@@ -1785,11 +1779,17 @@ bool Cursor::mathBackward(bool word)
        LASSERT(inMathed(), return false);
        if (pos() > 0) {
                if (word) {
-                       // word: skip a group of insets with same math class
+                       // word: skip a group of insets. See the comment in mathForward.
                        MathClass mc = prevMath().mathClass();
                        do
                                posBackward();
                        while (pos() > 0 && mc == prevMath().mathClass());
+                       if (pos() > 0 && (mc == MC_BIN || mc == MC_REL || mc == MC_PUNCT)) {
+                               mc = prevMath().mathClass();
+                               do
+                                       posBackward();
+                               while (pos() > 0 && mc == prevMath().mathClass());
+                       }
                } else if (openable(prevAtom())) {
                        // single step: try to enter the preceding inset
                        posBackward();
@@ -1924,10 +1924,13 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
                int yo = bv().getPos(*this).y_;
                Cursor old = *this;
                // To next/previous row
+               // FIXME: the y position is often guessed wrongly across styles and
+               // insets, which leads to weird behaviour.
                if (up)
                        tm.editXY(*this, xo, yo - textRow().ascent() - 1);
                else
                        tm.editXY(*this, xo, yo + textRow().descent() + 1);
+               x_target_ = old.x_target_;
                clearSelection();
 
                // This happens when you move out of an inset.
@@ -2436,4 +2439,39 @@ void Cursor::checkBufferStructure()
 }
 
 
+bool Cursor::confirmDeletion(bool const before) const
+{
+       if (!selection()) {
+               if (Inset const * inset = before ? prevInset() : nextInset())
+                       return inset->confirmDeletion();
+       } else {
+               DocIterator dit = selectionBegin();
+               CursorSlice const end = selectionEnd().top();
+               for (; dit.top() < end; dit.top().forwardPos())
+                       if (Inset const * inset = dit.nextInset())
+                               if (inset->confirmDeletion())
+                                       return true;
+       }
+       return false;
+}
+
+
+void Cursor::moveToClosestEdge(int const x, bool const edit)
+{
+       if (Inset const * inset = nextInset()) {
+               // stay in front of insets for which we want to open the dialog
+               // (e.g. InsetMathSpace).
+               if (edit && (inset->hasSettings() || !inset->contextMenuName().empty()))
+                       return;
+               CoordCache::Insets const & insetCache = bv().coordCache().getInsets();
+               if (!insetCache.has(inset))
+                       return;
+               int const wid = insetCache.dim(inset).wid;
+               Point p = insetCache.xy(inset);
+               if (x > p.x_ + (wid + 1) / 2)
+                       posForward();
+       }
+}
+
+
 } // namespace lyx