From 11398a3316421a9f339f00a44b374b055a852ec3 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Andr=C3=A9=20P=C3=B6nitz?= Date: Fri, 26 Jul 2002 14:11:19 +0000 Subject: [PATCH] move things around git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4798 a592a061-630c-0410-9148-cb99ea01b6c8 --- src/mathed/formulabase.C | 4 +-- src/mathed/math_cursor.C | 25 +++++++-------- src/mathed/math_cursor.h | 14 ++++---- src/mathed/math_iterator.C | 60 +++++++++++++---------------------- src/mathed/math_iterator.h | 40 +++++++++++++---------- src/mathed/math_parboxinset.C | 4 +-- 6 files changed, 67 insertions(+), 80 deletions(-) diff --git a/src/mathed/formulabase.C b/src/mathed/formulabase.C index 03cdf19d6c..dbc150a52f 100644 --- a/src/mathed/formulabase.C +++ b/src/mathed/formulabase.C @@ -882,7 +882,7 @@ bool InsetFormulaBase::searchForward(BufferView * bv, string const & str, //lyxerr << "searching '" << str << "' in " << this << ar << endl; for (MathIterator it = current; it != iend(par().nucleus()); ++it) { - if (it.cell().matchpart(ar, it.position().pos_)) { + if (it.cell().matchpart(ar, it.back().pos_)) { bv->unlockInset(bv->theLockingInset()); if (!bv->lockInset(this)) { lyxerr << "Cannot lock inset" << endl; @@ -891,7 +891,7 @@ bool InsetFormulaBase::searchForward(BufferView * bv, string const & str, delete mathcursor; mathcursor = new MathCursor(this, true); metrics(bv); - mathcursor->setSelection(it.cursor(), ar.size()); + mathcursor->setSelection(it, ar.size()); current = it; it.jump(ar.size()); updateLocal(bv, false); diff --git a/src/mathed/math_cursor.C b/src/mathed/math_cursor.C index 79e454e7e0..77b4a35697 100644 --- a/src/mathed/math_cursor.C +++ b/src/mathed/math_cursor.C @@ -173,7 +173,7 @@ bool MathCursor::openable(MathAtom const & t, bool sel) const if (t->asScriptInset()) return false; - if (!sel) { + if (sel) { // we can't move into anything new during selection if (depth() == Anchor_.size()) return false; @@ -258,15 +258,14 @@ void MathCursor::last() } -bool positionable(MathCursor::cursor_type const & cursor, - MathCursor::cursor_type const & anchor) +bool positionable(MathIterator const & cursor, MathIterator const & anchor) { // avoid deeper nested insets when selecting if (cursor.size() > anchor.size()) return false; // anchor might be deeper, should have same path then - for (MathCursor::cursor_type::size_type i = 0; i < cursor.size(); ++i) + for (MathIterator::size_type i = 0; i < cursor.size(); ++i) if (cursor[i].par_ != anchor[i].par_) return false; @@ -522,7 +521,7 @@ bool MathCursor::up(bool sel) dump("up 1"); macroModeClose(); selHandle(sel); - cursor_type save = Cursor_; + MathIterator save = Cursor_; if (goUpDown(true)) return true; Cursor_ = save; @@ -536,7 +535,7 @@ bool MathCursor::down(bool sel) dump("down 1"); macroModeClose(); selHandle(sel); - cursor_type save = Cursor_; + MathIterator save = Cursor_; if (goUpDown(false)) return true; Cursor_ = save; @@ -845,8 +844,8 @@ void MathCursor::pullArg() void MathCursor::touch() { - cursor_type::const_iterator it = Cursor_.begin(); - cursor_type::const_iterator et = Cursor_.end(); + MathIterator::const_iterator it = Cursor_.begin(); + MathIterator::const_iterator et = Cursor_.end(); for ( ; it != et; ++it) it->xcell().touch(); } @@ -1191,23 +1190,23 @@ bool MathCursor::goUpDown(bool up) bool MathCursor::bruteFind (int x, int y, int xlow, int xhigh, int ylow, int yhigh) { - cursor_type best_cursor; + MathIterator best_cursor; double best_dist = 1e10; MathIterator it = ibegin(formula()->par().nucleus()); MathIterator et = iend(formula()->par().nucleus()); while (1) { // avoid invalid nesting when selecting - if (!selection_ || positionable(it.cursor(), Anchor_)) { + if (!selection_ || positionable(it, Anchor_)) { int xo, yo; - it.position().getPos(xo, yo); + it.back().getPos(xo, yo); if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) { double d = (x - xo) * (x - xo) + (y - yo) * (y - yo); // '<=' 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) { best_dist = d; - best_cursor = it.cursor(); + best_cursor = it; } } } @@ -1516,7 +1515,7 @@ bool MathCursor::interpret(char c) } -void MathCursor::setSelection(cursor_type const & where, size_type n) +void MathCursor::setSelection(MathIterator const & where, size_type n) { selection_ = true; Anchor_ = where; diff --git a/src/mathed/math_cursor.h b/src/mathed/math_cursor.h index 161b70e3b1..38481da483 100644 --- a/src/mathed/math_cursor.h +++ b/src/mathed/math_cursor.h @@ -22,7 +22,7 @@ #endif #include "math_inset.h" -#include "math_pos.h" +#include "math_iterator.h" #include "LString.h" class InsetFormulaBase; @@ -36,9 +36,9 @@ class Selection; [Have a look at math_inset.h first] The MathCursor is different from the kind of cursor used in the Outer -World. It contains a stack of MathCursorPositions, each of which is made +World. It contains a stack of MathCursorPos, each of which is made up of a inset pointer, an index and a position offset, marking a path from -this formula's mathHullInset to the current position. +this formula's MathHullInset to the current position. */ @@ -55,8 +55,6 @@ public: typedef MathInset::row_type row_type; /// type for column numbers typedef MathInset::col_type col_type; - /// how to store a cursor - typedef std::vector cursor_type; /// explicit MathCursor(InsetFormulaBase *, bool left); @@ -246,7 +244,7 @@ public: /// dump selection information for debugging void dump(char const * str) const; /// moves on - void setSelection(cursor_type const & where, size_type n); + void setSelection(MathIterator const & where, size_type n); /// void insert(char c); /// @@ -303,9 +301,9 @@ private: idx_type & idx(); /// path of positions the cursor had to go if it were leaving each inset - cursor_type Cursor_; + MathIterator Cursor_; /// path of positions the anchor had to go if it were leaving each inset - mutable cursor_type Anchor_; + mutable MathIterator Anchor_; /// pointer to enclsing LyX inset InsetFormulaBase * formula_; // Selection stuff diff --git a/src/mathed/math_iterator.C b/src/mathed/math_iterator.C index 628ead5cab..087c5f27d5 100644 --- a/src/mathed/math_iterator.C +++ b/src/mathed/math_iterator.C @@ -1,12 +1,13 @@ #include #include "math_iterator.h" +#include "math_inset.h" #include "debug.h" #include "support/LAssert.h" -//MathIterator::MathIterator() -//{} +MathIterator::MathIterator() +{} MathIterator::MathIterator(MathInset * p) @@ -15,32 +16,21 @@ MathIterator::MathIterator(MathInset * p) } -//MathIterator::MathIterator(MathCursor::cursor_type const & c) -// : cursor_(c) -//{} - - -MathCursor::cursor_type const & MathIterator::cursor() const -{ - return cursor_; -} - - MathInset const * MathIterator::par() const { - return position().par_; + return back().par_; } MathInset * MathIterator::par() { - return position().par_; + return back().par_; } MathArray const & MathIterator::cell() const { - MathCursorPos const & top = position(); + MathCursorPos const & top = back(); return top.par_->cell(top.idx_); } @@ -49,33 +39,33 @@ MathArray const & MathIterator::cell() const void MathIterator::push(MathInset * p) { //lyxerr << "push: " << p << endl; - cursor_.push_back(MathCursorPos(p)); + push_back(MathCursorPos(p)); } void MathIterator::pop() { //lyxerr << "pop: " << endl; - lyx::Assert(cursor_.size()); - cursor_.pop_back(); + lyx::Assert(size()); + pop_back(); } MathCursorPos const & MathIterator::operator*() const { - return position(); + return back(); } MathCursorPos const & MathIterator::operator->() const { - return position(); + return back(); } void MathIterator::goEnd() { - MathCursorPos & top = position(); + MathCursorPos & top = back(); top.idx_ = top.par_->nargs() - 1; top.pos_ = cell().size(); } @@ -83,7 +73,7 @@ void MathIterator::goEnd() void MathIterator::operator++() { - MathCursorPos & top = position(); + MathCursorPos & top = back(); MathArray const & ar = top.par_->cell(top.idx_); // move into the current inset if possible @@ -96,7 +86,7 @@ void MathIterator::operator++() return; } - // otherwise move on one cell position if possible + // otherwise move on one cell back if possible if (top.pos_ < ar.size()) { // pos() == size() is valid! ++top.pos_; @@ -113,37 +103,31 @@ void MathIterator::operator++() } } - // otherwise leave array, move on one position + // otherwise leave array, move on one back // this might yield pos() == size(), but that's a ok. pop(); // it certainly invalidates top - ++position().pos_; + ++back().pos_; } -void MathIterator::jump(MathInset::difference_type i) +void MathIterator::jump(difference_type i) { - position().pos_ += i; - //lyx::Assert(position().pos_ >= 0); - lyx::Assert(position().pos_ <= cell().size()); + back().pos_ += i; + //lyx::Assert(back().pos_ >= 0); + lyx::Assert(back().pos_ <= cell().size()); } bool operator==(MathIterator const & it, MathIterator const & jt) { - //lyxerr << "==: " << it.cursor().size() << " " << jt.cursor().size() << endl; - if (it.cursor().size() != jt.cursor().size()) - return false; - return it.cursor() == jt.cursor(); + return MathIterator::base_type(it) == MathIterator::base_type(jt); } bool operator!=(MathIterator const & it, MathIterator const & jt) { - //lyxerr << "!=: " << it.cursor().size() << " " << jt.cursor().size() << endl; - if (it.cursor().size() != jt.cursor().size()) - return true; - return it.cursor() != jt.cursor(); + return MathIterator::base_type(it) != MathIterator::base_type(jt); } diff --git a/src/mathed/math_iterator.h b/src/mathed/math_iterator.h index d30bd47529..5d1e972a5e 100644 --- a/src/mathed/math_iterator.h +++ b/src/mathed/math_iterator.h @@ -2,18 +2,33 @@ #ifndef MATH_ITERATOR_H #define MATH_ITERATOR_H -#include "math_cursor.h" +#include "math_pos.h" +#include -// this helper struct is used for traversing math insets +// this is used for traversing math insets -class MathIterator { +class MathIterator : private std::vector { public: - /// default constructor, used for end of range - //MathIterator(); + // re-use inherited stuff + typedef std::vector base_type; + using base_type::clear; + using base_type::size; + using base_type::push_back; + using base_type::pop_back; + using base_type::back; + using base_type::begin; + using base_type::end; + using base_type::operator[]; + using base_type::size_type; + using base_type::difference_type; + using base_type::const_iterator; + friend bool operator!=(MathIterator const &, MathIterator const &); + friend bool operator==(MathIterator const &, MathIterator const &); + + /// default constructor + MathIterator(); /// start with given inset explicit MathIterator(MathInset * p); - /// start with given position - //explicit MathIterator(MathCursor::cursor_type const & cursor); /// MathCursorPos const & operator*() const; /// @@ -21,13 +36,7 @@ public: /// move on one step void operator++(); /// move on several steps - void jump(MathInset::difference_type); - /// read access to top most item (inline after running gprof!) - MathCursorPos const & position() const { return cursor_.back(); } - /// write access to top most item - MathCursorPos & position() { return cursor_.back(); } - /// read access to full path - MathCursor::cursor_type const & cursor() const; + void jump(difference_type); /// read access to top most inset MathInset const * par() const; /// read access to top most inset @@ -42,9 +51,6 @@ private: void push(MathInset *); /// own level up void pop(); - - /// current position - MathCursor::cursor_type cursor_; }; /// diff --git a/src/mathed/math_parboxinset.C b/src/mathed/math_parboxinset.C index a2ff54baf6..459949cc5f 100644 --- a/src/mathed/math_parboxinset.C +++ b/src/mathed/math_parboxinset.C @@ -189,7 +189,7 @@ void MathParboxInset::metrics(MathMetricsInfo & mi) const dim_.w = lyx_width_; dim_.a = rows_.front().dim.a; dim_.d = rows_.back().dim.d + yo; - metricsMarkers(); + metricsMarkers2(); xcell(0).setDim(dim_); #endif } @@ -203,7 +203,7 @@ void MathParboxInset::draw(MathPainterInfo & pi, int x, int y) const #else xcell(0).drawExternal(pi, x + 1, y, rows_); #endif - drawMarkers(pi, x, y); + drawMarkers2(pi, x, y); } -- 2.39.2