#include "insets/InsetBibtex.h"
#include "insets/InsetCaption.h"
#include "insets/InsetCitation.h"
-#include "insets/InsetCharStyle.h"
+#include "insets/InsetFlex.h"
#include "insets/InsetEnvironment.h"
#include "insets/InsetERT.h"
#include "insets/InsetListings.h"
#include "insets/InsetHFill.h"
#include "insets/InsetInclude.h"
#include "insets/InsetIndex.h"
+#include "insets/InsetInfo.h"
#include "insets/InsetNomencl.h"
#include "insets/InsetLabel.h"
#include "insets/InsetLine.h"
#include "insets/InsetSpace.h"
#include "insets/InsetTabular.h"
#include "insets/InsetTOC.h"
-#include "insets/InsetUrl.h"
+#include "insets/InsetHyperlink.h"
#include "insets/InsetVSpace.h"
#include "insets/InsetWrap.h"
Inset * createInset(BufferView * bv, FuncRequest const & cmd)
{
- BufferParams const & params = bv->buffer()->params();
+ BufferParams const & params = bv->buffer().params();
try {
case LFUN_CLEARDOUBLEPAGE_INSERT:
return new InsetClearDoublePage;
- case LFUN_CHARSTYLE_INSERT: {
+ case LFUN_FLEX_INSERT: {
string s = cmd.getArg(0);
TextClass tclass = params.getTextClass();
- 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);
+ InsetLayout il = tclass.insetlayout(from_utf8(s));
+ return new InsetFlex(params, il);
}
case LFUN_NOTE_INSERT: {
return new InsetOptArg(params);
case LFUN_BIBITEM_INSERT:
- return new InsetBibitem(InsetCommandParams("bibitem"));
+ return new InsetBibitem(InsetCommandParams(BIBITEM_CODE));
case LFUN_FLOAT_INSERT: {
// check if the float type exists
case LFUN_WRAP_INSERT: {
string const argument = to_utf8(cmd.argument());
- if (argument == "figure")
+ if (argument == "figure" || argument == "table")
return new InsetWrap(params, argument);
- lyxerr << "Non-existent floatflt type: " << argument << endl;
+ lyxerr << "Non-existent wrapfig 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_INDEX_INSERT:
+ return new InsetIndex(params);
case LFUN_NOMENCL_INSERT: {
- InsetCommandParams icp("nomenclature");
+ InsetCommandParams icp(NOMENCL_CODE);
icp["symbol"] = cmd.argument().empty() ?
bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
cmd.argument();
r = 2;
if (c <= 0)
c = 2;
- return new InsetTabular(*bv->buffer(), r, c);
+ return new InsetTabular(bv->buffer(), r, c);
}
case LFUN_CAPTION_INSERT: {
}
case LFUN_INDEX_PRINT:
- return new InsetPrintIndex(InsetCommandParams("printindex"));
+ return new InsetPrintIndex(InsetCommandParams(INDEX_PRINT_CODE));
case LFUN_NOMENCL_PRINT:
- return new InsetPrintNomencl(InsetCommandParams("printnomenclature"));
+ return new InsetPrintNomencl(InsetCommandParams(NOMENCL_PRINT_CODE));
case LFUN_TOC_INSERT:
- return new InsetTOC(InsetCommandParams("tableofcontents"));
+ return new InsetTOC(InsetCommandParams(TOC_CODE));
case LFUN_ENVIRONMENT_INSERT:
return new InsetEnvironment(params, cmd.argument());
+ case LFUN_INFO_INSERT:
+ return new InsetInfo(params, to_utf8(cmd.argument()));
#if 0
- case LFUN_LIST_INSERT:
- return new InsetList;
-
case LFUN_THEOREM_INSERT:
return new InsetTheorem;
#endif
case LFUN_INSET_INSERT: {
string const name = cmd.getArg(0);
-
- if (name == "bibitem") {
- InsetCommandParams icp(name);
- InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
- icp);
+ InsetCode code = insetCode(name);
+ switch (code) {
+ case NO_CODE:
+ lyxerr << "No such inset '" << name << "'.";
+ return 0;
+
+ case BIBITEM_CODE: {
+ InsetCommandParams icp(code);
+ 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);
+ }
+
+ case BIBTEX_CODE: {
+ InsetCommandParams icp(code);
+ 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);
+ }
+
+ case CITE_CODE: {
+ InsetCommandParams icp(code);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
return new InsetCitation(icp);
-
- } else if (name == "ert") {
+ }
+
+ case ERT_CODE: {
InsetCollapsable::CollapseStatus st;
InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
return new InsetERT(params, st);
-
- } else if (name == "listings") {
+ }
+
+ case LISTINGS_CODE: {
InsetListingsParams par;
InsetListingsMailer::string2params(to_utf8(cmd.argument()), par);
return new InsetListings(params, par);
-
- } else if (name == "external") {
- Buffer const & buffer = *bv->buffer();
+ }
+
+ case EXTERNAL_CODE: {
+ Buffer const & buffer = bv->buffer();
InsetExternalParams iep;
- InsetExternalMailer::string2params(to_utf8(cmd.argument()),
- buffer, 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();
+ }
+
+ case GRAPHICS_CODE: {
+ Buffer const & buffer = bv->buffer();
InsetGraphicsParams igp;
- InsetGraphicsMailer::string2params(to_utf8(cmd.argument()),
- buffer, 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);
+ }
+
+ case HYPERLINK_CODE: {
+ InsetCommandParams icp(code);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+ return new InsetHyperlink(icp);
+ }
+
+ case INCLUDE_CODE: {
+ InsetCommandParams icp(code);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+ return new InsetInclude(icp);
+ }
+
+ case INDEX_CODE:
+ return new InsetIndex(params);
+
+ case NOMENCL_CODE: {
+ InsetCommandParams icp(code);
+ 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);
+ }
+
+ case LABEL_CODE: {
+ InsetCommandParams icp(code);
+ 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);
+ }
+
+ case REF_CODE: {
+ InsetCommandParams icp(code);
+ InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+ return new InsetRef(icp, bv->buffer());
+ }
+
+ case TOC_CODE: {
+ InsetCommandParams icp(code);
+ 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") {
+ }
+
+ case VSPACE_CODE: {
VSpace vspace;
InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
return new InsetVSpace(vspace);
}
- }
+
+ default:
+ lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT."
+ << std::endl;
+ return 0;
+
+ }
+ } //end LFUN_INSET_INSERT
case LFUN_SPACE_INSERT: {
string const name = to_utf8(cmd.argument());
string tmptok = lex.getString();
// test the different insets
- if (tmptok == "LatexCommand") {
+
+ //FIXME It would be better if we did not have this branch and could
+ //just do one massive switch for all insets. But at present, it's easier
+ //to do it this way, and we can't do the massive switch until the conversion
+ //mentioned below.
+ //Note that if we do want to do a single switch, we need to remove
+ //this "CommandInset" line---or replace it with a single "InsetType" line
+ //that would be used in all insets.
+ if (tmptok == "CommandInset") {
lex.next();
- string const cmdName = lex.getString();
- lex.pushToken(cmdName);
-
- InsetCommandParams inscmd(cmdName);
+ string const insetType = lex.getString();
+ lex.pushToken(insetType);
+
+ InsetCode const code = insetCode(insetType);
+
+ //FIXME If we do the one massive switch, we cannot do this here, since
+ //we do not know in advance that we're dealing with a command inset.
+ //Worst case, we could put it in each case below. Better, we could
+ //pass the lexer to the constructor and let the params be built there.
+ InsetCommandParams inscmd(code);
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/frontend_helpers.cpp 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") {
- 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") {
- inset.reset(new InsetLabel(inscmd));
- } else if (cmdName == "url"
- || cmdName == "htmlurl") {
- inset.reset(new InsetUrl(inscmd));
- } else if (cmdName == "ref"
- || cmdName == "eqref"
- || cmdName == "pageref"
- || cmdName == "vref"
- || cmdName == "vpageref"
- || cmdName == "prettyref") {
- if (!inscmd["name"].empty()
- || !inscmd["reference"].empty()) {
- inset.reset(new InsetRef(inscmd, buf));
- }
- } else if (cmdName == "tableofcontents") {
- inset.reset(new InsetTOC(inscmd));
- } else if (cmdName == "listofalgorithms") {
- inset.reset(new InsetFloatList("algorithm"));
- } else if (cmdName == "listoffigures") {
- inset.reset(new InsetFloatList("figure"));
- } else if (cmdName == "listoftables") {
- 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;
- while (lex.isOK() && lex.getString() != "\\end_inset")
- lex.next();
- return 0;
+ switch (code) {
+ case BIBITEM_CODE:
+ inset.reset(new InsetBibitem(inscmd));
+ break;
+ case BIBTEX_CODE:
+ inset.reset(new InsetBibtex(inscmd));
+ break;
+ case CITE_CODE:
+ inset.reset(new InsetCitation(inscmd));
+ break;
+ case HYPERLINK_CODE:
+ inset.reset(new InsetHyperlink(inscmd));
+ break;
+ case INCLUDE_CODE:
+ inset.reset(new InsetInclude(inscmd));
+ break;
+ case INDEX_CODE:
+ inset.reset(new InsetIndex(buf.params()));
+ break;
+ case INDEX_PRINT_CODE:
+ inset.reset(new InsetPrintIndex(inscmd));
+ break;
+ case LABEL_CODE:
+ inset.reset(new InsetLabel(inscmd));
+ break;
+ case NOMENCL_CODE:
+ inset.reset(new InsetNomencl(inscmd));
+ break;
+ case NOMENCL_PRINT_CODE:
+ inset.reset(new InsetPrintNomencl(inscmd));
+ break;
+ case REF_CODE:
+ if (!inscmd["name"].empty() || !inscmd["reference"].empty())
+ inset.reset(new InsetRef(inscmd, buf));
+ break;
+ case TOC_CODE:
+ inset.reset(new InsetTOC(inscmd));
+ break;
+ case NO_CODE:
+ default:
+ lyxerr << "unknown CommandInset '" << insetType
+ << "'" << std::endl;
+ while (lex.isOK() && lex.getString() != "\\end_inset")
+ lex.next();
+ return 0;
}
- } else {
+ } else {
+ // FIXME This branch should be made to use inset codes as the preceding
+ // branch does. Unfortunately, that will take some doing. It requires
+ // converting the representation of the insets in LyX files so that they
+ // use the inset names listed in Inset.cpp. Then, as above, the inset names
+ // can be translated to inset codes using insetCode(). And the insets'
+ // write() routines should use insetName() rather than hardcoding it.
if (tmptok == "Quotes") {
inset.reset(new InsetQuotes);
} else if (tmptok == "External") {
inset.reset(new InsetNote(buf.params(), tmptok));
} else if (tmptok == "Box") {
inset.reset(new InsetBox(buf.params(), tmptok));
- } else if (tmptok == "CharStyle") {
+ } else if (tmptok == "Flex") {
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));
- }
+ InsetLayout il = tclass.insetlayout(from_utf8(s));
+ inset.reset(new InsetFlex(buf.params(), il));
} else if (tmptok == "Branch") {
inset.reset(new InsetBranch(buf.params(),
InsetBranchParams()));
- } else if (tmptok == "Include") {
- InsetCommandParams p("include");
- inset.reset(new InsetInclude(p));
} else if (tmptok == "Environment") {
lex.next();
inset.reset(new InsetEnvironment(buf.params(), lex.getDocString()));
string tmptok = lex.getString();
inset.reset(new InsetWrap(buf.params(), tmptok));
#if 0
- } else if (tmptok == "List") {
- inset.reset(new InsetList);
} else if (tmptok == "Theorem") {
inset.reset(new InsetList);
#endif
} else if (tmptok == "Caption") {
inset.reset(new InsetCaption(buf.params()));
+ } else if (tmptok == "Index") {
+ inset.reset(new InsetIndex(buf.params()));
} else if (tmptok == "FloatList") {
inset.reset(new InsetFloatList);
+ } else if (tmptok == "Info") {
+ inset.reset(new InsetInfo(buf.params()));
} else {
lyxerr << "unknown Inset type '" << tmptok
<< "'" << std::endl;
inset->read(buf, lex);
-#ifdef WITH_WARNINGS
-#warning hack..
-#endif
- if (inset->lyxCode() == Inset::MATHMACRO_CODE) {
+// FIXME: hack..
+ if (inset->lyxCode() == MATHMACRO_CODE) {
MathMacroTemplate const * tmpl =
static_cast<MathMacroTemplate*>(inset.get());
MacroTable::globalMacros().insert