-/*
-* File: formula.C
-* Purpose: Implementation of formula inset
-* Author: Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
-* Created: January 1996
-* Description: Allows the edition of math paragraphs inside Lyx.
-*
-* Copyright: 1996-1998 Alejandro Aguilar Sierra
-*
-* Version: 0.4, Lyx project.
-*
-* You are free to use and modify this code under the terms of
-* the GNU General Public Licence version 2 or later.
-*/
-
-#ifdef __GNUG__
-#pragma implementation
-#endif
+/**
+ * \file formula.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Alejandro Aguilar Sierra
+ * \author André Pönitz
+ *
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "formula.h"
-#include "commandtags.h"
#include "math_cursor.h"
#include "math_parser.h"
-#include "math_charinset.h"
-#include "math_arrayinset.h"
-#include "math_deliminset.h"
-#include "lyx_main.h"
-#include "BufferView.h"
-#include "gettext.h"
-#include "debug.h"
-#include "support/LOstream.h"
-#include "support/LAssert.h"
-#include "support/lyxlib.h"
-#include "support/systemcall.h"
-#include "support/filetools.h"
-#include "frontends/Alert.h"
-#include "frontends/LyXView.h"
-#include "frontends/Painter.h"
-#include "graphics/GraphicsImage.h"
-#include "lyxrc.h"
#include "math_hullinset.h"
-#include "math_support.h"
#include "math_mathmlstream.h"
#include "textpainter.h"
-#include <fstream>
+#include "BufferView.h"
+#include "debug.h"
+#include "LColor.h"
+#include "lyx_main.h"
+#include "outputparams.h"
+
+#include "frontends/Painter.h"
+
+#include "graphics/PreviewLoader.h"
+
+#include "insets/render_preview.h"
+
+#include "support/std_sstream.h"
+
#include <boost/bind.hpp>
-#include <boost/utility.hpp>
+using std::string;
using std::ostream;
-using std::ifstream;
-using std::istream;
-using std::pair;
-using std::endl;
+using std::ostringstream;
using std::vector;
-using std::getline;
+using std::auto_ptr;
+using std::endl;
+InsetFormula::InsetFormula(bool chemistry)
+ : par_(MathAtom(new MathHullInset)),
+ preview_(new RenderPreview)
+{
+ preview_->connect(boost::bind(&InsetFormula::statusChanged, this));
+ if (chemistry)
+ mutate("chemistry");
+}
-InsetFormula::InsetFormula()
- : par_(MathAtom(new MathHullInset)), loader_(0)
-{}
+
+InsetFormula::InsetFormula(InsetFormula const & other)
+ : InsetFormulaBase(other),
+ par_(other.par_),
+ preview_(new RenderPreview)
+{
+ preview_->connect(boost::bind(&InsetFormula::statusChanged, this));
+}
-InsetFormula::InsetFormula(BufferView * bv)
- : par_(MathAtom(new MathHullInset)), loader_(0)
+InsetFormula::InsetFormula(BufferView *)
+ : par_(MathAtom(new MathHullInset)),
+ preview_(new RenderPreview)
{
- view_ = bv;
+ preview_->connect(boost::bind(&InsetFormula::statusChanged, this));
}
InsetFormula::InsetFormula(string const & data)
- : par_(MathAtom(new MathHullInset)), loader_(0)
+ : par_(MathAtom(new MathHullInset)),
+ preview_(new RenderPreview)
{
+ preview_->connect(boost::bind(&InsetFormula::statusChanged, this));
if (!data.size())
return;
if (!mathed_parse_normal(par_, data))
- lyxerr << "cannot interpret '" << data << "' as math\n";
+ lyxerr << "cannot interpret '" << data << "' as math" << endl;
}
+InsetFormula::~InsetFormula()
+{}
+
-Inset * InsetFormula::clone(Buffer const &, bool) const
+auto_ptr<InsetBase> InsetFormula::clone() const
{
- return new InsetFormula(*this);
+ return auto_ptr<InsetBase>(new InsetFormula(*this));
}
-void InsetFormula::write(Buffer const *, ostream & os) const
+void InsetFormula::write(Buffer const &, ostream & os) const
{
- os << "Formula ";
WriteStream wi(os, false, false);
+ os << par_->fileInsetLabel() << ' ';
par_->write(wi);
}
-int InsetFormula::latex(Buffer const *, ostream & os, bool fragile, bool) const
+int InsetFormula::latex(Buffer const &, ostream & os,
+ OutputParams const & runparams) const
{
- WriteStream wi(os, fragile, true);
+ WriteStream wi(os, runparams.moving_arg, true);
par_->write(wi);
return wi.line();
}
-
-int InsetFormula::ascii(Buffer const *, ostream & os, int) const
+int InsetFormula::plaintext(Buffer const &, ostream & os,
+ OutputParams const &) const
{
-#if 0
- TextMetricsInfo mi;
- par()->metricsT(mi);
- TextPainter tpain(par()->width(), par()->height());
- par()->drawT(tpain, 0, par()->ascent());
- tpain.show(os);
- // reset metrics cache to "real" values
- metrics();
- return tpain.textheight();
-#else
- WriteStream wi(os, false, true);
- par_->write(wi);
- return wi.line();
-#endif
+ if (0 && display()) {
+ Dimension dim;
+ TextMetricsInfo mi;
+ par()->metricsT(mi, dim);
+ TextPainter tpain(dim.width(), dim.height());
+ par()->drawT(tpain, 0, dim.ascent());
+ tpain.show(os, 3);
+ // reset metrics cache to "real" values
+ //metrics();
+ return tpain.textheight();
+ } else {
+ WriteStream wi(os, false, true);
+ wi << ' ' << (par_->asNestInset()->cell(0)) << ' ';
+ return wi.line();
+ }
}
-int InsetFormula::linuxdoc(Buffer const * buf, ostream & os) const
+int InsetFormula::linuxdoc(Buffer const & buf, ostream & os,
+ OutputParams const & runparams) const
{
- return docbook(buf, os, false);
+ return docbook(buf, os, runparams);
}
-int InsetFormula::docbook(Buffer const * buf, ostream & os, bool) const
+int InsetFormula::docbook(Buffer const & buf, ostream & os,
+ OutputParams const & runparams) const
{
MathMLStream ms(os);
ms << MTag("equation");
ms << MTag("alt");
ms << "<[CDATA[";
- int res = ascii(buf, ms.os(), 0);
+ int res = plaintext(buf, ms.os(), runparams);
ms << "]]>";
ms << ETag("alt");
ms << MTag("math");
- ms << par_.nucleus();
+ ms << par_;
ms << ETag("math");
ms << ETag("equation");
return ms.line() + res;
}
-void InsetFormula::read(Buffer const *, LyXLex & lex)
+void InsetFormula::read(Buffer const &, LyXLex & lex)
{
mathed_parse_normal(par_, lex);
- metrics();
- updatePreview();
-}
-
-
-//ostream & operator<<(ostream & os, LyXCursor const & c)
-//{
-// os << '[' << c.x() << ' ' << c.y() << ' ' << c.pos() << ']';
-// return os;
-//}
-
-
-void InsetFormula::draw(BufferView * bv, LyXFont const & font,
- int y, float & xx, bool) const
-{
- int const x = int(xx);
- int const w = width(bv, font);
- int const d = descent(bv, font);
- int const a = ascent(bv, font);
- int const h = a + d;
-
- MathPainterInfo pi(bv->painter());
-
- if (canPreview()) {
- pi.pain.image(x + 1, y - a + 1, w - 2, h - 2, *(loader_->image()));
- } else {
- //pi.base.style = display() ? LM_ST_DISPLAY : LM_ST_TEXT;
- pi.base.style = LM_ST_TEXT;
- pi.base.font = font;
- pi.base.font.setColor(LColor::math);
- if (lcolor.getX11Name(LColor::mathbg)
- != lcolor.getX11Name(LColor::background))
- pi.pain.fillRectangle(x, y - a, w, h, LColor::mathbg);
-
- if (mathcursor &&
- const_cast<InsetFormulaBase const *>(mathcursor->formula()) == this)
- {
- mathcursor->drawSelection(pi);
- pi.pain.rectangle(x, y - a, w, h, LColor::mathframe);
+ // remove extra 'mathrm' for chemistry stuff.
+ // will be re-added on write
+ if (par_->asHullInset()->getType() =="chemistry") {
+ lyxerr << "this is chemistry" << endl;
+ if (par_->cell(0).size() == 1) {
+ lyxerr << "this is size 1" << endl;
+ if (par_->cell(0)[0]->asFontInset()) {
+ lyxerr << "this is a font inset "
+ << "replacing " << par_.nucleus()->cell(0) <<
+ " with " << par_->cell(0)[0]->cell(0) << endl;
+ }
}
-
- par_->draw(pi, x, y);
}
-
- xx += w;
- xo_ = x;
- yo_ = y;
-
- setCursorVisible(false);
+ //metrics();
}
-vector<string> const InsetFormula::getLabelList() const
-{
- return hull()->getLabelList();
-}
-
+namespace {
-UpdatableInset::RESULT
-InsetFormula::localDispatch(BufferView * bv, kb_action action,
- string const & arg)
+bool editing_inset(InsetFormula const * inset)
{
- RESULT result = DISPATCHED;
-
- switch (action) {
-
- case LFUN_BREAKLINE:
- bv->lockedInsetStoreUndo(Undo::INSERT);
- mathcursor->breakLine();
- mathcursor->normalize();
- updateLocal(bv, true);
- break;
-
- case LFUN_MATH_NUMBER:
- {
- //lyxerr << "toggling all numbers\n";
- if (display()) {
- bv->lockedInsetStoreUndo(Undo::INSERT);
- bool old = hull()->numberedType();
- for (MathInset::row_type row = 0; row < par_->nrows(); ++row)
- hull()->numbered(row, !old);
- bv->owner()->message(old ? _("No number") : _("Number"));
- updateLocal(bv, true);
- }
- break;
- }
-
- case LFUN_MATH_NONUMBER:
- {
- //lyxerr << "toggling line number\n";
- if (display()) {
- bv->lockedInsetStoreUndo(Undo::INSERT);
- MathCursor::row_type row = mathcursor->hullRow();
- bool old = hull()->numbered(row);
- bv->owner()->message(old ? _("No number") : _("Number"));
- hull()->numbered(row, !old);
- updateLocal(bv, true);
- }
- break;
- }
-
- case LFUN_INSERT_LABEL:
- {
- bv->lockedInsetStoreUndo(Undo::INSERT);
-
- MathCursor::row_type row = mathcursor->hullRow();
- string old_label = hull()->label(row);
- string new_label = arg;
-
- if (new_label.empty()) {
- string const default_label =
- (lyxrc.label_init_length >= 0) ? "eq:" : "";
- pair<bool, string> const res = old_label.empty()
- ? Alert::askForText(_("Enter new label to insert:"), default_label)
- : Alert::askForText(_("Enter label:"), old_label);
- if (!res.first)
- break;
- new_label = frontStrip(strip(res.second));
- }
-
- //if (new_label == old_label)
- // break; // Nothing to do
-
- if (!new_label.empty()) {
- lyxerr << "setting label to '" << new_label << "'\n";
- hull()->numbered(row, true);
- }
+ return mathcursor &&
+ (const_cast<InsetFormulaBase const *>(mathcursor->formula()) ==
+ inset);
+}
-#warning FIXME: please check you really mean repaint() ... is it needed,
-#warning and if so, should it be update() instead ?
- if (!new_label.empty() && bv->ChangeRefsIfUnique(old_label, new_label))
- bv->repaint();
+} // namespace anon
- hull()->label(row, new_label);
- updateLocal(bv, true);
- break;
- }
+void InsetFormula::draw(PainterInfo & pi, int x, int y) const
+{
+ xo_ = x;
+ yo_ = y;
- case LFUN_MATH_MUTATE:
- {
- bv->lockedInsetStoreUndo(Undo::EDIT);
- int x;
- int y;
- mathcursor->getPos(x, y);
- mutate(arg);
- mathcursor->setPos(x, y);
- mathcursor->normalize();
- updateLocal(bv, true);
- break;
- }
+ // The previews are drawn only when we're not editing the inset.
+ bool const use_preview = !editing_inset(this)
+ && RenderPreview::activated()
+ && preview_->previewReady();
- case LFUN_MATH_EXTERN:
- {
- bv->lockedInsetStoreUndo(Undo::EDIT);
- if (mathcursor)
- mathcursor->handleExtern(arg);
- // re-compute inset dimension
- metrics(bv);
- updateLocal(bv, true);
- break;
- }
+ int const w = dim_.wid;
+ int const d = dim_.des;
+ int const a = dim_.asc;
+ int const h = a + d;
- case LFUN_MATH_DISPLAY:
- {
- int x = 0;
- int y = 0;
- mathcursor->getPos(x, y);
- if (hullType() == "simple")
- mutate("equation");
- else
- mutate("simple");
- mathcursor->setPos(x, y);
- mathcursor->normalize();
- updateLocal(bv, true);
- break;
- }
+ if (use_preview) {
+ // one pixel gap in front
+ preview_->draw(pi, x + 1, y);
+ } else {
+ PainterInfo p(pi.base.bv);
+ p.base.style = LM_ST_TEXT;
+ p.base.font = pi.base.font;
+ p.base.font.setColor(LColor::math);
+ if (lcolor.getX11Name(LColor::mathbg)
+ != lcolor.getX11Name(LColor::background))
+ p.pain.fillRectangle(x, y - a, w, h, LColor::mathbg);
- case LFUN_PASTESELECTION:
- {
- string const clip = bv->getClipboard();
- if (!clip.empty())
- mathed_parse_normal(par_, clip);
- break;
+ if (editing_inset(this)) {
+ mathcursor->drawSelection(pi);
+ //p.pain.rectangle(x, y - a, w, h, LColor::mathframe);
}
- default:
- result = InsetFormulaBase::localDispatch(bv, action, arg);
+ par_->draw(p, x, y);
}
-
- //updatePreview();
-
- return result;
-}
-
-
-bool InsetFormula::display() const
-{
- return hullType() != "simple" && hullType() != "none";
-}
-
-
-MathHullInset const * InsetFormula::hull() const
-{
- lyx::Assert(par_->asHullInset());
- return par_->asHullInset();
}
-MathHullInset * InsetFormula::hull()
+void InsetFormula::getLabelList(Buffer const & buffer,
+ vector<string> & res) const
{
- lyx::Assert(par_->asHullInset());
- return par_->asHullInset();
+ par()->getLabelList(buffer, res);
}
-Inset::Code InsetFormula::lyxCode() const
+InsetOld::Code InsetFormula::lyxCode() const
{
- return Inset::MATH_CODE;
+ return InsetOld::MATH_CODE;
}
}
-bool InsetFormula::insetAllowed(Inset::Code code) const
+bool InsetFormula::insetAllowed(InsetOld::Code code) const
{
return
- (code == Inset::LABEL_CODE && display())
- || code == Inset::REF_CODE
- || code == Inset::ERT_CODE;
-}
-
-
-int InsetFormula::ascent(BufferView *, LyXFont const &) const
-{
- const int a = par_->ascent();
- if (!canPreview())
- return a + 1;
- return a + 1 - (par_->height() - loader_->image()->getHeight()) / 2;
+ code == InsetOld::LABEL_CODE
+ || code == InsetOld::REF_CODE
+ || code == InsetOld::ERT_CODE;
}
-int InsetFormula::descent(BufferView *, LyXFont const &) const
+void InsetFormula::metrics(MetricsInfo & m, Dimension & dim) const
{
- const int d = par_->descent();
- if (!canPreview())
- return d + 1;
- return d + 1 - (par_->height() - loader_->image()->getHeight()) / 2;
-}
-
-
-int InsetFormula::width(BufferView * bv, LyXFont const & font) const
-{
- metrics(bv, font);
- return canPreview() ? loader_->image()->getWidth() : par_->width();
-}
-
+ bool const use_preview = !editing_inset(this)
+ && RenderPreview::activated()
+ && preview_->previewReady();
+
+ if (use_preview) {
+ preview_->metrics(m, dim);
+ // insert a one pixel gap in front of the formula
+ dim.wid += 1;
+ if (display())
+ dim.des += 12;
+ } else {
+ MetricsInfo mi = m;
+ mi.base.style = LM_ST_TEXT;
+ mi.base.font.setColor(LColor::math);
+ par()->metrics(mi, dim);
+ dim.asc += 1;
+ dim.des += 1;
+ }
-string InsetFormula::hullType() const
-{
- return hull() ? hull()->getType() : "none";
+ dim_ = dim;
}
-void InsetFormula::mutate(string const & type )
+void InsetFormula::mutate(string const & type)
{
- if (hull())
- hull()->mutate(type);
+ par_.nucleus()->mutate(type);
}
// preview stuff
//
-bool InsetFormula::canPreview() const
+void InsetFormula::statusChanged() const
{
- return lyxrc.preview && loader_ && !par_->asNestInset()->editing()
- && loader_->status() == grfx::Ready;
+ LyX::cref().updateInset(this);
}
-void InsetFormula::statusChanged()
+namespace {
+
+string const latex_string(InsetFormula const & inset, Buffer const &)
{
- lyxerr << "### InsetFormula::statusChanged called!, status: "
- << loader_->status() << "\n";
- if (loader_->status() == grfx::Ready)
- view()->updateInset(this, false);
- else if (loader_->status() == grfx::WaitingToLoad)
- loader_->startLoading();
+ ostringstream os;
+ WriteStream wi(os, false, false);
+ inset.par()->write(wi);
+ return os.str();
}
+} // namespace anon
+
-void InsetFormula::updatePreview()
+void InsetFormula::addPreview(lyx::graphics::PreviewLoader & ploader) const
{
- // nothing to be done if no preview requested
- lyxerr << "### updatePreview() called\n";
- if (!lyxrc.preview)
- return;
+ string const snippet = latex_string(*this, ploader.buffer());
+ preview_->addPreview(snippet, ploader);
+}
- // get LaTeX
- ostringstream ls;
- WriteStream wi(ls, false, false);
- par_->write(wi);
- string const data = ls.str();
-
- // the preview cache, maps contents to image loaders
- typedef std::map<string, boost::shared_ptr<grfx::Loader> > cache_type;
- static cache_type theCache;
- static int theCounter = 0;
-
- // set our loader corresponding to our current data
- cache_type::const_iterator it = theCache.find(data);
-
- // is this old data?
- if (it != theCache.end()) {
- // we have already a loader, connect to it anyway
- //lyxerr << "### updatePreview(), old loader: " << loader_ << "\n";
- loader_ = it->second.get();
- loader_->statusChanged.connect
- (boost::bind(&InsetFormula::statusChanged, this));
- return;
- }
- // construct new file name
- static string const dir = OnlyPath(lyx::tempName());
- ostringstream os;
- os << dir << theCounter++ << ".lyxpreview";
- string file = os.str();
-
- // the real work starts
- //lyxerr << "### updatePreview(), new file " << file << "\n";
- std::ofstream of(file.c_str());
- of << "\\batchmode"
- << "\\documentclass{article}"
- << "\\usepackage{amssymb}"
- << "\\thispagestyle{empty}"
- << "\\pdfoutput=0"
- << "\\begin{document}"
- << data
- << "\\end{document}\n";
- of.close();
-
- // now we are done, start actual loading we will get called back via
- // InsetFormula::statusChanged() if this is finished
- theCache[data].reset(new grfx::Loader(file));
- //lyxerr << "### updatePreview(), new loader: " << loader_ << "\n";
- loader_ = theCache.find(data)->second.get();
- loader_->startLoading();
- loader_->statusChanged.connect(boost::bind(&InsetFormula::statusChanged, this));
+void InsetFormula::generatePreview(Buffer const & buffer) const
+{
+ string const snippet = latex_string(*this, buffer);
+ preview_->addPreview(snippet, buffer);
+ preview_->startLoading(buffer);
}
projects / lyx.git / blobdiff