Le 17/12/2015 16:50, Guillaume Munch a écrit :
Le 14/12/2015 12:27, Jean-Marc Lasgouttes a écrit :
Le 14/12/2015 12:05, Guillaume Munch a écrit :
You're right, see now second patch attached. It's a fairly simple
change, only adding some information to Georg's displayColAlign(), in
addition to some mechanical refactoring and disabling of horizontal
alignment buttons which were wrongly enabled. See the new commit log.
Thanks for the patches. A couple remarks:
- in switches it would be better to avoid using default:. This way, when
adding a new hull type, we'll get a warning for each un-handled case and
we'll have to think about the right value.
I agree, and thanks for the information. I never know what I am allowed
to expect from c++ compilers, so I tend to imitate the style I find in
the LyX sources...
- if defaultColAlign and defaultColSpace are broken in some way, the
least we shell do is add a FIXME in the source. Deciding what to do with
them would be even better.
Yes: are these data used in output formats different from LaTeX (e.g.
LyXHTML)? Then we should add a FIXME. Otherwise they are useless and we
can remove them.
I concluded that defaultCol* were now superfluous (in addition to
broken), and there already are FIXMEs regarding the alignment in html,
so I removed them in the attached.
>From ddc5488d0a78b1a0a6fc7cced1bc621229b3f1da Mon Sep 17 00:00:00 2001
From: Guillaume Munch <g...@lyx.org>
Date: Mon, 14 Dec 2015 01:54:27 +0000
Subject: [PATCH 1/3] Sanitize InsetMathHull and add a check for mutability in
LFUN_MATH_MUTATE
The transformation is purely mechanical (apart for the addition of
isMutable()). Remove in particular all comparisons < and >= involving HullType.
Add a guard to make sure that mutate() only operates on types it has been
designed for. Then I figured I could use this new knowledge to give feedback
when math-mutate is not implemented via getStatus(). (To test this, insert a
regexp in Advanced Search & Replace and try to change it into a standard
equation via the contextual menu.)
---
src/mathed/InsetMath.h | 3 +-
src/mathed/InsetMathHull.cpp | 357 +++++++++++++++++++++++++++----------------
src/mathed/InsetMathHull.h | 2 +
3 files changed, 231 insertions(+), 131 deletions(-)
diff --git a/src/mathed/InsetMath.h b/src/mathed/InsetMath.h
index bd72863..deb6915 100644
--- a/src/mathed/InsetMath.h
+++ b/src/mathed/InsetMath.h
@@ -34,7 +34,8 @@ enum HullType {
hullFlAlign,
hullMultline,
hullGather,
- hullRegexp
+ hullRegexp,
+ hullUnknown
};
HullType hullType(docstring const & name);
diff --git a/src/mathed/InsetMathHull.cpp b/src/mathed/InsetMathHull.cpp
index 097a344..1fa9fbd 100644
--- a/src/mathed/InsetMathHull.cpp
+++ b/src/mathed/InsetMathHull.cpp
@@ -79,16 +79,18 @@ namespace {
int getCols(HullType type)
{
switch (type) {
- case hullEqnArray:
- return 3;
- case hullAlign:
- case hullFlAlign:
- case hullAlignAt:
- case hullXAlignAt:
- case hullXXAlignAt:
- return 2;
- default:
- return 1;
+ case hullEqnArray:
+ return 3;
+
+ case hullAlign:
+ case hullFlAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullXXAlignAt:
+ return 2;
+
+ default:
+ return 1;
}
}
@@ -128,28 +130,29 @@ HullType hullType(docstring const & s)
if (s == "flalign") return hullFlAlign;
if (s == "regexp") return hullRegexp;
lyxerr << "unknown hull type '" << to_utf8(s) << "'" << endl;
- return HullType(-1);
+ return hullUnknown;
}
docstring hullName(HullType type)
{
switch (type) {
- case hullNone: return from_ascii("none");
- case hullSimple: return from_ascii("simple");
- case hullEquation: return from_ascii("equation");
- case hullEqnArray: return from_ascii("eqnarray");
- case hullAlign: return from_ascii("align");
- case hullAlignAt: return from_ascii("alignat");
- case hullXAlignAt: return from_ascii("xalignat");
- case hullXXAlignAt: return from_ascii("xxalignat");
- case hullMultline: return from_ascii("multline");
- case hullGather: return from_ascii("gather");
- case hullFlAlign: return from_ascii("flalign");
- case hullRegexp: return from_ascii("regexp");
- default:
- lyxerr << "unknown hull type '" << type << "'" << endl;
- return from_ascii("none");
+ case hullNone: return from_ascii("none");
+ case hullSimple: return from_ascii("simple");
+ case hullEquation: return from_ascii("equation");
+ case hullEqnArray: return from_ascii("eqnarray");
+ case hullAlign: return from_ascii("align");
+ case hullAlignAt: return from_ascii("alignat");
+ case hullXAlignAt: return from_ascii("xalignat");
+ case hullXXAlignAt: return from_ascii("xxalignat");
+ case hullMultline: return from_ascii("multline");
+ case hullGather: return from_ascii("gather");
+ case hullFlAlign: return from_ascii("flalign");
+ case hullRegexp: return from_ascii("regexp");
+ case hullUnknown:
+ default:
+ lyxerr << "unknown hull type" << endl;
+ return from_ascii("unknown");
}
}
@@ -326,10 +329,15 @@ Inset * InsetMathHull::editXY(Cursor & cur, int x, int y)
InsetMath::mode_type InsetMathHull::currentMode() const
{
- if (type_ == hullNone)
+ switch (type_) {
+ case hullNone:
+ case hullUnknown:
return UNDECIDED_MODE;
+
// definitely math mode ...
- return MATH_MODE;
+ default:
+ return MATH_MODE;
+ }
}
@@ -351,15 +359,24 @@ bool InsetMathHull::idxLast(Cursor & cur) const
char InsetMathHull::defaultColAlign(col_type col)
{
- if (type_ == hullEqnArray)
+ switch (type_) {
+ case hullEqnArray:
return "rcl"[col];
- if (type_ == hullMultline)
+
+ case hullMultline:
+ case hullGather:
return 'c';
- if (type_ == hullGather)
- return 'c';
- if (type_ >= hullAlign)
+
+ case hullAlign:
+ case hullFlAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullXXAlignAt:
return "rl"[col & 1];
- return 'c';
+
+ default:
+ return 'c';
+ }
}
@@ -378,45 +395,48 @@ char InsetMathHull::displayColAlign(idx_type idx) const
int InsetMathHull::defaultColSpace(col_type col)
{
- if (type_ == hullAlign || type_ == hullAlignAt)
+ switch (type_) {
+ case hullAlign:
+ case hullAlignAt:
+ //FIXME: this should be wider
return 0;
- if (type_ == hullXAlignAt)
+
+ case hullXAlignAt:
return (col & 1) ? 20 : 0;
- if (type_ == hullXXAlignAt || type_ == hullFlAlign)
+
+ case hullXXAlignAt:
+ case hullFlAlign:
return (col & 1) ? 40 : 0;
- return 0;
+
+ default:
+ return 0;
+ }
}
docstring InsetMathHull::standardFont() const
{
- docstring font_name;
switch (type_) {
case hullRegexp:
- font_name = from_ascii("texttt");
- break;
+ return from_ascii("texttt");
case hullNone:
- font_name = from_ascii("lyxnochange");
- break;
+ return from_ascii("lyxnochange");
default:
- font_name = from_ascii("mathnormal");
+ return from_ascii("mathnormal");
}
- return font_name;
}
ColorCode InsetMathHull::standardColor() const
{
- ColorCode color;
switch (type_) {
case hullRegexp:
case hullNone:
- color = Color_foreground;
- break;
+ return Color_foreground;
+
default:
- color = Color_math;
+ return Color_math;
}
- return color;
}
@@ -840,20 +860,17 @@ bool InsetMathHull::numbered(row_type row) const
bool InsetMathHull::ams() const
{
switch (type_) {
- case hullAlign:
- case hullFlAlign:
- case hullMultline:
- case hullGather:
- case hullAlignAt:
- case hullXAlignAt:
- case hullXXAlignAt:
- return true;
- case hullNone:
- case hullSimple:
- case hullEquation:
- case hullEqnArray:
- case hullRegexp:
- break;
+ case hullAlign:
+ case hullFlAlign:
+ case hullMultline:
+ case hullGather:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullXXAlignAt:
+ return true;
+
+ default:
+ break;
}
for (size_t row = 0; row < numbered_.size(); ++row)
if (numbered_[row] == NOTAG)
@@ -864,25 +881,34 @@ bool InsetMathHull::ams() const
Inset::DisplayType InsetMathHull::display() const
{
- if (type_ == hullSimple || type_ == hullNone || type_ == hullRegexp)
+ switch (type_) {
+ case hullSimple:
+ case hullNone:
+ case hullRegexp:
+ case hullUnknown:
return Inline;
- return AlignCenter;
+
+ default:
+ return AlignCenter;
+ }
}
bool InsetMathHull::numberedType() const
{
- if (type_ == hullNone)
- return false;
- if (type_ == hullSimple)
- return false;
- if (type_ == hullXXAlignAt)
- return false;
- if (type_ == hullRegexp)
- return false;
- for (row_type row = 0; row < nrows(); ++row)
- if (numbered(row))
- return true;
- return false;
+ switch (type_) {
+ case hullNone:
+ case hullSimple:
+ case hullXXAlignAt:
+ case hullRegexp:
+ case hullUnknown:
+ return false;
+
+ default:
+ for (row_type row = 0; row < nrows(); ++row)
+ if (numbered(row))
+ return true;
+ return false;
+ }
}
@@ -977,7 +1003,7 @@ void InsetMathHull::header_write(WriteStream & os) const
os << "\\regexp{";
break;
- default:
+ case hullUnknown:
os << "\n";
os.startOuterRow();
os << "\\begin{unknown" << star(n) << "}\n";
@@ -1031,7 +1057,7 @@ void InsetMathHull::footer_write(WriteStream & os) const
os << "\\endregexp{}}";
break;
- default:
+ case hullUnknown:
os << "\n";
os.startOuterRow();
os << "\\end{unknown" << star(n) << "}\n";
@@ -1241,10 +1267,41 @@ void InsetMathHull::setType(HullType type)
}
+bool InsetMathHull::isMutable(HullType type)
+{
+ switch (type) {
+ case hullNone:
+ case hullSimple:
+ case hullEquation:
+ case hullEqnArray:
+ case hullAlign:
+ case hullFlAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullXXAlignAt:
+ case hullMultline:
+ case hullGather:
+ return true;
+ default:
+ return false;
+ }
+}
+
+
void InsetMathHull::mutate(HullType newtype)
{
//lyxerr << "mutating from '" << type_ << "' to '" << newtype << "'" << endl;
+ if (newtype == type_)
+ return;
+
+ // This guards the algorithm below it, which is designed with certain types
+ // in mind.
+ if (!isMutable(newtype) || !isMutable(type_))
+ lyxerr << "mutation from '" << to_utf8(hullName(type_))
+ << "' to '" << to_utf8(hullName(newtype))
+ << "' not implemented" << endl;
+
// we try to move along the chain
// none <-> simple <-> equation <-> eqnarray -> *align* -> multline, gather -+
// ^ |
@@ -1253,22 +1310,14 @@ void InsetMathHull::mutate(HullType newtype)
// directly supported because it handles labels and numbering for
// "down mutation".
- if (newtype == type_) {
- // done
- }
-
- else if (newtype < hullNone) {
- // unknown type
- dump();
- }
-
- else if (type_ == hullNone) {
+ switch (type_) {
+ case hullNone:
setType(hullSimple);
numbered(0, false);
mutate(newtype);
- }
+ break;
- else if (type_ == hullSimple) {
+ case hullSimple:
if (newtype == hullNone) {
setType(hullNone);
numbered(0, false);
@@ -1277,95 +1326,138 @@ void InsetMathHull::mutate(HullType newtype)
numbered(0, label_[0] ? true : false);
mutate(newtype);
}
- }
+ break;
- else if (type_ == hullEquation) {
- if (newtype < type_) {
+ case hullEquation:
+ switch (newtype) {
+ case hullNone:
+ case hullSimple:
setType(hullSimple);
numbered(0, false);
mutate(newtype);
- } else if (newtype == hullEqnArray) {
+ break;
+ case hullEqnArray:
// split it "nicely" on the first relop
splitTo3Cols();
setType(hullEqnArray);
- } else if (newtype == hullMultline || newtype == hullGather) {
+ break;
+ case hullMultline:
+ case hullGather:
setType(newtype);
- } else {
+ break;
+ default:
+ // *align*
// split it "nicely"
splitTo2Cols();
setType(hullAlign);
mutate(newtype);
+ break;
}
- }
+ break;
- else if (type_ == hullEqnArray) {
- if (newtype < type_) {
+ case hullEqnArray:
+ switch (newtype) {
+ case hullNone:
+ case hullSimple:
+ case hullEquation:
glueall(newtype);
mutate(newtype);
- } else { // align & Co.
+ break;
+ default:
+ // align & Co.
changeCols(2);
setType(hullAlign);
mutate(newtype);
+ break;
}
- }
+ break;
- else if (type_ == hullAlign || type_ == hullAlignAt ||
- type_ == hullXAlignAt || type_ == hullFlAlign) {
- if (newtype < hullAlign) {
+ case hullAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullFlAlign:
+ switch (newtype) {
+ case hullNone:
+ case hullSimple:
+ case hullEquation:
+ case hullEqnArray:
changeCols(3);
setType(hullEqnArray);
mutate(newtype);
- } else if (newtype == hullGather || newtype == hullMultline) {
+ break;
+ case hullGather:
+ case hullMultline:
changeCols(1);
setType(newtype);
- } else if (newtype == hullXXAlignAt) {
+ break;
+ case hullXXAlignAt:
for (row_type row = 0; row < nrows(); ++row)
numbered(row, false);
setType(newtype);
- } else {
+ break;
+ default:
setType(newtype);
+ break;
}
- }
+ break;
- else if (type_ == hullXXAlignAt) {
+ case hullXXAlignAt:
for (row_type row = 0; row < nrows(); ++row)
numbered(row, false);
- if (newtype < hullAlign) {
+ switch (newtype) {
+ case hullNone:
+ case hullSimple:
+ case hullEquation:
+ case hullEqnArray:
changeCols(3);
setType(hullEqnArray);
mutate(newtype);
- } else if (newtype == hullGather || newtype == hullMultline) {
+ break;
+ case hullGather:
+ case hullMultline:
changeCols(1);
setType(newtype);
- } else {
+ break;
+ default:
setType(newtype);
+ break;
}
- }
+ break;
- else if (type_ == hullMultline || type_ == hullGather) {
- if (newtype == hullGather || newtype == hullMultline)
+ case hullMultline:
+ case hullGather:
+ switch (newtype) {
+ case hullGather:
+ case hullMultline:
setType(newtype);
- else if (newtype == hullAlign || newtype == hullFlAlign ||
- newtype == hullAlignAt || newtype == hullXAlignAt) {
+ break;
+ case hullAlign:
+ case hullFlAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
splitTo2Cols();
setType(newtype);
- } else if (newtype == hullXXAlignAt) {
+ break;
+ case hullXXAlignAt:
splitTo2Cols();
for (row_type row = 0; row < nrows(); ++row)
numbered(row, false);
setType(newtype);
- } else {
+ break;
+ default:
+ // first we mutate to EqnArray
splitTo3Cols();
setType(hullEqnArray);
mutate(newtype);
+ break;
}
- }
+ break;
- else {
- lyxerr << "mutation from '" << to_utf8(hullName(type_))
- << "' to '" << to_utf8(hullName(newtype))
- << "' not implemented" << endl;
- }
+ default:
+ // we passed the guard so we should not be here
+ LASSERT("Mutation not implemented, but should have been.", return);
+ break;
+ }// switch
}
@@ -1443,7 +1535,12 @@ void InsetMathHull::doExtern(Cursor & cur, FuncRequest & func)
}
// only inline, display or eqnarray math is allowed
- if (getType() > hullEqnArray) {
+ switch (getType()) {
+ case hullSimple:
+ case hullEquation:
+ case hullEqnArray:
+ break;
+ default:
frontend::Alert::warning(_("Bad math environment"),
_("Computation cannot be performed for AMS "
"math environments.\nChange the math "
@@ -1733,9 +1830,9 @@ bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
case LFUN_MATH_MUTATE: {
HullType const ht = hullType(cmd.argument());
status.setOnOff(type_ == ht);
- status.setEnabled(true);
+ status.setEnabled(isMutable(ht) && isMutable(type_));
- if (ht != hullSimple) {
+ if (ht != hullSimple && status.enabled()) {
Cursor tmpcur = cur;
while (!tmpcur.empty()) {
InsetCode code = tmpcur.inset().lyxCode();
diff --git a/src/mathed/InsetMathHull.h b/src/mathed/InsetMathHull.h
index 9598ad4..462cac2 100644
--- a/src/mathed/InsetMathHull.h
+++ b/src/mathed/InsetMathHull.h
@@ -105,6 +105,8 @@ public:
/// get type
HullType getType() const;
+ /// is mutation implemented for this type?
+ static bool isMutable(HullType type);
/// change type
void mutate(HullType newtype);
--
2.1.4
>From 73e33f571d0c8c401202cada8ae9c4436bdbc87c Mon Sep 17 00:00:00 2001
From: Guillaume Munch <g...@lyx.org>
Date: Sun, 13 Dec 2015 03:32:32 +0000
Subject: [PATCH 2/3] Display the correct horizontal alignment in AMS
environments
A longstanding problem... (related: #1861)
The columns in AMS math environments have a fixed alignment (colAlign() in
InsetMathGrid.cpp). We set this alignment for display (Georg's
displayColAlign()) in InsetMathHull and InsetMathSplit. This is done according
to tests and documentation for the various environments.
There is also some mechanical code factoring via colAlign(). We also remove
defaultColAlign() because they were wrong and had no effect.
Finally, I disable setting the horizontal alignment in InsetMathSplit, which has
no impact on the LaTeX output, and has no longer any impact on the screen. (As
for vertical alignment I discovered that it was in fact customisable for
\aligned & friends! I hope that the more faithful interface will let other
users discover that too.)
---
src/mathed/InsetMathGrid.cpp | 25 +++++++++++++++++++++++++
src/mathed/InsetMathGrid.h | 5 +++--
src/mathed/InsetMathHull.cpp | 41 +++++++++++++++--------------------------
src/mathed/InsetMathHull.h | 2 --
src/mathed/InsetMathSplit.cpp | 23 +++++++++++++++--------
src/mathed/InsetMathSplit.h | 2 +-
6 files changed, 59 insertions(+), 39 deletions(-)
diff --git a/src/mathed/InsetMathGrid.cpp b/src/mathed/InsetMathGrid.cpp
index 8ea3940..6c5fbbf 100644
--- a/src/mathed/InsetMathGrid.cpp
+++ b/src/mathed/InsetMathGrid.cpp
@@ -1837,4 +1837,29 @@ bool InsetMathGrid::getStatus(Cursor & cur, FuncRequest const & cmd,
}
+// static
+char InsetMathGrid::colAlign(HullType type, col_type col)
+{
+ switch (type) {
+ case hullMultline:
+ case hullGather:
+ return 'c';
+
+ case hullEqnArray:
+ return "rcl"[col % 3];
+
+ case hullAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullXXAlignAt:
+ case hullFlAlign:
+ return "rl"[col & 1];
+
+ default:
+ return 'c';
+ }
+}
+
+
+
} // namespace lyx
diff --git a/src/mathed/InsetMathGrid.h b/src/mathed/InsetMathGrid.h
index bd3066d..709f492 100644
--- a/src/mathed/InsetMathGrid.h
+++ b/src/mathed/InsetMathGrid.h
@@ -258,10 +258,11 @@ protected:
virtual docstring eocString(col_type col, col_type lastcol) const;
/// splits cells and shifts right part to the next cell
void splitCell(Cursor & cur);
- /// Column aligmment for display of cell \p idx.
+ /// Column alignment for display of cell \p idx.
/// Must not be written to file!
virtual char displayColAlign(idx_type idx) const;
-
+ /// The value of a fixed col align for a certain hull type
+ static char colAlign(HullType type, col_type col);
/// row info.
/// rowinfo_[nrows()] is a dummy row used only for hlines.
diff --git a/src/mathed/InsetMathHull.cpp b/src/mathed/InsetMathHull.cpp
index 1fa9fbd..373af2e1 100644
--- a/src/mathed/InsetMathHull.cpp
+++ b/src/mathed/InsetMathHull.cpp
@@ -357,37 +357,27 @@ bool InsetMathHull::idxLast(Cursor & cur) const
}
-char InsetMathHull::defaultColAlign(col_type col)
-{
- switch (type_) {
- case hullEqnArray:
- return "rcl"[col];
-
- case hullMultline:
- case hullGather:
- return 'c';
-
- case hullAlign:
- case hullFlAlign:
- case hullAlignAt:
- case hullXAlignAt:
- case hullXXAlignAt:
- return "rl"[col & 1];
-
- default:
- return 'c';
- }
-}
-
-
char InsetMathHull::displayColAlign(idx_type idx) const
{
- if (type_ == hullMultline) {
+ switch (type_) {
+ case hullMultline: {
row_type const r = row(idx);
if (r == 0)
return 'l';
if (r == nrows() - 1)
return 'r';
+ return 'c';
+ }
+ case hullEqnArray:
+ case hullGather:
+ case hullAlign:
+ case hullAlignAt:
+ case hullXAlignAt:
+ case hullXXAlignAt:
+ case hullFlAlign:
+ return colAlign(type_, col(idx));
+ default:
+ break;
}
return InsetMathGrid::displayColAlign(idx);
}
@@ -1967,10 +1957,9 @@ bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
}
default:
- return InsetMathGrid::getStatus(cur, cmd, status);
+ break;
}
- // This cannot really happen, but inserted to shut-up gcc
return InsetMathGrid::getStatus(cur, cmd, status);
}
diff --git a/src/mathed/InsetMathHull.h b/src/mathed/InsetMathHull.h
index 462cac2..61fb0b8 100644
--- a/src/mathed/InsetMathHull.h
+++ b/src/mathed/InsetMathHull.h
@@ -113,8 +113,6 @@ public:
///
int defaultColSpace(col_type col);
///
- char defaultColAlign(col_type col);
- ///
char displayColAlign(idx_type idx) const;
///
bool idxFirst(Cursor &) const;
diff --git a/src/mathed/InsetMathSplit.cpp b/src/mathed/InsetMathSplit.cpp
index 5c425fb..5f89cd8 100644
--- a/src/mathed/InsetMathSplit.cpp
+++ b/src/mathed/InsetMathSplit.cpp
@@ -48,17 +48,20 @@ Inset * InsetMathSplit::clone() const
}
-char InsetMathSplit::defaultColAlign(col_type col)
+char InsetMathSplit::displayColAlign(idx_type idx) const
{
- if (name_ == "split")
- return 'l';
if (name_ == "gathered")
return 'c';
- if (name_ == "aligned" || name_ == "align")
- return (col & 1) ? 'l' : 'r';
- if (name_ == "alignedat")
- return (col & 1) ? 'l' : 'r';
- return 'l';
+ if (name_ == "lgathered")
+ return 'l';
+ if (name_ == "rgathered")
+ return 'r';
+ if (name_ == "split"
+ || name_ == "aligned"
+ || name_ == "align"
+ || name_ == "alignedat")
+ return colAlign(hullAlign, col(idx));
+ return InsetMathGrid::displayColAlign(idx);
}
@@ -86,6 +89,10 @@ bool InsetMathSplit::getStatus(Cursor & cur, FuncRequest const & cmd,
flag.setEnabled(false);
return true;
}
+ if (s == "align-left" || s == "align-center" || s == "align-right") {
+ flag.setEnabled(false);
+ return true;
+ }
break;
}
default:
diff --git a/src/mathed/InsetMathSplit.h b/src/mathed/InsetMathSplit.h
index b0ff437..e6bf8f3 100644
--- a/src/mathed/InsetMathSplit.h
+++ b/src/mathed/InsetMathSplit.h
@@ -41,7 +41,7 @@ public:
///
int defaultColSpace(col_type) { return 0; }
///
- char defaultColAlign(col_type);
+ char displayColAlign(idx_type idx) const;
///
InsetCode lyxCode() const { return MATH_SPLIT_CODE; }
--
2.1.4
>From 987f18b7b8834abe983f305c35d22f0242c787df Mon Sep 17 00:00:00 2001
From: Guillaume Munch <g...@lyx.org>
Date: Sun, 20 Dec 2015 20:56:34 +0000
Subject: [PATCH 3/3] Fix the display of column spacing in AMS environments
AMS align environment should have some spacing between odd and even columns.
Add a new virtual method displayColSpace() to InsetMathGrid, InsetMathHull and
InsetMathSplit. I remove defaultColSpace() because it does not seem to have any
effect and appeared broken anyway (e.g. if when adding a new column).
---
src/mathed/InsetMathGrid.cpp | 41 +++++++++++++++++++++++++++++++++++++----
src/mathed/InsetMathGrid.h | 10 +++++++++-
src/mathed/InsetMathHull.cpp | 19 ++-----------------
src/mathed/InsetMathHull.h | 2 +-
src/mathed/InsetMathSplit.cpp | 11 +++++++++++
src/mathed/InsetMathSplit.h | 2 +-
6 files changed, 61 insertions(+), 24 deletions(-)
diff --git a/src/mathed/InsetMathGrid.cpp b/src/mathed/InsetMathGrid.cpp
index 6c5fbbf..db57cbf 100644
--- a/src/mathed/InsetMathGrid.cpp
+++ b/src/mathed/InsetMathGrid.cpp
@@ -486,7 +486,7 @@ void InsetMathGrid::metrics(MetricsInfo & mi, Dimension & dim) const
colinfo_[col].offset_ =
colinfo_[col - 1].offset_ +
colinfo_[col - 1].width_ +
- colinfo_[col - 1].skip_ +
+ displayColSpace(col - 1) +
colsep() +
colinfo_[col].lines_ * vlinesep();
}
@@ -508,7 +508,7 @@ void InsetMathGrid::metrics(MetricsInfo & mi, Dimension & dim) const
int const nextoffset =
colinfo_[first].offset_ +
wid +
- colinfo_[last].skip_ +
+ displayColSpace(last) +
colsep() +
colinfo_[last+1].lines_ * vlinesep();
int const dx = nextoffset - colinfo_[last+1].offset_;
@@ -741,7 +741,7 @@ void InsetMathGrid::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
colinfo_[col].offset_ =
colinfo_[col - 1].offset_ +
colinfo_[col - 1].width_ +
- colinfo_[col - 1].skip_ +
+ displayColSpace(col - 1) +
1 ; //colsep() +
//colinfo_[col].lines_ * vlinesep();
}
@@ -953,7 +953,7 @@ int InsetMathGrid::cellWidth(idx_type idx) const
col_type c2 = c1 + ncellcols(idx);
return colinfo_[c2].offset_
- colinfo_[c1].offset_
- - colinfo_[c2].skip_
+ - displayColSpace(c2)
- colsep()
- colinfo_[c2].lines_ * vlinesep();
}
@@ -1378,6 +1378,11 @@ char InsetMathGrid::displayColAlign(idx_type idx) const
}
+int InsetMathGrid::displayColSpace(col_type col) const
+{
+ return colinfo_[col].skip_;
+}
+
void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
{
//lyxerr << "*** InsetMathGrid: request: " << cmd << endl;
@@ -1861,5 +1866,33 @@ char InsetMathGrid::colAlign(HullType type, col_type col)
}
+//static
+int InsetMathGrid::colSpace(HullType type, col_type col)
+{
+ int alignInterSpace;
+ switch (type) {
+ case hullEqnArray:
+ return 5;
+
+ // FIXME: some values should vary depending on the available length. See #1861
+ case hullAlign:
+ alignInterSpace = 20;
+ break;
+ case hullAlignAt:
+ alignInterSpace = 0;
+ break;
+ case hullXAlignAt:
+ alignInterSpace = 40;
+ break;
+ case hullXXAlignAt:
+ case hullFlAlign:
+ alignInterSpace = 60;
+ break;
+ default:
+ return 0;
+ }
+ return (col % 2) ? alignInterSpace : 0;
+}
+
} // namespace lyx
diff --git a/src/mathed/InsetMathGrid.h b/src/mathed/InsetMathGrid.h
index 709f492..d4df80d 100644
--- a/src/mathed/InsetMathGrid.h
+++ b/src/mathed/InsetMathGrid.h
@@ -261,8 +261,16 @@ protected:
/// Column alignment for display of cell \p idx.
/// Must not be written to file!
virtual char displayColAlign(idx_type idx) const;
- /// The value of a fixed col align for a certain hull type
+ /// Column spacing for display of column \p col.
+ /// Must not be written to file!
+ virtual int displayColSpace(col_type col) const;
+
+ // The following two functions are used in InsetMathHull and
+ // InsetMathSplit.
+ /// The value of a fixed col align for a certain hull type
static char colAlign(HullType type, col_type col);
+ /// The value of a fixed col spacing for a certain hull type
+ static int colSpace(HullType type, col_type col);
/// row info.
/// rowinfo_[nrows()] is a dummy row used only for hlines.
diff --git a/src/mathed/InsetMathHull.cpp b/src/mathed/InsetMathHull.cpp
index 373af2e1..a2964af 100644
--- a/src/mathed/InsetMathHull.cpp
+++ b/src/mathed/InsetMathHull.cpp
@@ -383,24 +383,9 @@ char InsetMathHull::displayColAlign(idx_type idx) const
}
-int InsetMathHull::defaultColSpace(col_type col)
+int InsetMathHull::displayColSpace(col_type col) const
{
- switch (type_) {
- case hullAlign:
- case hullAlignAt:
- //FIXME: this should be wider
- return 0;
-
- case hullXAlignAt:
- return (col & 1) ? 20 : 0;
-
- case hullXXAlignAt:
- case hullFlAlign:
- return (col & 1) ? 40 : 0;
-
- default:
- return 0;
- }
+ return colSpace(type_, col);
}
diff --git a/src/mathed/InsetMathHull.h b/src/mathed/InsetMathHull.h
index 61fb0b8..ca99d97 100644
--- a/src/mathed/InsetMathHull.h
+++ b/src/mathed/InsetMathHull.h
@@ -111,7 +111,7 @@ public:
void mutate(HullType newtype);
///
- int defaultColSpace(col_type col);
+ int displayColSpace(col_type col) const;
///
char displayColAlign(idx_type idx) const;
///
diff --git a/src/mathed/InsetMathSplit.cpp b/src/mathed/InsetMathSplit.cpp
index 5f89cd8..08ed938 100644
--- a/src/mathed/InsetMathSplit.cpp
+++ b/src/mathed/InsetMathSplit.cpp
@@ -65,6 +65,17 @@ char InsetMathSplit::displayColAlign(idx_type idx) const
}
+int InsetMathSplit::displayColSpace(col_type col) const
+{
+ if (name_ == "split" || name_ == "aligned" || name_ == "align")
+ return colSpace(hullAlign, col);
+ if (name_ == "alignedat")
+ return colSpace(hullAlignAt, col);
+ return 0;
+}
+
+
+
void InsetMathSplit::draw(PainterInfo & pi, int x, int y) const
{
InsetMathGrid::draw(pi, x, y);
diff --git a/src/mathed/InsetMathSplit.h b/src/mathed/InsetMathSplit.h
index e6bf8f3..5ab074a 100644
--- a/src/mathed/InsetMathSplit.h
+++ b/src/mathed/InsetMathSplit.h
@@ -39,7 +39,7 @@ public:
///
void validate(LaTeXFeatures & features) const;
///
- int defaultColSpace(col_type) { return 0; }
+ int displayColSpace(col_type col) const;
///
char displayColAlign(idx_type idx) const;
///
--
2.1.4
