Removed unused private variable

[lyx.git] / src / mathed / InsetMathChar.cpp

diff --git a/src/mathed/InsetMathChar.cpp b/src/mathed/InsetMathChar.cpp
index 1669515b66dcfbe9126634bfde75c7f57b6ed08e..1137c95e75a8b0e709f91169b52465978ccc837d 100644 (file)
--- a/src/mathed/InsetMathChar.cpp
+++ b/src/mathed/InsetMathChar.cpp
@@ -29,6 +29,10 @@
 #include "support/lstrings.h"
 #include "support/textutils.h"
 
+#include <algorithm>
+
+using namespace std;
+
 
 namespace lyx {
 
@@ -36,7 +40,6 @@ extern bool has_math_fonts;
 
 
 namespace {
-
 latexkeys const * makeSubstitute(char_type c)
 {
        std::string name;
@@ -106,20 +109,38 @@ Inset * InsetMathChar::clone() const
 
 void InsetMathChar::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-       bool const mathfont = isMathFont(mi.base.fontname);
-       if (mathfont && subst_) {
+       string const & f = mi.base.fontname;
+       if (isMathFont(f) && subst_) {
                // If the char has a substitute, draw the replacement symbol
                // instead, but only in math mode.
-               mathedSymbolDim(mi, dim, subst_);
+               mathedSymbolDim(mi.base, dim, subst_);
                kerning_ = mathed_char_kerning(mi.base.font, *subst_->draw.rbegin());
                return;
-       } else if (!slanted(char_) && mi.base.fontname == "mathnormal") {
+       } else if (!slanted(char_) && f == "mathnormal") {
                Changer dummy = mi.base.font.changeShape(UP_SHAPE);
                dim = theFontMetrics(mi.base.font).dimension(char_);
+               kerning_ = 0;
        } else {
                frontend::FontMetrics const & fm = theFontMetrics(mi.base.font);
                dim = fm.dimension(char_);
-               kerning_ = fm.rbearing(char_) - dim.wid;
+               kerning_ = mathed_char_kerning(mi.base.font, char_);
+               // cmmi has almost no left bearing: simulate this
+               if (f == "mathnormal") {
+                       dim.wid += max(-fm.lbearing(char_), 0);
+               }
+               // Rule 17 from Appendix G
+               // These are the fonts with fontdimen(2)==0.
+               // To properly handle the case fontdimen(2)!=0 (that is for all other
+               // math fonts), where the italic correction must also be converted into
+               // kerning but only at the end of strings of characters with the same
+               // font, one would need a more elaborate implementation in MathRow. For
+               // now the case fontdimen(2)==0 is the most important.
+               if (f == "mathnormal" || f == "mathscr" || f == "mathcal") {
+                       dim.wid += kerning_;
+                       // We use a negative value to tell InsetMathScript to move the
+                       // subscript leftwards instead of the superscript rightwards
+                       kerning_ = -kerning_;
+               }
        }
 }
 
@@ -139,6 +160,10 @@ void InsetMathChar::draw(PainterInfo & pi, int x, int y) const
                        return;
                }
        }
+       // cmmi has almost no left bearing: simulate this
+       if (pi.base.fontname == "mathnormal") {
+               x += max(-theFontMetrics(pi.base.font).lbearing(char_), 0);
+       }
        pi.draw(x, y, char_);
 }
 
@@ -187,8 +212,8 @@ void InsetMathChar::octave(OctaveStream & os) const
 
 // We have a bit of a problem here. MathML wants to know whether the
 // character represents an "identifier" or an "operator", and we have
-// no general way of telling. So we shall guess: If it's alpha or 
-// mathalpha, then we'll treat it as an identifier, otherwise as an 
+// no general way of telling. So we shall guess: If it's alpha or
+// mathalpha, then we'll treat it as an identifier, otherwise as an
 // operator.
 // Worst case: We get bad spacing, or bad italics.
 void InsetMathChar::mathmlize(MathStream & ms) const
@@ -204,11 +229,11 @@ void InsetMathChar::mathmlize(MathStream & ms) const
                }
                default: break;
        }
-       
+
        if (ms.inText()) {
                if (entity.empty())
                        ms.os().put(char_);
-               else 
+               else
                        ms << from_ascii(entity);
                return;
        }
@@ -216,13 +241,13 @@ void InsetMathChar::mathmlize(MathStream & ms) const
        if (!entity.empty()) {
                ms << "<mo>" << from_ascii(entity) << "</mo>";
                return;
-       }               
+       }
 
-       char const * type = 
+       char const * type =
                (isAlphaASCII(char_) || Encodings::isMathAlpha(char_))
                        ? "mi" : "mo";
        // we don't use MTag and ETag because we do not want the spacing
-       ms << "<" << type << ">" << char_type(char_) << "</" << type << ">";    
+       ms << "<" << type << ">" << char_type(char_) << "</" << type << ">";
 }
 
 
@@ -238,9 +263,9 @@ void InsetMathChar::htmlize(HtmlStream & ms) const
                case ' ': entity = "&nbsp;"; break;
                default: break;
        }
-       
+
        bool have_entity = !entity.empty();
-       
+
        if (ms.inText()) {
                if (have_entity)
                        ms << from_ascii(entity);
@@ -248,12 +273,12 @@ void InsetMathChar::htmlize(HtmlStream & ms) const
                        ms.os().put(char_);
                return;
        }
-       
+
        if (have_entity) {
                // an operator, so give some space
                ms << ' ' << from_ascii(entity) << ' ';
                return;
-       }               
+       }
 
        if (isAlphaASCII(char_) || Encodings::isMathAlpha(char_))
                // we don't use MTag and ETag because we do not want the spacing