rename commandtags.h to lfuns.h and renumber/cleanup. Rebuild the tree !

[lyx.git] / src / mathed / math_cursor.C

diff --git a/src/mathed/math_cursor.C b/src/mathed/math_cursor.C
index fec411d7b378680d5c6d35ca51c250c9650dafb9..cfc4f88e5688c1bb4a4b66f979b0ed0142a244ab 100644 (file)
--- a/src/mathed/math_cursor.C
+++ b/src/mathed/math_cursor.C
@@ -18,9 +18,6 @@
 #include <config.h>
 #include <lyxrc.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
 
 #include "support/lstrings.h"
 #include "support/LAssert.h"
@@ -65,7 +62,7 @@ string theCutBuffer;
 
 
 MathCursor::MathCursor(InsetFormulaBase * formula, bool front)
-       :       formula_(formula), autocorrect_(false), selection_(false)
+       :       formula_(formula), autocorrect_(false), selection_(false), targetx_(-1)
 {
        front ? first() : last();
        Anchor_ = Cursor_;
@@ -136,14 +133,14 @@ bool MathCursor::popRight()
 #if FILEDEBUG
        void MathCursor::dump(char const * what) const
        {
-               lyxerr << "MC: " << what << "\n";
-               lyxerr << " Cursor: " << depth() << "\n";
+               lyxerr << "MC: " << what << endl;
+               lyxerr << " Cursor: " << depth() << endl;
                for (unsigned i = 0; i < depth(); ++i)
-                       lyxerr << "    i: " << i << " " << Cursor_[i] << "\n";
-               lyxerr << " Anchor: " << Anchor_.size() << "\n";
+                       lyxerr << "    i: " << i << ' ' << Cursor_[i] << endl;
+               lyxerr << " Anchor: " << Anchor_.size() << endl;
                for (unsigned i = 0; i < Anchor_.size(); ++i)
-                       lyxerr << "    i: " << i << " " << Anchor_[i] << "\n";
-               lyxerr  << " sel: " << selection_ << "\n";
+                       lyxerr << "    i: " << i << ' ' << Anchor_[i] << endl;
+               lyxerr  << " sel: " << selection_ << endl;
        }
 #else
        void MathCursor::dump(char const *) const {}
@@ -413,56 +410,67 @@ void MathCursor::paste(string const & data)
 }
 
 
-void MathCursor::backspace()
+bool MathCursor::backspace()
 {
        autocorrect_ = false;
 
        if (selection_) {
                selDel();
-               return;
+               return true;
        }
 
        if (pos() == 0) {
+               if (par()->ncols() == 1 &&
+                         par()->nrows() == 1 &&
+                         depth() == 1 &&
+                         size() == 0)
+                       return false;
                pullArg();
-               return;
+               return true;
        }
 
        if (inMacroMode()) {
                MathUnknownInset * p = activeMacro();
                if (p->name().size() > 1) {
                        p->setName(p->name().substr(0, p->name().size() - 1));
-                       return;
+                       return true;
                }
        }
 
        --pos();
        plainErase();
+       return true;
 }
 
 
-void MathCursor::erase()
+bool MathCursor::erase()
 {
        autocorrect_ = false;
        if (inMacroMode())
-               return;
+               return true;
 
        if (selection_) {
                selDel();
-               return;
+               return true;
        }
 
        // delete empty cells if possible
        if (array().empty())
                if (par()->idxDelete(idx()))
-                       return;
+                       return true;
 
        // old behaviour when in last position of cell
        if (pos() == size()) {
-               par()->idxGlue(idx());
-               return;
+               if (par()->ncols() == 1 && par()->nrows() == 1 && depth() == 1 && size() == 0)
+                       return false;
+               else{
+                       par()->idxGlue(idx());
+                       return true;
+               }
        }
 
        plainErase();
+       return true;
 }
 
 
@@ -666,12 +674,12 @@ MathCursor::pos_type MathCursor::pos() const
 }
 
 
-void MathCursor::adjust(pos_type from, size_type size)
+void MathCursor::adjust(pos_type from, difference_type diff)
 {
        if (cursor().pos_ > from)
-               cursor().pos_ += size;
+               cursor().pos_ += diff;
        if (Anchor_.back().pos_ > from)
-               Anchor_.back().pos_ += size;
+               Anchor_.back().pos_ += diff;
        // just to be on the safe side
        // theoretically unecessary
        normalize();
@@ -778,18 +786,19 @@ void MathCursor::normalize()
 {
        if (idx() >= par()->nargs()) {
                lyxerr << "this should not really happen - 1: "
-                      << idx() << " " << par()->nargs() << " in: " << par() << "\n";
+                      << idx() << ' ' << par()->nargs()
+                      << " in: " << par() << endl;
                dump("error 2");
        }
        idx() = min(idx(), par()->nargs() - 1);
 
        if (pos() > size()) {
                lyxerr << "this should not really happen - 2: "
-                       << pos() << " " << size() <<  " in idx: " << idx()
-                       << " in atom: '";
+                       << pos() << ' ' << size() <<  " in idx: " << idx()
+                      << " in atom: '";
                WriteStream wi(lyxerr, false, true);
                par()->write(wi);
-               lyxerr << "\n";
+               lyxerr << endl;
                dump("error 4");
        }
        pos() = min(pos(), size());
@@ -1287,10 +1296,9 @@ string MathCursor::info() const
                os << "  ";
        }
        if (hasPrevAtom())
-               if (prevAtom()->asSymbolInset() || prevAtom()->asScriptInset())
-                       prevAtom()->infoize(os);
+               prevAtom()->infoize2(os);
        os << "                    ";
-       return os.str().c_str(); // .c_str() needed for lyxstring
+       return STRCONV(os.str());
 }
 
 
@@ -1346,7 +1354,7 @@ string MathCursor::grabSelection() const
                        data += "\\\\";
                for (col_type col = c1; col <= c2; ++col) {
                        if (col > c1)
-                               data += "&";
+                               data += '&';
                        data += asString(i1.par_->cell(i1.par_->index(row, col)));
                }
        }
@@ -1402,21 +1410,46 @@ MathCursorPos MathCursor::normalAnchor() const
 }
 
 
-MathInset::result_type MathCursor::dispatch(FuncRequest const & cmd)
-{
+dispatch_result MathCursor::dispatch(FuncRequest const & cmd)
+{
+       // mouse clicks are somewhat special 
+       // check
+       switch (cmd.action) {
+               case LFUN_MOUSE_PRESS:
+               case LFUN_MOUSE_MOTION:
+               case LFUN_MOUSE_RELEASE:
+               case LFUN_MOUSE_DOUBLE: {
+                       MathCursorPos & pos = Cursor_.back();
+                       dispatch_result res = UNDISPATCHED;
+                       int x = 0, y = 0;
+                       getPos(x, y);
+                       if (x < cmd.x && hasPrevAtom()) {
+                               res = prevAtom().nucleus()->dispatch(cmd, pos.idx_, pos.pos_);
+                               if (res != UNDISPATCHED)
+                                       return res;
+                       }
+                       if (x > cmd.x && hasNextAtom()) {
+                               res = nextAtom().nucleus()->dispatch(cmd, pos.idx_, pos.pos_);
+                               if (res != UNDISPATCHED)
+                                       return res;
+                       }
+               }
+               default:
+                       break;
+       }
+
        for (int i = Cursor_.size() - 1; i >= 0; --i) {
                MathCursorPos & pos = Cursor_[i];
-               MathInset::result_type
-                       res = pos.par_->dispatch(cmd, pos.idx_, pos.pos_);
-               if (res != MathInset::UNDISPATCHED) {
-                       if (res == MathInset::DISPATCHED_POP) {
+               dispatch_result res = pos.par_->dispatch(cmd, pos.idx_, pos.pos_);
+               if (res != UNDISPATCHED) {
+                       if (res == DISPATCHED_POP) {
                                Cursor_.shrink(i + 1);
                                selClear();
                        }
                        return res;
                }
        }
-       return MathInset::UNDISPATCHED;
+       return UNDISPATCHED;
 }
 
 
@@ -1467,9 +1500,11 @@ void MathCursor::handleFont(string const & font)
 
 void releaseMathCursor(BufferView * bv)
 {
-       if (!mathcursor)
-               return;
-       mathcursor->formula()->hideInsetCursor(bv);
-       delete mathcursor;
-       mathcursor = 0;
+       if (mathcursor) {
+               InsetFormulaBase * f =  mathcursor->formula();
+               f->hideInsetCursor(bv);
+               delete mathcursor;
+               mathcursor = 0;
+               f->insetUnlock(bv);
+       }
 }