#include <config.h>
#include "InsetMathHull.h"
-
#include "InsetMathChar.h"
#include "InsetMathColor.h"
#include "InsetMathFrac.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "ColorSet.h"
+#include "Cursor.h"
#include "CutAndPaste.h"
#include "Encoding.h"
#include "Exporter.h"
#include "InsetMathMacro.h"
#include "InsetMathMacroTemplate.h"
#include "MetricsInfo.h"
-#include "xml.h"
#include "Paragraph.h"
#include "ParIterator.h"
#include "xml.h"
#include "insets/InsetRef.h"
#include "insets/RenderPreview.h"
-#include "graphics/GraphicsImage.h"
#include "graphics/PreviewImage.h"
#include "graphics/PreviewLoader.h"
#include "support/filetools.h"
#include "support/lassert.h"
#include "support/lstrings.h"
-#include "support/RefChanger.h"
+#include "support/Changer.h"
#include <sstream>
// writes a preamble for underlined or struck out math display
- void writeMathdisplayPreamble(WriteStream & os)
+ void writeMathdisplayPreamble(TeXMathStream & os)
{
if (os.strikeoutMath())
return;
- if (os.ulemCmd() == WriteStream::UNDERLINE)
+ if (os.ulemCmd() == TeXMathStream::UNDERLINE)
os << "\\raisebox{-\\belowdisplayshortskip}{"
"\\parbox[b]{\\linewidth}{";
- else if (os.ulemCmd() == WriteStream::STRIKEOUT)
+ else if (os.ulemCmd() == TeXMathStream::STRIKEOUT)
os << "\\parbox{\\linewidth}{";
}
// writes a postamble for underlined or struck out math display
- void writeMathdisplayPostamble(WriteStream & os)
+ void writeMathdisplayPostamble(TeXMathStream & os)
{
if (os.strikeoutMath())
return;
- if (os.ulemCmd() == WriteStream::UNDERLINE)
+ if (os.ulemCmd() == TeXMathStream::UNDERLINE)
os << "}}\\\\\n";
- else if (os.ulemCmd() == WriteStream::STRIKEOUT)
+ else if (os.ulemCmd() == TeXMathStream::STRIKEOUT)
os << "}\\\\\n";
}
-
} // namespace
-HullType hullType(docstring const & s)
-{
- if (s == "none") return hullNone;
- if (s == "simple") return hullSimple;
- if (s == "equation") return hullEquation;
- if (s == "eqnarray") return hullEqnArray;
- if (s == "align") return hullAlign;
- if (s == "alignat") return hullAlignAt;
- if (s == "xalignat") return hullXAlignAt;
- if (s == "xxalignat") return hullXXAlignAt;
- if (s == "multline") return hullMultline;
- if (s == "gather") return hullGather;
- if (s == "flalign") return hullFlAlign;
- if (s == "regexp") return hullRegexp;
- lyxerr << "unknown hull type '" << to_utf8(s) << "'" << endl;
- return hullUnknown;
-}
-
-
-docstring hullName(HullType type)
-{
- switch (type) {
- case hullNone: return from_ascii("none");
- case hullSimple: return from_ascii("simple");
- case hullEquation: return from_ascii("equation");
- case hullEqnArray: return from_ascii("eqnarray");
- case hullAlign: return from_ascii("align");
- case hullAlignAt: return from_ascii("alignat");
- case hullXAlignAt: return from_ascii("xalignat");
- case hullXXAlignAt: return from_ascii("xxalignat");
- case hullMultline: return from_ascii("multline");
- case hullGather: return from_ascii("gather");
- case hullFlAlign: return from_ascii("flalign");
- case hullRegexp: return from_ascii("regexp");
- case hullUnknown:
- lyxerr << "unknown hull type" << endl;
- break;
- }
- return from_ascii("none");
-}
-
-static InsetLabel * dummy_pointer = 0;
+static InsetLabel * dummy_pointer = nullptr;
InsetMathHull::InsetMathHull(Buffer * buf)
: InsetMathGrid(buf, 1, 1), type_(hullNone), numbered_(1, NONUMBER),
InsetMathHull::~InsetMathHull()
{
- for (size_t i = 0; i < label_.size(); ++i)
- delete label_[i];
+ for (auto & i : label_)
+ delete i;
}
numbered_ = other.numbered_;
numbers_ = other.numbers_;
buffer_ = other.buffer_;
- for (size_t i = 0; i < label_.size(); ++i)
- delete label_[i];
+ for (auto & i : label_)
+ delete i;
label_ = other.label_;
for (size_t i = 0; i != label_.size(); ++i) {
if (label_[i])
}
-// FIXME This should really be controlled by the TOC level, or
-// something of the sort.
-namespace {
- const char * counters_to_save[] = {"section", "chapter"};
- unsigned int const numcnts = sizeof(counters_to_save)/sizeof(char *);
-} // namespace
-
-
void InsetMathHull::updateBuffer(ParIterator const & it, UpdateType utype, bool const deleted)
{
if (!buffer_) {
Counters & cnts =
buffer_->masterBuffer()->params().documentClass().counters();
- // right now, we only need to do this at export time
- if (utype == OutputUpdate) {
- for (size_t i = 0; i < numcnts; ++i) {
- docstring const cnt = from_ascii(counters_to_save[i]);
- if (cnts.hasCounter(cnt))
- counter_map[cnt] = cnts.value(cnt);
- }
- }
-
// this has to be done separately
docstring const eqstr = from_ascii("equation");
if (cnts.hasCounter(eqstr)) {
- if (utype == OutputUpdate)
- counter_map[eqstr] = cnts.value(eqstr);
for (size_t i = 0; i != label_.size(); ++i) {
+ docstring const oldnumber = numbers_[i];
if (numbered(i)) {
Paragraph const & par = it.paragraph();
if (!par.isDeleted(it.pos())) {
numbers_[i] = from_ascii("#");
} else
numbers_[i] = empty_docstring();
+ // If the numbering has changed, trigger a new preview
+ if (oldnumber != numbers_[i] && RenderPreview::previewMath()) {
+ // Do we need to remove it first?
+ //preview_->removePreview(*buffer_);
+ preparePreview(it);
+ }
}
}
}
if (label_[i])
label_[i]->updateBuffer(it, utype, deleted);
}
+ // set up equation numbers
+
+ // compute first and last item
+ row_type first = nrows();
+ for (row_type row = 0; row != nrows(); ++row)
+ if (numbered(row)) {
+ first = row;
+ break;
+ }
+ if (first != nrows()) {
+ row_type last = nrows() - 1;
+ for (; last != 0; --last)
+ if (numbered(last))
+ break;
+
+ for (row_type row = 0; row != nrows(); ++row) {
+ if (!numbered(row))
+ continue;
+ if (label_[row]) {
+ label_[row]->setCounterValue(numbers_[row]);
+ label_[row]->setPrettyCounter("(" + numbers_[row] + ")");
+ label_[row]->setFormattedCounter("(" + numbers_[row] + ")");
+ }
+ }
+ }
+
// pass down
InsetMathGrid::updateBuffer(it, utype, deleted);
}
return;
}
- TocBuilder & b = backend.builder("equation");
// compute first and last item
row_type first = nrows();
for (row_type row = 0; row != nrows(); ++row)
row_type last = nrows() - 1;
for (; last != 0; --last)
if (numbered(last))
- break;
- // add equation numbers
- b.pushItem(pit, docstring(), output_active);
+ break;
+
+ TocBuilder & b = backend.builder("equation");
+ b.pushItem(pit, docstring(), output_active);
if (first != last)
b.argumentItem(bformat(from_ascii("(%1$s-%2$s)"),
numbers_[first], numbers_[last]));
+
+ odocstringstream ods;
+ Encoding const * enc = encodings.fromLyXName("utf8");
+ OutputParams ops(enc);
+ ops.for_toc = true;
+ int const max_length = 30;
+
for (row_type row = 0; row != nrows(); ++row) {
if (!numbered(row))
continue;
- if (label_[row])
+ if (label_[row]) {
label_[row]->addToToc(pit, output_active, utype, backend);
+ }
docstring label = nicelabel(row);
- if (first == last)
+ if (first == last) {
// this is the only equation
- b.argumentItem(label);
- else {
+ plaintext(ods, ops, max_length);
+ b.argumentItem(label + " " + ods.str());
+ } else {
// insert as sub-items
- b.pushItem(pit, label, output_active);
+ otexrowstream ots(ods);
+ TeXMathStream wi(ots, false, false, TeXMathStream::wsDefault, enc);
+ docstring d;
+ for (col_type c = 0; c < ncols(); ++c) {
+ wi << cell(index(row, c));
+ d = ods.str();
+ if (d.size() > max_length) {
+ d = d.substr(0, max_length - 1);
+ break;
+ }
+ }
+ b.pushItem(pit, label+ " " + d, output_active);
+ // clear the stringstream
+ odocstringstream().swap(ods);
b.pop();
}
}
{
/* Compute \(above|below)displayskip
true value in LaTeX is 10pt plus 2pt minus 5pt (in normal size at 10pt)
- FIXME: make this dependent of current size? (minor improvement)
- FIXME: if would be nice if this was not part of the inset, but
- just increased the row ascent/descent.
- FIXME: even better would be to handle the short skip case.
+ But we use a fixed number of pixels and scale them with zoom.
*/
- int const bottom_display_margin = mi.base.inPixels(Length(10, Length::PT));
+ int const bottom_display_margin = mi.base.bv->zoomedPixels(6);
int top_display_margin = bottom_display_margin;
// at start of paragraph, add an empty line
if (mi.vmode)
top_display_margin += theFontMetrics(mi.base.font).maxHeight() + 2;
+ int const ind = indent(*mi.base.bv);
+ mi.extrawidth = ind;
+
if (previewState(mi.base.bv)) {
preview_->metrics(mi, dim);
if (previewTooSmall(dim)) {
if (numberedType()) {
BufferParams::MathNumber const math_number = buffer().params().getMathNumber();
int extra_offset = 0;
+ int max_nlwid = 0;
for (row_type row = 0; row < nrows(); ++row) {
rowinfo(row).offset[mi.base.bv] += extra_offset;
- if (!numbered(row))
- continue;
docstring const nl = nicelabel(row);
+ if (nl.empty())
+ continue;
Dimension dimnl;
mathed_string_dim(mi.base.font, nl, dimnl);
- int const ind = indent(*mi.base.bv);
int const x = ind ? ind : (mi.base.textwidth - dim.wid) / 2;
// for some reason metrics does not trigger at the
// same point as draw, and therefore we use >= instead of >
|| (math_number == BufferParams::RIGHT
&& dimnl.wid >= mi.base.textwidth - x - dim.wid)) {
extra_offset += dimnl.height();
- }
+ } else if (dimnl.wid > max_nlwid)
+ max_nlwid = dimnl.wid;
}
+ mi.extrawidth += max_nlwid;
dim.des += extra_offset;
}
dim.wid, dim.asc + dim.des, backgroundColor(pi));
return;
}
- // If there are numbers, the margins around the (displayed)
- // equation have to be cleared.
- if (numberedType())
- pi.pain.fillRectangle(pi.leftx, y - dim.asc,
- pi.rightx - pi.leftx, dim.height(), pi.background_color);
+
pi.pain.fillRectangle(x + 1, y - dim.asc + 1, dim.wid - 2,
- dim.asc + dim.des - 1, pi.backgroundColor(this));
+ dim.height() - 1, pi.backgroundColor(this));
}
if (previewState(bv)) {
// Do not draw change tracking cue if taken care of by RowPainter
// already.
- Changer dummy = !canPaintChange(*bv) ? make_change(pi.change, Change())
- : Changer();
+ Changer dummy = !canPaintChange(*bv) ? changeVar(pi.change, Change())
+ : noChange();
if (previewTooSmall(dim)) {
// we have an extra frame
preview_->draw(pi, x + ERROR_FRAME_WIDTH, y);
}
// First draw the numbers
- ColorCode color = pi.selected && lyxrc.use_system_colors
- ? Color_selectiontext : standardColor();
- bool const really_change_color = pi.base.font.color() == Color_none;
- Changer dummy0 = really_change_color ? pi.base.font.changeColor(color)
- : Changer();
if (numberedType()) {
BufferParams::MathNumber const math_number = buffer().params().getMathNumber();
for (row_type row = 0; row < nrows(); ++row) {
Dimension dimnl;
mathed_string_dim(pi.base.font, nl, dimnl);
if (math_number == BufferParams::LEFT) {
+ ColorCode const col = pi.selected_left
+ ? Color_selectiontext
+ : pi.base.font.color();
+ Changer dummy0 = pi.base.font.changeColor(col);
if (dimnl.wid > x - pi.leftx)
yy += rowinfo(row).descent + dimnl.asc;
+ pi.pain.fillRectangle(pi.leftx, yy - dimnl.asc,
+ dimnl.width(), dimnl.height(),
+ pi.selected_left ? Color_selection : pi.background_color);
pi.draw(pi.leftx, yy, nl);
} else {
+ ColorCode const col = pi.selected_right
+ ? Color_selectiontext
+ : pi.base.font.color();
+ Changer dummy0 = pi.base.font.changeColor(col);
if (dimnl.wid > pi.rightx - x - dim.wid)
yy += rowinfo(row).descent + dimnl.asc;
+ pi.pain.fillRectangle(pi.rightx - dimnl.wid, yy - dimnl.asc,
+ dimnl.width(), dimnl.height(),
+ pi.selected_right ? Color_selection : pi.background_color);
pi.draw(pi.rightx - dimnl.wid, yy, nl);
}
}
}
// Then the equations
+ ColorCode color = pi.selected ? Color_selectionmath : standardColor();
+ bool const really_change_color = pi.base.font.color() == Color_none;
+ Changer dummy0 = really_change_color ? pi.base.font.changeColor(color)
+ : noChange();
Changer dummy1 = pi.base.changeFontSet(standardFont());
Changer dummy2 = pi.base.font.changeStyle(display() ? DISPLAY_STYLE
: TEXT_STYLE);
} else {
odocstringstream os;
otexrowstream ots(os);
- WriteStream wi(ots, false, true, WriteStream::wsDefault);
+ TeXMathStream wi(ots, false, true, TeXMathStream::wsDefault);
write(wi);
dim.wid = os.str().size();
dim.asc = 1;
} else {
odocstringstream os;
otexrowstream ots(os);
- WriteStream wi(ots, false, true, WriteStream::wsDefault);
+ TeXMathStream wi(ots, false, true, TeXMathStream::wsDefault);
write(wi);
pain.draw(x, y, os.str().c_str());
}
// \newcommand{\xxx}{\text{$\phi$}}) gets processed twice. The
// first time as a whole, and the second time only the inner math.
// In this last case inset.buffer() would be invalid.
- static Encoding const * encoding = 0;
+ static Encoding const * encoding = nullptr;
if (inset.isBufferValid())
encoding = &(inset.buffer().params().encoding());
otexrowstream ots(ls);
- WriteStream wi(ots, false, true, WriteStream::wsPreview, encoding);
+ TeXMathStream wi(ots, false, true, TeXMathStream::wsPreview, encoding);
inset.write(wi);
return ls.str();
}
if (lsize != "normalsize" && !prefixIs(lsize, "error"))
setfont += from_ascii("\\" + lsize + '\n');
- docstring setcnt;
- if (forexport && haveNumbers()) {
- docstring eqstr = from_ascii("equation");
- CounterMap::const_iterator it = counter_map.find(eqstr);
- if (it != counter_map.end()) {
- int num = it->second;
- if (num >= 0)
- setcnt += from_ascii("\\setcounter{") + eqstr + '}' +
- '{' + convert<docstring>(num) + '}' + '\n';
- }
- for (size_t i = 0; i != numcnts; ++i) {
- docstring cnt = from_ascii(counters_to_save[i]);
- it = counter_map.find(cnt);
- if (it == counter_map.end())
- continue;
- int num = it->second;
- if (num > 0)
- setcnt += from_ascii("\\setcounter{") + cnt + '}' +
- '{' + convert<docstring>(num) + '}';
- }
- }
- docstring const snippet = macro_preamble + setfont + setcnt
- + latexString(*this) + endfont;
+ docstring const snippet = macro_preamble + setfont + latexString(*this) + endfont;
LYXERR(Debug::MACROS, "Preview snippet: " << snippet);
preview_->addPreview(snippet, *buffer, forexport);
}
void InsetMathHull::numbered(row_type row, Numbered num)
{
numbered_[row] = num;
- if (!numbered(row) && label_[row]) {
- delete label_[row];
- label_[row] = 0;
- }
}
case hullEqnArray:
break;
}
- for (size_t row = 0; row < numbered_.size(); ++row)
- if (numbered_[row] == NOTAG)
+ for (auto const & row : numbered_)
+ if (row == NOTAG)
return true;
return false;
}
}
-Inset::RowFlags InsetMathHull::rowFlags() const
+int InsetMathHull::rowFlags() const
{
switch (type_) {
case hullUnknown:
}
-OutputParams::CtObject InsetMathHull::CtObject(OutputParams const & runparams) const
+CtObject InsetMathHull::getCtObject(OutputParams const & runparams) const
{
- OutputParams::CtObject res = OutputParams::CT_NORMAL;
+ CtObject res = CtObject::Normal;
switch(type_) {
case hullNone:
case hullSimple:
case hullMultline: {
if (runparams.inulemcmd
&& (!runparams.local_font || runparams.local_font->fontInfo().strikeout() != FONT_ON))
- res = OutputParams::CT_UDISPLAYOBJECT;
+ res = CtObject::UDisplayObject;
else
- res = OutputParams::CT_DISPLAYOBJECT;
+ res = CtObject::DisplayObject;
break;
}
}
}
-void InsetMathHull::header_write(WriteStream & os) const
+void InsetMathHull::header_write(TeXMathStream & os) const
{
bool n = numberedType();
}
-void InsetMathHull::footer_write(WriteStream & os) const
+void InsetMathHull::footer_write(TeXMathStream & os) const
{
bool n = numberedType();
docstring InsetMathHull::nicelabel(row_type row) const
{
- if (!numbered(row))
- return docstring();
+ if (!numbered(row)) {
+ if (!label_[row])
+ return docstring();
+ return '[' + label_[row]->screenLabel() + ']';
+ }
docstring const & val = numbers_[row];
if (!label_[row])
return '(' + val + ')';
MathData ar;
for (idx_type i = 0; i < nargs(); ++i)
ar.append(cell(i));
- InsetLabel * label = 0;
+ InsetLabel * label = nullptr;
if (type == hullEquation) {
// preserve first non-empty label
for (row_type row = 0; row < nrows(); ++row) {
numbered(0, false);
} else {
setType(hullEquation);
- numbered(0, label_[0] ? true : false);
+ numbered(0, label_[0] != nullptr);
mutate(newtype);
}
break;
}
-docstring InsetMathHull::eolString(row_type row, bool fragile, bool latex,
- bool last_eoln) const
+void InsetMathHull::eol(TeXMathStream & os, row_type row, bool fragile, bool latex,
+ bool last_eoln) const
{
- docstring res;
if (numberedType()) {
- if (label_[row] && numbered(row)) {
- docstring const name =
- latex ? escape(label_[row]->getParam("name"))
- : label_[row]->getParam("name");
- res += "\\label{" + name + '}';
+ bool const for_preview =
+ (os.output() == TeXMathStream::wsPreview);
+ if (label_[row]) {
+ // Use utf8 strings for previewed labels when possible
+ bool use_utf8 = for_preview &&
+ (buffer().params().useNonTeXFonts ||
+ buffer().params().encoding().package() == Encoding::japanese);
+ docstring const name = (latex && !use_utf8)
+ ? escape(label_[row]->getParam("name"))
+ : label_[row]->getParam("name");
+ os << "\\label{" + name + '}';
}
if (type_ != hullMultline) {
if (numbered_[row] == NONUMBER)
- res += "\\nonumber ";
+ os << "\\nonumber ";
else if (numbered_[row] == NOTAG)
- res += "\\notag ";
+ os<< "\\notag ";
+ }
+ if (for_preview && !numbers_[row].empty()) {
+ os << "\\global\\def\\theequation{" << numbers_[row] << "}\n";
}
+
}
// Never add \\ on the last empty line of eqnarray and friends
last_eoln = false;
- return res + InsetMathGrid::eolString(row, fragile, latex, last_eoln);
+ InsetMathGrid::eol(os, row, fragile, latex, last_eoln);
}
-void InsetMathHull::write(WriteStream & os) const
+void InsetMathHull::write(TeXMathStream & os) const
{
ModeSpecifier specifier(os, MATH_MODE);
header_write(os);
//lyxerr << "toggling all numbers" << endl;
cur.recordUndoInset();
bool old = numberedType();
- if (type_ == hullMultline)
- numbered(nrows() - 1, !old);
- else
- for (row_type row = 0; row < nrows(); ++row)
+ if (type_ == hullMultline) {
+ row_type row = nrows() - 1;
+ numbered(row, !old);
+ if (old && label_[row]) {
+ delete label_[row];
+ label_[row] = 0;
+ }
+ } else {
+ for (row_type row = 0; row < nrows(); ++row) {
numbered(row, !old);
+ if (old && label_[row]) {
+ delete label_[row];
+ label_[row] = 0;
+ }
+ }
+ }
cur.message(old ? _("No number") : _("Number"));
cur.forceBufferUpdate();
bool old = numbered(r);
cur.message(old ? _("No number") : _("Number"));
numbered(r, !old);
+ if (old && label_[r]) {
+ delete label_[r];
+ label_[r] = 0;
+ }
cur.forceBufferUpdate();
break;
}
// if there is an argument, find the corresponding label, else
// check whether there is at least one label.
for (row = 0; row != nrows(); ++row)
- if (numbered(row) && label_[row]
+ if (label_[row]
&& (cmd.argument().empty() || label(row) == cmd.argument()))
break;
}
// if there is no argument and we're inside math, we retrieve
// the row number from the cursor position.
row_type row = (type_ == hullMultline) ? nrows() - 1 : cur.row();
- enabled = numberedType() && label_[row] && numbered(row);
+ enabled = numberedType() && label_[row];
} else {
// if there is an argument, find the corresponding label, else
// check whether there is at least one label.
for (row_type row = 0; row != nrows(); ++row) {
- if (numbered(row) && label_[row] &&
+ if (label_[row] &&
(cmd.argument().empty() || label(row) == cmd.argument())) {
enabled = true;
break;
-// simply scrap this function if you want
-void InsetMathHull::mutateToText()
-{
-#if 0
- // translate to latex
- ostringstream os;
- latex(os, false, false);
- string str = os.str();
-
- // insert this text
- Text * lt = view_->cursor().innerText();
- string::const_iterator cit = str.begin();
- string::const_iterator end = str.end();
- for (; cit != end; ++cit)
- view_->getIntl()->getTransManager().TranslateAndInsert(*cit, lt);
-
- // remove ourselves
- //dispatch(LFUN_ESCAPE);
-#endif
-}
-
-
void InsetMathHull::handleFont(Cursor & cur, docstring const & arg,
docstring const & font)
{
void InsetMathHull::edit(Cursor & cur, bool front, EntryDirection entry_from)
{
- InsetMathNest::edit(cur, front, entry_from);
+ cur.push(*this);
+ bool enter_front = (entry_from == Inset::ENTRY_DIRECTION_LEFT ||
+ (entry_from == Inset::ENTRY_DIRECTION_IGNORE && front));
+ enter_front ? idxFirst(cur) : idxLast(cur);
// The inset formula dimension is not necessarily the same as the
// one of the instant preview image, so we have to indicate to the
// BufferView that a metrics update is needed.
/////////////////////////////////////////////////////////////////////
-#if 0
-bool InsetMathHull::searchForward(BufferView * bv, string const & str,
- bool, bool)
-{
- // FIXME: completely broken
- static InsetMathHull * lastformula = 0;
- static CursorBase current = DocIterator(ibegin(nucleus()));
- static MathData ar;
- static string laststr;
-
- if (lastformula != this || laststr != str) {
- //lyxerr << "reset lastformula to " << this << endl;
- lastformula = this;
- laststr = str;
- current = ibegin(nucleus());
- ar.clear();
- mathed_parse_cell(ar, str, Parse::NORMAL, &buffer());
- } else {
- increment(current);
- }
- //lyxerr << "searching '" << str << "' in " << this << ar << endl;
-
- for (DocIterator it = current; it != iend(nucleus()); increment(it)) {
- CursorSlice & top = it.back();
- MathData const & a = top.asInsetMath()->cell(top.idx_);
- if (a.matchpart(ar, top.pos_)) {
- bv->cursor().setSelection(it, ar.size());
- current = it;
- top.pos_ += ar.size();
- bv->update();
- return true;
- }
- }
-
- //lyxerr << "not found!" << endl;
- lastformula = 0;
- return false;
-}
-#endif
-
-
void InsetMathHull::write(ostream & os) const
{
odocstringstream oss;
otexrowstream ots(oss);
- WriteStream wi(ots, false, false, WriteStream::wsDefault);
+ TeXMathStream wi(ots, false, false, TeXMathStream::wsDefault);
oss << "Formula ";
write(wi);
os << to_utf8(oss.str());
odocstringstream oss;
otexrowstream ots(oss);
Encoding const * const enc = encodings.fromLyXName("utf8");
- WriteStream wi(ots, false, true, WriteStream::wsDefault, enc);
+ TeXMathStream::OutputType ot;
+ if (op.find_effective())
+ ot = TeXMathStream::wsSearchAdv;
+ else
+ ot = TeXMathStream::wsDefault;
// Fix Bug #6139
- if (type_ == hullRegexp)
+ if (type_ == hullRegexp) {
+ TeXMathStream wi(ots, false, true, ot, enc);
write(wi);
+ }
else {
+ TeXMathStream wi(ots, false, true, ot, enc);
for (row_type r = 0; r < nrows(); ++r) {
for (col_type c = 0; c < ncols(); ++c)
wi << (c == 0 ? "" : "\t") << cell(index(r, c));
}
-void InsetMathHull::docbook(XMLStream & xs, OutputParams const & runparams) const
-{
+void InsetMathHull::docbook(XMLStream & xs, OutputParams const & runparams) const {
// Choose the tag around the MathML equation.
docstring name;
+ bool doCR = false;
if (getType() == hullSimple)
name = from_ascii("inlineequation");
- else
+ else {
+ doCR = true; // This is a block equation, always have <informalequation> on its own line.
name = from_ascii("informalequation");
+ }
// DocBook also has <equation>, but it comes with a title.
+ // TODO: recognise \tag from amsmath? This would allow having <equation> with a proper title.
docstring attr;
+
+ bool mathmlNamespaceInline = buffer().params().docbook_mathml_prefix == BufferParams::NoPrefix;
+ if (mathmlNamespaceInline)
+ attr += "xmlns=\"http://www.w3.org/1998/Math/MathML\"";
+
for (row_type i = 0; i < nrows(); ++i) {
if (!label(i).empty()) {
- attr = "xml:id=\"" + xml::cleanID(label(i)) + "\"";
+ if (!attr.empty())
+ attr += " ";
+
+ attr += "xml:id=\"" + xml::cleanID(label(i)) + "\"";
break;
}
}
+ if (doCR)
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+
xs << xml::StartTag(name, attr);
xs << xml::CR();
- // With DocBook 5, MathML must be within its own namespace; defined in Buffer.cpp::writeDocBookSource as "m".
+ // With DocBook 5, MathML must be within its own namespace (defined in Buffer.cpp::writeDocBookSource, except when
+ // it should be inlined).
// Output everything in a separate stream so that this does not interfere with the standard flow of DocBook tags.
+ std::string mathmlNamespacePrefix;
+ if (!mathmlNamespaceInline) {
+ if (buffer().params().docbook_mathml_prefix == BufferParams::MPrefix)
+ mathmlNamespacePrefix = "m";
+ else if (buffer().params().docbook_mathml_prefix == BufferParams::MMLPrefix)
+ mathmlNamespacePrefix = "mml";
+ }
+
odocstringstream osmath;
- MathStream ms(osmath, "m", true);
+ MathMLStream ms(osmath, mathmlNamespacePrefix);
// Output the MathML subtree.
- odocstringstream ls;
- otexstream ols(ls);
-
// TeX transcription. Avoid MTag/ETag so that there are no extraneous spaces.
ms << "<" << from_ascii("alt") << " role='tex'" << ">";
// Workaround for db2latex: db2latex always includes equations with
// \ensuremath{} or \begin{display}\end{display}
// so we strip LyX' math environment
- WriteStream wi(ols, false, false, WriteStream::wsDefault, runparams.encoding);
+ odocstringstream ls;
+ otexstream ols(ls);
+ TeXMathStream wi(ols, false, false, TeXMathStream::wsDefault, runparams.encoding);
InsetMathGrid::write(wi);
ms << from_utf8(subst(subst(to_utf8(ls.str()), "&", "&"), "<", "<"));
ms << "</" << from_ascii("alt") << ">";
// temporary stream; then, if it is possible without error, then copy it back to the "real" stream. Otherwise,
// some incomplete tags might be put into the real stream.
try {
- // First, generate the MathML expression.
+ // First, generate the MathML expression. If there is an error in the generation, this block is not fully
+ // executed, and the formula is not output to the DocBook stream.
odocstringstream ostmp;
- MathStream mstmp(ostmp, ms.xmlns(), ms.xmlMode());
- InsetMathGrid::mathmlize(mstmp);
+ MathMLStream mstmp(ostmp, ms.xmlns());
+ mathmlize(mstmp);
- // Then, output it (but only if the generation can be done without errors!).
- ms << MTag("math");
+ // Choose the display style for the formula, to be output as an attribute near the formula root.
+ std::string mathmlAttr;
+ if (getType() == hullSimple)
+ mathmlAttr = "display=\"inline\"";
+ else
+ mathmlAttr = "display=\"block\"";
+
+ // Then, output the formula.
+ ms << MTag("math", mathmlAttr);
ms.cr();
osmath << ostmp.str(); // osmath is not a XMLStream, so no need for XMLStream::ESCAPE_NONE.
ms << ETag("math");
} catch (MathExportException const &) {
- osmath << "MathML export failed. Please report this as a bug.";
+ ms.cr();
+ osmath << "<mathphrase>MathML export failed. Please report this as a bug to the LyX developers: "
+ "https://www.lyx.org/trac.</mathphrase>";
}
// Output the complete formula to the DocBook stream.
xs << XMLStream::ESCAPE_NONE << osmath.str();
xs << xml::CR();
xs << xml::EndTag(name);
+ if (doCR)
+ xs << xml::CR();
}
// this duplicates code from InsetMathGrid, but
// we need access here to number information,
// and we simply do not have that in InsetMathGrid.
-void InsetMathHull::mathmlize(MathStream & ms) const
+void InsetMathHull::mathmlize(MathMLStream & ms) const
{
- bool const havenumbers = haveNumbers();
- bool const havetable = havenumbers || nrows() > 1 || ncols() > 1;
+ bool const havetable = haveNumbers() || nrows() > 1 || ncols() > 1;
+
+ // Simplest case: single row, single column, no numbering.
+ if (!havetable) {
+ ms << cell(index(0, 0));
+ return;
+ }
+
+ // More complex case: wrap elements in a table.
+ if (getType() == hullSimple) {
+ ms << MTag("mtable");
+ } else if (getType() >= hullAlign && getType() <= hullXXAlignAt) {
+ // hullAlign, hullAlignAt, hullXAlignAt, hullXXAlignAt
+ string alignment;
+ for (col_type col = 0; col < ncols(); ++col) {
+ alignment += (col % 2) ? "left " : "right ";
+ }
+ ms << MTag("mtable", "displaystyle='true' columnalign='" + alignment + "'");
+ } else {
+ ms << MTag("mtable", "displaystyle='true'");
+ }
- if (havetable)
- ms << MTag("mtable");
- char const * const celltag = havetable ? "mtd" : "mrow";
- // FIXME There does not seem to be wide support at the moment
- // for mlabeledtr, so we have to use just mtr for now.
- // char const * const rowtag = havenumbers ? "mlabeledtr" : "mtr";
- char const * const rowtag = "mtr";
for (row_type row = 0; row < nrows(); ++row) {
- if (havetable)
- ms << MTag(rowtag);
+ // No Wed browser supports mlabeledtr in 2023, even though it has been introduced in
+ // MathML 2 (2003). Moreover, it is not supported in MathML 4 Core.
+ ms << MTag("mtr");
+
for (col_type col = 0; col < ncols(); ++col) {
- ms << MTag(celltag)
+ ms << MTag("mtd")
<< cell(index(row, col))
- << ETag(celltag);
+ << ETag("mtd");
}
+
// fleqn?
- if (havenumbers) {
+ if (haveNumbers()) {
ms << MTag("mtd");
docstring const & num = numbers_[row];
if (!num.empty())
- ms << '(' << num << ')';
- ms << ETag("mtd");
+ ms << MTagInline("mtext") << '(' << num << ')' << ETagInline("mtext");
+ ms << ETag("mtd");
}
- if (havetable)
- ms << ETag(rowtag);
+
+ ms << ETag("mtr");
}
- if (havetable)
- ms << ETag("mtable");
+
+ ms << ETag("mtable");
}
-void InsetMathHull::mathAsLatex(WriteStream & os) const
+docstring InsetMathHull::mathAsLatex() const
{
- MathEnsurer ensurer(os, false);
- bool havenumbers = haveNumbers();
+ bool const havenumbers = haveNumbers();
bool const havetable = havenumbers || nrows() > 1 || ncols() > 1;
if (!havetable) {
+ odocstringstream ls;
+ otexrowstream ots(ls);
+ TeXMathStream os(ots, false, true, TeXMathStream::wsPreview);
+ ModeSpecifier specifier(os, MATH_MODE);
+ MathEnsurer ensurer(os, false);
+
os << cell(index(0, 0));
- return;
+ return ls.str();
}
- os << "<table class='mathtable'>";
+ odocstringstream ods;
+ XMLStream xs(ods);
+
+ xs << xml::StartTag("table", "class='mathtable'");
for (row_type row = 0; row < nrows(); ++row) {
- os << "<tr>";
+ xs << xml::StartTag("tr");
for (col_type col = 0; col < ncols(); ++col) {
- os << "<td class='math'>";
- os << cell(index(row, col));
- os << "</td>";
+ xs << xml::StartTag("td", "class='math'");
+
+ odocstringstream ls;
+ otexrowstream ots(ls);
+ TeXMathStream os(ots, false, true, TeXMathStream::wsPreview);
+ ModeSpecifier specifier(os, MATH_MODE);
+ MathEnsurer ensurer(os, false);
+
+ os << cell(index(0, 0));
+ // ls.str() contains a raw LaTeX string, which might require some encoding before being valid XML.
+ xs << ls.str();
+
+ xs << xml::EndTag("td");
}
if (havenumbers) {
- os << "<td>";
+ xs << xml::StartTag("td");
docstring const & num = numbers_[row];
- if (!num.empty())
- os << '(' << num << ')';
- os << "</td>";
+ if (!num.empty()) {
+ xs << '(' << num << ')';
+ }
+ xs << xml::EndTag("td");
}
- os << "</tr>";
+ xs << xml::EndTag("tr");
}
- os << "</table>";
+ xs << xml::EndTag("table");
+
+ return ods.str();
}
// FIXME Eventually we would like to do this inset by inset.
if (mathtype == BufferParams::MathML) {
odocstringstream os;
- MathStream ms(os);
+ MathMLStream ms(os);
try {
mathmlize(ms);
success = true;
} catch (MathExportException const &) {}
if (success) {
+ string const name_space_declaration = "xmlns='http://www.w3.org/1998/Math/MathML'";
if (getType() == hullSimple)
- xs << xml::StartTag("math",
- "xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
- else
- xs << xml::StartTag("math",
- "display=\"block\" xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
+ xs << xml::StartTag("math", name_space_declaration, true);
+ else {
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::StartTag("math", name_space_declaration + " display='block'", true);
+ }
+
xs << XMLStream::ESCAPE_NONE
- << os.str()
- << xml::EndTag("math");
+ << os.str();
+
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::EndTag("math") << xml::CR();
}
+ // In case of failure, generate an image.
} else if (mathtype == BufferParams::HTML) {
odocstringstream os;
HtmlStream ms(os);
<< os.str()
<< xml::EndTag(tag);
}
+ // In case of failure, generate an image.
}
// what we actually want is this:
//
// so this is for Images.
if (!success && mathtype != BufferParams::LaTeX) {
- graphics::PreviewImage const * pimage = 0;
+ graphics::PreviewImage const * pimage = nullptr;
if (!op.dryrun) {
loadPreview(docit_);
pimage = preview_->getPreviewImage(buffer());
string const tag = (getType() == hullSimple) ? "span" : "div";
xs << xml::CR()
<< xml::StartTag(tag, "style = \"text-align: center;\"")
- << xml::CompTag("img", "src=\"" + filename + "\" alt=\"Mathematical Equation\"")
- << xml::EndTag(tag)
- << xml::CR();
+ << xml::CompTag("img", "src=\"" + filename + R"(" alt="Mathematical Equation")")
+ << xml::EndTag(tag)
+ << xml::CR();
success = true;
}
}
if (!success /* || mathtype != BufferParams::LaTeX */) {
// Unfortunately, we cannot use latexString() because we do not want
// $...$ or whatever.
- odocstringstream ls;
- otexrowstream ots(ls);
- WriteStream wi(ots, false, true, WriteStream::wsPreview);
- ModeSpecifier specifier(wi, MATH_MODE);
- mathAsLatex(wi);
- docstring const latex = ls.str();
+ // The returned value already has the correct escaping for HTML.
+ docstring const latex = mathAsLatex();
// class='math' allows for use of jsMath
// http://www.math.union.edu/~dpvc/jsMath/
// probably should allow for some kind of customization here
string const tag = (getType() == hullSimple) ? "span" : "div";
xs << xml::StartTag(tag, "class='math'")
- << latex
+ << XMLStream::ESCAPE_NONE << latex // Don't escape anything: latex might contain XML.
<< xml::EndTag(tag)
<< xml::CR();
}
void InsetMathHull::toString(odocstream & os) const
{
odocstringstream ods;
- plaintext(ods, OutputParams(0));
+ plaintext(ods, OutputParams(nullptr));
os << ods.str();
}
void InsetMathHull::forOutliner(docstring & os, size_t const, bool const) const
{
odocstringstream ods;
- OutputParams op(0);
+ OutputParams op(nullptr);
op.for_toc = true;
// FIXME: this results in spilling TeX into the LyXHTML output since the
// outliner is used to generate the LyXHTML list of figures/etc.
projects / lyx.git / blobdiff