#include "InsetMathHull.h"
-#include "InsetMathArray.h"
#include "InsetMathChar.h"
#include "InsetMathColor.h"
-#include "InsetMathDelim.h"
-#include "InsetMathRef.h"
-#include "InsetMathSpace.h"
-#include "MathData.h"
#include "MathExtern.h"
#include "MathFactory.h"
-#include "MathParser.h"
#include "MathStream.h"
#include "MathSupport.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "Cursor.h"
+#include "ColorSet.h"
#include "CutAndPaste.h"
-#include "DispatchResult.h"
#include "Encoding.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
#include "LaTeXFeatures.h"
-#include "Language.h"
#include "LyXRC.h"
-#include "OutputParams.h"
-#include "ParIterator.h"
+#include "MacroTable.h"
+#include "output_xhtml.h"
#include "sgml.h"
-#include "Text.h"
#include "TextPainter.h"
#include "TocBackend.h"
static InsetLabel * dummy_pointer = 0;
InsetMathHull::InsetMathHull(Buffer * buf)
- : InsetMathGrid(1, 1), type_(hullNone), nonum_(1, false),
+ : InsetMathGrid(buf, 1, 1), type_(hullNone), nonum_(1, false),
label_(1, dummy_pointer), preview_(new RenderPreview(this))
{
//lyxerr << "sizeof InsetMath: " << sizeof(InsetMath) << endl;
}
-InsetMathHull::InsetMathHull(HullType type, Buffer * buf)
- : InsetMathGrid(getCols(type), 1), type_(type), nonum_(1, false),
+InsetMathHull::InsetMathHull(Buffer * buf, HullType type)
+ : InsetMathGrid(buf, getCols(type), 1), type_(type), nonum_(1, false),
label_(1, dummy_pointer), preview_(new RenderPreview(this))
{
buffer_ = buf;
}
-InsetMathHull::InsetMathHull(InsetMathHull const & other) : InsetMathGrid()
+InsetMathHull::InsetMathHull(InsetMathHull const & other) : InsetMathGrid(other)
{
operator=(other);
}
}
-void InsetMathHull::updateLabels(ParIterator const & it)
+void InsetMathHull::updateBuffer(ParIterator const & it, UpdateType utype)
{
if (!buffer_) {
//FIXME: buffer_ should be set at creation for this inset! Problem is
}
for (size_t i = 0; i != label_.size(); ++i) {
if (label_[i])
- label_[i]->updateLabels(it);
+ label_[i]->updateBuffer(it, utype);
}
+ // pass down
+ InsetMathGrid::updateBuffer(it, utype);
}
docstring InsetMathHull::standardFont() const
{
- return from_ascii(type_ == hullNone ? "lyxnochange" : "mathnormal");
+ const char *font_name;
+ switch (type_) {
+ case hullRegexp:
+ font_name = "texttt";
+ break;
+ case hullNone:
+ font_name = "lyxnochange";
+ break;
+ default:
+ font_name = "mathnormal";
+ }
+ return from_ascii(font_name);
}
}
+ColorCode InsetMathHull::backgroundColor(PainterInfo const & pi) const
+{
+ if (previewState(pi.base.bv))
+ return graphics::PreviewLoader::backgroundColor();
+ return Color_mathbg;
+}
+
+
void InsetMathHull::drawBackground(PainterInfo & pi, int x, int y) const
{
Dimension const dim = dimension(*pi.base.bv);
{
use_preview_ = previewState(pi.base.bv);
+ if (type_ == hullRegexp) {
+ Dimension const dim = dimension(*pi.base.bv);
+ pi.pain.rectangle(x + 1, y - dim.ascent() + 1,
+ dim.width() - 2, dim.height() - 2, Color_regexpframe);
+ }
if (use_preview_) {
// one pixel gap in front
preview_->draw(pi, x + 1, y);
}
-void InsetMathHull::addPreview(graphics::PreviewLoader & ploader) const
+void InsetMathHull::addPreview(DocIterator const & inset_pos,
+ graphics::PreviewLoader & /*ploader*/) const
{
if (RenderPreview::status() == LyXRC::PREVIEW_ON) {
- docstring const snippet = latexString(*this);
- preview_->addPreview(snippet, ploader);
+ preparePreview(inset_pos);
}
}
-bool InsetMathHull::notifyCursorLeaves(Cursor const & /*old*/, Cursor & cur)
+void InsetMathHull::preparePreview(DocIterator const & pos) const
+{
+ Buffer const * buffer = pos.buffer();
+
+ // collect macros at this position
+ MacroNameSet macros;
+ buffer->listMacroNames(macros);
+ MacroNameSet::iterator it = macros.begin();
+ MacroNameSet::iterator end = macros.end();
+ odocstringstream macro_preamble;
+ for (; it != end; ++it) {
+ MacroData const * data = buffer->getMacro(*it, pos, true);
+ if (data) {
+ data->write(macro_preamble, true);
+ macro_preamble << endl;
+ }
+ }
+
+ docstring const snippet = macro_preamble.str() + latexString(*this);
+ LYXERR(Debug::MACROS, "Preview snippet: " << snippet);
+ preview_->addPreview(snippet, *buffer);
+}
+
+
+void InsetMathHull::reloadPreview(DocIterator const & pos) const
+{
+ preparePreview(pos);
+ preview_->startLoading(*pos.buffer());
+}
+
+
+bool InsetMathHull::notifyCursorLeaves(Cursor const & old, Cursor & cur)
{
if (RenderPreview::status() == LyXRC::PREVIEW_ON) {
- Buffer const * buffer = cur.buffer();
- docstring const snippet = latexString(*this);
- preview_->addPreview(snippet, *buffer);
- preview_->startLoading(*buffer);
+ reloadPreview(old);
cur.updateFlags(Update::Force);
}
return false;
delete label_[row];
label_[row] = dummy_pointer;
// We need an update of the Buffer reference cache.
- // This is achieved by updateLabels().
+ // This is achieved by updateBuffer().
if (buffer_)
- buffer().updateLabels();
+ buffer().updateBuffer();
} else {
if (buffer_)
label_[row]->updateCommand(label);
}
InsetCommandParams p(LABEL_CODE);
p["name"] = label;
- label_[row] = new InsetLabel(p);
+ label_[row] = new InsetLabel(buffer_, p);
if (buffer_)
label_[row]->setBuffer(buffer());
}
return;
}
// We need an update of the Buffer reference cache.
- // This is achieved by updateLabels().
- buffer().updateLabels();
+ // This is achieved by updateBuffer().
+ buffer().updateBuffer();
}
}
if (ams())
features.require("amsmath");
+ if (type_ == hullRegexp) {
+ features.require("color");
+ string frcol = lcolor.getLaTeXName(Color_regexpframe);
+ string bgcol = "white";
+ features.addPreambleSnippet(
+ string("\\newcommand{\\regexp}[1]{\\fcolorbox{")
+ + frcol + string("}{")
+ + bgcol + string("}{\\texttt{#1}}}"));
+ }
+
// Validation is necessary only if not using AMS math.
// To be safe, we will always run mathedvalidate.
//if (features.amsstyle)
break;
case hullRegexp:
- os << "\\regexp{";
+ os << "\\regexp{{{";
break;
default:
break;
case hullRegexp:
- os << "}";
+ os << "}}}";
break;
default:
MathData ar;
for (idx_type i = 0; i < nargs(); ++i)
ar.append(cell(i));
- *this = InsetMathHull(hullSimple, &buffer());
+ *this = InsetMathHull(buffer_, hullSimple);
cell(0) = ar;
setDefaults();
}
for (row_type row = 0; row < nrows(); ++row) {
idx_type const i = 2 * row;
pos_type pos = firstRelOp(cell(i));
- cell(i + 1) = MathData(cell(i).begin() + pos, cell(i).end());
+ cell(i + 1) = MathData(buffer_, cell(i).begin() + pos, cell(i).end());
cell(i).erase(pos, cell(i).size());
}
}
for (row_type row = 0; row < nrows(); ++row) {
idx_type const i = 3 * row + 1;
if (cell(i).size()) {
- cell(i + 1) = MathData(cell(i).begin() + 1, cell(i).end());
+ cell(i + 1) = MathData(buffer_, cell(i).begin() + 1, cell(i).end());
cell(i).erase(1, cell(i).size());
}
}
docstring res;
if (numberedType()) {
if (label_[row] && !nonum_[row])
- res += "\\label{" + label_[row]->getParam("name") + '}';
+ res += "\\label{" +
+ escape(label_[row]->getParam("name")) + '}';
if (nonum_[row] && (type_ != hullMultline))
res += "\\nonumber ";
}
ar = cur.cell();
lyxerr << "use whole cell: " << ar << endl;
} else {
- ar = MathData(cur.cell().begin() + pos + 1, cur.cell().end());
+ ar = MathData(buffer_, cur.cell().begin() + pos + 1, cur.cell().end());
lyxerr << "use partial cell form pos: " << pos << endl;
}
cur.cell().append(eq);
InsetCommandParams p(REF_CODE, "ref");
p["reference"] = label(row);
cap::clearSelection();
- cap::copyInset(cur, new InsetRef(*cur.buffer(), p), label(row));
+ cap::copyInset(cur, new InsetRef(buffer_, p), label(row));
break;
}
}
return InsetMathGrid::getStatus(cur, cmd, status);
- case LFUN_TABULAR_FEATURE: {
+ case LFUN_INSET_MODIFY: {
istringstream is(to_utf8(cmd.argument()));
string s;
is >> s;
+ if (s != "tabular")
+ return InsetMathGrid::getStatus(cur, cmd, status);
+ is >> s;
if (!rowChangeOK()
&& (s == "append-row"
|| s == "delete-row"
if (cur.inset().asInsetMath()->name() == font)
cur.handleFont(to_utf8(font));
else {
- cur.handleNest(createInsetMath(font));
+ cur.handleNest(createInsetMath(font, cur.buffer()));
cur.insert(arg);
}
}
bool b;
font.fromString(to_utf8(arg), b);
if (font.fontInfo().color() != Color_inherit) {
- MathAtom at = MathAtom(new InsetMathColor(true, font.fontInfo().color()));
+ MathAtom at = MathAtom(new InsetMathColor(buffer_, true, font.fontInfo().color()));
cur.handleNest(at, 0);
}
}
void InsetMathHull::read(Lexer & lex)
{
MathAtom at;
- mathed_parse_normal(at, lex, Parse::NORMAL, &buffer());
+ mathed_parse_normal(buffer_, at, lex, Parse::TRACKMACRO);
operator=(*at->asHullInset());
}
bool InsetMathHull::readQuiet(Lexer & lex)
{
MathAtom at;
- bool success = mathed_parse_normal(at, lex, Parse::QUIET, &buffer());
+ bool success = mathed_parse_normal(buffer_, at, lex, Parse::QUIET);
if (success)
operator=(*at->asHullInset());
return success;
}
+docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const &) const
+{
+ if (getType() == hullSimple)
+ xs << html::StartTag("math", "xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
+ else
+ xs << html::StartTag("math",
+ "display=\"block\" xmlns=\"http://www.w3.org/1998/Math/MathML\"", true);
+ MathStream ms(xs.os());
+ InsetMathGrid::mathmlize(ms);
+ xs << html::EndTag("math");
+ return docstring();
+}
+
+
void InsetMathHull::tocString(odocstream & os) const
{
plaintext(os, OutputParams(0));
projects / features.git / blobdiff