#include "funcrequest.h"
#include "LColor.h"
#include "lyxlex.h"
+#include "lyx_main.h"
#include "paragraph.h"
#include "insets/insetbibitem.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/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 "frontends/Alert.h"
+
#include "support/lstrings.h"
-#include "support/std_sstream.h"
+#include "support/ExceptionMessage.h"
#include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+
+#include <sstream>
+
-using lyx::support::compare_ascii_no_case;
+namespace lyx {
+
+namespace Alert = frontend::Alert;
+
+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;
+ try {
- case LFUN_INSERT_LINE:
- return new InsetLine;
+ switch (cmd.action) {
+ case LFUN_HFILL_INSERT:
+ return new InsetHFill;
- case LFUN_INSERT_PAGEBREAK:
- return new InsetPagebreak;
+ case LFUN_LINE_INSERT:
+ return new InsetLine;
- case LFUN_INSERT_CHARSTYLE: {
- string s = cmd.getArg(0);
- CharStyles::iterator found_cs = params.getLyXTextClass().charstyle(s);
- return new InsetCharStyle(params, found_cs);
- }
+ case LFUN_PAGEBREAK_INSERT:
+ return new InsetPagebreak;
- case LFUN_INSERT_NOTE: {
- string arg = cmd.getArg(0);
- if (arg.empty())
- arg = "Note";
- return new InsetNote(params, arg);
- }
+ case LFUN_CLEARPAGE_INSERT:
+ return new InsetClearPage;
- case LFUN_INSERT_BOX: {
- string arg = cmd.getArg(0);
- if (arg.empty())
- arg = "Boxed";
- return new InsetBox(params, arg);
- }
+ case LFUN_CLEARDOUBLEPAGE_INSERT:
+ return new InsetClearDoublePage;
- case LFUN_INSERT_BRANCH: {
- string arg = cmd.getArg(0);
- if (arg.empty())
- arg = "none";
- return new InsetBranch(params, InsetBranchParams(arg));
- }
+ 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_INSET_ERT:
- return new InsetERT(params);
+ 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_INSET_FOOTNOTE:
- return new InsetFoot(params);
+ case LFUN_BRANCH_INSERT: {
+ docstring arg = cmd.argument();
+ if (arg.empty())
+ arg = from_ascii("none");
+ return new InsetBranch(params, InsetBranchParams(arg));
+ }
- case LFUN_INSET_MARGINAL:
- return new InsetMarginal(params);
+ case LFUN_ERT_INSERT:
+ return new InsetERT(params);
- case LFUN_INSET_OPTARG:
- return new InsetOptArg(params);
+ case LFUN_FOOTNOTE_INSERT:
+ return new InsetFoot(params);
- case LFUN_INSERT_BIBITEM:
- return new InsetBibitem(InsetCommandParams("bibitem"));
+ case LFUN_MARGINALNOTE_INSERT:
+ return new InsetMarginal(params);
- case LFUN_INSET_FLOAT:
- // 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;
- return 0;
+ case LFUN_OPTIONAL_INSERT:
+ return new InsetOptArg(params);
- case LFUN_INSET_WIDE_FLOAT:
- // check if the float type exists
- if (params.getLyXTextClass().floats().typeExist(cmd.argument)) {
- auto_ptr<InsetFloat> p(new InsetFloat(params, cmd.argument));
- p->wide(true, params);
- return p.release();
+ case LFUN_BIBITEM_INSERT:
+ return new InsetBibitem(InsetCommandParams("bibitem"));
+
+ case LFUN_FLOAT_INSERT: {
+ // check if the float type exists
+ 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;
}
- lyxerr << "Non-existent float type: " << cmd.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;
- 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();
-
- if (icp.getContents().empty()) {
- lv->getDialogs().show("index", data, 0);
- } else {
- lv->dispatch(FuncRequest(bv, LFUN_INSET_APPLY, data));
+
+ case LFUN_FLOAT_WIDE_INSERT: {
+ // check if the float type exists
+ 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: " << argument << endl;
+ return 0;
+ }
+
+ 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");
+ icp["name"] = cmd.argument().empty() ?
+ bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
+ cmd.argument();
+ return new InsetIndex(icp);
+ }
+
+ case LFUN_NOMENCL_INSERT: {
+ InsetCommandParams icp("nomenclature");
+ icp["symbol"] = cmd.argument().empty() ?
+ bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
+ cmd.argument();
+ return new InsetNomencl(icp);
}
- return 0;
- }
- case LFUN_TABULAR_INSERT:
- if (!cmd.argument.empty()) {
- std::istringstream ss(cmd.argument);
+ 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;
+ 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_INSET_CAPTION:
- if (!bv->innerInset()) {
- auto_ptr<InsetCaption> inset(new InsetCaption(params));
- inset->setOwner(bv->innerInset());
- inset->setAutoBreakRows(true);
- inset->setDrawFrame(InsetText::LOCKED);
- inset->setFrameColor(LColor::captionframe);
- return inset.release();
- }
- return 0;
- case LFUN_INDEX_PRINT:
- return new InsetPrintIndex(InsetCommandParams("printindex"));
+ 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_TOC_INSERT:
- return new InsetTOC(InsetCommandParams("tableofcontents"));
+ case LFUN_INDEX_PRINT:
+ return new InsetPrintIndex(InsetCommandParams("printindex"));
- case LFUN_ENVIRONMENT_INSERT:
- return new InsetEnvironment(params, cmd.argument);
+ case LFUN_NOMENCL_PRINT:
+ return new InsetPrintNomencl(InsetCommandParams("printnomenclature"));
-#if 0
- case LFUN_INSET_LIST:
- return new InsetList;
+ case LFUN_TOC_INSERT:
+ return new InsetTOC(InsetCommandParams("tableofcontents"));
- case LFUN_INSET_THEOREM:
- return new InsetTheorem;
-#endif
+ case LFUN_ENVIRONMENT_INSERT:
+ return new InsetEnvironment(params, to_utf8(cmd.argument()));
- case LFUN_INSET_INSERT: {
- string const name = cmd.getArg(0);
-
- if (name == "bibitem") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetBibitem(icp);
-
- } else if (name == "bibtex") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetBibtex(icp);
-
- } else if (name == "citation") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetCitation(icp);
-
- } else if (name == "ert") {
- InsetCollapsable::CollapseStatus st;
- InsetERTMailer::string2params(cmd.argument, st);
- return new InsetERT(params, st);
-
- } else if (name == "external") {
- Buffer const & buffer = *cmd.view()->buffer();
- InsetExternalParams iep;
- InsetExternalMailer::string2params(cmd.argument,
- buffer, iep);
- auto_ptr<InsetExternal> inset(new InsetExternal);
- inset->setParams(iep, buffer);
- return inset.release();
+#if 0
+ case LFUN_LIST_INSERT:
+ return new InsetList;
- } else if (name == "graphics") {
- Buffer const & buffer = *cmd.view()->buffer();
- InsetGraphicsParams igp;
- InsetGraphicsMailer::string2params(cmd.argument,
- buffer, igp);
- auto_ptr<InsetGraphics> inset(new InsetGraphics);
- inset->setParams(igp);
- return inset.release();
+ case LFUN_THEOREM_INSERT:
+ return new InsetTheorem;
+#endif
- } else if (name == "include") {
- InsetCommandParams iip;
- InsetIncludeMailer::string2params(cmd.argument, iip);
- return new InsetInclude(iip);
+ case LFUN_INSET_INSERT: {
+ string const name = cmd.getArg(0);
+
+ if (name == "bibitem") {
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetBibitem(icp);
+
+ } else if (name == "bibtex") {
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetBibtex(icp);
+
+ } else if (name == "citation") {
+ InsetCommandParams icp("cite");
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetCitation(icp);
+
+ } else if (name == "ert") {
+ InsetCollapsable::CollapseStatus st;
+ InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
+ return new InsetERT(params, st);
+
+ } else if (name == "external") {
+ Buffer const & buffer = *bv->buffer();
+ InsetExternalParams iep;
+ InsetExternalMailer::string2params(to_utf8(cmd.argument()),
+ buffer, iep);
+ auto_ptr<InsetExternal> inset(new InsetExternal);
+ inset->setParams(iep, buffer);
+ return inset.release();
+
+ } else if (name == "graphics") {
+ Buffer const & buffer = *bv->buffer();
+ InsetGraphicsParams igp;
+ InsetGraphicsMailer::string2params(to_utf8(cmd.argument()),
+ buffer, igp);
+ auto_ptr<InsetGraphics> inset(new InsetGraphics);
+ inset->setParams(igp);
+ return inset.release();
+
+ } else if (name == "include") {
+ InsetCommandParams iip(name);
+ InsetIncludeMailer::string2params(to_utf8(cmd.argument()), iip);
+ return new InsetInclude(iip);
+
+ } else if (name == "index") {
+ 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(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetLabel(icp);
+
+ } else if (name == "ref") {
+ InsetCommandParams icp(name);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetRef(icp, *bv->buffer());
+
+ } else if (name == "toc") {
+ InsetCommandParams icp("tableofcontents");
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
+ icp);
+ return new InsetTOC(icp);
+
+ } else if (name == "url") {
+ 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);
+ }
+ }
- } else if (name == "index") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetIndex(icp);
+ case LFUN_SPACE_INSERT: {
+ string const name = to_utf8(cmd.argument());
+ if (name == "normal")
+ return new InsetSpace(InsetSpace::NORMAL);
+ else if (name == "protected")
+ return new InsetSpace(InsetSpace::PROTECTED);
+ else if (name == "thin")
+ return new InsetSpace(InsetSpace::THIN);
+ else if (name == "quad")
+ return new InsetSpace(InsetSpace::QUAD);
+ else if (name == "qquad")
+ return new InsetSpace(InsetSpace::QQUAD);
+ else if (name == "enspace")
+ return new InsetSpace(InsetSpace::ENSPACE);
+ else if (name == "enskip")
+ return new InsetSpace(InsetSpace::ENSKIP);
+ else if (name == "negthinspace")
+ return new InsetSpace(InsetSpace::NEGTHIN);
+ else if (name.empty())
+ lyxerr << "LyX function 'space' needs an argument." << endl;
+ else
+ lyxerr << "Wrong argument for LyX function 'space'." << endl;
+ }
+ break;
- } else if (name == "label") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetLabel(icp);
-
- } else if (name == "ref") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetRef(icp, *bv->buffer());
-
- } else if (name == "toc") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetTOC(icp);
-
- } else if (name == "url") {
- InsetCommandParams icp;
- InsetCommandMailer::string2params(name, cmd.argument,
- icp);
- return new InsetUrl(icp);
-
- } else if (name == "vspace") {
- VSpace vspace;
- InsetVSpaceMailer::string2params(cmd.argument, vspace);
- return new InsetVSpace(vspace);
+ default:
+ break;
}
- }
- case LFUN_SPACE_INSERT: {
- string const name = cmd.argument;
- if (name == "normal")
- return new InsetSpace(InsetSpace::NORMAL);
- else if (name == "protected")
- return new InsetSpace(InsetSpace::PROTECTED);
- else if (name == "thin")
- return new InsetSpace(InsetSpace::THIN);
- else if (name == "quad")
- return new InsetSpace(InsetSpace::QUAD);
- else if (name == "qquad")
- return new InsetSpace(InsetSpace::QQUAD);
- else if (name == "enspace")
- return new InsetSpace(InsetSpace::ENSPACE);
- else if (name == "enskip")
- return new InsetSpace(InsetSpace::ENSKIP);
- else if (name == "negthinspace")
- return new InsetSpace(InsetSpace::NEGTHIN);
- else if (name.empty())
- lyxerr << "LyX function 'space' needs an argument." << endl;
- else
- lyxerr << "Wrong argument for LyX function 'space'." << endl;
+ } catch (support::ExceptionMessage const & message) {
+ if (message.type_ == support::ErrorException) {
+ Alert::error(message.title_, message.details_);
+ LyX::cref().emergencyCleanup();
+ abort();
+ } else if (message.type_ == support::WarningException) {
+ Alert::warning(message.title_, message.details_);
+ return 0;
+ }
}
- break;
-
- default:
- break;
- }
return 0;
}
-InsetOld * readInset(LyXLex & lex, Buffer const & buf)
+InsetBase * readInset(LyXLex & lex, Buffer const & buf)
{
// consistency check
if (lex.getString() != "\\begin_inset") {
<< endl;
}
- auto_ptr<InsetOld> inset;
+ auto_ptr<InsetBase> inset;
LyXTextClass tclass = buf.params().getLyXTextClass();
-
+
lex.next();
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.reset(new InsetCitation(inscmd));
} else if (cmdName == "bibitem") {
- lex.printError("Wrong place for bibitem");
inset.reset(new InsetBibitem(inscmd));
} else if (cmdName == "bibtex") {
inset.reset(new InsetBibtex(inscmd));
} else if (cmdName == "index") {
inset.reset(new InsetIndex(inscmd));
+ } else if (cmdName == "nomenclature") {
+ inset.reset(new InsetNomencl(inscmd));
} else if (cmdName == "include") {
inset.reset(new InsetInclude(inscmd));
} else if (cmdName == "label") {
|| cmdName == "vref"
|| cmdName == "vpageref"
|| cmdName == "prettyref") {
- if (!inscmd.getOptions().empty()
- || !inscmd.getContents().empty()) {
+ if (!inscmd["name"].empty()
+ || !inscmd["reference"].empty()) {
inset.reset(new InsetRef(inscmd, buf));
}
} else if (cmdName == "tableofcontents") {
inset.reset(new InsetFloatList("table"));
} else if (cmdName == "printindex") {
inset.reset(new InsetPrintIndex(inscmd));
+ } else if (cmdName == "printnomenclature") {
+ inset.reset(new InsetPrintNomencl(inscmd));
} else {
lyxerr << "unknown CommandInset '" << cmdName
<< "'" << std::endl;
} else if (tmptok == "External") {
inset.reset(new InsetExternal);
} else if (tmptok == "FormulaMacro") {
- inset.reset(new InsetFormulaMacro);
+ inset.reset(new MathMacroTemplate);
} else if (tmptok == "Formula") {
- inset.reset(new InsetFormula);
+ inset.reset(new InsetMathHull);
} else if (tmptok == "Graphics") {
inset.reset(new InsetGraphics);
} else if (tmptok == "Note") {
lex.next();
string s = lex.getString();
CharStyles::iterator found_cs = tclass.charstyle(s);
- inset.reset(new InsetCharStyle(buf.params(), found_cs));
+ 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.reset(new InsetBranch(buf.params(),
InsetBranchParams()));
} else if (tmptok == "Include") {
- InsetCommandParams p("Include");
+ InsetCommandParams p("include");
inset.reset(new InsetInclude(p));
} else if (tmptok == "Environment") {
lex.next();
}
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.release();
}
+
+
+} // namespace lyx