some (yet unfinished) up/down work

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@10333 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/cursor.C b/src/cursor.C
index c15864e809e4ba1590913588594530374409de28..5440d88c8d8a0e3c46193c9f1fbcb331f76cec3e 100644 (file)
--- a/src/cursor.C
+++ b/src/cursor.C
@@ -120,10 +120,10 @@ namespace {
                int x, int y, int xlow, int xhigh, int ylow, int yhigh)
        {
                BOOST_ASSERT(!cursor.empty());
-               CursorSlice bottom = cursor[0];
+               InsetBase & inset = cursor[0].inset();
 
-               DocIterator it = doc_iterator_begin(bottom.inset());
-               DocIterator const et = doc_iterator_end(bottom.inset());
+               DocIterator it = doc_iterator_begin(inset);
+               DocIterator const et = doc_iterator_end(inset);
 
                double best_dist = std::numeric_limits<double>::max();;
                DocIterator best_cursor = et;
@@ -136,12 +136,13 @@ namespace {
                                int xo = p.x_;
                                int yo = p.y_;
                                if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
-                                       double d = (x - xo) * (x - xo) + (y - yo) * (y - yo);
-                                       //lyxerr << "xo: " << xo << " yo: " << yo << " d: " << d << endl;
+                                       double const dx = xo - x;
+                                       double const dy = yo - y;
+                                       double const d = dx * dx + dy * dy;
                                        // '<=' in order to take the last possible position
                                        // this is important for clicking behind \sum in e.g. '\sum_i a'
                                        if (d <= best_dist) {
-                                               //lyxerr << "*" << endl;
+                                               lyxerr << "*" << endl;
                                                best_dist   = d;
                                                best_cursor = it;
                                        }
@@ -149,7 +150,6 @@ namespace {
                        }
                }
 
-               //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl;
                if (best_cursor != et) {
                        cursor.setCursor(best_cursor);
                        return true;
@@ -158,6 +158,67 @@ namespace {
                return false;
        }
 
+
+       /// moves position closest to (x, y) in given box
+       bool bruteFind3(LCursor & cur, int x, int y, bool up)
+       {
+               BufferView & bv = cur.bv();
+               int ylow  = up ? 0 : y + 1;
+               int yhigh = up ? y - 1 : bv.workHeight();
+               int xlow = 0;
+               int xhigh = bv.workWidth();
+
+// FIXME: bit more work needed to get 'from' and 'to' right.
+               pit_type from = cur.bottom().pit();
+               pit_type to = cur.bottom().pit();
+               //lyxerr << "Pit start: " << from << endl;
+
+               //lyxerr << "bruteFind3: x: " << x << " y: " << y
+               //      << " xlow: " << xlow << " xhigh: " << xhigh 
+               //      << " ylow: " << ylow << " yhigh: " << yhigh 
+               //      << endl;
+               InsetBase & inset = bv.buffer()->inset();
+               DocIterator it = doc_iterator_begin(inset);
+               it.pit() = from;
+               DocIterator et = doc_iterator_end(inset);
+
+               double best_dist = std::numeric_limits<double>::max();
+               DocIterator best_cursor = et;
+
+               for ( ; it != et; it.forwardPos()) {
+                       // avoid invalid nesting when selecting
+                       if (bv_funcs::status(&bv, it) == bv_funcs::CUR_INSIDE
+                           && (!cur.selection() || positionable(it, cur.anchor_))) {
+                               Point p = bv_funcs::getPos(it, false);
+                               int xo = p.x_;
+                               int yo = p.y_;
+                               if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
+                                       double const dx = xo - x;
+                                       double const dy = yo - y;
+                                       double const d = dx * dx + dy * dy;
+                                       //lyxerr << "itx: " << xo << " ity: " << yo << " d: " << d
+                                       //      << " dx: " << dx << " dy: " << dy
+                                       //      << " idx: " << it.idx() << " pos: " << it.pos()
+                                       //      << " it:\n" << it
+                                       //      << endl;
+                                       // '<=' in order to take the last possible position
+                                       // this is important for clicking behind \sum in e.g. '\sum_i a'
+                                       if (d <= best_dist) {
+                                               //lyxerr << "*" << endl;
+                                               best_dist   = d;
+                                               best_cursor = it;
+                                       }
+                               }
+                       }
+               }
+
+               //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl;
+               if (best_cursor == et)
+                       return false;
+               cur.setCursor(best_cursor);
+               return true;
+       }
+
 } // namespace anon
 
 
@@ -873,12 +934,12 @@ void LCursor::touch()
 
 void LCursor::normalize()
 {
-       if (idx() >= nargs()) {
+       if (idx() > lastidx()) {
                lyxerr << "this should not really happen - 1: "
                       << idx() << ' ' << nargs()
                       << " in: " << &inset() << endl;
+               idx() = lastidx();
        }
-       idx() = min(idx(), lastidx());
 
        if (pos() > lastpos()) {
                lyxerr << "this should not really happen - 2: "
@@ -887,8 +948,8 @@ void LCursor::normalize()
                WriteStream wi(lyxerr, false, true);
                inset().asMathInset()->write(wi);
                lyxerr << endl;
+               pos() = lastpos();
        }
-       pos() = min(pos(), lastpos());
 }
 
 
@@ -935,6 +996,12 @@ bool LCursor::goUpDown(bool up)
                }
        }
 
+// FIXME: Switch this on for more robust movement
+#if 0
+
+       return bruteFind3(*this, xo, yo, up); 
+
+#else
        //xarray().boundingBox(xlow, xhigh, ylow, yhigh);
        //if (up)
        //      yhigh = yo - 4;
@@ -947,9 +1014,10 @@ bool LCursor::goUpDown(bool up)
 
        // try to find an inset that knows better then we
        while (true) {
-               //lyxerr << "updown: We are in " << &inset() << " idx: " << idx() << endl;
+               lyxerr << "updown: We are in " << &inset() << " idx: " << idx() << endl;
                // ask inset first
                if (inset().idxUpDown(*this, up)) {
+                       lyxerr << "idxUpDown triggered" << endl;
                        // try to find best position within this inset
                        if (!selection())
                                setCursor(bruteFind2(*this, xo, yo));
@@ -957,14 +1025,15 @@ bool LCursor::goUpDown(bool up)
                }
 
                // no such inset found, just take something "above"
-               //lyxerr << "updown: handled by strange case" << endl;
                if (!popLeft()) {
+                       lyxerr << "updown: popleft failed (strange case)" << endl;
                        int ylow  = up ? 0 : yo + 1;
                        int yhigh = up ? yo - 1 : bv().workHeight();
                        return bruteFind(*this, xo, yo, 0, bv().workWidth(), ylow, yhigh);
                }
 
                // any improvement so far?
+               lyxerr << "updown: popLeft succeeded" << endl;
                int xnew;
                int ynew;
                getPos(xnew, ynew);
@@ -974,6 +1043,7 @@ bool LCursor::goUpDown(bool up)
 
        // we should not come here.
        BOOST_ASSERT(false);
+#endif
 }
 
 

diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C
index deebec57b793157d215e0ebca429619da8a4df3b..ac76e28039101f070fb4ae746c5c05b13d3ca2e4 100644 (file)
--- a/src/insets/insettabular.C
+++ b/src/insets/insettabular.C
@@ -432,8 +432,8 @@ void InsetTabular::edit(LCursor & cur, bool left)
 
 void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 {
-       //lyxerr << "# InsetTabular::dispatch: cmd: " << cmd << endl;
-       //lyxerr << "  cur:\n" << cur << endl;
+       lyxerr << "# InsetTabular::dispatch: cmd: " << cmd << endl;
+       lyxerr << "  cur:\n" << cur << endl;
        CursorSlice sl = cur.top();
        LCursor & bvcur = cur.bv().cursor();
 
@@ -1169,7 +1169,6 @@ void InsetTabular::setCursorFromCoordinates(LCursor & cur, int x, int y) const
 {
        cur.idx() = getNearestCell(x, y);
        cell(cur.idx())->text_.setCursorFromCoordinates(cur, x, y);
-       resetPos(cur);
 }
 
 

diff --git a/src/mathed/math_hullinset.C b/src/mathed/math_hullinset.C
index ba3204c7a4df4842dafcd3c267be8e0bfac15f61..972f0d03642a97a57ce609581559bfd2da39a972 100644 (file)
--- a/src/mathed/math_hullinset.C
+++ b/src/mathed/math_hullinset.C
@@ -979,14 +979,17 @@ void MathHullInset::doExtern(LCursor & cur, FuncRequest & func)
 
 void MathHullInset::doDispatch(LCursor & cur, FuncRequest & cmd)
 {
+       lyxerr << "action: " << cmd.action << endl;
        switch (cmd.action) {
 
        case LFUN_FINISHED_LEFT:
        case LFUN_FINISHED_RIGHT:
        case LFUN_FINISHED_UP:
        case LFUN_FINISHED_DOWN:
+               lyxerr << "action: " << cmd.action << endl;
                MathGridInset::doDispatch(cur, cmd);
                notifyCursorLeaves(cur);
+               cur.undispatched();
                break;
 
        case LFUN_BREAKPARAGRAPH:
@@ -1113,7 +1116,12 @@ bool MathHullInset::getStatus(LCursor & cur, FuncRequest const & cmd,
                FuncStatus & status) const
 {
        switch (cmd.action) {
-       // These are only enabled inside tabular
+       case LFUN_FINISHED_LEFT:
+       case LFUN_FINISHED_RIGHT:
+       case LFUN_FINISHED_UP:
+       case LFUN_FINISHED_DOWN:
+               status.enabled(true);
+               return true;
        case LFUN_BREAKLINE:
        case LFUN_MATH_NUMBER:
        case LFUN_MATH_NONUMBER:

diff --git a/src/text.C b/src/text.C
index 6a6922c561a97731c3d84806204ece667efa45c8..657b8f5ff48df385ab750de01580242ae264a968 100644 (file)
--- a/src/text.C
+++ b/src/text.C
@@ -419,8 +419,6 @@ int LyXText::singleWidth(Paragraph const & par, pos_type pos) const
 int LyXText::singleWidth(Paragraph const & par,
                         pos_type pos, char c, LyXFont const & font) const
 {
-       BOOST_ASSERT(pos < par.size());
-
        // The most common case is handled first (Asger)
        if (IsPrintable(c)) {
                Language const * language = font.language();
@@ -2101,8 +2099,8 @@ int LyXText::cursorX(CursorSlice const & sl, bool boundary) const
                body_pos = 0;
 
        // Use font span to speed things up, see below
-       FontSpan font_span = par.fontSpan(row_pos);
-       LyXFont font = getFont(par, row_pos);
+       FontSpan font_span;
+       LyXFont font;
 
        for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) {
                pos_type pos = bidi.vis2log(vpos);