fine-tuning for mouse clicks on script insets;

a few more /// comments

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

diff --git a/src/mathed/math_nestinset.C b/src/mathed/math_nestinset.C
index e12664d3f818f315915c4f7efb0173bab593f54e..f7264827e04e97675da21c7c07dfb0f12f5b9776 100644 (file)
--- a/src/mathed/math_nestinset.C
+++ b/src/mathed/math_nestinset.C
@@ -146,15 +146,6 @@ void MathNestInset::dump() const
 }
 
 
-void MathNestInset::push_back(MathAtom const & t)
-{
-       if (nargs())
-               cells_.back().data_.push_back(t);
-       else
-               lyxerr << "can't push without a cell\n";
-}
-
-
 void MathNestInset::validate(LaTeXFeatures & features) const
 {
        for (idx_type i = 0; i < nargs(); ++i)

diff --git a/src/mathed/math_nestinset.h b/src/mathed/math_nestinset.h
index 5945f55e46d74954926bffb6d5a5d9f8a6f9ac5d..755198a8477e45ee5d13ad07c3464653a288cb53 100644 (file)
--- a/src/mathed/math_nestinset.h
+++ b/src/mathed/math_nestinset.h
@@ -7,7 +7,9 @@
 
 #include "math_diminset.h"
 
-/** Abstract base class for all math objects that conatin nested items.
+/** Abstract base class for all math objects that contain nested items.
+    This is basically everything that is not a single character or a
+    single symbol
 */
 
 
@@ -15,10 +17,10 @@ class LaTeXFeatures;
 
 class MathNestInset : public MathDimInset {
 public: 
-       ///
+       /// nestinsets have a fixed size to start with
        explicit MathNestInset(idx_type ncells);
 
-       ///
+       /// the size is usuall some sort of convex hull of the cells
        void metrics(MathMetricsInfo const & st) const;
        /// draw the object, sets xo_ and yo_ cached values 
        void draw(Painter &, int x, int y) const;
@@ -27,58 +29,57 @@ public:
        /// identifies NestInsets
        MathNestInset * asNestInset() { return this; }
 
-       /// The left key
+       /// order of movement through the cells when pressing the left key
        bool idxLeft(idx_type & idx, pos_type & pos) const;
-       /// The right key
+       /// order of movement through the cells when pressing the right key
        bool idxRight(idx_type & idx, pos_type & pos) const;
 
-       /// Move one physical cell up
+       /// move one physical cell up
        bool idxNext(idx_type & idx, pos_type & pos) const;
-       /// Move one physical cell down
+       /// move one physical cell down
        bool idxPrev(idx_type & idx, pos_type & pos) const;
 
-       /// Target pos when we enter the inset from the left by pressing "Right"
+       /// target pos when we enter the inset from the left by pressing "Right"
        bool idxFirst(idx_type & idx, pos_type & pos) const;
-       /// Target pos when we enter the inset from the right by pressing "Left"
+       /// target pos when we enter the inset from the right by pressing "Left"
        bool idxLast(idx_type & idx, pos_type & pos) const;
 
-       /// Where should we go if we press home?
+       /// where should we go if we press home?
        bool idxHome(idx_type & idx, pos_type & pos) const;
-       /// Where should we go if we press end?
+       /// where should we go if we press end?
        bool idxEnd(idx_type & idx, pos_type & pos) const;
 
-       ///
+       /// number of cells currently governed by us
        idx_type nargs() const;
 
-       ///
+       /// direct access to the cell
        MathArray & cell(idx_type);
-       ///
+       /// direct access to the cell
        MathArray const & cell(idx_type) const;
-       ///
+       /// direct access to the cell including the drawing cache
        MathXArray & xcell(idx_type);
-       ///
+       /// direct access to the cell including the drawing cache
        MathXArray const & xcell(idx_type) const;
                        
-       ///
+       /// can we move into this cell (see macroarg.h)
        bool isActive() const { return nargs() > 0; }
-       ///
-       void push_back(MathAtom const &);
-       ///
-       void dump() const;
-       ///
+       /// request "external features"
+       void validate(LaTeXFeatures & features) const;
+       /// do we cover the point (x,y)?
+       bool covers(int x, int y) const;
+
+       /// match in all cells
        bool match(MathInset *) const;
-       ///
+       /// replace in all cells
        void replace(ReplaceData &);
 
-       ///
-       void validate(LaTeXFeatures & features) const;
-       ///
-       bool covers(int x, int y) const;
+       /// debug helper
+       void dump() const;
 
 protected:
-       ///
+       /// we store the cells in a vector
        typedef std::vector<MathXArray> cells_type;
-       /// The nested contents of the inset are contained here.
+       /// thusly:
        cells_type cells_;
 };
 

diff --git a/src/mathed/math_scriptinset.C b/src/mathed/math_scriptinset.C
index 2de23d00eeb90d6b3d72bd30dce5d4acce5fb193..bff30b20f140d4bd094fcdc749986f40278395d0 100644 (file)
--- a/src/mathed/math_scriptinset.C
+++ b/src/mathed/math_scriptinset.C
@@ -73,6 +73,15 @@ void MathScriptInset::ensure(bool up)
 }
 
 
+bool MathScriptInset::covers(int x, int y) const
+{
+       for (idx_type i = 0; i < 2; ++i)
+               if (has(i) && xcell(i).covers(x, y))
+                       return true;
+       return false;
+}
+
+
 int MathScriptInset::dy0(MathInset const * nuc) const
 {
        int nd = ndes(nuc);

diff --git a/src/mathed/math_scriptinset.h b/src/mathed/math_scriptinset.h
index 45920dbc73590baf2b861dabd5600e5b99c6086e..f11c6002505b9b40d1c87b0d7296fc1f63ff9151 100644 (file)
--- a/src/mathed/math_scriptinset.h
+++ b/src/mathed/math_scriptinset.h
@@ -14,9 +14,9 @@
 
 class MathScriptInset : public MathNestInset {
 public:
-       ///
+       /// create inset without scripts
        MathScriptInset();
-       ///
+       /// create inset with single script
        explicit MathScriptInset(bool up);
        ///
        MathInset * clone() const;
@@ -53,17 +53,15 @@ public:
        ///
        bool idxLastDown(idx_type &, pos_type &) const;
 
-       ///
+       /// identifies scriptinsets
        MathScriptInset const * asScriptInset() const;
        ///
        MathScriptInset * asScriptInset();
 
        /// set limits
        void limits(int lim) { limits_ = lim; }
-       /// 
+       /// get limits
        int limits() const { return limits_; }
-       ///
-       bool hasLimits(MathInset const * nuc) const;
        /// true if we have an "inner" position
        MathXArray const & up() const;
        /// returns subscript
@@ -82,19 +80,17 @@ public:
        void removeScript(bool up);
        /// remove script
        void removeEmptyScripts();
-       ///
+       /// make sure a script is accessible
        void ensure(bool up);
+       /// only true if we are _in_ sub- or superscript, not in the convex hull
+       bool covers(int x, int y) const;
 
        // call these methods ...2 to make compaq cxx in anal mode happy...
        /// suppresses empty braces if necessary
        virtual void write2(MathInset const * nuc, WriteStream & os) const;
-       /// 
        virtual void normalize2(MathInset const * nuc, NormalStream & os) const;
-       ///
        virtual void octavize2(MathInset const * nuc, OctaveStream & os) const;
-       ///
        virtual void maplize2(MathInset const * nuc, MapleStream & os) const;
-       ///
        virtual void mathmlize2(MathInset const * nuc, MathMLStream & os) const;
 
 public:
@@ -115,12 +111,14 @@ private:
        int nasc(MathInset const * nuc) const;
        /// returns descent of nucleus if any
        int ndes(MathInset const * nuc) const;
+       /// where do we have to draw the scripts?
+       bool hasLimits(MathInset const * nuc) const;
 
        /// possible subscript (index 0) and superscript (index 1)
        bool script_[2]; 
-       ///
+       /// 1 - "limits", -1 - "nolimits", 0 - "default"
        int limits_;
-       ///
+       /// cached MathMetricsInfo
        mutable MathMetricsInfo mi_;
 };
 

diff --git a/src/mathed/math_xdata.C b/src/mathed/math_xdata.C
index f7e5a092d01acb07176cd14637e6df5445755757..8663e7f115e75dff2566e9a9e9271330eed172f4 100644 (file)
--- a/src/mathed/math_xdata.C
+++ b/src/mathed/math_xdata.C
@@ -141,3 +141,13 @@ int MathXArray::dist(int x, int y) const
 
        return xx + yy; 
 }
+
+
+bool MathXArray::covers(int x, int y) const
+{
+       int const x0 = xo_;
+       int const y0 = yo_ - ascent_;
+       int const x1 = xo_ + width_;
+       int const y1 = yo_ + descent_;
+       return x >= x0 && x <= x1 && y >= y0 && y <= y1;
+}

diff --git a/src/mathed/math_xdata.h b/src/mathed/math_xdata.h
index 08e06b12a6036e9aef1ea55d20070c33ca408064..0fb7842d66c014307706bfffc544b71c6007f810 100644 (file)
--- a/src/mathed/math_xdata.h
+++ b/src/mathed/math_xdata.h
@@ -49,6 +49,8 @@ public:
        int height() const { return ascent_ + descent_; }
        ///
        int width() const { return width_; }
+       /// do we cover point(x, y)?
+       bool covers(int x, int y) const;
 
        ///
        const_iterator begin() const { return data_.begin(); }