Support for units and fractional units with values

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

diff --git a/lib/ui/stdtoolbars.inc b/lib/ui/stdtoolbars.inc
index f1fb9c2bbddf7446dc980b1cf5be20f487259156..0caab3fa1a5a61c591f71adf9e3028fb5e8e8098 100644 (file)
--- a/lib/ui/stdtoolbars.inc
+++ b/lib/ui/stdtoolbars.inc
@@ -274,7 +274,9 @@ ToolbarSet
                Item "Standard  \\frac" "math-insert \frac"
                Item "No hor. line      \\atop" "math-insert \atop"
                Item "Nice (3/4)        \\nicefrac" "math-insert \nicefrac"
+               Item "Unit (864 m)      \\unit" "math-insert \unit"
                Item "Units (km/h)      \\unitfrac" "math-insert \unitfrac"
+               Item "Units3 ( 20 km/h) \\unitfrac3" "math-insert \unitfracthree"
                Item "Text frac (amsmath)       \\tfrac" "math-insert \tfrac"
                Item "Display frac (amsmath)    \\dfrac" "math-insert \dfrac"
                Item "Binomial  \\choose"  "math-insert \choose"

diff --git a/src/mathed/InsetMathFrac.cpp b/src/mathed/InsetMathFrac.cpp
index 867b04d96a8c36c71dfe45d1e45f83db7355818c..59c0d58c594ec0783af10c693c9ba3440bd059dc 100644 (file)
--- a/src/mathed/InsetMathFrac.cpp
+++ b/src/mathed/InsetMathFrac.cpp
@@ -17,13 +17,14 @@
 #include "TextPainter.h"
 #include "LaTeXFeatures.h"
 #include "Color.h"
+#include "Cursor.h"
 #include "frontends/Painter.h"
 
 
 namespace lyx {
 
-InsetMathFrac::InsetMathFrac(Kind kind)
-       : kind_(kind)
+InsetMathFrac::InsetMathFrac(Kind kind, InsetMath::idx_type ncells)
+       : InsetMathFracBase(ncells), kind_(kind)
 {}
 
 
@@ -45,24 +46,76 @@ InsetMathFrac const * InsetMathFrac::asFracInset() const
 }
 
 
+bool InsetMathFrac::idxRight(Cursor & cur) const
+{
+       InsetMath::idx_type target;
+       if (kind_ == UNITFRAC3)
+               target = 0;
+       else if (kind_ == UNIT) 
+               target = 1;
+       else
+               return false;
+       if (cur.idx() == target)
+               return false;
+       cur.idx() = target;
+       cur.pos() = cell(target).x2pos(cur.x_target());
+       return true;
+}
+
+
+bool InsetMathFrac::idxLeft(Cursor & cur) const
+{
+       InsetMath::idx_type target;
+       if (kind_ == UNITFRAC3)
+               target = 2;
+       else if (kind_ == UNIT) 
+               target = 0;
+       else
+               return false;
+       if (cur.idx() == target)
+               return false;
+       cur.idx() = target;
+       cur.pos() = cell(target).x2pos(cur.x_target());
+       return true;
+}
+
+
 bool InsetMathFrac::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       FracChanger dummy(mi.base);
-       cell(0).metrics(mi);
-       cell(1).metrics(mi);
-       if (kind_ == NICEFRAC) {
-               dim.wid = cell(0).width() + cell(1).width() + 5;
-               dim.asc = cell(0).height() + 5;
-               dim.des = cell(1).height() - 5;
-       } else if (kind_ == UNITFRAC) {
+       if (kind_ == UNIT) {
+               cell(0).metrics(mi);
                ShapeChanger dummy2(mi.base.font, Font::UP_SHAPE);
+               cell(1).metrics(mi);
                dim.wid = cell(0).width() + cell(1).width() + 5;
-               dim.asc = cell(0).height() + 5;
-               dim.des = cell(1).height() - 5;
+               dim.asc = std::max(cell(0).ascent(), cell(1).ascent());
+               dim.des = std::max(cell(0).descent(), cell(1).descent());
+       } else if (kind_ == UNITFRAC3) {
+               cell(2).metrics(mi);
+               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);
        } 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;
+               FracChanger dummy(mi.base);
+               cell(0).metrics(mi);
+               cell(1).metrics(mi);
+               if (kind_ == NICEFRAC) {
+                       dim.wid = cell(0).width() + cell(1).width() + 5;
+                       dim.asc = cell(0).height() + 5;
+                       dim.des = cell(1).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;
+               } 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;
+               }
        }
        metricsMarkers(dim);
        if (dim_ == dim)
@@ -76,28 +129,48 @@ void InsetMathFrac::draw(PainterInfo & pi, int x, int y) const
 {
        setPosCache(pi, x, y);
        int m = x + dim_.wid / 2;
-       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);
-       } else if (kind_ == UNITFRAC) {
+       if (kind_ == UNIT) {
+               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);
+       } else if (kind_ == UNITFRAC3) {
+               cell(2).draw(pi, x + 1, y);
                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);
+               FracChanger dummy(pi.base);
+               int xx = x + cell(2).width() + 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);
        } else {
-               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);
+               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);
+               } 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);
+               } 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);
+               }
        }
-       if (kind_ == NICEFRAC || kind_ == UNITFRAC) {
-               pi.pain.line(x + cell(0).width(),
+       if (kind_ == NICEFRAC || kind_ == UNITFRAC || kind_ == UNITFRAC3) {
+               // Diag line:
+               int xx = x;
+               if (kind_ == UNITFRAC3)
+                       xx += cell(2).width() + 5;
+               pi.pain.line(xx + cell(0).width(),
                                y + dim_.des - 2,
-                               x + cell(0).width() + 5,
+                               xx + cell(0).width() + 5,
                                y - dim_.asc + 2, Color::math);
        }
        if (kind_ == FRAC || kind_ == OVER)
@@ -144,6 +217,12 @@ void InsetMathFrac::write(WriteStream & os) const
        case UNITFRAC:
                InsetMathNest::write(os);
                break;
+       case UNIT:
+               os << "\\unit[" << cell(0) << "]{" << cell(1) << '}';
+               break;
+       case UNITFRAC3:
+               os << "\\unitfrac[" << cell(2) << "]{" << cell(0) << "}{" << cell(1) << '}';
+               break;
        }
 }
 
@@ -159,6 +238,10 @@ docstring InsetMathFrac::name() const
                return from_ascii("nicefrac");
        case UNITFRAC:
                return from_ascii("unitfrac");
+       case UNITFRAC3:
+               return from_ascii("unitfracthree");
+       case UNIT:
+               return from_ascii("unit");
        case ATOP:
                return from_ascii("atop");
        }
@@ -199,7 +282,8 @@ void InsetMathFrac::mathmlize(MathStream & os) const
 
 void InsetMathFrac::validate(LaTeXFeatures & features) const
 {
-       if (kind_ == NICEFRAC || kind_ == UNITFRAC)
+       if (kind_ == NICEFRAC || kind_ == UNITFRAC 
+        || kind_ == UNIT || kind_ == UNITFRAC3)
                features.require("units");
        InsetMathNest::validate(features);
 }

diff --git a/src/mathed/InsetMathFrac.h b/src/mathed/InsetMathFrac.h
index 9b7a0ad3be6f8b781b637a609a299502ac1df3ee..6668654b7567b688dea22064d0f9e15cf36750f8 100644 (file)
--- a/src/mathed/InsetMathFrac.h
+++ b/src/mathed/InsetMathFrac.h
@@ -28,11 +28,17 @@ public:
                OVER,
                ATOP,
                NICEFRAC,
-               UNITFRAC
+               UNITFRAC,
+               UNIT,
+               UNITFRAC3
        };
 
        ///
-       explicit InsetMathFrac(Kind kind = FRAC);
+       explicit InsetMathFrac(Kind kind = FRAC, idx_type ncells = 2);
+       ///
+       bool idxRight(Cursor &) const;
+       ///
+       bool idxLeft(Cursor &) const;
        ///
        bool metrics(MetricsInfo & mi, Dimension & dim) const;
        ///

diff --git a/src/mathed/InsetMathFracBase.cpp b/src/mathed/InsetMathFracBase.cpp
index f76986a07c9db1a68d6d10f8ec5243849f85f573..1138d6561db4ad35b7ca58ccbce122bf4a6a0cbc 100644 (file)
--- a/src/mathed/InsetMathFracBase.cpp
+++ b/src/mathed/InsetMathFracBase.cpp
@@ -18,8 +18,8 @@
 namespace lyx {
 
 
-InsetMathFracBase::InsetMathFracBase()
-       : InsetMathNest(2)
+InsetMathFracBase::InsetMathFracBase(idx_type ncells)
+       : InsetMathNest(ncells)
 {}
 
 

diff --git a/src/mathed/InsetMathFracBase.h b/src/mathed/InsetMathFracBase.h
index 1dae634a4040bad2fb5b9bd5d04a9ebac0028511..88236a0b2633b4cd7675afe8d36c8f3cea3e0018 100644 (file)
--- a/src/mathed/InsetMathFracBase.h
+++ b/src/mathed/InsetMathFracBase.h
@@ -21,7 +21,7 @@ namespace lyx {
 class InsetMathFracBase : public InsetMathNest {
 public:
        ///
-       InsetMathFracBase();
+       explicit InsetMathFracBase(idx_type ncells = 2);
        ///
        bool idxUpDown(Cursor &, bool up) const;
        ///

diff --git a/src/mathed/MathFactory.cpp b/src/mathed/MathFactory.cpp
index 20af5fc592af4fe7327feeaccd70369ddc30cb4a..16801643d44cd3d147dc94f7b789de5c59e70582 100644 (file)
--- a/src/mathed/MathFactory.cpp
+++ b/src/mathed/MathFactory.cpp
@@ -260,7 +260,7 @@ MathAtom createInsetMath(char const * const s)
 
 MathAtom createInsetMath(docstring const & s)
 {
-       //lyxerr << "creating inset with name: '" << s << '\'' << endl;
+       //lyxerr << "creating inset with name: '" << to_utf8(s) << '\'' << endl;
        latexkeys const * l = in_word_set(s);
        if (l) {
                docstring const & inset = l->inset;
@@ -372,6 +372,10 @@ MathAtom createInsetMath(docstring const & s)
                return MathAtom(new InsetMathFrac(InsetMathFrac::NICEFRAC));
        if (s == "unitfrac")
                return MathAtom(new InsetMathFrac(InsetMathFrac::UNITFRAC));
+       if (s == "unitfracthree")
+               return MathAtom(new InsetMathFrac(InsetMathFrac::UNITFRAC3, 3));
+       if (s == "unit")
+               return MathAtom(new InsetMathFrac(InsetMathFrac::UNIT));
        //if (s == "infer")
        //      return MathAtom(new MathInferInset);
        if (s == "atop")