X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathMacro.cpp;h=6a5c904df7161855c8c9286df8e7e95142355870;hb=2de30c62f8d671a8c8d4d52a6a7310e2c5ca84de;hp=13d6e0e1103a465627a898d0a3c889e226930c17;hpb=948ed1ffd50923f3e63204c65a08cb308ebc4b63;p=lyx.git diff --git a/src/mathed/MathMacro.cpp b/src/mathed/MathMacro.cpp index 13d6e0e110..6a5c904df7 100644 --- a/src/mathed/MathMacro.cpp +++ b/src/mathed/MathMacro.cpp @@ -30,6 +30,7 @@ #include "LaTeXFeatures.h" #include "LyX.h" #include "LyXRC.h" +#include "MetricsInfo.h" #include "frontends/Painter.h" @@ -37,6 +38,7 @@ #include "support/gettext.h" #include "support/lassert.h" #include "support/lstrings.h" +#include "support/RefChanger.h" #include "support/textutils.h" #include @@ -52,72 +54,92 @@ namespace lyx { class ArgumentProxy : public InsetMath { public: /// - ArgumentProxy(MathMacro & mathMacro, size_t idx) + ArgumentProxy(MathMacro * mathMacro, size_t idx) : mathMacro_(mathMacro), idx_(idx) {} /// - ArgumentProxy(MathMacro & mathMacro, size_t idx, docstring const & def) + ArgumentProxy(MathMacro * mathMacro, size_t idx, docstring const & def) : mathMacro_(mathMacro), idx_(idx) { asArray(def, def_); } /// + void setOwner(MathMacro * mathMacro) { mathMacro_ = mathMacro; } + /// + 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_); + } /// - void metrics(MetricsInfo & mi, Dimension & dim) const { - mathMacro_.macro()->unlock(); - mathMacro_.cell(idx_).metrics(mi, dim); + bool addToMathRow(MathRow & mrow, MetricsInfo & mi) const + { + // macro arguments are in macros + 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); + e_beg.macro = mathMacro_; + e_beg.ar = &mathMacro_->cell(idx_); + mrow.push_back(e_beg); + + mathMacro_->macro()->unlock(); + 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 && 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; + } + + MathRow::Element e_end(MathRow::END_ARG); + e_end.macro = mathMacro_; + e_end.ar = &mathMacro_->cell(idx_); - if (!mathMacro_.editMetrics(mi.base.bv) - && mathMacro_.cell(idx_).empty()) - def_.metrics(mi, dim); + mrow.push_back(e_end); - mathMacro_.macro()->lock(); + return has_contents; } - // write(), normalize(), infoize() and infoize2() are not needed since - // MathMacro uses the definition and not the expanded cells. /// - void maple(MapleStream & ms) const { ms << mathMacro_.cell(idx_); } + void metrics(MetricsInfo &, Dimension &) const { + // This should never be invoked, since ArgumentProxy insets are linearized + LATTEST(false); + } /// - void maxima(MaximaStream & ms) const { ms << mathMacro_.cell(idx_); } + int kerning(BufferView const * bv) const + { + return displayCell(bv).kerning(bv); + } /// - void mathematica(MathematicaStream & ms) const { ms << mathMacro_.cell(idx_); } + 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. /// - void mathmlize(MathStream & ms) const { ms << mathMacro_.cell(idx_); } + void maple(MapleStream & ms) const { ms << mathMacro_->cell(idx_); } /// - void htmlize(HtmlStream & ms) const { ms << mathMacro_.cell(idx_); } + void maxima(MaximaStream & ms) const { ms << mathMacro_->cell(idx_); } /// - void octave(OctaveStream & os) const { os << mathMacro_.cell(idx_); } + void mathematica(MathematicaStream & ms) const { ms << mathMacro_->cell(idx_); } /// - void draw(PainterInfo & pi, int x, int y) const { - 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); - } + void mathmlize(MathStream & ms) const { ms << mathMacro_->cell(idx_); } /// - size_t idx() const { return idx_; } + void htmlize(HtmlStream & ms) const { ms << mathMacro_->cell(idx_); } /// - int kerning(BufferView const * bv) const - { - if (mathMacro_.editMetrics(bv) - || !mathMacro_.cell(idx_).empty()) - return mathMacro_.cell(idx_).kerning(bv); - else - return def_.kerning(bv); - } + void octave(OctaveStream & os) const { os << mathMacro_->cell(idx_); } private: /// @@ -126,7 +148,7 @@ private: return new ArgumentProxy(*this); } /// - MathMacro & mathMacro_; + MathMacro * mathMacro_; /// size_t idx_; /// @@ -134,6 +156,7 @@ private: }; +/// Private implementation of MathMacro class MathMacro::Private { public: Private(Buffer * buf, docstring const & name) @@ -144,6 +167,13 @@ public: appetite_(9) { } + /// Update the pointers to our owner of all expanded macros. + /// This needs to be called every time a copy of the owner is created + /// (bug 9418). + void updateChildren(MathMacro * owner); + /// Recursively update the pointers of all expanded macros + /// appearing in the arguments of the current macro + void updateNestedChildren(MathMacro * owner, InsetMathNest * ni); /// name of macro docstring name_; /// current display mode @@ -174,9 +204,57 @@ 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_; }; +void MathMacro::Private::updateChildren(MathMacro * owner) +{ + for (size_t i = 0; i < expanded_.size(); ++i) { + ArgumentProxy * p = dynamic_cast(expanded_[i].nucleus()); + if (p) + p->setOwner(owner); + + InsetMathNest * ni = expanded_[i].nucleus()->asNestInset(); + if (ni) + updateNestedChildren(owner, ni); + } + + if (macro_) { + // The macro_ pointer is updated when MathData::metrics() is + // called. However, when instant preview is on or the macro is + // not on screen, MathData::metrics() is not called and we may + // have a dangling pointer. As a safety measure, when a macro + // is copied, always let macro_ point to the backup copy of the + // MacroData structure. This backup is updated every time the + // macro is changed, so it will not become stale. + macro_ = ¯oBackup_; + } +} + + +void MathMacro::Private::updateNestedChildren(MathMacro * owner, InsetMathNest * ni) +{ + for (size_t i = 0; i < ni->nargs(); ++i) { + MathData & ar = ni->cell(i); + for (size_t j = 0; j < ar.size(); ++j) { + ArgumentProxy * ap = dynamic_cast + (ar[j].nucleus()); + if (ap) { + MathMacro::Private * md = ap->owner()->d; + if (md->macro_) + md->macro_ = &md->macroBackup_; + ap->setOwner(owner); + } + InsetMathNest * imn = ar[j].nucleus()->asNestInset(); + if (imn) + updateNestedChildren(owner, imn); + } + } +} + + MathMacro::MathMacro(Buffer * buf, docstring const & name) : InsetMathNest(buf, 0), d(new Private(buf, name)) {} @@ -185,6 +263,8 @@ MathMacro::MathMacro(Buffer * buf, docstring const & name) MathMacro::MathMacro(MathMacro const & that) : InsetMathNest(that), d(new Private(*that.d)) { + setBuffer(*that.buffer_); + d->updateChildren(this); } @@ -194,6 +274,7 @@ MathMacro & MathMacro::operator=(MathMacro const & that) return *this; InsetMathNest::operator=(that); *d = *that.d; + d->updateChildren(this); return *this; } @@ -204,6 +285,45 @@ MathMacro::~MathMacro() } +bool MathMacro::addToMathRow(MathRow & mrow, MetricsInfo & mi) const +{ + // set edit mode for which we will have calculated row. + // 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); + e_beg.macro = this; + mrow.push_back(e_beg); + + d->macro_->lock(); + bool has_contents = d->expanded_.addToMathRow(mrow, mi); + d->macro_->unlock(); + + // 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) { + // 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; + } + + MathRow::Element e_end(MathRow::END_MACRO); + e_end.macro = this; + mrow.push_back(e_end); + + return has_contents; +} + + Inset * MathMacro::clone() const { MathMacro * copy = new MathMacro(*this); @@ -249,6 +369,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 { @@ -282,7 +408,7 @@ bool MathMacro::editMode(BufferView const * bv) const { } -MacroData const * MathMacro::macro() +MacroData const * MathMacro::macro() const { return d->macro_; } @@ -296,21 +422,25 @@ bool MathMacro::editMetrics(BufferView const * bv) const void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const { + /// 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); // calculate new metrics according to display mode - if (d->displayMode_ == DISPLAY_INIT || - d->displayMode_ == DISPLAY_INTERACTIVE_INIT) { + if (d->displayMode_ == DISPLAY_INIT || d->displayMode_ == DISPLAY_INTERACTIVE_INIT) { + Changer dummy = mi.base.changeFontSet("lyxtex"); mathed_string_dim(mi.base.font, from_ascii("\\") + name(), dim); } else if (d->displayMode_ == DISPLAY_UNFOLDED) { + Changer dummy = mi.base.changeFontSet("lyxtex"); cell(0).metrics(mi, dim); Dimension bsdim; mathed_string_dim(mi.base.font, from_ascii("\\"), bsdim); dim.wid += bsdim.width() + 1; dim.asc = max(bsdim.ascent(), dim.ascent()); dim.des = max(bsdim.descent(), dim.descent()); - metricsMarkers(dim); + metricsMarkers(mi, dim); } else if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_LIST && d->editing_[mi.base.bv]) { // Macro will be edited in a old-style list mode here: @@ -350,10 +480,14 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const dim.asc += 1; dim.des += 1; dim.wid += 2; - metricsMarkers2(dim); + metricsMarkers2(mi, dim); } 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); @@ -372,7 +506,7 @@ void MathMacro::metrics(MetricsInfo & mi, Dimension & dim) const if (lyxrc.macro_edit_style == LyXRC::MACRO_EDIT_INLINE_BOX && d->editing_[mi.base.bv]) { FontInfo font = mi.base.font; - augmentFont(font, from_ascii("lyxtex")); + augmentFont(font, "lyxtex"); Dimension namedim; mathed_string_dim(font, name(), namedim); #if 0 @@ -431,7 +565,7 @@ private: void MathMacro::updateRepresentation(Cursor * cur, MacroContext const & mc, - UpdateType utype) + UpdateType utype, int nesting) { // block recursive calls (bug 8999) if (d->isUpdating_) @@ -443,6 +577,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(); @@ -461,9 +598,9 @@ void MathMacro::updateRepresentation(Cursor * cur, MacroContext const & mc, for (size_t i = 0; i < nargs(); ++i) { ArgumentProxy * proxy; if (i < defaults.size()) - proxy = new ArgumentProxy(*this, i, defaults[i]); + proxy = new ArgumentProxy(this, i, defaults[i]); else - proxy = new ArgumentProxy(*this, i); + proxy = new ArgumentProxy(this, i); values[i].insert(0, MathAtom(proxy)); } // expanding macro with the values @@ -474,11 +611,12 @@ 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(); - asArray(display.empty() ? d->macro_->definition() : display, d->definition_); + asArray(display.empty() ? d->macro_->definition() : display, + d->definition_, Parse::QUIET); } @@ -486,15 +624,14 @@ 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; if (d->displayMode_ == DISPLAY_INIT || d->displayMode_ == DISPLAY_INTERACTIVE_INIT) { - FontSetChanger dummy(pi.base, "lyxtex"); + Changer dummy = pi.base.changeFontSet("lyxtex"); pi.pain.text(x, y, from_ascii("\\") + name(), pi.base.font); } else if (d->displayMode_ == DISPLAY_UNFOLDED) { - FontSetChanger dummy(pi.base, "lyxtex"); + Changer dummy = pi.base.changeFontSet("lyxtex"); pi.pain.text(x, y, from_ascii("\\"), pi.base.font); x += mathed_string_width(pi.base.font, from_ascii("\\")) + 1; cell(0).draw(pi, x, y); @@ -553,6 +690,9 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const drawMarkers2(pi, expx, expy); } else { 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) @@ -561,7 +701,7 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const if (drawBox && d->editing_[pi.base.bv]) { // draw header and rectangle around FontInfo font = pi.base.font; - augmentFont(font, from_ascii("lyxtex")); + augmentFont(font, "lyxtex"); font.setSize(FONT_SIZE_TINY); font.setColor(Color_mathmacrolabel); Dimension namedim; @@ -585,6 +725,7 @@ void MathMacro::draw(PainterInfo & pi, int x, int y) const if (!drawBox) drawMarkers(pi, x, y); + } // edit mode changed? @@ -660,7 +801,7 @@ bool MathMacro::validName() const size_t MathMacro::arity() const -{ +{ if (d->displayMode_ == DISPLAY_NORMAL ) return cells_.size(); else @@ -687,10 +828,34 @@ size_t MathMacro::appetite() const } +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. + + MacroData const * data = MacroTable::globalMacros().get(name()); + bool textmode = data && data->symbol() && data->symbol()->extra == "textmode"; + return textmode ? TEXT_MODE : MATH_MODE; +} + + void MathMacro::validate(LaTeXFeatures & features) const { + // Immediately after a document is loaded, in some cases the MacroData + // of the global macros defined in the lib/symbols file may still not + // be known to the macro machinery because it will be set only after + // the first call to updateMacros(). This is not a problem unless + // instant preview is on for math, in which case we will be missing + // the corresponding requirements. + // In this case, we get the required info from the global macro table. if (!d->requires_.empty()) features.require(d->requires_); + else if (!d->macro_) { + // Update requires for known global macros. + MacroData const * data = MacroTable::globalMacros().get(name()); + if (data && !data->requires().empty()) + features.require(data->requires()); + } if (name() == "binom") features.require("binom"); @@ -851,7 +1016,13 @@ bool MathMacro::folded() const void MathMacro::write(WriteStream & os) const { - MathEnsurer ensurer(os, d->macro_ != 0, true); + 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"); + + MathEnsurer ensurer(os, needs_mathmode, true, textmode_macro); // non-normal mode if (d->displayMode_ != DISPLAY_NORMAL) { @@ -865,6 +1036,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"; @@ -903,9 +1083,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); } @@ -935,7 +1119,7 @@ void MathMacro::mathmlize(MathStream & os) const docstring const xmlname = d->macro_->xmlname(); if (!xmlname.empty()) { char const * type = d->macro_->MathMLtype(); - os << '<' << type << "> " << xmlname << " /<" + os << '<' << type << "> " << xmlname << " '; return; }