anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-16 07:55:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6c13af3f29
lyx_mirror/src/mathed/MathRow.cpp

376 lines
9.2 KiB
C++
Raw Normal View History

Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
/**
* \file MathRow.cpp
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author Jean-Marc Lasgouttes
*
* Full author contact details are available in file CREDITS.
*/
#include <config.h>
#include "MathRow.h"
#include "InsetMath.h"
#include "MathClass.h"
#include "MathData.h"
#include "MathSupport.h"
#include "BufferView.h"
#include "CoordCache.h"
#include "MetricsInfo.h"
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
#include "frontends/FontMetrics.h"
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
#include "frontends/Painter.h"
#include "support/debug.h"
#include "support/docstring.h"
#include "support/lassert.h"
#include <ostream>
using namespace std;
namespace lyx {
Fix issues with macro_nesting handling The rewrite of macro_nesting done at 0f15dcc6 was faulty, in particular since the information should be available also at draw time. To this end, we revert the patch of the said commit that removes macro nesting information from MathRow::Element. In the next commit, we will change the marker code so that MathRow::draw does not need the nesting information. Actually the code is now cleaner since the macro nesting stack of MathRow::metrics can be removed.
2017-01-05 12:25:28 +00:00
MathRow::Element::Element(MetricsInfo const & mi, Type t, MathClass mc)
: type(t), mclass(mc), before(0), after(0), macro_nesting(mi.base.macro_nesting),
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
marker(InsetMath::NO_MARKER), inset(0), compl_unique_to(0),
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
color(Color_red)
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
{}
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
MathRow::MathRow(MetricsInfo & mi, MathData const * ar)
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
{
// First there is a dummy element of type "open"
Fix issues with macro_nesting handling The rewrite of macro_nesting done at 0f15dcc6 was faulty, in particular since the information should be available also at draw time. To this end, we revert the patch of the said commit that removes macro nesting information from MathRow::Element. In the next commit, we will change the marker code so that MathRow::draw does not need the nesting information. Actually the code is now cleaner since the macro nesting stack of MathRow::metrics can be removed.
2017-01-05 12:25:28 +00:00
push_back(Element(mi, DUMMY, MC_OPEN));
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
// Then insert the MathData argument
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
bool const has_contents = ar->addToMathRow(*this, mi);
BOX tweak Add a pixel gap around boxes. When a box is invisible, its width should be null (but keep the weight to avoid drawing problems (think empty sqrt in a macro).
2017-01-13 09:17:05 +00:00
// A MathRow should not be completely empty
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
if (!has_contents) {
Fix issues with macro_nesting handling The rewrite of macro_nesting done at 0f15dcc6 was faulty, in particular since the information should be available also at draw time. To this end, we revert the patch of the said commit that removes macro nesting information from MathRow::Element. In the next commit, we will change the marker code so that MathRow::draw does not need the nesting information. Actually the code is now cleaner since the macro nesting stack of MathRow::metrics can be removed.
2017-01-05 12:25:28 +00:00
Element e(mi, BOX, MC_ORD);
BOX tweak Add a pixel gap around boxes. When a box is invisible, its width should be null (but keep the weight to avoid drawing problems (think empty sqrt in a macro).
2017-01-13 09:17:05 +00:00
// empty arrays are visible when they are editable
Rewrite handling of macro nesting in math rows Macro nesting is now recorded into the macro inset itself. This allows the ArgumentProxy inset to determine whether it is editable or not by looking at its macro. Remove code in the metrics and draw methods of ArgumentProxy: this code is AFAICS not active anymore, since arguments are linearized into math rows. Use Changer idiom to change locally the values of MecticsInfo::base.macro_nesting.
2016-11-28 12:13:36 +00:00
e.color = mi.base.macro_nesting == 0 ? Color_mathline : Color_none;
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
push_back(e);
}
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
// Finally there is a dummy element of type "close"
Fix issues with macro_nesting handling The rewrite of macro_nesting done at 0f15dcc6 was faulty, in particular since the information should be available also at draw time. To this end, we revert the patch of the said commit that removes macro nesting information from MathRow::Element. In the next commit, we will change the marker code so that MathRow::draw does not need the nesting information. Actually the code is now cleaner since the macro nesting stack of MathRow::metrics can be removed.
2017-01-05 12:25:28 +00:00
push_back(Element(mi, DUMMY, MC_CLOSE));
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
/* Do spacing only in math mode. This test is a bit clumsy,
* but it is used in other places for guessing the current mode.
*/
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
bool const dospacing = isMathFont(mi.base.fontname);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
// update classes
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
if (dospacing) {
for (int i = 1 ; i != static_cast<int>(elements_.size()) - 1 ; ++i) {
if (elements_[i].mclass != MC_UNKNOWN)
update_class(elements_[i].mclass, elements_[before(i)].mclass,
elements_[after(i)].mclass);
}
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
}
// set spacing
// We go to the end to handle spacing at the end of equation
for (int i = 1 ; i != static_cast<int>(elements_.size()) ; ++i) {
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
Element & e = elements_[i];
if (e.mclass == MC_UNKNOWN)
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
continue;
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
Element & bef = elements_[before(i)];
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
if (dospacing) {
int spc = class_spacing(bef.mclass, e.mclass, mi.base);
bef.after += spc / 2;
// this is better than spc / 2 to avoid rounding problems
e.before += spc - spc / 2;
}
// finally reserve space for markers
if (bef.marker != Inset::NO_MARKER)
bef.after = max(bef.after, 1);
if (e.marker != Inset::NO_MARKER)
e.before = max(e.before, 1);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
}
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
// Do not lose spacing allocated to extremities
if (!elements_.empty()) {
elements_[after(0)].before += elements_.front().after;
elements_[before(elements_.size() - 1)].after += elements_.back().before;
}
}
int MathRow::before(int i) const
{
do
--i;
Improve spacing of BOX elements Tweak the algorithm so that a BOX math row element can have some spacing. To this end, MathRow::before/after do not look at the type of an element for deciding when to skip it, but rather to its math class. In the new setting, the spacing algorithm works on all elements, but skips the MC_UNKNOWN elements as if they were not present. As a consequence, the two element types BEGIN and END have been replaced by a single DUMMY (they can be recognized from their class). To simply the code, add a new `mclass' argument to the MathRow::Element constructor (default is MC_UNKNOWN).
2016-12-02 14:58:39 +00:00
while (elements_[i].mclass == MC_UNKNOWN);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
return i;
}
int MathRow::after(int i) const
{
do
++i;
Improve spacing of BOX elements Tweak the algorithm so that a BOX math row element can have some spacing. To this end, MathRow::before/after do not look at the type of an element for deciding when to skip it, but rather to its math class. In the new setting, the spacing algorithm works on all elements, but skips the MC_UNKNOWN elements as if they were not present. As a consequence, the two element types BEGIN and END have been replaced by a single DUMMY (they can be recognized from their class). To simply the code, add a new `mclass' argument to the MathRow::Element constructor (default is MC_UNKNOWN).
2016-12-02 14:58:39 +00:00
while (elements_[i].mclass == MC_UNKNOWN);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
return i;
}
void MathRow::metrics(MetricsInfo & mi, Dimension & dim) const
{
dim.asc = 0;
dim.wid = 0;
// In order to compute the dimension of macros and their
// arguments, it is necessary to keep track of them.
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
map<InsetMath const *, Dimension> dim_insets;
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
map<MathData const *, Dimension> dim_arrays;
CoordCache & coords = mi.base.bv->coordCache();
for (Element const & e : elements_) {
Fix issues with macro_nesting handling The rewrite of macro_nesting done at 0f15dcc6 was faulty, in particular since the information should be available also at draw time. To this end, we revert the patch of the said commit that removes macro nesting information from MathRow::Element. In the next commit, we will change the marker code so that MathRow::draw does not need the nesting information. Actually the code is now cleaner since the macro nesting stack of MathRow::metrics can be removed.
2017-01-05 12:25:28 +00:00
mi.base.macro_nesting = e.macro_nesting;
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
Dimension d;
switch (e.type) {
Improve spacing of BOX elements Tweak the algorithm so that a BOX math row element can have some spacing. To this end, MathRow::before/after do not look at the type of an element for deciding when to skip it, but rather to its math class. In the new setting, the spacing algorithm works on all elements, but skips the MC_UNKNOWN elements as if they were not present. As a consequence, the two element types BEGIN and END have been replaced by a single DUMMY (they can be recognized from their class). To simply the code, add a new `mclass' argument to the MathRow::Element constructor (default is MC_UNKNOWN).
2016-12-02 14:58:39 +00:00
case DUMMY:
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
case INSET:
e.inset->metrics(mi, d);
d.wid += e.before + e.after;
coords.insets().add(e.inset, d);
break;
case BEG_MACRO:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->beforeMetrics();
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
// Add a macro to current list
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
dim_insets[e.inset] = Dimension();
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
case END_MACRO:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
LATTEST(dim_insets.find(e.inset) != dim_insets.end());
e.inset->afterMetrics();
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
// Cache the dimension of the macro and remove it from
// tracking map.
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
coords.insets().add(e.inset, dim_insets[e.inset]);
dim_insets.erase(e.inset);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
// This is basically like macros
case BEG_ARG:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->beforeMetrics();
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
dim_arrays[e.ar] = Dimension();
break;
case END_ARG:
LATTEST(dim_arrays.find(e.ar) != dim_arrays.end());
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->afterMetrics();
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
coords.arrays().add(e.ar, dim_arrays[e.ar]);
dim_arrays.erase(e.ar);
break;
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
case BOX:
d = theFontMetrics(mi.base.font).dimension('I');
BOX tweak Add a pixel gap around boxes. When a box is invisible, its width should be null (but keep the weight to avoid drawing problems (think empty sqrt in a macro).
2017-01-13 09:17:05 +00:00
if (e.color != Color_none) {
// allow for one pixel before/after the box.
d.wid += e.before + e.after + 2;
} else {
// hide the box, but give it some height
d.wid = 0;
}
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
break;
}
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
// handle vertical space for markers
switch(e.marker) {
case InsetMath::NO_MARKER:
break;
case InsetMath::MARKER:
++d.des;
break;
case InsetMath::MARKER2:
++d.asc;
++d.des;
}
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
if (!d.empty()) {
dim += d;
// Now add the dimension to current macros and arguments.
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
for (auto & dim_macro : dim_insets)
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
dim_macro.second += d;
for (auto & dim_array : dim_arrays)
dim_array.second += d;
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
}
if (e.compl_text.empty())
continue;
FontInfo font = mi.base.font;
augmentFont(font, "mathnormal");
dim.wid += mathed_string_width(font, e.compl_text);
}
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
LATTEST(dim_insets.empty() && dim_arrays.empty());
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
}
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
namespace {
void drawMarkers(PainterInfo const & pi, MathRow::Element const & e, int const x, int const y)
{
if (e.marker == InsetMath::NO_MARKER)
return;
CoordCache const & coords = pi.base.bv->coordCache();
Dimension const dim = coords.getInsets().dim(e.inset);
// the marker is before/after the inset. Normally some space has been reserved already.
int const l = x + e.before - 1;
int const r = x + dim.width() - e.after;
// Duplicated from Inset.cpp and adapted. It is believed that the
// Inset version should die eventually
ColorCode pen_color = e.inset->mouseHovered(pi.base.bv) || e.inset->editing(pi.base.bv)?
Color_mathframe : Color_mathcorners;
int const d = y + dim.descent();
pi.pain.line(l, d - 3, l, d, pen_color);
pi.pain.line(r, d - 3, r, d, pen_color);
pi.pain.line(l, d, l + 3, d, pen_color);
pi.pain.line(r - 3, d, r, d, pen_color);
if (e.marker == InsetMath::MARKER)
return;
int const a = y - dim.ascent();
pi.pain.line(l, a + 3, l, a, pen_color);
pi.pain.line(r, a + 3, r, a, pen_color);
pi.pain.line(l, a, l + 3, a, pen_color);
pi.pain.line(r - 3, a, r, a, pen_color);
}
}
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
void MathRow::draw(PainterInfo & pi, int x, int const y) const
{
CoordCache & coords = pi.base.bv->coordCache();
for (Element const & e : elements_) {
switch (e.type) {
case INSET: {
// This is hackish: the math inset does not know that space
// has been added before and after it; we alter its dimension
// while it is drawing, because it relies on this value.
Dimension const d = coords.insets().dim(e.inset);
Dimension d2 = d;
d2.wid -= e.before + e.after;
coords.insets().add(e.inset, d2);
e.inset->drawSelection(pi, x + e.before, y);
e.inset->draw(pi, x + e.before, y);
coords.insets().add(e.inset, x, y);
coords.insets().add(e.inset, d);
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
drawMarkers(pi, e, x, y);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
x += d.wid;
break;
}
case BEG_MACRO:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
coords.insets().add(e.inset, x, y);
Re-implement math markers logic. The goal of this patch is to be able to properly remove the space needed for markers in the case of insets that are inside macros and do not need these markers. This was attempted at 9a9a6a8, but did not work reliably. To this end, the following simplifications are made: * instead of drawing its own markers, each inset has a virtual method marker() which prescribes either NO_MARKER, MARKER (normal bottom marker) or MARKER2 (top and bottom marker). All explicit calls to (draw|metrics)Markers(|2) are removed. * the space necessary for the markers is now counted in the before/above margins in the row structure. Therefore painting will not happen at (x + 1, y), but just (x,y). * the methods drawDecoration are removed. * the helper methods InsetMath::(draw|metrics)Markers(|2) are removed and replaced by a new function drawMarkers in MathRow.cpp. Now the marker type is kept in the MathRow::Element object (and set to NO_MARKER in not editable context) and the marker is accounted for in MathRow::(metrics|draw). Moreover, the extra pixel for the marker is taken on the before/After space if possible. The marker will only require extra space when before/after is 0. See comment 168 of #8883 to understand what issues are fixed.
2017-01-06 08:52:10 +00:00
drawMarkers(pi, e, x, y);
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->beforeDraw(pi);
Linearize macros also when editing them In the case of inline editing, this avoids unpleasant jumping issues. This may requires to enter monochrome mode before painting the macro elements.
2017-02-01 10:53:23 +00:00
break;
case END_MACRO:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->afterDraw(pi);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
case BEG_ARG:
coords.arrays().add(e.ar, x, y);
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->beforeDraw(pi);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
case END_ARG:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
e.inset->afterDraw(pi);
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
case BOX: {
BOX tweak Add a pixel gap around boxes. When a box is invisible, its width should be null (but keep the weight to avoid drawing problems (think empty sqrt in a macro).
2017-01-13 09:17:05 +00:00
if (e.color == Color_none)
break;
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
Dimension const d = theFontMetrics(pi.base.font).dimension('I');
BOX tweak Add a pixel gap around boxes. When a box is invisible, its width should be null (but keep the weight to avoid drawing problems (think empty sqrt in a macro).
2017-01-13 09:17:05 +00:00
pi.pain.rectangle(x + e.before + 1, y - d.ascent(),
d.width() - 1, d.height() - 1, e.color);
x += d.wid + 2 + e.before + e.after;
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
break;
}
Improve spacing of BOX elements Tweak the algorithm so that a BOX math row element can have some spacing. To this end, MathRow::before/after do not look at the type of an element for deciding when to skip it, but rather to its math class. In the new setting, the spacing algorithm works on all elements, but skips the MC_UNKNOWN elements as if they were not present. As a consequence, the two element types BEGIN and END have been replaced by a single DUMMY (they can be recognized from their class). To simply the code, add a new `mclass' argument to the MathRow::Element constructor (default is MC_UNKNOWN).
2016-12-02 14:58:39 +00:00
case DUMMY:
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
}
if (e.compl_text.empty())
continue;
FontInfo f = pi.base.font;
augmentFont(f, "mathnormal");
// draw the unique and the non-unique completion part
// Note: this is not time-critical as it is
// only done once per screen.
docstring const s1 = e.compl_text.substr(0, e.compl_unique_to);
docstring const s2 = e.compl_text.substr(e.compl_unique_to);
if (!s1.empty()) {
f.setColor(Color_inlinecompletion);
pi.pain.text(x, y, s1, f);
x += mathed_string_width(f, s1);
}
if (!s2.empty()) {
f.setColor(Color_nonunique_inlinecompletion);
pi.pain.text(x, y, s2, f);
x += mathed_string_width(f, s2);
}
}
}
int MathRow::kerning(BufferView const * bv) const
{
if (elements_.empty())
return 0;
InsetMath const * inset = elements_[before(elements_.size() - 1)].inset;
return inset ? inset->kerning(bv) : 0;
}
ostream & operator<<(ostream & os, MathRow::Element const & e)
{
switch (e.type) {
Improve spacing of BOX elements Tweak the algorithm so that a BOX math row element can have some spacing. To this end, MathRow::before/after do not look at the type of an element for deciding when to skip it, but rather to its math class. In the new setting, the spacing algorithm works on all elements, but skips the MC_UNKNOWN elements as if they were not present. As a consequence, the two element types BEGIN and END have been replaced by a single DUMMY (they can be recognized from their class). To simply the code, add a new `mclass' argument to the MathRow::Element constructor (default is MC_UNKNOWN).
2016-12-02 14:58:39 +00:00
case MathRow::DUMMY:
os << (e.mclass == MC_OPEN ? "{" : "}");
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
case MathRow::INSET:
os << "<" << e.before << "-"
<< to_utf8(class_to_string(e.mclass))
<< "-" << e.after << ">";
break;
case MathRow::BEG_MACRO:
Introduce hooks to encapsulate macro code of MathRow New hooks (before|after)(Metrics|Draw) are run by the MathRow code as needed. They are actually also used internally by the MathMacro code. The gain is that most traces of explicit macro handling (and the MathRow::Element::macro member) have been removed from MathRw.cpp. The next step will be to extend the tokenizing process to allow for linearizing insets other than macros.
2017-02-01 14:20:06 +00:00
os << "\\" << to_utf8(e.inset->name())
<< "^" << e.macro_nesting << "[";
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
break;
case MathRow::END_MACRO:
os << "]";
break;
case MathRow::BEG_ARG:
os << "#(";
break;
case MathRow::END_ARG:
os << ")";
break;
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
case MathRow::BOX:
Improve spacing of BOX elements Tweak the algorithm so that a BOX math row element can have some spacing. To this end, MathRow::before/after do not look at the type of an element for deciding when to skip it, but rather to its math class. In the new setting, the spacing algorithm works on all elements, but skips the MC_UNKNOWN elements as if they were not present. As a consequence, the two element types BEGIN and END have been replaced by a single DUMMY (they can be recognized from their class). To simply the code, add a new `mclass' argument to the MathRow::Element constructor (default is MC_UNKNOWN).
2016-12-02 14:58:39 +00:00
os << "<" << e.before << "-[]-" << e.after << ">";
Only display a blue rectangle for editable empty insets Empty insets should use a minimal amount of space, especially when they are part of a built-in macro in lib/symbols. With this change, blue rectangles signal actually editable places. Empty macros in editable data are shown as grey boxes, but they do not appear when further nested. This is done by adding a new type BOX of MathRow::Element object and a MetricsInfo::macro_nesting that keeps track of macros (and is reset to 0 in editable macro arguments).
2016-10-04 22:25:38 +00:00
break;
Set correctly the spacing between atoms in MathData * new MathRow class which contains the description of a MathData object in terms of math class and spacing + macros and their arguments used in the MathData object are linearized (replaced with their contents) so that all math insets are typeset as a string together. To this end, we introduce a method addToMathRow to InsetMath and MathData. This method allows to linearize recursively a MathData object. + It is then necessary to set manually the dimension and position of the macros and arguments. + the class class and spacing are computed using the MathClass helpers. The MathRow data is cached in the MathData object in a bufferview-dependent way (different dpi for different screens). * delegate most of the work MathData::metrics/draw to MathRow metrics/draw. The case of draw is trickier, since many draw() methods rely on their metrics without any spacing added.
2016-11-16 14:07:00 +00:00
}
return os;
}
ostream & operator<<(ostream & os, MathRow const & mrow)
{
for (MathRow::Element const & e : mrow)
os << e << " ";
return os;
}
} // namespace lyx
Reference in New Issue Copy Permalink