#include "MathCompletionList.h"
#include "MathExtern.h"
#include "MathFactory.h"
+#include "MathRow.h"
#include "MathStream.h"
#include "MathSupport.h"
#include "support/gettext.h"
#include "support/lassert.h"
#include "support/lstrings.h"
-#include "support/RefChanger.h"
+#include "support/Changer.h"
#include "support/textutils.h"
#include <ostream>
///
InsetMathMacro const * owner() { return mathMacro_; }
///
- marker_type marker(BufferView const *) const override { return NO_MARKER; }
+ marker_type marker(BufferView const *) const override { return marker_type::NO_MARKER; }
///
InsetCode lyxCode() const override { return ARGUMENT_PROXY_CODE; }
/// The math data to use for display
// 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,
+ Changer chg = changeVar(mi.base.macro_nesting,
mathMacro_->nesting() == 1 ? 0 : mathMacro_->nesting());
MathRow::Element e_beg(mi, MathRow::BEGIN);
///
void mathematica(MathematicaStream & ms) const override { ms << mathMacro_->cell(idx_); }
///
- void mathmlize(MathStream & ms) const override { ms << mathMacro_->cell(idx_); }
+ void mathmlize(MathMLStream & ms) const override { ms << mathMacro_->cell(idx_); }
///
void htmlize(HtmlStream & ms) const override { ms << mathMacro_->cell(idx_); }
///
: name_(name), displayMode_(DISPLAY_INIT),
expanded_(buf), definition_(buf), attachedArgsNum_(0),
optionals_(0), nextFoldMode_(true), macroBackup_(buf),
- macro_(0), needsUpdate_(false), isUpdating_(false),
+ macro_(nullptr), needsUpdate_(false), isUpdating_(false),
appetite_(9), nesting_(0), limits_(AUTO_LIMITS)
{
}
InsetMathMacro::InsetMathMacro(InsetMathMacro const & that)
: InsetMathNest(that), d(new Private(*that.d))
{
- setBuffer(*that.buffer_);
+ // FIXME This should not really be necessary, but when we are
+ // initializing the table of global macros, we create macros
+ // with no associated Buffer.
+ if (that.buffer_)
+ setBuffer(*that.buffer_);
d->updateChildren(this);
}
return InsetMath::addToMathRow(mrow, mi);
/// The macro nesting can change display of insets. Change it locally.
- Changer chg = make_change(mi.base.macro_nesting, d->nesting_);
+ Changer chg = changeVar(mi.base.macro_nesting, d->nesting_);
MathRow::Element e_beg(mi, MathRow::BEGIN);
e_beg.inset = this;
- e_beg.marker = (d->nesting_ == 1) ? marker(mi.base.bv) : NO_MARKER;
+ e_beg.marker = (d->nesting_ == 1) ? marker(mi.base.bv) : marker_type::NO_MARKER;
mrow.push_back(e_beg);
d->macro_->lock();
MathRow::Element e_end(mi, MathRow::END);
e_end.inset = this;
- e_end.marker = (d->nesting_ == 1) ? marker(mi.base.bv) : NO_MARKER;
+ e_end.marker = (d->nesting_ == 1) ? marker(mi.base.bv) : marker_type::NO_MARKER;
mrow.push_back(e_end);
return has_contents;
}
-Limits InsetMathMacro::defaultLimits() const
+Limits InsetMathMacro::defaultLimits(bool display) const
{
if (d->expanded_.empty())
return NO_LIMITS;
// Guess from the expanded macro
InsetMath const * in = d->expanded_.back().nucleus();
Limits const lim = in->limits() == AUTO_LIMITS
- ? in->defaultLimits() : in->limits();
+ ? in->defaultLimits(display) : in->limits();
LATTEST(lim != AUTO_LIMITS);
return lim;
}
}
-InsetMath::marker_type InsetMathMacro::marker(BufferView const * bv) const
+marker_type InsetMathMacro::marker(BufferView const * bv) const
{
if (nargs() == 0)
- return NO_MARKER;
+ return marker_type::NO_MARKER;
switch (d->displayMode_) {
case DISPLAY_INIT:
case DISPLAY_INTERACTIVE_INIT:
- return NO_MARKER;
+ return marker_type::NO_MARKER;
case DISPLAY_UNFOLDED:
- return MARKER;
+ return marker_type::MARKER;
case DISPLAY_NORMAL:
switch (lyxrc.macro_edit_style) {
case LyXRC::MACRO_EDIT_INLINE:
- return MARKER2;
+ return marker_type::MARKER2;
case LyXRC::MACRO_EDIT_INLINE_BOX:
- return d->editing_[bv] ? BOX_MARKER : MARKER2;
+ return d->editing_[bv] ? marker_type::BOX_MARKER : marker_type::MARKER2;
case LyXRC::MACRO_EDIT_LIST:
- return MARKER2;
+ return marker_type::MARKER2;
}
}
// please gcc 4.6
- return NO_MARKER;
+ return marker_type::NO_MARKER;
}
void InsetMathMacro::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_);
+ Changer chg = changeVar(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);
d->needsUpdate_ = true;
}
} else {
- d->macro_ = 0;
+ d->macro_ = nullptr;
}
}
UpdateLocker locker(*this);
// known macro?
- if (d->macro_ == 0)
+ if (d->macro_ == nullptr)
return;
// remember nesting level of this macro
InsetMathMacro::DisplayMode InsetMathMacro::computeDisplayMode() const
{
- if (d->nextFoldMode_ == true && d->macro_ && !d->macro_->locked())
+ if (d->nextFoldMode_ && d->macro_ && !d->macro_->locked())
return DISPLAY_NORMAL;
else
return DISPLAY_UNFOLDED;
// valid characters?
if (n.size() > 1) {
- for (size_t i = 0; i<n.size(); ++i) {
- if (!(n[i] >= 'a' && n[i] <= 'z')
- && !(n[i] >= 'A' && n[i] <= 'Z')
- && n[i] != '*')
+ for (char_type c : n) {
+ if (!(c >= 'a' && c <= 'z')
+ && !(c >= 'A' && c <= 'Z')
+ && c != '*')
return false;
}
}
}
-void InsetMathMacro::removeArgument(Inset::pos_type pos) {
+void InsetMathMacro::removeArgument(pos_type pos) {
if (d->displayMode_ == DISPLAY_NORMAL) {
LASSERT(size_t(pos) < cells_.size(), return);
cells_.erase(cells_.begin() + pos);
}
-void InsetMathMacro::insertArgument(Inset::pos_type pos) {
+void InsetMathMacro::insertArgument(pos_type pos) {
if (d->displayMode_ == DISPLAY_NORMAL) {
LASSERT(size_t(pos) <= cells_.size(), return);
cells_.insert(cells_.begin() + pos, MathData());
}
-void InsetMathMacro::write(WriteStream & os) const
+void InsetMathMacro::write(TeXMathStream & os) const
{
mode_type mode = currentMode();
MathEnsurer ensurer(os, mode == MATH_MODE, true, mode == TEXT_MODE);
// contains macros with optionals.
bool braced = false;
size_type last = cell(i).size() - 1;
- if (cell(i).size() && cell(i)[last]->asUnknownInset()) {
+ if (!cell(i).empty() && cell(i)[last]->asUnknownInset()) {
latexkeys const * l = in_word_set(cell(i)[last]->name());
braced = (l && l->inset == "big");
- } else if (cell(i).size() && cell(i)[0]->asScriptInset()) {
+ } else if (!cell(i).empty() && cell(i)[0]->asScriptInset()) {
braced = cell(i)[0]->asScriptInset()->nuc().empty();
} else {
for (size_type j = 0; j < cell(i).size(); ++j) {
}
// add space if there was no argument
- if (first)
+ // or add braces if we have optionals but none are present and [ follows
+ if (first) {
os.pendingSpace(true);
+ os.useBraces(d->optionals_ > 0);
+ }
// write \(no)limits modifiers if relevant
writeLimits(os);
}
-void InsetMathMacro::mathmlize(MathStream & ms) const
+void InsetMathMacro::mathmlize(MathMLStream & ms) const
{
// macro_ is 0 if this is an unknown macro
LATTEST(d->macro_ || d->displayMode_ != DISPLAY_NORMAL);