Put MathData on a diet: transfer dimension cache to BufferView' CoordCache along...

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

diff --git a/src/mathed/InsetMathBinom.cpp b/src/mathed/InsetMathBinom.cpp
index 325dfdd509239c4acf82e949f0077ae4e6f585ee..7f4873a474e548bed30c0eb15ae79836ca938199 100644 (file)
--- a/src/mathed/InsetMathBinom.cpp
+++ b/src/mathed/InsetMathBinom.cpp
@@ -43,11 +43,12 @@ int InsetMathBinom::dw(int height) const
 void InsetMathBinom::metrics(MetricsInfo & mi, Dimension & dim) const
 {
        ScriptChanger dummy(mi.base);
-       cell(0).metrics(mi);
-       cell(1).metrics(mi);
-       dim.asc = cell(0).height() + 4 + 5;
-       dim.des = cell(1).height() + 4 - 5;
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 2 * dw(dim.height()) + 4;
+       Dimension dim0, dim1;
+       cell(0).metrics(mi, dim0);
+       cell(1).metrics(mi, dim1);
+       dim.asc = dim0.height() + 4 + 5;
+       dim.des = dim1.height() + 4 - 5;
+       dim.wid = std::max(dim0.width(), dim1.wid) + 2 * dw(dim.height()) + 4;
        metricsMarkers2(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -57,10 +58,12 @@ void InsetMathBinom::metrics(MetricsInfo & mi, Dimension & dim) const
 void InsetMathBinom::draw(PainterInfo & pi, int x, int y) const
 {
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
        int m = x + dim.width() / 2;
        ScriptChanger dummy(pi.base);
-       cell(0).draw(pi, m - cell(0).width() / 2, y - cell(0).descent() - 3 - 5);
-       cell(1).draw(pi, m - cell(1).width() / 2, y + cell(1).ascent()  + 3 - 5);
+       cell(0).draw(pi, m - dim0.width() / 2, y - dim0.des - 3 - 5);
+       cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc  + 3 - 5);
        mathed_draw_deco(pi, x, y - dim.ascent(), dw(dim.height()), dim.height(), from_ascii("("));
        mathed_draw_deco(pi, x + dim.width() - dw(dim.height()), y - dim.ascent(),
                dw(dim.height()), dim.height(), from_ascii(")"));

diff --git a/src/mathed/InsetMathBrace.cpp b/src/mathed/InsetMathBrace.cpp
index fc5058972330b93573284a8c6dca34d0f83573d6..1acc85517d657e5f302f02354730093a020e1c72 100644 (file)
--- a/src/mathed/InsetMathBrace.cpp
+++ b/src/mathed/InsetMathBrace.cpp
@@ -43,11 +43,12 @@ Inset * InsetMathBrace::clone() const
 
 void InsetMathBrace::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       cell(0).metrics(mi);
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
        Dimension t = theFontMetrics(mi.base.font).dimension('{');
-       dim.asc = std::max(cell(0).ascent(), t.asc);
-       dim.des = std::max(cell(0).descent(), t.des);
-       dim.wid = cell(0).width() + 2 * t.wid;
+       dim.asc = std::max(dim0.asc, t.asc);
+       dim.des = std::max(dim0.des, t.des);
+       dim.wid = dim0.width() + 2 * t.wid;
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -61,7 +62,8 @@ void InsetMathBrace::draw(PainterInfo & pi, int x, int y) const
        Dimension t = theFontMetrics(font).dimension('{');
        pi.pain.text(x, y, '{', font);
        cell(0).draw(pi, x + t.wid, y);
-       pi.pain.text(x + t.wid + cell(0).width(), y, '}', font);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       pi.pain.text(x + t.wid + dim0.width(), y, '}', font);
        drawMarkers(pi, x, y);
 }
 

diff --git a/src/mathed/InsetMathDFrac.cpp b/src/mathed/InsetMathDFrac.cpp
index 6b051ab7d5320c969b92fc55989d868af9448532..280a6dfef20abd530f99e68e7d43ea7edb5a1467 100644 (file)
--- a/src/mathed/InsetMathDFrac.cpp
+++ b/src/mathed/InsetMathDFrac.cpp
@@ -33,11 +33,12 @@ Inset * InsetMathDFrac::clone() const
 
 void InsetMathDFrac::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       cell(0).metrics(mi);
-       cell(1).metrics(mi);
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 2;
-       dim.asc = cell(0).height() + 2 + 5;
-       dim.des = cell(1).height() + 2 - 5;
+       Dimension dim0, dim1;
+       cell(0).metrics(mi, dim0);
+       cell(1).metrics(mi, dim1);
+       dim.wid = std::max(dim0.wid, dim1.wid) + 2;
+       dim.asc = dim0.height() + 2 + 5;
+       dim.des = dim1.height() + 2 - 5;
        // Cache the inset dimension. 
        setDimCache(mi, dim);
 }
@@ -46,9 +47,11 @@ void InsetMathDFrac::metrics(MetricsInfo & mi, Dimension & dim) const
 void InsetMathDFrac::draw(PainterInfo & pi, int x, int y) const
 {
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
        int m = x + dim.wid / 2;
-       cell(0).draw(pi, m - cell(0).width() / 2, y - cell(0).descent() - 2 - 5);
-       cell(1).draw(pi, m - cell(1).width() / 2, y + cell(1).ascent()  + 2 - 5);
+       cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
+       cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc  + 2 - 5);
        pi.pain.line(x + 1, y - 5, x + dim.wid - 2, y - 5, Color::math);
        setPosCache(pi, x, y);
 }

diff --git a/src/mathed/InsetMathDecoration.cpp b/src/mathed/InsetMathDecoration.cpp
index 2ef910d8751f7c132e92284d55f836c440428e74..1dc8a1471bc18784256ddea93cb333d3ad5f2efe 100644 (file)
--- a/src/mathed/InsetMathDecoration.cpp
+++ b/src/mathed/InsetMathDecoration.cpp
@@ -125,10 +125,11 @@ void InsetMathDecoration::metrics(MetricsInfo & mi, Dimension & dim) const
 void InsetMathDecoration::draw(PainterInfo & pi, int x, int y) const
 {
        cell(0).draw(pi, x + 1, y);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
        if (wide())
-               mathed_draw_deco(pi, x + 1, y + dy_, cell(0).width(), dh_, key_->name);
+               mathed_draw_deco(pi, x + 1, y + dy_, dim0.wid, dh_, key_->name);
        else
-               mathed_draw_deco(pi, x + 1 + (cell(0).width() - dw_) / 2,
+               mathed_draw_deco(pi, x + 1 + (dim0.wid - dw_) / 2,
                        y + dy_, dw_, dh_, key_->name);
        drawMarkers(pi, x, y);
        setPosCache(pi, x, y);

diff --git a/src/mathed/InsetMathDelim.cpp b/src/mathed/InsetMathDelim.cpp
index 19bcc6ccd8f254ad12bec287986575e18a5f97c2..45dd1ffcf39389c26c97f3089a783e6886bb0d42 100644 (file)
--- a/src/mathed/InsetMathDelim.cpp
+++ b/src/mathed/InsetMathDelim.cpp
@@ -70,17 +70,18 @@ void InsetMathDelim::normalize(NormalStream & os) const
 void InsetMathDelim::metrics(MetricsInfo & mi, Dimension & dim) const
 {
        using std::max;
-       cell(0).metrics(mi);
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
        Dimension t = theFontMetrics(mi.base.font).dimension('I');
        int h0 = (t.asc + t.des) / 2;
-       int a0 = max(cell(0).ascent(), t.asc)   - h0;
-       int d0 = max(cell(0).descent(), t.des)  + h0;
-       dw_ = cell(0).height() / 5;
+       int a0 = max(dim0.asc, t.asc)   - h0;
+       int d0 = max(dim0.des, t.des)  + h0;
+       dw_ = dim0.height() / 5;
        if (dw_ > 8)
                dw_ = 8;
        if (dw_ < 4)
                dw_ = 4;
-       dim.wid = cell(0).width() + 2 * dw_ + 8;
+       dim.wid = dim0.width() + 2 * dw_ + 8;
        dim.asc = max(a0, d0) + h0;
        dim.des = max(a0, d0) - h0;
        // Cache the inset dimension. 

diff --git a/src/mathed/InsetMathFrac.cpp b/src/mathed/InsetMathFrac.cpp
index c0364829610169f6b12d2a0616c4e397e9f887b6..863107403074570638dd0181e2fb938488eecada 100644 (file)
--- a/src/mathed/InsetMathFrac.cpp
+++ b/src/mathed/InsetMathFrac.cpp
@@ -84,47 +84,49 @@ bool InsetMathFrac::idxLeft(Cursor & cur) const
 
 void InsetMathFrac::metrics(MetricsInfo & mi, Dimension & dim) const
 {
+       Dimension dim0, dim1, dim2;
+
        if (kind_ == UNIT || (kind_ == UNITFRAC && nargs() == 3)) {
                if (nargs() == 1) {
                        ShapeChanger dummy2(mi.base.font, Font::UP_SHAPE);
-                       cell(0).metrics(mi);
-                       dim.wid = cell(0).width()+ 3;
-                       dim.asc = cell(0).ascent();
-                       dim.des = cell(0).descent();
+                       cell(0).metrics(mi, dim0);
+                       dim.wid = dim0.width()+ 3;
+                       dim.asc = dim0.asc;
+                       dim.des = dim0.des;
                } else if (nargs() == 2) {
-                       cell(0).metrics(mi);
+                       cell(0).metrics(mi, dim0);
                        ShapeChanger dummy2(mi.base.font, Font::UP_SHAPE);
-                       cell(1).metrics(mi);
-                       dim.wid = cell(0).width() + cell(1).width() + 5;
-                       dim.asc = std::max(cell(0).ascent(), cell(1).ascent());
-                       dim.des = std::max(cell(0).descent(), cell(1).descent());
+                       cell(1).metrics(mi, dim1);
+                       dim.wid = dim0.width() + dim1.wid + 5;
+                       dim.asc = std::max(dim0.asc, dim1.asc);
+                       dim.des = std::max(dim0.des, dim1.des);
                } else {
-                       cell(2).metrics(mi);
+                       cell(2).metrics(mi, dim2);
                        ShapeChanger dummy2(mi.base.font, Font::UP_SHAPE);
                        FracChanger dummy(mi.base);
-                       cell(0).metrics(mi);
-                       cell(1).metrics(mi);
-                       dim.wid = cell(0).width() + cell(1).width() + cell(2).width() + 10;
-                       dim.asc = std::max(cell(2).ascent(), cell(0).height() + 5);
-                       dim.des = std::max(cell(2).descent(), cell(1).height() - 5);
+                       cell(0).metrics(mi, dim0);
+                       cell(1).metrics(mi, dim1);
+                       dim.wid = dim0.width() + dim1.wid + dim2.wid + 10;
+                       dim.asc = std::max(dim2.asc, dim0.height() + 5);
+                       dim.des = std::max(dim2.des, dim1.height() - 5);
                }
        } else {
                FracChanger dummy(mi.base);
-               cell(0).metrics(mi);
-               cell(1).metrics(mi);
+               cell(0).metrics(mi, dim0);
+               cell(1).metrics(mi, dim1);
                if (kind_ == NICEFRAC) {
-                       dim.wid = cell(0).width() + cell(1).width() + 5;
-                       dim.asc = cell(0).height() + 5;
-                       dim.des = cell(1).height() - 5;
+                       dim.wid = dim0.width() + dim1.wid + 5;
+                       dim.asc = dim0.height() + 5;
+                       dim.des = dim1.height() - 5;
                } else if (kind_ == UNITFRAC) {
                        ShapeChanger dummy2(mi.base.font, Font::UP_SHAPE);
-                       dim.wid = cell(0).width() + cell(1).width() + 5;
-                       dim.asc = cell(0).height() + 5;
-                       dim.des = cell(1).height() - 5;
+                       dim.wid = dim0.width() + dim1.wid + 5;
+                       dim.asc = dim0.height() + 5;
+                       dim.des = dim1.height() - 5;
                } else {
-                       dim.wid = std::max(cell(0).width(), cell(1).width()) + 2;
-                       dim.asc = cell(0).height() + 2 + 5;
-                       dim.des = cell(1).height() + 2 - 5;
+                       dim.wid = std::max(dim0.width(), dim1.wid) + 2;
+                       dim.asc = dim0.height() + 2 + 5;
+                       dim.des = dim1.height() + 2 - 5;
                }
        }
        metricsMarkers(dim);
@@ -137,6 +139,9 @@ void InsetMathFrac::draw(PainterInfo & pi, int x, int y) const
 {
        setPosCache(pi, x, y);
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const dim1 = cell(1).dimension(*pi.base.bv);
+       Dimension const dim2 = cell(0).dimension(*pi.base.bv);
        int m = x + dim.wid / 2;
        if (kind_ == UNIT || (kind_ == UNITFRAC && nargs() == 3)) {
                if (nargs() == 1) {
@@ -145,46 +150,46 @@ void InsetMathFrac::draw(PainterInfo & pi, int x, int y) const
                } else if (nargs() == 2) {
                        cell(0).draw(pi, x + 1, y);
                        ShapeChanger dummy2(pi.base.font, Font::UP_SHAPE);
-                       cell(1).draw(pi, x + cell(0).width() + 5, y);
+                       cell(1).draw(pi, x + dim0.width() + 5, y);
                } else {
                        cell(2).draw(pi, x + 1, y);
                        ShapeChanger dummy2(pi.base.font, Font::UP_SHAPE);
                        FracChanger dummy(pi.base);
-                       int xx = x + cell(2).width() + 5;
+                       int xx = x + dim2.wid + 5;
                        cell(0).draw(pi, xx + 2, 
-                                        y - cell(0).descent() - 5);
-                       cell(1).draw(pi, xx  + cell(0).width() + 5, 
-                                        y + cell(1).ascent() / 2);
+                                        y - dim0.des - 5);
+                       cell(1).draw(pi, xx  + dim0.width() + 5, 
+                                        y + dim1.asc / 2);
                }
        } else {
                FracChanger dummy(pi.base);
                if (kind_ == NICEFRAC) {
                        cell(0).draw(pi, x + 2,
-                                       y - cell(0).descent() - 5);
-                       cell(1).draw(pi, x + cell(0).width() + 5,
-                                       y + cell(1).ascent() / 2);
+                                       y - dim0.des - 5);
+                       cell(1).draw(pi, x + dim0.width() + 5,
+                                       y + dim1.asc / 2);
                } else if (kind_ == UNITFRAC) {
                        ShapeChanger dummy2(pi.base.font, Font::UP_SHAPE);
                        cell(0).draw(pi, x + 2,
-                                       y - cell(0).descent() - 5);
-                       cell(1).draw(pi, x + cell(0).width() + 5,
-                                       y + cell(1).ascent() / 2);
+                                       y - dim0.des - 5);
+                       cell(1).draw(pi, x + dim0.width() + 5,
+                                       y + dim1.asc / 2);
                } else {
                        // Classical fraction
-                       cell(0).draw(pi, m - cell(0).width() / 2,
-                                       y - cell(0).descent() - 2 - 5);
-                       cell(1).draw(pi, m - cell(1).width() / 2,
-                                       y + cell(1).ascent()  + 2 - 5);
+                       cell(0).draw(pi, m - dim0.width() / 2,
+                                       y - dim0.des - 2 - 5);
+                       cell(1).draw(pi, m - dim1.wid / 2,
+                                       y + dim1.asc  + 2 - 5);
                }
        }
        if (kind_ == NICEFRAC || kind_ == UNITFRAC) {
                // Diag line:
                int xx = x;
                if (nargs() == 3)
-                       xx += cell(2).width() + 5;
-               pi.pain.line(xx + cell(0).width(),
+                       xx += dim2.wid + 5;
+               pi.pain.line(xx + dim0.wid,
                                y + dim.des - 2,
-                               xx + cell(0).width() + 5,
+                               xx + dim0.wid + 5,
                                y - dim.asc + 2, Color::math);
        }
        if (kind_ == FRAC || kind_ == OVER)
@@ -196,24 +201,27 @@ void InsetMathFrac::draw(PainterInfo & pi, int x, int y) const
 
 void InsetMathFrac::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
 {
-       cell(0).metricsT(mi, dim);
-       cell(1).metricsT(mi, dim);
-       dim.wid = std::max(cell(0).width(), cell(1).width());
-       dim.asc = cell(0).height() + 1;
-       dim.des = cell(1).height();
+       Dimension dim0, dim1;
+       cell(0).metricsT(mi, dim0);
+       cell(1).metricsT(mi, dim1);
+       dim.wid = std::max(dim0.width(), dim1.wid);
+       dim.asc = dim0.height() + 1;
+       dim.des = dim1.height();
 }
 
 
 void InsetMathFrac::drawT(TextPainter & pain, int x, int y) const
 {
        // FIXME: BROKEN!
+       /*
        Dimension dim;
        int m = x + dim.width() / 2;
-       cell(0).drawT(pain, m - cell(0).width() / 2, y - cell(0).descent() - 1);
-       cell(1).drawT(pain, m - cell(1).width() / 2, y + cell(1).ascent());
+       cell(0).drawT(pain, m - dim0.width() / 2, y - dim0.des - 1);
+       cell(1).drawT(pain, m - dim1.wid / 2, y + dim1.asc);
        // ASCII art: ignore niceties
        if (kind_ == FRAC || kind_ == OVER || kind_ == NICEFRAC || kind_ == UNITFRAC)
                pain.horizontalLine(x, y, dim.width());
+       */
 }
 
 

diff --git a/src/mathed/InsetMathFrameBox.cpp b/src/mathed/InsetMathFrameBox.cpp
index 5123e17646245dba0f18a7646ac9bf3aa9f24680..90bcacdc5ee34165f5cc48ce57e20abb9e653ade 100644 (file)
--- a/src/mathed/InsetMathFrameBox.cpp
+++ b/src/mathed/InsetMathFrameBox.cpp
@@ -36,9 +36,9 @@ void InsetMathFrameBox::metrics(MetricsInfo & mi, Dimension & dim) const
        FontSetChanger dummy(mi.base, "textnormal");
        w_ = mathed_char_width(mi.base.font, '[');
        InsetMathNest::metrics(mi);
-       dim  = cell(0).dim();
-       dim += cell(1).dim();
-       dim += cell(2).dim();
+       dim  = cell(0).dimension(*mi.base.bv);
+       dim += cell(1).dimension(*mi.base.bv);
+       dim += cell(2).dimension(*mi.base.bv);
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -52,18 +52,19 @@ void InsetMathFrameBox::draw(PainterInfo & pi, int x, int y) const
        pi.pain.rectangle(x + 1, y - dim.ascent() + 1,
                dim.width() - 2, dim.height() - 2, Color::foreground);
        x += 5;
+       BufferView const & bv = *pi.base.bv;
 
        drawStrBlack(pi, x, y, from_ascii("["));
        x += w_;
        cell(0).draw(pi, x, y);
-       x += cell(0).width();
+       x += cell(0).dimension(bv).wid;
        drawStrBlack(pi, x, y, from_ascii("]"));
        x += w_ + 4;
 
        drawStrBlack(pi, x, y, from_ascii("["));
        x += w_;
        cell(1).draw(pi, x, y);
-       x += cell(1).width();
+       x += cell(1).dimension(bv).wid;
        drawStrBlack(pi, x, y, from_ascii("]"));
        x += w_ + 4;
 

diff --git a/src/mathed/InsetMathGrid.cpp b/src/mathed/InsetMathGrid.cpp
index 99bb9ded1d7c1607c83012a2cc918f914ce457b9..26319250ecd1600116095af274aa0324c1dbd262 100644 (file)
--- a/src/mathed/InsetMathGrid.cpp
+++ b/src/mathed/InsetMathGrid.cpp
@@ -370,14 +370,16 @@ void InsetMathGrid::metrics(MetricsInfo & mi, Dimension & dim) const
        // let the cells adjust themselves
        InsetMathNest::metrics(mi);
 
+       BufferView & bv = *mi.base.bv;
+
        // compute absolute sizes of vertical structure
        for (row_type row = 0; row < nrows(); ++row) {
                int asc  = 0;
                int desc = 0;
                for (col_type col = 0; col < ncols(); ++col) {
-                       MathData const & c = cell(index(row, col));
-                       asc  = max(asc,  c.ascent());
-                       desc = max(desc, c.descent());
+                       Dimension const & dimc = cell(index(row, col)).dimension(bv);
+                       asc  = max(asc,  dimc.asc);
+                       desc = max(desc, dimc.des);
                }
                rowinfo_[row].ascent_  = asc;
                rowinfo_[row].descent_ = desc;
@@ -418,7 +420,7 @@ void InsetMathGrid::metrics(MetricsInfo & mi, Dimension & dim) const
        for (col_type col = 0; col < ncols(); ++col) {
                int wid = 0;
                for (row_type row = 0; row < nrows(); ++row)
-                       wid = max(wid, cell(index(row, col)).width());
+                       wid = max(wid, cell(index(row, col)).dimension(bv).wid);
                colinfo_[col].width_ = wid;
        }
        colinfo_[ncols()].width_  = 0;
@@ -517,9 +519,10 @@ void InsetMathGrid::drawWithMargin(PainterInfo & pi, int x, int y,
        int lmargin, int rmargin) const
 {
        Dimension const dim = dimension(*pi.base.bv);
+       BufferView const & bv = *pi.base.bv;
 
        for (idx_type idx = 0; idx < nargs(); ++idx)
-               cell(idx).draw(pi, x + lmargin + cellXOffset(idx),
+               cell(idx).draw(pi, x + lmargin + cellXOffset(bv, idx),
                        y + cellYOffset(idx));
 
        for (row_type row = 0; row <= nrows(); ++row)
@@ -555,9 +558,11 @@ void InsetMathGrid::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
                int asc  = 0;
                int desc = 0;
                for (col_type col = 0; col < ncols(); ++col) {
-                       MathData const & c = cell(index(row, col));
-                       asc  = max(asc,  c.ascent());
-                       desc = max(desc, c.descent());
+                       //MathData const & c = cell(index(row, col));
+                       // FIXME: BROKEN!
+                       Dimension dimc;
+                       asc  = max(asc,  dimc.ascent());
+                       desc = max(desc, dimc.descent());
                }
                rowinfo_[row].ascent_  = asc;
                rowinfo_[row].descent_ = desc;
@@ -597,8 +602,10 @@ void InsetMathGrid::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
        // compute absolute sizes of horizontal structure
        for (col_type col = 0; col < ncols(); ++col) {
                int wid = 0;
-               for (row_type row = 0; row < nrows(); ++row)
-                       wid = max(wid, cell(index(row, col)).width());
+               for (row_type row = 0; row < nrows(); ++row) {
+                       // FIXME: BROKEN!
+                       //wid = max(wid, cell(index(row, col)).width());
+               }
                colinfo_[col].width_ = wid;
        }
        colinfo_[ncols()].width_  = 0;
@@ -634,8 +641,8 @@ void InsetMathGrid::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
 
 void InsetMathGrid::drawT(TextPainter & pain, int x, int y) const
 {
-       for (idx_type idx = 0; idx < nargs(); ++idx)
-               cell(idx).drawT(pain, x + cellXOffset(idx), y + cellYOffset(idx));
+//     for (idx_type idx = 0; idx < nargs(); ++idx)
+//             cell(idx).drawT(pain, x + cellXOffset(idx), y + cellYOffset(idx));
 }
 
 
@@ -789,15 +796,16 @@ void InsetMathGrid::swapCol(col_type col)
 }
 
 
-int InsetMathGrid::cellXOffset(idx_type idx) const
+int InsetMathGrid::cellXOffset(BufferView const & bv, idx_type idx) const
 {
        col_type c = col(idx);
        int x = colinfo_[c].offset_;
        char align = colinfo_[c].align_;
+       Dimension const & celldim = cell(idx).dimension(bv);
        if (align == 'r' || align == 'R')
-               x += colinfo_[c].width_ - cell(idx).width();
+               x += colinfo_[c].width_ - celldim.wid;
        if (align == 'c' || align == 'C')
-               x += (colinfo_[c].width_ - cell(idx).width()) / 2;
+               x += (colinfo_[c].width_ - celldim.wid) / 2;
        return x;
 }
 

diff --git a/src/mathed/InsetMathGrid.h b/src/mathed/InsetMathGrid.h
index 4bea98172c9f0d295bbd2d81889d03edea94c6b0..7683ad6305a9a22d9cdf99a80cd7b9bc1a67b5b0 100644 (file)
--- a/src/mathed/InsetMathGrid.h
+++ b/src/mathed/InsetMathGrid.h
@@ -224,7 +224,7 @@ protected:
        bool getStatus(Cursor & cur, FuncRequest const & cmd,
                FuncStatus & flag) const;
        /// returns x offset of cell compared to inset
-       int cellXOffset(idx_type idx) const;
+       int cellXOffset(BufferView const &, idx_type idx) const;
        /// returns y offset of cell compared to inset
        int cellYOffset(idx_type idx) const;
        /// returns proper 'end of line' code for LaTeX

diff --git a/src/mathed/InsetMathMakebox.cpp b/src/mathed/InsetMathMakebox.cpp
index 4ab87db31f062677881d9ba2db1f4155a8d5a4ce..c8ba21931e3bed9251dfb403b023a1c9f28f01e9 100644 (file)
--- a/src/mathed/InsetMathMakebox.cpp
+++ b/src/mathed/InsetMathMakebox.cpp
@@ -36,9 +36,9 @@ void InsetMathMakebox::metrics(MetricsInfo & mi, Dimension & dim) const
        FontSetChanger dummy(mi.base, from_ascii("textnormal"));
        w_ = mathed_char_width(mi.base.font, '[');
        InsetMathNest::metrics(mi);
-       dim   = cell(0).dim();
-       dim  += cell(1).dim();
-       dim  += cell(2).dim();
+       dim   = cell(0).dimension(*mi.base.bv);
+       dim  += cell(1).dimension(*mi.base.bv);
+       dim  += cell(2).dimension(*mi.base.bv);
        dim.wid += 4 * w_ + 4;
        metricsMarkers(dim);
        // Cache the inset dimension. 
@@ -54,14 +54,14 @@ void InsetMathMakebox::draw(PainterInfo & pi, int x, int y) const
        drawStrBlack(pi, x, y, from_ascii("["));
        x += w_;
        cell(0).draw(pi, x, y);
-       x += cell(0).width();
+       x += cell(0).dimension(*pi.base.bv).width();
        drawStrBlack(pi, x, y, from_ascii("]"));
        x += w_ + 2;
 
        drawStrBlack(pi, x, y, from_ascii("["));
        x += w_;
        cell(1).draw(pi, x, y);
-       x += cell(1).width();
+       x += cell(1).dimension(*pi.base.bv).wid;
        drawStrBlack(pi, x, y, from_ascii("]"));
        x += w_ + 2;
 

diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp
index 28b799ffb7b8aeea186595f079af1130c898e40e..f027b326feb29dfa19f668c4bad88e9bdbb32168 100644 (file)
--- a/src/mathed/InsetMathNest.cpp
+++ b/src/mathed/InsetMathNest.cpp
@@ -148,8 +148,10 @@ void InsetMathNest::cursorPos(BufferView const & bv,
 void InsetMathNest::metrics(MetricsInfo const & mi) const
 {
        MetricsInfo m = mi;
-       for (idx_type i = 0, n = nargs(); i != n; ++i)
-               cell(i).metrics(m);
+       for (idx_type i = 0, n = nargs(); i != n; ++i) {
+               Dimension dim;
+               cell(i).metrics(m, dim);
+       }
 }
 
 
@@ -256,10 +258,11 @@ void InsetMathNest::drawSelection(PainterInfo & pi, int x, int y) const
        //      << " s1: " << s1 << " s2: " << s2 << endl;
        if (s1.idx() == s2.idx()) {
                MathData const & c = cell(s1.idx());
-               int x1 = c.xo(bv) + c.pos2x(s1.pos());
-               int y1 = c.yo(bv) - c.ascent();
-               int x2 = c.xo(bv) + c.pos2x(s2.pos());
-               int y2 = c.yo(bv) + c.descent();
+               Geometry const & g = bv.coordCache().getArrays().geometry(&c);
+               int x1 = g.pos.x_ + c.pos2x(s1.pos());
+               int y1 = g.pos.y_ - g.dim.ascent();
+               int x2 = g.pos.x_ + c.pos2x(s2.pos());
+               int y2 = g.pos.y_ + g.dim.descent();
                pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, Color::selection);
        //lyxerr << "InsetMathNest::drawing selection 3: "
        //      << " x1: " << x1 << " x2: " << x2
@@ -268,10 +271,11 @@ void InsetMathNest::drawSelection(PainterInfo & pi, int x, int y) const
                for (idx_type i = 0; i < nargs(); ++i) {
                        if (idxBetween(i, s1.idx(), s2.idx())) {
                                MathData const & c = cell(i);
-                               int x1 = c.xo(bv);
-                               int y1 = c.yo(bv) - c.ascent();
-                               int x2 = c.xo(bv) + c.width();
-                               int y2 = c.yo(bv) + c.descent();
+                               Geometry const & g = bv.coordCache().getArrays().geometry(&c);
+                               int x1 = g.pos.x_;
+                               int y1 = g.pos.y_ - g.dim.ascent();
+                               int x2 = g.pos.x_ + g.dim.width();
+                               int y2 = g.pos.y_ + g.dim.descent();
                                pi.pain.fillRectangle(x1, y1, x2 - x1, y2 - y1, Color::selection);
                        }
                }

diff --git a/src/mathed/InsetMathOverset.cpp b/src/mathed/InsetMathOverset.cpp
index 82b80d7d438234e943b3d5fadbe0c536f420fa46..318e634a3afb57a5b5c62ec99bcfc1e685a51abc 100644 (file)
--- a/src/mathed/InsetMathOverset.cpp
+++ b/src/mathed/InsetMathOverset.cpp
@@ -28,12 +28,14 @@ Inset * InsetMathOverset::clone() const
 
 void InsetMathOverset::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       cell(1).metrics(mi);
+       Dimension dim1;
+       cell(1).metrics(mi, dim1);
        FracChanger dummy(mi.base);
-       cell(0).metrics(mi);
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 4;
-       dim.asc = cell(1).ascent() + cell(0).height() + 4;
-       dim.des = cell(1).descent();
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
+       dim.wid = std::max(dim0.width(), dim1.wid) + 4;
+       dim.asc = dim1.asc + dim0.height() + 4;
+       dim.des = dim1.des;
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -43,11 +45,13 @@ void InsetMathOverset::metrics(MetricsInfo & mi, Dimension & dim) const
 void InsetMathOverset::draw(PainterInfo & pi, int x, int y) const
 {
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
        int m  = x + dim.wid / 2;
-       int yo = y - cell(1).ascent() - cell(0).descent() - 1;
-       cell(1).draw(pi, m - cell(1).width() / 2, y);
+       int yo = y - dim1.asc - dim0.des - 1;
+       cell(1).draw(pi, m - dim1.wid / 2, y);
        FracChanger dummy(pi.base);
-       cell(0).draw(pi, m - cell(0).width() / 2, yo);
+       cell(0).draw(pi, m - dim0.width() / 2, yo);
        drawMarkers(pi, x, y);
 }
 

diff --git a/src/mathed/InsetMathRoot.cpp b/src/mathed/InsetMathRoot.cpp
index f1318ab03deb535dde26c2891fe4c1ec3292ba6c..d48eeece0e3beb40c1b7442aa639109376447a26 100644 (file)
--- a/src/mathed/InsetMathRoot.cpp
+++ b/src/mathed/InsetMathRoot.cpp
@@ -38,9 +38,11 @@ void InsetMathRoot::metrics(MetricsInfo & mi, Dimension & dim) const
 {
        using std::max;
        InsetMathNest::metrics(mi);
-       dim.asc = max(cell(0).ascent()  + 5, cell(1).ascent())  + 2;
-       dim.des = max(cell(0).descent() - 5, cell(1).descent()) + 2;
-       dim.wid = cell(0).width() + cell(1).width() + 10;
+       Dimension const & dim0 = cell(0).dimension(*mi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*mi.base.bv);
+       dim.asc = max(dim0.ascent()  + 5, dim1.ascent())  + 2;
+       dim.des = max(dim0.descent() - 5, dim1.descent()) + 2;
+       dim.wid = dim0.width() + dim1.width() + 10;
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -49,9 +51,10 @@ void InsetMathRoot::metrics(MetricsInfo & mi, Dimension & dim) const
 
 void InsetMathRoot::draw(PainterInfo & pi, int x, int y) const
 {
-       int const w = cell(0).width();
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       int const w = dim0.width();
        // the "exponent"
-       cell(0).draw(pi, x, y - 5 - cell(0).descent());
+       cell(0).draw(pi, x, y - 5 - dim0.descent());
        // the "base"
        cell(1).draw(pi, x + w + 8, y);
        Dimension const dim = dimension(*pi.base.bv);

diff --git a/src/mathed/InsetMathScript.cpp b/src/mathed/InsetMathScript.cpp
index 6145628247736f23b1b1d0ed5dc40359e7711c47..a9e1afa03ddc6c9038a579fb0e8cc1b8e77047d6 100644 (file)
--- a/src/mathed/InsetMathScript.cpp
+++ b/src/mathed/InsetMathScript.cpp
@@ -169,13 +169,14 @@ bool isAlphaSymbol(MathAtom const & at)
 } // namespace anon
 
 
-int InsetMathScript::dy01(int asc, int des, int what) const
+int InsetMathScript::dy01(BufferView const & bv, int asc, int des, int what) const
 {
        int dasc = 0;
        int slevel = 0;
        bool isCharBox = nuc().size() ? isAlphaSymbol(nuc().back()) : false;
        if (hasDown()) {
-               dasc = down().ascent();
+               Dimension const & dimdown = down().dimension(bv);
+               dasc = dimdown.ascent();
                slevel = nuc().slevel();
                int ascdrop = dasc - slevel;
                int desdrop = isCharBox ? 0 : des + nuc().sshift();
@@ -184,9 +185,10 @@ int InsetMathScript::dy01(int asc, int des, int what) const
                des = max(mindes, des);
        }
        if (hasUp()) {
+               Dimension const & dimup = up().dimension(bv);
                int minasc = nuc().minasc();
                int ascdrop = isCharBox ? 0 : asc - up().mindes();
-               int udes = up().descent();
+               int udes = dimup.descent();
                asc = udes + nuc().sshift();
                asc = max(ascdrop, asc);
                asc = max(minasc, asc);
@@ -207,33 +209,33 @@ int InsetMathScript::dy01(int asc, int des, int what) const
 }
 
 
-int InsetMathScript::dy0() const
+int InsetMathScript::dy0(BufferView const & bv) const
 {
-       int nd = ndes();
+       int nd = ndes(bv);
        if (!hasDown())
                return nd;
-       int des = down().ascent();
+       int des = down().dimension(bv).ascent();
        if (hasLimits())
                des += nd + 2;
        else {
-               int na = nasc();
-               des = dy01(na, nd, 0);
+               int na = nasc(bv);
+               des = dy01(bv, na, nd, 0);
        }
        return des;
 }
 
 
-int InsetMathScript::dy1() const
+int InsetMathScript::dy1(BufferView const & bv) const
 {
-       int na = nasc();
+       int na = nasc(bv);
        if (!hasUp())
                return na;
-       int asc = up().descent();
+       int asc = up().dimension(bv).descent();
        if (hasLimits())
                asc += na + 2;
        else {
-               int nd = ndes();
-               asc = dy01(na, nd, 1);
+               int nd = ndes(bv);
+               asc = dy01(bv, na, nd, 1);
        }
        asc = max(asc, 5);
        return asc;
@@ -244,7 +246,7 @@ int InsetMathScript::dx0(BufferView const & bv) const
 {
        BOOST_ASSERT(hasDown());
        Dimension const dim = dimension(bv);
-       return hasLimits() ? (dim.wid - down().width()) / 2 : nwid();
+       return hasLimits() ? (dim.wid - down().dimension(bv).width()) / 2 : nwid(bv);
 }
 
 
@@ -252,32 +254,32 @@ int InsetMathScript::dx1(BufferView const & bv) const
 {
        BOOST_ASSERT(hasUp());
        Dimension const dim = dimension(bv);
-       return hasLimits() ? (dim.wid - up().width()) / 2 : nwid() + nker();
+       return hasLimits() ? (dim.wid - up().dimension(bv).width()) / 2 : nwid(bv) + nker();
 }
 
 
 int InsetMathScript::dxx(BufferView const & bv) const
 {
        Dimension const dim = dimension(bv);
-       return hasLimits() ? (dim.wid - nwid()) / 2  :  0;
+       return hasLimits() ? (dim.wid - nwid(bv)) / 2  :  0;
 }
 
 
-int InsetMathScript::nwid() const
+int InsetMathScript::nwid(BufferView const & bv) const
 {
-       return nuc().size() ? nuc().width() : 2;
+       return nuc().size() ? nuc().dimension(bv).width() : 2;
 }
 
 
-int InsetMathScript::nasc() const
+int InsetMathScript::nasc(BufferView const & bv) const
 {
-       return nuc().size() ? nuc().ascent() : 5;
+       return nuc().size() ? nuc().dimension(bv).ascent() : 5;
 }
 
 
-int InsetMathScript::ndes() const
+int InsetMathScript::ndes(BufferView const & bv) const
 {
-       return nuc().size() ? nuc().descent() : 0;
+       return nuc().size() ? nuc().dimension(bv).descent() : 0;
 }
 
 
@@ -293,35 +295,48 @@ int InsetMathScript::nker() const
 
 void InsetMathScript::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       cell(0).metrics(mi);
+       Dimension dim0;
+       Dimension dim1;
+       Dimension dim2;
+       cell(0).metrics(mi, dim0);
        ScriptChanger dummy(mi.base);
        if (nargs() > 1)
-               cell(1).metrics(mi);
+               cell(1).metrics(mi, dim1);
        if (nargs() > 2)
-               cell(2).metrics(mi);
+               cell(2).metrics(mi, dim2);
+
        dim.wid = 0;
+       BufferView & bv = *mi.base.bv;
+       // FIXME: data copying... not very efficient.
+       Dimension dimup;
+       Dimension dimdown;
+       if (hasUp())
+               dimup = up().dimension(bv);
+       if (hasDown())
+               dimdown = down().dimension(bv);
+
        if (hasLimits()) {
-               dim.wid = nwid();
+               dim.wid = nwid(bv);
                if (hasUp())
-                       dim.wid = max(dim.wid, up().width());
+                       dim.wid = max(dim.wid, dimup.width());
                if (hasDown())
-                       dim.wid = max(dim.wid, down().width());
+                       dim.wid = max(dim.wid, dimdown.width());
        } else {
                if (hasUp())
-                       dim.wid = max(dim.wid, nker() + up().width());
+                       dim.wid = max(dim.wid, nker() + dimup.width());
                if (hasDown())
-                       dim.wid = max(dim.wid, down().width());
-               dim.wid += nwid();
+                       dim.wid = max(dim.wid, dimdown.width());
+               dim.wid += nwid(bv);
        }
-       int na = nasc();
+       int na = nasc(bv);
        if (hasUp()) {
-               int asc = dy1() + up().ascent();
+               int asc = dy1(bv) + dimup.ascent();
                dim.asc = max(na, asc);
        } else
                dim.asc = na;
-       int nd = ndes();
+       int nd = ndes(bv);
        if (hasDown()) {
-               int des = dy0() + down().descent();
+               int des = dy0(bv) + dimdown.descent();
                dim.des = max(nd, des);
        } else
                dim.des = nd;
@@ -333,18 +348,19 @@ void InsetMathScript::metrics(MetricsInfo & mi, Dimension & dim) const
 
 void InsetMathScript::draw(PainterInfo & pi, int x, int y) const
 {
+       BufferView & bv = *pi.base.bv;
        if (nuc().size())
-               nuc().draw(pi, x + dxx(*pi.base.bv), y);
+               nuc().draw(pi, x + dxx(bv), y);
        else {
-               nuc().setXY(*pi.base.bv, x + dxx(*pi.base.bv), y);
-               if (editing(pi.base.bv))
-                       pi.draw(x + dxx(*pi.base.bv), y, char_type('.'));
+               nuc().setXY(bv, x + dxx(bv), y);
+               if (editing(&bv))
+                       pi.draw(x + dxx(bv), y, char_type('.'));
        }
        ScriptChanger dummy(pi.base);
        if (hasUp())
-               up().draw(pi, x + dx1(*pi.base.bv), y - dy1());
+               up().draw(pi, x + dx1(bv), y - dy1(bv));
        if (hasDown())
-               down().draw(pi, x + dx0(*pi.base.bv), y + dy0());
+               down().draw(pi, x + dx0(bv), y + dy0(bv));
        drawMarkers(pi, x, y);
 }
 
@@ -361,12 +377,13 @@ void InsetMathScript::metricsT(TextMetricsInfo const & mi, Dimension & dim) cons
 
 void InsetMathScript::drawT(TextPainter & pain, int x, int y) const
 {
+       // FIXME: BROKEN
        if (nuc().size())
                nuc().drawT(pain, x + 1, y);
        if (hasUp())
-               up().drawT(pain, x + 1, y - dy1());
+               up().drawT(pain, x + 1, y - 1 /*dy1()*/);
        if (hasDown())
-               down().drawT(pain, x + 1, y + dy0());
+               down().drawT(pain, x + 1, y + 1 /*dy0()*/);
 }
 
 

diff --git a/src/mathed/InsetMathScript.h b/src/mathed/InsetMathScript.h
index e705ea6ebfbd5f6a01e689c2d07fc089592246dc..68a4572d7365df6f604c91bc6d0b25c7427246b0 100644 (file)
--- a/src/mathed/InsetMathScript.h
+++ b/src/mathed/InsetMathScript.h
@@ -109,21 +109,21 @@ private:
        /// returns x offset for main part
        int dxx(BufferView const & bv) const;
        /// returns width of nucleus if any
-       int nwid() const;
+       int nwid(BufferView const &) const;
        /// returns y offset for either superscript or subscript
-       int dy01(int asc, int des, int what) const;
+       int dy01(BufferView const &, int asc, int des, int what) const;
        /// returns y offset for superscript
-       int dy0() const;
+       int dy0(BufferView const &) const;
        /// returns y offset for subscript
-       int dy1() const;
+       int dy1(BufferView const &) const;
        /// returns x offset for superscript
        int dx0(BufferView const & bv) const;
        /// returns x offset for subscript
        int dx1(BufferView const & bv) const;
        /// returns ascent of nucleus if any
-       int nasc() const;
+       int nasc(BufferView const &) const;
        /// returns descent of nucleus if any
-       int ndes() const;
+       int ndes(BufferView const &) const;
        /// returns superscript kerning of nucleus if any
        int nker() const;
        /// where do we have to draw the scripts?

diff --git a/src/mathed/InsetMathSqrt.cpp b/src/mathed/InsetMathSqrt.cpp
index 2528b265322b9a2b25ea9580b75fa736b111b679..eaf207f71be5c93ef2e0cf5ecf64ee9acaa48e7a 100644 (file)
--- a/src/mathed/InsetMathSqrt.cpp
+++ b/src/mathed/InsetMathSqrt.cpp
@@ -71,10 +71,13 @@ void InsetMathSqrt::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
 
 void InsetMathSqrt::drawT(TextPainter & pain, int x, int y) const
 {
+       /*
        cell(0).drawT(pain, x + 2, y);
-       pain.horizontalLine(x + 2, y - cell(0).ascent(), cell(0).width(), '_');
-       pain.verticalLine  (x + 1, y - cell(0).ascent() + 1, cell(0).height());
-       pain.draw(x, y + cell(0).descent(), '\\');
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       pain.horizontalLine(x + 2, y - dim0.ascent(), dim0.width(), '_');
+       pain.verticalLine  (x + 1, y - dim0.ascent() + 1, dim0.height());
+       pain.draw(x, y + dim0.descent(), '\\');
+       */
 }
 
 

diff --git a/src/mathed/InsetMathStackrel.cpp b/src/mathed/InsetMathStackrel.cpp
index 953b62ba41c2b0a016fa1c740d10cb71dc5ad771..0655f39b5d17a8d323e7ad68e8e105d23f3fbb98 100644 (file)
--- a/src/mathed/InsetMathStackrel.cpp
+++ b/src/mathed/InsetMathStackrel.cpp
@@ -29,12 +29,14 @@ Inset * InsetMathStackrel::clone() const
 
 void InsetMathStackrel::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       cell(1).metrics(mi);
+       Dimension dim1;
+       cell(1).metrics(mi, dim1);
        FracChanger dummy(mi.base);
-       cell(0).metrics(mi);
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 4;
-       dim.asc = cell(1).ascent() + cell(0).height() + 4;
-       dim.des = cell(1).descent();
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
+       dim.wid = std::max(dim0.width(), dim1.width()) + 4;
+       dim.asc = dim1.ascent() + dim0.height() + 4;
+       dim.des = dim1.descent();
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -44,11 +46,13 @@ void InsetMathStackrel::metrics(MetricsInfo & mi, Dimension & dim) const
 void InsetMathStackrel::draw(PainterInfo & pi, int x, int y) const
 {
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
        int m  = x + dim.width() / 2;
-       int yo = y - cell(1).ascent() - cell(0).descent() - 1;
-       cell(1).draw(pi, m - cell(1).width() / 2, y);
+       int yo = y - dim1.ascent() - dim0.descent() - 1;
+       cell(1).draw(pi, m - dim1.width() / 2, y);
        FracChanger dummy(pi.base);
-       cell(0).draw(pi, m - cell(0).width() / 2, yo);
+       cell(0).draw(pi, m - dim0.width() / 2, yo);
        drawMarkers(pi, x, y);
 }
 

diff --git a/src/mathed/InsetMathTFrac.cpp b/src/mathed/InsetMathTFrac.cpp
index c375e68020506a09b4c882a26454ab988f6448ca..ee6085434ca3062f114e1271c37709d71a23780d 100644 (file)
--- a/src/mathed/InsetMathTFrac.cpp
+++ b/src/mathed/InsetMathTFrac.cpp
@@ -37,11 +37,13 @@ Inset * InsetMathTFrac::clone() const
 void InsetMathTFrac::metrics(MetricsInfo & mi, Dimension & dim) const
 {
        StyleChanger dummy(mi.base, LM_ST_SCRIPT);
-       cell(0).metrics(mi);
-       cell(1).metrics(mi);
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 2;
-       dim.asc = cell(0).height() + 2 + 5;
-       dim.des = cell(1).height() + 2 - 5;
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
+       Dimension dim1;
+       cell(1).metrics(mi, dim1);
+       dim.wid = std::max(dim0.width(), dim1.width()) + 2;
+       dim.asc = dim0.height() + 2 + 5;
+       dim.des = dim1.height() + 2 - 5;
        // Cache the inset dimension. 
        setDimCache(mi, dim);
 }
@@ -51,9 +53,11 @@ void InsetMathTFrac::draw(PainterInfo & pi, int x, int y) const
 {
        StyleChanger dummy(pi.base, LM_ST_SCRIPT);
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
        int m = x + dim.wid / 2;
-       cell(0).draw(pi, m - cell(0).width() / 2, y - cell(0).descent() - 2 - 5);
-       cell(1).draw(pi, m - cell(1).width() / 2, y + cell(1).ascent()  + 2 - 5);
+       cell(0).draw(pi, m - dim0.width() / 2, y - dim0.descent() - 2 - 5);
+       cell(1).draw(pi, m - dim1.width() / 2, y + dim1.ascent()  + 2 - 5);
        pi.pain.line(x + 1, y - 5, x + dim.wid - 2, y - 5, Color::math);
        setPosCache(pi, x, y);
 }

diff --git a/src/mathed/InsetMathUnderset.cpp b/src/mathed/InsetMathUnderset.cpp
index f213b80cb04f60f2e6af87bac53485505ef70f7f..7fd57abee36492cd206e283cb4fc225bc2adab79 100644 (file)
--- a/src/mathed/InsetMathUnderset.cpp
+++ b/src/mathed/InsetMathUnderset.cpp
@@ -28,12 +28,14 @@ Inset * InsetMathUnderset::clone() const
 
 void InsetMathUnderset::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       cell(1).metrics(mi);
+       Dimension dim1;
+       cell(1).metrics(mi, dim1);
        FracChanger dummy(mi.base);
-       cell(0).metrics(mi);
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 4;
-       dim.asc = cell(1).ascent();
-       dim.des = cell(1).descent() + cell(0).height() + 4;
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
+       dim.wid = std::max(dim0.width(), dim1.width()) + 4;
+       dim.asc = dim1.ascent();
+       dim.des = dim1.descent() + dim0.height() + 4;
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -43,11 +45,13 @@ void InsetMathUnderset::metrics(MetricsInfo & mi, Dimension & dim) const
 void InsetMathUnderset::draw(PainterInfo & pi, int x, int y) const
 {
        Dimension const dim = dimension(*pi.base.bv);
+       Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
        int m  = x + dim.wid / 2;
-       int yo = y + cell(1).descent() + cell(0).ascent() + 1;
-       cell(1).draw(pi, m - cell(1).width() / 2, y);
+       int yo = y + dim1.descent() + dim0.ascent() + 1;
+       cell(1).draw(pi, m - dim1.width() / 2, y);
        FracChanger dummy(pi.base);
-       cell(0).draw(pi, m - cell(0).width() / 2, yo);
+       cell(0).draw(pi, m - dim0.width() / 2, yo);
        drawMarkers(pi, x, y);
 }
 

diff --git a/src/mathed/InsetMathXArrow.cpp b/src/mathed/InsetMathXArrow.cpp
index 886c8a6e7fde57ebf991edc7be19767201ab8dc4..a2aef402d28beb7e7fa7db60c370041985059ed9 100644 (file)
--- a/src/mathed/InsetMathXArrow.cpp
+++ b/src/mathed/InsetMathXArrow.cpp
@@ -36,11 +36,13 @@ Inset * InsetMathXArrow::clone() const
 void InsetMathXArrow::metrics(MetricsInfo & mi, Dimension & dim) const
 {
        ScriptChanger dummy(mi.base);
-       cell(0).metrics(mi);
-       cell(1).metrics(mi);
-       dim.wid = std::max(cell(0).width(), cell(1).width()) + 10;
-       dim.asc = cell(0).height() + 10;
-       dim.des = cell(1).height();
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
+       Dimension dim1;
+       cell(1).metrics(mi, dim1);
+       dim.wid = std::max(dim0.width(), dim1.width()) + 10;
+       dim.asc = dim0.height() + 10;
+       dim.des = dim1.height();
        metricsMarkers(dim);
        // Cache the inset dimension. 
        setDimCache(mi, dim);
@@ -51,7 +53,8 @@ void InsetMathXArrow::draw(PainterInfo & pi, int x, int y) const
 {
        ScriptChanger dummy(pi.base);
        cell(0).draw(pi, x + 5, y - 10);
-       cell(1).draw(pi, x + 5, y + cell(1).height());
+       Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
+       cell(1).draw(pi, x + 5, y + dim1.height());
        Dimension const dim = dimension(*pi.base.bv);
        mathed_draw_deco(pi, x + 1, y - 7, dim.wid - 2, 5, name_);
        drawMarkers(pi, x, y);

diff --git a/src/mathed/InsetMathXYArrow.cpp b/src/mathed/InsetMathXYArrow.cpp
index 884e78423bb9153659be15f8a06c1bfac944ea05..38841b9577a18cc895a0c033f5180d315cf7d14e 100644 (file)
--- a/src/mathed/InsetMathXYArrow.cpp
+++ b/src/mathed/InsetMathXYArrow.cpp
@@ -91,9 +91,9 @@ bool InsetMathXYArrow::metrics(MetricsInfo & mi) const
 
        if (editing()) {
                int w    = mathed_string_width(mi.base.font, from_ascii("target: "));
-               width_   = w + max(cell(0).width(), cell(1).width());
-               ascent_  = cell(0).ascent();
-               descent_ = cell(0).descent() + cell(1).height() + 10;
+               width_   = w + max(dim0.width(), dim1.wid);
+               ascent_  = dim0.asc;
+               descent_ = dim0.des + dim1.height() + 10;
        } else {
                width_   = 0;
                ascent_  = 0;
@@ -120,9 +120,9 @@ void InsetMathXYArrow::draw(PainterInfo & pi, int x, int y) const
 
                cell(0).draw(pi, x + lwid, y);
                pi.base.text(x + 3, y, "target");
-               y += max(cell(0).descent(), ldes) + 5;
+               y += max(dim0.des, ldes) + 5;
 
-               y += max(cell(1).ascent(), lasc) + 5;
+               y += max(dim1.asc, lasc) + 5;
                cell(1).draw(pi, x + lwid, y);
                pi.base.text(x + 3, y, "label");
 

diff --git a/src/mathed/MathData.cpp b/src/mathed/MathData.cpp
index b256e81d8eb91543142ac8f40504b57d559dc13b..a841d1ad9839319535753090817b1835578037b3 100644 (file)
--- a/src/mathed/MathData.cpp
+++ b/src/mathed/MathData.cpp
@@ -210,13 +210,6 @@ void MathData::touch() const
 }
 
 
-void MathData::metrics(MetricsInfo & mi, Dimension & dim) const
-{
-       metrics(mi);
-       dim = dim_;
-}
-
-
 namespace {
 
 bool isInside(DocIterator const & it, MathData const & ar,
@@ -234,13 +227,13 @@ bool isInside(DocIterator const & it, MathData const & ar,
 
 
 
-void MathData::metrics(MetricsInfo & mi) const
+void MathData::metrics(MetricsInfo & mi, Dimension & dim) const
 {
        frontend::FontMetrics const & fm = theFontMetrics(mi.base.font);
-       dim_ = fm.dimension('I');
+       dim = fm.dimension('I');
        int xascent = fm.dimension('x').ascent();
-       if (xascent >= dim_.asc)
-               xascent = (2 * dim_.asc) / 3;
+       if (xascent >= dim.asc)
+               xascent = (2 * dim.asc) / 3;
        minasc_ = xascent;
        mindes_ = (3 * xascent) / 4;
        slevel_ = (4 * xascent) / 5;
@@ -250,8 +243,8 @@ void MathData::metrics(MetricsInfo & mi) const
        if (empty())
                return;
 
-       dim_.asc = 0;
-       dim_.wid = 0;
+       dim.asc = 0;
+       dim.wid = 0;
        Dimension d;
        atom_dims_.clear();
        //BufferView & bv  = *mi.base.bv;
@@ -273,7 +266,7 @@ void MathData::metrics(MetricsInfo & mi) const
                                tmpl.expand(args, exp);
                                mac->setExpansion(exp, args);
                                mac->metricsExpanded(mi, d);
-                               dim_.wid += mac->widthExpanded();
+                               dim.wid += mac->widthExpanded();
                                i += numargs;
                                continue;
                        }
@@ -281,10 +274,12 @@ void MathData::metrics(MetricsInfo & mi) const
 #endif
                at->metrics(mi, d);
                atom_dims_.push_back(d);
-               dim_ += d;
+               dim += d;
                if (i == n - 1)
                        kerning_ = at->kerning();
        }
+       // Cache the dimension.
+       mi.base.bv->coordCache().arrays().add(this, dim);
 }
 
 
@@ -294,15 +289,17 @@ void MathData::draw(PainterInfo & pi, int x, int y) const
        BufferView & bv  = *pi.base.bv;
        setXY(bv, x, y);
 
+       Dimension const & dim = bv.coordCache().getArrays().dim(this);
+
        if (empty()) {
-               pi.pain.rectangle(x, y - ascent(), width(), height(), Color::mathline);
+               pi.pain.rectangle(x, y - dim.ascent(), dim.width(), dim.height(), Color::mathline);
                return;
        }
 
        // don't draw outside the workarea
-       if (y + descent() <= 0
-               || y - ascent() >= bv.workHeight()
-               || x + width() <= 0
+       if (y + dim.descent() <= 0
+               || y - dim.ascent() >= bv.workHeight()
+               || x + dim.width() <= 0
                || x >= bv. workWidth())
                return;
 
@@ -422,30 +419,41 @@ MathData::size_type MathData::x2pos(int targetx, int glue) const
 
 int MathData::dist(BufferView const & bv, int x, int y) const
 {
-       int xx = 0;
-       int yy = 0;
+       return bv.coordCache().getArrays().squareDistance(this, x, y);
+}
 
-       const int xo_ = xo(bv);
-       const int yo_ = yo(bv);
 
-       if (x < xo_)
-               xx = xo_ - x;
-       else if (x > xo_ + width())
-               xx = x - xo_ - width();
+void MathData::setXY(BufferView & bv, int x, int y) const
+{
+       //lyxerr << "setting position cache for MathData " << this << std::endl;
+       bv.coordCache().arrays().add(this, x, y);
+}
 
-       if (y < yo_ - ascent())
-               yy = yo_ - ascent() - y;
-       else if (y > yo_ + descent())
-               yy = y - yo_ - descent();
 
-       return xx + yy;
+Dimension const & MathData::dimension(BufferView const & bv) const
+{
+       if (empty()) {
+               static Dimension dummy;
+               return dummy;
+       }
+
+       return bv.coordCache().getArrays().dim(this);
 }
 
 
-void MathData::setXY(BufferView & bv, int x, int y) const
+int MathData::xm(BufferView const & bv) const
 {
-       //lyxerr << "setting position cache for MathData " << this << std::endl;
-       bv.coordCache().arrays().add(this, x, y);
+       Geometry const & g = bv.coordCache().getArrays().geometry(this);
+
+       return g.pos.x_ + g.dim.wid / 2;
+}
+
+
+int MathData::ym(BufferView const & bv) const
+{
+       Geometry const & g = bv.coordCache().getArrays().geometry(this);
+
+       return g.pos.y_ + (g.dim.des - g.dim.asc) / 2;
 }
 
 

diff --git a/src/mathed/MathData.h b/src/mathed/MathData.h
index db29ec9bad0cf92ba3e14e717fe2dfcb2add65ba..7983cf65a3788240b4dc7efdcb6e58ab5f753bd7 100644 (file)
--- a/src/mathed/MathData.h
+++ b/src/mathed/MathData.h
@@ -103,11 +103,9 @@ public:
        /// checked read access
        MathAtom const & operator[](pos_type) const;
        /// rebuild cached metrics information
-       void metrics(MetricsInfo & mi) const;
-       /// rebuild cached metrics information
        void metrics(MetricsInfo & mi, Dimension & dim) const;
        ///
-       Dimension const & dimension(BufferView const &) const { return dim_; };
+       Dimension const & dimension(BufferView const &) const;
 
        /// redraw cell using cache metrics information
        void draw(PainterInfo & pi, int x, int y) const;
@@ -123,9 +121,9 @@ public:
        /// access to cached y coordinate of last drawing
        int yo(BufferView const & bv) const;
        /// access to cached x coordinate of mid point of last drawing
-       int xm(BufferView const & bv) const { return xo(bv) + dim_.wid / 2; }
+       int xm(BufferView const & bv) const;
        /// access to cached y coordinate of mid point of last drawing
-       int ym(BufferView const & bv) const { return yo(bv) + (dim_.des - dim_.asc) / 2; }
+       int ym(BufferView const & bv) const;
        /// write access to coordinate;
        void setXY(BufferView & bv, int x, int y) const;
        /// returns x coordinate of given position in the array
@@ -140,18 +138,6 @@ public:
        // assumes valid position and size cache
        int dist(BufferView const & bv, int x, int y) const;
 
-       /// ascent of this cell above the baseline
-       int ascent() const { return dim_.asc; }
-       /// descent of this cell below the baseline
-       int descent() const { return dim_.des; }
-       /// height of the cell
-       int height() const { return dim_.asc + dim_.des; }
-       /// width of this cell
-       int width() const { return dim_.wid; }
-       /// dimensions of cell
-       Dimension const & dim() const { return dim_; }
-       /// dimensions of cell
-       void setDim(Dimension const & d) const { dim_ = d; }
        /// minimum ascent offset for superscript
        int minasc() const { return minasc_; }
        /// minimum descent offset for subscript
@@ -166,8 +152,6 @@ public:
        void swap(MathData & ar) { base_type::swap(ar); }
 
 protected:
-       /// cached dimensions of cell
-       mutable Dimension dim_;
        /// cached values for super/subscript placement
        mutable int minasc_;
        mutable int mindes_;

diff --git a/src/mathed/MathMacro.cpp b/src/mathed/MathMacro.cpp
index 8711cc6999291ab14efea97ec98697438d88e278..d11e2a8f09544316f187e8c7083ce0f009aca1d7 100644 (file)
--- a/src/mathed/MathMacro.cpp
+++ b/src/mathed/MathMacro.cpp
@@ -129,9 +129,10 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const
                        int ww = mathed_string_width(font, from_ascii("#1: "));
                        for (idx_type i = 0; i < nargs(); ++i) {
                                MathData const & c = cell(i);
-                               c.metrics(mi);
-                               dim.wid  = max(dim.wid, c.width() + ww);
-                               dim.des += c.height() + 10;
+                               Dimension dimc;
+                               c.metrics(mi, dimc);
+                               dim.wid  = max(dim.wid, dimc.width() + ww);
+                               dim.des += dimc.height() + 10;
                        }
                        editing_ = true;
                } else {
@@ -166,22 +167,24 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const
                        Font font = pi.base.font;
                        augmentFont(font, from_ascii("lyxtex"));
                        Dimension const dim = dimension(*pi.base.bv);
-                       int h = y - dim.ascent() + 2 + tmpl_.ascent();
+                       Dimension const & dim_tmpl = tmpl_.dimension(*pi.base.bv);
+                       int h = y - dim.ascent() + 2 + dim_tmpl.ascent();
                        pi.pain.text(x + 3, h, name(), font);
                        int const w = mathed_string_width(font, name());
                        tmpl_.draw(pi, x + w + 12, h);
-                       h += tmpl_.descent();
+                       h += dim_tmpl.descent();
                        Dimension ldim;
                        docstring t = from_ascii("#1: ");
                        mathed_string_dim(font, t, ldim);
                        for (idx_type i = 0; i < nargs(); ++i) {
                                MathData const & c = cell(i);
-                               h += max(c.ascent(), ldim.asc) + 5;
+                               Dimension const & dimc = c.dimension(*pi.base.bv);
+                               h += max(dimc.ascent(), ldim.asc) + 5;
                                c.draw(pi, x + ldim.wid, h);
                                char_type str[] = { '#', '1', ':', '\0' };
                                str[1] += static_cast<char_type>(i);
                                pi.pain.text(x + 3, h, str, font);
-                               h += max(c.descent(), ldim.des) + 5;
+                               h += max(dimc.descent(), ldim.des) + 5;
                        }
                } else {
                        macro.lock();

diff --git a/src/mathed/MathMacroTemplate.cpp b/src/mathed/MathMacroTemplate.cpp
index 923276fabc0221b11c8281e66462e292a493a4a1..490333bf2ae5433199055290a9002f7d3ed160d9 100644 (file)
--- a/src/mathed/MathMacroTemplate.cpp
+++ b/src/mathed/MathMacroTemplate.cpp
@@ -115,13 +115,15 @@ void MathMacroTemplate::metrics(MetricsInfo & mi, Dimension & dim) const
        if (lockMacro)
                MacroTable::globalMacros().get(name_).lock();
 
-       cell(0).metrics(mi);
-       cell(1).metrics(mi);
+       Dimension dim0;
+       cell(0).metrics(mi, dim0);
+       Dimension dim1;
+       cell(1).metrics(mi, dim1);
        docstring dp = prefix();
-       dim.wid = cell(0).width() + cell(1).width() + 20
+       dim.wid = dim0.width() + dim1.width() + 20
                + theFontMetrics(mi.base.font).width(dp);
-       dim.asc = std::max(cell(0).ascent(),  cell(1).ascent())  + 7;
-       dim.des = std::max(cell(0).descent(), cell(1).descent()) + 7;
+       dim.asc = std::max(dim0.ascent(),  dim1.ascent())  + 7;
+       dim.des = std::max(dim0.descent(), dim1.descent()) + 7;
 
        if (lockMacro)
                MacroTable::globalMacros().get(name_).unlock();
@@ -169,8 +171,8 @@ void MathMacroTemplate::draw(PainterInfo & p, int x, int y) const
        // FIXME: Painter text should retain the drawn text width
        x += theFontMetrics(font).width(dp) + 6;
 
-       int const w0 = cell(0).width();
-       int const w1 = cell(1).width();
+       int const w0 = cell(0).dimension(*pi.base.bv).width();
+       int const w1 = cell(1).dimension(*pi.base.bv).width();
        cell(0).draw(pi, x + 2, y + 1);
        pi.pain.rectangle(x, y - dim.ascent() + 3,
                w0 + 4, dim.height() - 6, Color::mathline);