X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathMacro.cpp;h=1311bc9c2ce49d405f093622c72c0ded4cbdd94e;hb=5fdc577badb1cb133d6a0dc7d831bb1f82576adb;hp=34b5160a5f84dc90ff13109ef26643457ca5a754;hpb=c3e33b765e7f6716e5f5ed7b7e248fa41f278e9e;p=lyx.git diff --git a/src/mathed/MathMacro.cpp b/src/mathed/MathMacro.cpp index 34b5160a5f..1311bc9c2c 100644 --- a/src/mathed/MathMacro.cpp +++ b/src/mathed/MathMacro.cpp @@ -38,6 +38,7 @@ #include "support/gettext.h" #include "support/lassert.h" #include "support/lstrings.h" +#include "support/RefChanger.h" #include "support/textutils.h" #include @@ -67,36 +68,42 @@ public: MathMacro const * owner() { return mathMacro_; } /// InsetCode lyxCode() const { return ARGUMENT_PROXY_CODE; } + /// The math data to use for display + MathData const & displayCell(BufferView const * bv) const + { + // handle default macro arguments + bool use_def_arg = !mathMacro_->editMetrics(bv) + && mathMacro_->cell(idx_).empty(); + return use_def_arg ? def_ : mathMacro_->cell(idx_); + } /// bool addToMathRow(MathRow & mrow, MetricsInfo & mi) const { // macro arguments are in macros - LATTEST(mi.base.macro_nesting > 0); - if (mi.base.macro_nesting == 1) - mi.base.macro_nesting = 0; + LATTEST(mathMacro_->nesting() > 0); + /// The macro nesting can change display of insets. Change it locally. + Changer chg = make_change(mi.base.macro_nesting, mathMacro_->nesting()); - MathRow::Element e_beg(MathRow::BEG_ARG, mi); + MathRow::Element e_beg(MathRow::BEG_ARG); e_beg.macro = mathMacro_; e_beg.ar = &mathMacro_->cell(idx_); mrow.push_back(e_beg); mathMacro_->macro()->unlock(); - bool has_contents = mathMacro_->cell(idx_).addToMathRow(mrow, mi); + bool has_contents = displayCell(mi.base.bv).addToMathRow(mrow, mi); mathMacro_->macro()->lock(); // if there was no contents, and the contents is editable, // then we insert a box instead. - if (!has_contents && mi.base.macro_nesting == 0) { - MathRow::Element e(MathRow::BOX, mi); + if (!has_contents && mathMacro_->nesting() == 1) { + // mathclass is ord because it should be spaced as a normal atom + MathRow::Element e(MathRow::BOX, MC_ORD); e.color = Color_mathline; mrow.push_back(e); has_contents = true; } - if (mi.base.macro_nesting == 0) - mi.base.macro_nesting = 1; - - MathRow::Element e_end(MathRow::END_ARG, mi); + MathRow::Element e_end(MathRow::END_ARG); e_end.macro = mathMacro_; e_end.ar = &mathMacro_->cell(idx_); @@ -105,22 +112,19 @@ public: return has_contents; } /// - void metrics(MetricsInfo & mi, Dimension & dim) const { - // macro arguments are in macros - LATTEST(mi.base.macro_nesting > 0); - if (mi.base.macro_nesting == 1) - mi.base.macro_nesting = 0; - - mathMacro_->macro()->unlock(); - mathMacro_->cell(idx_).metrics(mi, dim); - - if (!mathMacro_->editMetrics(mi.base.bv) - && mathMacro_->cell(idx_).empty()) - def_.metrics(mi, dim); - - mathMacro_->macro()->lock(); - if (mi.base.macro_nesting == 0) - mi.base.macro_nesting = 1; + void metrics(MetricsInfo &, Dimension &) const { + // This should never be invoked, since ArgumentProxy insets are linearized + LATTEST(false); + } + /// + int kerning(BufferView const * bv) const + { + return displayCell(bv).kerning(bv); + } + /// + void draw(PainterInfo &, int, int) const { + // This should never be invoked, since ArgumentProxy insets are linearized + LATTEST(false); } // write(), normalize(), infoize() and infoize2() are not needed since // MathMacro uses the definition and not the expanded cells. @@ -137,42 +141,13 @@ public: /// void octave(OctaveStream & os) const { os << mathMacro_->cell(idx_); } /// - void draw(PainterInfo & pi, int x, int y) const { - LATTEST(pi.base.macro_nesting > 0); - if (pi.base.macro_nesting == 1) - pi.base.macro_nesting = 0; - - if (mathMacro_->editMetrics(pi.base.bv)) { - // The only way a ArgumentProxy can appear is in a cell of the - // MathMacro. Moreover the cells are only drawn in the DISPLAY_FOLDED - // mode and then, if the macro is edited the monochrome - // mode is entered by the MathMacro before calling the cells' draw - // method. Then eventually this code is reached and the proxy leaves - // monochrome mode temporarely. Hence, if it is not in monochrome - // here (and the assert triggers in pain.leaveMonochromeMode()) - // it's a bug. - pi.pain.leaveMonochromeMode(); - mathMacro_->cell(idx_).draw(pi, x, y); - pi.pain.enterMonochromeMode(Color_mathbg, Color_mathmacroblend); - } else if (mathMacro_->cell(idx_).empty()) { - mathMacro_->cell(idx_).setXY(*pi.base.bv, x, y); - def_.draw(pi, x, y); - } else - mathMacro_->cell(idx_).draw(pi, x, y); - - if (pi.base.macro_nesting == 0) - pi.base.macro_nesting = 1; - } - /// - size_t idx() const { return idx_; } - /// - int kerning(BufferView const * bv) const + MathClass mathClass() const { - if (mathMacro_->editMetrics(bv) - || !mathMacro_->cell(idx_).empty()) - return mathMacro_->cell(idx_).kerning(bv); - else - return def_.kerning(bv); + return MC_UNKNOWN; + // This can be refined once the pointer issues are fixed. I did not + // notice any immediate crash with the following code, but it is risky + // nevertheless: + //return mathMacro_->cell(idx_).mathClass(); } private: @@ -238,6 +213,8 @@ public: bool isUpdating_; /// maximal number of arguments the macro is greedy for size_t appetite_; + /// Level of nesting in macros (including this one) + int nesting_; }; @@ -323,16 +300,17 @@ bool MathMacro::addToMathRow(MathRow & mrow, MetricsInfo & mi) const // This is the same as what is done in metrics(). d->editing_[mi.base.bv] = editMode(mi.base.bv); + /// The macro nesting can change display of insets. Change it locally. + Changer chg = make_change(mi.base.macro_nesting, d->nesting_); + if (displayMode() != MathMacro::DISPLAY_NORMAL || d->editing_[mi.base.bv]) return InsetMath::addToMathRow(mrow, mi); - MathRow::Element e_beg(MathRow::BEG_MACRO, mi); + MathRow::Element e_beg(MathRow::BEG_MACRO); e_beg.macro = this; mrow.push_back(e_beg); - ++mi.base.macro_nesting; - d->macro_->lock(); bool has_contents = d->expanded_.addToMathRow(mrow, mi); d->macro_->unlock(); @@ -340,15 +318,14 @@ bool MathMacro::addToMathRow(MathRow & mrow, MetricsInfo & mi) const // if there was no contents and the array is editable, then we // insert a grey box instead. if (!has_contents && mi.base.macro_nesting == 1) { - MathRow::Element e(MathRow::BOX, mi); + // mathclass is unknown because it is irrelevant for spacing + MathRow::Element e(MathRow::BOX); e.color = Color_mathmacroblend; mrow.push_back(e); has_contents = true; } - --mi.base.macro_nesting; - - MathRow::Element e_end(MathRow::END_MACRO, mi); + MathRow::Element e_end(MathRow::END_MACRO); e_end.macro = this; mrow.push_back(e_end); @@ -401,6 +378,12 @@ docstring MathMacro::macroName() const } +int MathMacro::nesting() const +{ + return d->nesting_; +} + + void MathMacro::cursorPos(BufferView const & bv, CursorSlice const & sl, bool boundary, int & x, int & y) const { @@ -448,8 +431,8 @@ bool MathMacro::editMetrics(BufferView const * bv) const void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const { - // the macro contents is not editable (except the arguments) - ++mi.base.macro_nesting; + /// The macro nesting can change display of insets. Change it locally. + Changer chg = make_change(mi.base.macro_nesting, d->nesting_); // set edit mode for which we will have calculated metrics. But only d->editing_[mi.base.bv] = editMode(mi.base.bv); @@ -510,10 +493,6 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const } else { LBUFERR(d->macro_); - Changer dummy = (currentMode() == TEXT_MODE) - ? mi.base.font.changeShape(UP_SHAPE) - : Changer(); - // calculate metrics, hoping that all cells are seen d->macro_->lock(); d->expanded_.metrics(mi, dim); @@ -545,9 +524,6 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const dim.des += 2; } } - - // restore macro nesting - --mi.base.macro_nesting; } @@ -594,7 +570,7 @@ private: void MathMacro::updateRepresentation(Cursor * cur, MacroContext const & mc, - UpdateType utype) + UpdateType utype, int nesting) { // block recursive calls (bug 8999) if (d->isUpdating_) @@ -606,6 +582,9 @@ void MathMacro::updateRepresentation(Cursor * cur, MacroContext const & mc, if (d->macro_ == 0) return; + // remember nesting level of this macro + d->nesting_ = nesting; + // update requires d->requires_ = d->macro_->requires(); @@ -637,7 +616,7 @@ void MathMacro::updateRepresentation(Cursor * cur, MacroContext const & mc, // protected by UpdateLocker. if (d->macro_->expand(values, d->expanded_)) { if (utype == OutputUpdate && !d->expanded_.empty()) - d->expanded_.updateMacros(cur, mc, utype); + d->expanded_.updateMacros(cur, mc, utype, nesting); } // get definition for list edit mode docstring const & display = d->macro_->display(); @@ -650,7 +629,6 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const { Dimension const dim = dimension(*pi.base.bv); - setPosCache(pi, x, y); int expx = x; int expy = y; @@ -716,13 +694,7 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const dim.height() - 2, Color_mathmacroframe); drawMarkers2(pi, expx, expy); } else { - // the macro contents is not editable (except the arguments) - ++pi.base.macro_nesting; - bool drawBox = lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_INLINE_BOX; - Changer dummy = (currentMode() == TEXT_MODE) - ? pi.base.font.changeShape(UP_SHAPE) - : Changer(); // warm up cells for (size_t i = 0; i < nargs(); ++i) @@ -753,8 +725,6 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const } else d->expanded_.draw(pi, expx, expy); - --pi.base.macro_nesting; - if (!drawBox) drawMarkers(pi, x, y); @@ -860,14 +830,56 @@ size_t MathMacro::appetite() const } +MathClass MathMacro::mathClass() const +{ + // This can be just a heuristic, since it is only considered for display + // when the macro is not linearised. Therefore it affects: + // * The spacing of the inset while being edited, + // * Intelligent splitting + // * Cursor word movement (Ctrl-Arrow). + if (MacroData const * m = macroBackup()) { + // If it is a global macro and is defined explicitly + if (m->symbol()) { + MathClass mc = string_to_class(m->symbol()->extra); + if (mc != MC_UNKNOWN) + return mc; + } + } + // Otherwise guess from the expanded macro + return d->expanded_.mathClass(); +} + + InsetMath::mode_type MathMacro::currentMode() const { - // User defined macros are always assumed to be mathmode macros. - // Only the global macros defined in lib/symbols may be textmode. + // There is no way to guess the mode of user defined macros, so they are + // always assumed to be mathmode. Only the global macros defined in + // lib/symbols may be textmode. + mode_type mode = modeToEnsure(); + return (mode == UNDECIDED_MODE) ? MATH_MODE : mode; +} + - MacroData const * data = MacroTable::globalMacros().get(name()); - bool textmode = data && data->symbol() && data->symbol()->extra == "textmode"; - return textmode ? TEXT_MODE : MATH_MODE; +InsetMath::mode_type MathMacro::modeToEnsure() const +{ + // User defined macros can be either text mode or math mode for output and + // display. There is no way to guess. For global macros defined in + // lib/symbols, we ensure textmode if flagged as such, otherwise we ensure + // math mode. + if (MacroData const * m = macroBackup()) + if (m->symbol()) + return (m->symbol()->extra == "textmode") ? TEXT_MODE : MATH_MODE; + return UNDECIDED_MODE; +} + + +MacroData const * MathMacro::macroBackup() const +{ + if (macro()) + return &d->macroBackup_; + if (MacroData const * data = MacroTable::globalMacros().get(name())) + return data; + return nullptr; } @@ -1048,12 +1060,9 @@ bool MathMacro::folded() const void MathMacro::write(WriteStream & os) const { - MacroData const * data = MacroTable::globalMacros().get(name()); - bool textmode_macro = data && data->symbol() - && data->symbol()->extra == "textmode"; - bool needs_mathmode = data && (!data->symbol() - || data->symbol()->extra != "textmode"); - + mode_type mode = modeToEnsure(); + bool textmode_macro = mode == TEXT_MODE; + bool needs_mathmode = mode == MATH_MODE; MathEnsurer ensurer(os, needs_mathmode, true, textmode_macro); // non-normal mode @@ -1068,6 +1077,15 @@ void MathMacro::write(WriteStream & os) const // we should be ok to continue even if this fails. LATTEST(d->macro_); + // We may already be in the argument of a macro + bool const inside_macro = os.insideMacro(); + os.insideMacro(true); + + // Enclose in braces to avoid latex errors with xargs if we have + // optional arguments and are in the optional argument of a macro + if (d->optionals_ && inside_macro) + os << '{'; + // Always protect macros in a fragile environment if (os.fragile()) os << "\\protect"; @@ -1106,9 +1124,13 @@ void MathMacro::write(WriteStream & os) const first = false; } - // add space if there was no argument - if (first) + // Close the opened brace or add space if there was no argument + if (d->optionals_ && inside_macro) + os << '}'; + else if (first) os.pendingSpace(true); + + os.insideMacro(inside_macro); }