#include <config.h>
#include "factory.h"
-#include "funcrequest.h"
+
#include "buffer.h"
-#include "FloatList.h"
-#include "debug.h"
#include "BufferView.h"
+#include "bufferparams.h"
+#include "debug.h"
+#include "FloatList.h"
+#include "funcrequest.h"
+#include "LColor.h"
#include "lyxlex.h"
+#include "paragraph.h"
#include "insets/insetbibitem.h"
#include "insets/insetbibtex.h"
#include "insets/insetcaption.h"
#include "insets/insetcite.h"
+#include "insets/insetcharstyle.h"
#include "insets/insetenv.h"
#include "insets/insetert.h"
#include "insets/insetexternal.h"
#include "insets/insethfill.h"
#include "insets/insetinclude.h"
#include "insets/insetindex.h"
+#include "insets/insetnomencl.h"
#include "insets/insetlabel.h"
+#include "insets/insetline.h"
#include "insets/insetmarginal.h"
-#include "insets/insetminipage.h"
#include "insets/insetnote.h"
+#include "insets/insetbox.h"
#include "insets/insetbranch.h"
#include "insets/insetoptarg.h"
+#include "insets/insetpagebreak.h"
#include "insets/insetref.h"
#include "insets/insetspace.h"
#include "insets/insettabular.h"
#include "insets/insettoc.h"
#include "insets/inseturl.h"
+#include "insets/insetvspace.h"
#include "insets/insetwrap.h"
-#include "mathed/formulamacro.h"
-#include "mathed/formula.h"
-#include "frontends/Dialogs.h"
-#include "frontends/LyXView.h"
+#include "mathed/MathMacroTemplate.h"
+#include "mathed/InsetMathHull.h"
+
#include "support/lstrings.h"
-#include "support/std_sstream.h"
-using namespace lyx::support;
+#include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+
+#include <sstream>
+
+
+namespace lyx {
+using support::compare_ascii_no_case;
+
+using std::auto_ptr;
using std::endl;
+using std::string;
-InsetOld * createInset(FuncRequest const & cmd)
+InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
{
- BufferView * bv = cmd.view();
BufferParams const & params = bv->buffer()->params();
switch (cmd.action) {
- case LFUN_HFILL:
- return new InsetHFill();
-
- case LFUN_INSET_MINIPAGE:
- return new InsetMinipage(params);
-
- case LFUN_INSERT_NOTE:
- {
- string arg = cmd.getArg(0);
- if (arg.empty())
- arg = "Note";
- return new InsetNote(params, arg);
- }
- case LFUN_INSERT_BRANCH:
- {
- string arg = cmd.getArg(0);
- if (arg.empty())
- arg = "none";
- return new InsetBranch(params, arg);
- }
+ case LFUN_HFILL_INSERT:
+ return new InsetHFill;
- case LFUN_INSET_ERT:
+ case LFUN_LINE_INSERT:
+ return new InsetLine;
+
+ case LFUN_PAGEBREAK_INSERT:
+ return new InsetPagebreak;
+
+ case LFUN_CLEARPAGE_INSERT:
+ return new InsetClearPage;
+
+ case LFUN_CLEARDOUBLEPAGE_INSERT:
+ return new InsetClearDoublePage;
+
+ case LFUN_CHARSTYLE_INSERT: {
+ string s = cmd.getArg(0);
+ LyXTextClass tclass = params.getLyXTextClass();
+ CharStyles::iterator found_cs = tclass.charstyle(s);
+ if (found_cs != tclass.charstyles().end())
+ return new InsetCharStyle(params, found_cs);
+ else
+ return new InsetCharStyle(params, s);
+ }
+
+ case LFUN_NOTE_INSERT: {
+ string arg = cmd.getArg(0);
+ if (arg.empty())
+ arg = "Note";
+ return new InsetNote(params, arg);
+ }
+
+ case LFUN_BOX_INSERT: {
+ string arg = cmd.getArg(0);
+ if (arg.empty())
+ arg = "Boxed";
+ return new InsetBox(params, arg);
+ }
+
+ case LFUN_BRANCH_INSERT: {
+ docstring arg = cmd.argument();
+ if (arg.empty())
+ arg = from_ascii("none");
+ return new InsetBranch(params, InsetBranchParams(arg));
+ }
+
+ case LFUN_ERT_INSERT:
return new InsetERT(params);
- case LFUN_INSET_FOOTNOTE:
+ case LFUN_FOOTNOTE_INSERT:
return new InsetFoot(params);
- case LFUN_INSET_MARGINAL:
+ case LFUN_MARGINALNOTE_INSERT:
return new InsetMarginal(params);
- case LFUN_INSET_OPTARG:
+ case LFUN_OPTIONAL_INSERT:
return new InsetOptArg(params);
- case LFUN_INSERT_BIBITEM:
+ case LFUN_BIBITEM_INSERT:
return new InsetBibitem(InsetCommandParams("bibitem"));
- case LFUN_INSET_FLOAT:
+ case LFUN_FLOAT_INSERT: {
// check if the float type exists
- if (params.getLyXTextClass().floats().typeExist(cmd.argument))
- return new InsetFloat(params, cmd.argument);
- lyxerr << "Non-existent float type: " << cmd.argument << endl;
+ string const argument = to_utf8(cmd.argument());
+ if (params.getLyXTextClass().floats().typeExist(argument))
+ return new InsetFloat(params, argument);
+ lyxerr << "Non-existent float type: " << argument << endl;
return 0;
+ }
- case LFUN_INSET_WIDE_FLOAT:
+ case LFUN_FLOAT_WIDE_INSERT: {
// check if the float type exists
- if (params.getLyXTextClass().floats().typeExist(cmd.argument)) {
- InsetFloat * p = new InsetFloat(params, cmd.argument);
+ string const argument = to_utf8(cmd.argument());
+ if (params.getLyXTextClass().floats().typeExist(argument)) {
+ auto_ptr<InsetFloat> p(new InsetFloat(params, argument));
p->wide(true, params);
+ return p.release();
}
- lyxerr << "Non-existent float type: " << cmd.argument << endl;
+ lyxerr << "Non-existent float type: " << argument << endl;
return 0;
+ }
- case LFUN_INSET_WRAP:
- if (cmd.argument == "figure")
- return new InsetWrap(params, cmd.argument);
- lyxerr << "Non-existent floatflt type: " << cmd.argument << endl;
+ case LFUN_WRAP_INSERT: {
+ string const argument = to_utf8(cmd.argument());
+ if (argument == "figure")
+ return new InsetWrap(params, argument);
+ lyxerr << "Non-existent floatflt type: " << argument << endl;
return 0;
+ }
case LFUN_INDEX_INSERT: {
// Try and generate a valid index entry.
InsetCommandParams icp("index");
- string const contents = cmd.argument.empty() ?
- bv->getLyXText()->getStringToIndex() :
- cmd.argument;
- icp.setContents(contents);
-
- string data = InsetCommandMailer::params2string("index", icp);
- LyXView * lv = bv->owner();
+ icp["name"] = cmd.argument().empty() ?
+ bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
+ cmd.argument();
+ return new InsetIndex(icp);
+ }
- if (icp.getContents().empty()) {
- lv->getDialogs().show("index", data, 0);
- } else {
- lv->dispatch(FuncRequest(bv, LFUN_INSET_APPLY, data));
- }
- return 0;
+ case LFUN_NOMENCL_INSERT: {
+ InsetCommandParams icp("nomenclature");
+ icp["symbol"] = cmd.argument().empty() ?
+ bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
+ cmd.argument();
+ return new InsetNomencl(icp);
}
- case LFUN_TABULAR_INSERT:
- if (!cmd.argument.empty()) {
- std::istringstream ss(cmd.argument);
- int r, c;
- ss >> r >> c;
- if (r <= 0) r = 2;
- if (c <= 0) c = 2;
- return new InsetTabular(*bv->buffer(), r, c);
- }
- bv->owner()->getDialogs().show("tabularcreate");
- return 0;
+ case LFUN_TABULAR_INSERT: {
+ if (cmd.argument().empty())
+ return 0;
+ std::istringstream ss(to_utf8(cmd.argument()));
+ int r = 0, c = 0;
+ ss >> r >> c;
+ if (r <= 0)
+ r = 2;
+ if (c <= 0)
+ c = 2;
+ return new InsetTabular(*bv->buffer(), r, c);
+ }
- case LFUN_INSET_CAPTION:
- if (bv->theLockingInset()) {
- lyxerr << "Locking inset code: "
- << static_cast<int>(bv->theLockingInset()->lyxCode());
- InsetCaption * inset = new InsetCaption(params);
- inset->setOwner(bv->theLockingInset());
- inset->setAutoBreakRows(true);
- inset->setDrawFrame(InsetText::LOCKED);
- inset->setFrameColor(LColor::captionframe);
- return inset;
- }
- return 0;
+ case LFUN_CAPTION_INSERT: {
+ auto_ptr<InsetCaption> inset(new InsetCaption(params));
+ inset->setAutoBreakRows(true);
+ inset->setDrawFrame(true);
+ inset->setFrameColor(LColor::captionframe);
+ return inset.release();
+ }
case LFUN_INDEX_PRINT:
return new InsetPrintIndex(InsetCommandParams("printindex"));
+ case LFUN_NOMENCL_PRINT:
+ return new InsetPrintNomencl(InsetCommandParams("printnomenclature"));
+
case LFUN_TOC_INSERT:
return new InsetTOC(InsetCommandParams("tableofcontents"));
case LFUN_ENVIRONMENT_INSERT:
- return new InsetEnvironment(params, cmd.argument);
+ return new InsetEnvironment(params, to_utf8(cmd.argument()));
#if 0
- case LFUN_INSET_LIST:
+ case LFUN_LIST_INSERT:
return new InsetList;
- case LFUN_INSET_THEOREM:
+ case LFUN_THEOREM_INSERT:
return new InsetTheorem;
#endif
string const name = cmd.getArg(0);
if (name == "bibitem") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetBibitem(icp);
} else if (name == "bibtex") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetBibtex(icp);
} else if (name == "citation") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
- InsetCitation * inset = new InsetCitation(icp);
- inset->setLoadingBuffer(*bv->buffer(), false);
- return inset;
+ InsetCommandParams icp("cite");
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetCitation(icp);
} else if (name == "ert") {
- InsetERT * inset = new InsetERT(params);
- InsetERT::ERTStatus s;
- InsetERTMailer::string2params(cmd.argument, s);
- inset->status(bv, s);
- return inset;
+ InsetCollapsable::CollapseStatus st;
+ InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
+ return new InsetERT(params, st);
} else if (name == "external") {
- Buffer const & buffer = *cmd.view()->buffer();
- InsetExternal::Params iep;
- InsetExternalMailer::string2params(cmd.argument,
+ Buffer const & buffer = *bv->buffer();
+ InsetExternalParams iep;
+ InsetExternalMailer::string2params(to_utf8(cmd.argument()),
buffer, iep);
- InsetExternal * inset = new InsetExternal;
+ auto_ptr<InsetExternal> inset(new InsetExternal);
inset->setParams(iep, buffer);
- return inset;
+ return inset.release();
} else if (name == "graphics") {
- Buffer const & buffer = *cmd.view()->buffer();
+ Buffer const & buffer = *bv->buffer();
InsetGraphicsParams igp;
- InsetGraphicsMailer::string2params(cmd.argument,
+ InsetGraphicsMailer::string2params(to_utf8(cmd.argument()),
buffer, igp);
- InsetGraphics * inset = new InsetGraphics;
+ auto_ptr<InsetGraphics> inset(new InsetGraphics);
inset->setParams(igp);
- return inset;
+ return inset.release();
} else if (name == "include") {
- InsetInclude::Params iip;
- InsetIncludeMailer::string2params(cmd.argument, iip);
+ InsetCommandParams iip(name);
+ InsetIncludeMailer::string2params(to_utf8(cmd.argument()), iip);
return new InsetInclude(iip);
} else if (name == "index") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetIndex(icp);
+ } else if (name == "nomenclature") {
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+ icp);
+ return new InsetNomencl(icp);
+
} else if (name == "label") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetLabel(icp);
} else if (name == "ref") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetRef(icp, *bv->buffer());
} else if (name == "toc") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp("tableofcontents");
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetTOC(icp);
} else if (name == "url") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(cmd.argument, icp);
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
return new InsetUrl(icp);
+
+ } else if (name == "vspace") {
+ VSpace vspace;
+ InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
+ return new InsetVSpace(vspace);
}
}
case LFUN_SPACE_INSERT: {
- string const name = cmd.argument;
+ string const name = to_utf8(cmd.argument());
if (name == "normal")
return new InsetSpace(InsetSpace::NORMAL);
else if (name == "protected")
}
-InsetOld * readInset(LyXLex & lex, Buffer const & buf)
+InsetBase * readInset(LyXLex & lex, Buffer const & buf)
{
// consistency check
if (lex.getString() != "\\begin_inset") {
<< endl;
}
- InsetOld * inset = 0;
+ auto_ptr<InsetBase> inset;
+
+ LyXTextClass tclass = buf.params().getLyXTextClass();
lex.next();
- string const tmptok = lex.getString();
+ string tmptok = lex.getString();
// test the different insets
if (tmptok == "LatexCommand") {
- InsetCommandParams inscmd;
- inscmd.read(lex);
+ lex.next();
+ string const cmdName = lex.getString();
+ lex.pushToken(cmdName);
- string const cmdName = inscmd.getCmdName();
+ InsetCommandParams inscmd(cmdName);
+ inscmd.read(lex);
// This strange command allows LyX to recognize "natbib" style
// citations: citet, citep, Citet etc.
+ // FIXME: We already have partial support for \\fullcite and
+ // the various \\footcite commands. We should increase the
+ // file format number and read these commands here, too.
+ // Then we should use is_possible_cite_command() in
+ // src/frontends/controllers/biblio.C to test for valid cite
+ // commands.
if (compare_ascii_no_case(cmdName.substr(0,4), "cite") == 0) {
- inset = new InsetCitation(inscmd);
+ inset.reset(new InsetCitation(inscmd));
} else if (cmdName == "bibitem") {
- lex.printError("Wrong place for bibitem");
- inset = new InsetBibitem(inscmd);
+ inset.reset(new InsetBibitem(inscmd));
} else if (cmdName == "bibtex") {
- inset = new InsetBibtex(inscmd);
+ inset.reset(new InsetBibtex(inscmd));
} else if (cmdName == "index") {
- inset = new InsetIndex(inscmd);
+ inset.reset(new InsetIndex(inscmd));
+ } else if (cmdName == "nomenclature") {
+ inset.reset(new InsetNomencl(inscmd));
} else if (cmdName == "include") {
- inset = new InsetInclude(inscmd, buf);
+ inset.reset(new InsetInclude(inscmd));
} else if (cmdName == "label") {
- inset = new InsetLabel(inscmd);
+ inset.reset(new InsetLabel(inscmd));
} else if (cmdName == "url"
|| cmdName == "htmlurl") {
- inset = new InsetUrl(inscmd);
+ inset.reset(new InsetUrl(inscmd));
} else if (cmdName == "ref"
|| cmdName == "eqref"
|| cmdName == "pageref"
|| cmdName == "vref"
|| cmdName == "vpageref"
|| cmdName == "prettyref") {
- if (!inscmd.getOptions().empty()
- || !inscmd.getContents().empty()) {
- inset = new InsetRef(inscmd, buf);
+ if (!inscmd["name"].empty()
+ || !inscmd["reference"].empty()) {
+ inset.reset(new InsetRef(inscmd, buf));
}
} else if (cmdName == "tableofcontents") {
- inset = new InsetTOC(inscmd);
+ inset.reset(new InsetTOC(inscmd));
} else if (cmdName == "listofalgorithms") {
- inset = new InsetFloatList("algorithm");
+ inset.reset(new InsetFloatList("algorithm"));
} else if (cmdName == "listoffigures") {
- inset = new InsetFloatList("figure");
+ inset.reset(new InsetFloatList("figure"));
} else if (cmdName == "listoftables") {
- inset = new InsetFloatList("table");
+ inset.reset(new InsetFloatList("table"));
} else if (cmdName == "printindex") {
- inset = new InsetPrintIndex(inscmd);
+ inset.reset(new InsetPrintIndex(inscmd));
+ } else if (cmdName == "printnomenclature") {
+ inset.reset(new InsetPrintNomencl(inscmd));
+ } else {
+ lyxerr << "unknown CommandInset '" << cmdName
+ << "'" << std::endl;
+ while (lex.isOK() && lex.getString() != "\\end_inset")
+ lex.next();
+ return 0;
}
} else {
if (tmptok == "Quotes") {
- inset = new InsetQuotes;
+ inset.reset(new InsetQuotes);
} else if (tmptok == "External") {
- inset = new InsetExternal;
+ inset.reset(new InsetExternal);
} else if (tmptok == "FormulaMacro") {
- inset = new InsetFormulaMacro;
+ inset.reset(new MathMacroTemplate);
} else if (tmptok == "Formula") {
- inset = new InsetFormula;
+ inset.reset(new InsetMathHull);
} else if (tmptok == "Graphics") {
- inset = new InsetGraphics;
- } else if (tmptok == "Note" || tmptok == "Comment"
- || tmptok == "Greyedout") {
- inset = new InsetNote(buf.params(), tmptok);
+ inset.reset(new InsetGraphics);
+ } else if (tmptok == "Note") {
+ inset.reset(new InsetNote(buf.params(), tmptok));
+ } else if (tmptok == "Box") {
+ inset.reset(new InsetBox(buf.params(), tmptok));
+ } else if (tmptok == "CharStyle") {
+ lex.next();
+ string s = lex.getString();
+ CharStyles::iterator found_cs = tclass.charstyle(s);
+ if (found_cs != tclass.charstyles().end())
+ inset.reset(new InsetCharStyle(buf.params(), found_cs));
+ else {
+ // "Undefined" inset
+ inset.reset(new InsetCharStyle(buf.params(), s));
+ }
} else if (tmptok == "Branch") {
- inset = new InsetBranch(buf.params(), tmptok);
+ inset.reset(new InsetBranch(buf.params(),
+ InsetBranchParams()));
} else if (tmptok == "Include") {
- InsetCommandParams p("Include");
- inset = new InsetInclude(p, buf);
+ InsetCommandParams p("include");
+ inset.reset(new InsetInclude(p));
} else if (tmptok == "Environment") {
lex.next();
- inset = new InsetEnvironment(buf.params(), lex.getString());
+ inset.reset(new InsetEnvironment(buf.params(), lex.getString()));
} else if (tmptok == "ERT") {
- inset = new InsetERT(buf.params());
+ inset.reset(new InsetERT(buf.params()));
} else if (tmptok == "InsetSpace") {
- inset = new InsetSpace;
+ inset.reset(new InsetSpace);
} else if (tmptok == "Tabular") {
- inset = new InsetTabular(buf);
+ inset.reset(new InsetTabular(buf));
} else if (tmptok == "Text") {
- inset = new InsetText(buf.params());
+ inset.reset(new InsetText(buf.params()));
+ } else if (tmptok == "VSpace") {
+ inset.reset(new InsetVSpace);
} else if (tmptok == "Foot") {
- inset = new InsetFoot(buf.params());
+ inset.reset(new InsetFoot(buf.params()));
} else if (tmptok == "Marginal") {
- inset = new InsetMarginal(buf.params());
+ inset.reset(new InsetMarginal(buf.params()));
} else if (tmptok == "OptArg") {
- inset = new InsetOptArg(buf.params());
- } else if (tmptok == "Minipage") {
- inset = new InsetMinipage(buf.params());
+ inset.reset(new InsetOptArg(buf.params()));
} else if (tmptok == "Float") {
lex.next();
string tmptok = lex.getString();
- inset = new InsetFloat(buf.params(), tmptok);
+ inset.reset(new InsetFloat(buf.params(), tmptok));
} else if (tmptok == "Wrap") {
lex.next();
string tmptok = lex.getString();
- inset = new InsetWrap(buf.params(), tmptok);
+ inset.reset(new InsetWrap(buf.params(), tmptok));
#if 0
} else if (tmptok == "List") {
- inset = new InsetList;
+ inset.reset(new InsetList);
} else if (tmptok == "Theorem") {
- inset = new InsetList;
+ inset.reset(new InsetList);
#endif
} else if (tmptok == "Caption") {
- inset = new InsetCaption(buf.params());
+ inset.reset(new InsetCaption(buf.params()));
} else if (tmptok == "FloatList") {
- inset = new InsetFloatList;
+ inset.reset(new InsetFloatList);
+ } else {
+ lyxerr << "unknown Inset type '" << tmptok
+ << "'" << std::endl;
+ while (lex.isOK() && lex.getString() != "\\end_inset")
+ lex.next();
+ return 0;
}
- if (inset)
- inset->read(buf, lex);
+ inset->read(buf, lex);
+
+#ifdef WITH_WARNINGS
+#warning hack..
+#endif
+ if (inset->lyxCode() == InsetBase::MATHMACRO_CODE) {
+ MathMacroTemplate const * tmpl =
+ static_cast<MathMacroTemplate*>(inset.get());
+ MacroTable::globalMacros().insert
+ (tmpl->name(), tmpl->asMacroData());
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": creating local macro " << to_utf8(tmpl->name())
+ << endl;
+ }
}
- return inset;
+ return inset.release();
}
+
+
+} // namespace lyx
projects / lyx.git / blobdiff