X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffactory.cpp;h=1b773c50e901b4aeba6c79d042177862de2588c5;hb=fa79ff2db2c8e0746447cf7eaa5eebbd575ebe97;hp=9f39a2d2291a1920814132ac252c96cce457f3ad;hpb=0345bef67b701e54fd16d9336ec082b474c0146c;p=lyx.git diff --git a/src/factory.cpp b/src/factory.cpp index 9f39a2d229..1b773c50e9 100644 --- a/src/factory.cpp +++ b/src/factory.cpp @@ -38,6 +38,8 @@ #include "insets/InsetInclude.h" #include "insets/InsetIndex.h" #include "insets/InsetInfo.h" +#include "insets/InsetIPA.h" +#include "insets/InsetIPAMacro.h" #include "insets/InsetLabel.h" #include "insets/InsetLine.h" #include "insets/InsetMarginal.h" @@ -49,25 +51,28 @@ #include "insets/InsetPhantom.h" #include "insets/InsetPreview.h" #include "insets/InsetRef.h" +#include "insets/InsetScript.h" +#include "insets/InsetSeparator.h" #include "insets/InsetSpace.h" #include "insets/InsetTabular.h" #include "insets/InsetTOC.h" #include "insets/InsetVSpace.h" #include "insets/InsetWrap.h" -#include "mathed/MathMacroTemplate.h" +#include "mathed/InsetMathMacroTemplate.h" #include "mathed/InsetMathHull.h" #include "frontends/alert.h" #include "support/debug.h" -#include "support/lstrings.h" #include "support/ExceptionMessage.h" - #include "support/lassert.h" +#include "support/lstrings.h" +#include "support/unique_ptr.h" #include + using namespace std; using namespace lyx::support; @@ -82,9 +87,6 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) switch (cmd.action()) { - case LFUN_LINE_INSERT: - return new InsetLine; - case LFUN_NEWPAGE_INSERT: { string const name = cmd.getArg(0); InsetNewpageParams inp; @@ -99,6 +101,22 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) return new InsetNewpage(inp); } + case LFUN_SEPARATOR_INSERT: { + string const name = cmd.getArg(0); + InsetSeparatorParams inp; + if (name.empty() || name == "plain") + inp.kind = InsetSeparatorParams::PLAIN; + else if (name == "parbreak") + inp.kind = InsetSeparatorParams::PARBREAK; + else if (name == "latexpar") + inp.kind = InsetSeparatorParams::LATEXPAR; + else { + lyxerr << "Wrong argument for LyX function 'separator-insert'." << endl; + break; + } + return new InsetSeparator(inp); + } + case LFUN_FLEX_INSERT: { string s = cmd.getArg(0); return new InsetFlex(buf, s); @@ -132,6 +150,16 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) return new InsetPhantom(buf, arg); } + case LFUN_IPAMACRO_INSERT: { + string const arg1 = cmd.getArg(0); + string const arg2 = cmd.getArg(1); + if (arg1 != "deco") { + LYXERR0("LFUN_IPAMACRO_INSERT: wrong argument"); + return 0; + } + return new InsetIPADeco(buf, arg2); + } + case LFUN_ERT_INSERT: return new InsetERT(buf); @@ -144,14 +172,37 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) case LFUN_MARGINALNOTE_INSERT: return new InsetMarginal(buf); - case LFUN_ARGUMENT_INSERT: - return new InsetArgument(buf); + case LFUN_ARGUMENT_INSERT: { + string arg = cmd.getArg(0); + if (arg.empty()) { + LYXERR0("argument-insert needs an argument!"); + return 0; + } + return new InsetArgument(buf, arg); + } - case LFUN_FLOAT_INSERT: - return new InsetFloat(buf, to_utf8(cmd.argument())); + case LFUN_FLOAT_INSERT: { + string argument = to_utf8(cmd.argument()); + if (!argument.empty()) { + if (!contains(argument, "sideways")) { + if (!contains(argument, "wide")) + argument += "\nwide false"; + argument += "\nsideways false"; + } + } + return new InsetFloat(buf, argument); + } case LFUN_FLOAT_WIDE_INSERT: { - InsetFloat * fl = new InsetFloat(buf, to_utf8(cmd.argument())); + string argument = to_utf8(cmd.argument()); + if (!argument.empty()) { + if (!contains(argument, "sideways")) { + if (!contains(argument, "wide")) + argument += "\nwide true"; + argument += "\nsideways false"; + } + } + InsetFloat * fl = new InsetFloat(buf, argument); fl->setWide(true); return fl; } @@ -169,6 +220,9 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) return new InsetIndex(buf, InsetIndexParams(arg)); } + case LFUN_IPA_INSERT: + return new InsetIPA(buf); + case LFUN_NOMENCL_INSERT: { InsetCommandParams icp(NOMENCL_CODE); icp["symbol"] = cmd.argument(); @@ -188,8 +242,12 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) return new InsetTabular(buf, r, c); } - case LFUN_CAPTION_INSERT: - return new InsetCaption(buf); + case LFUN_CAPTION_INSERT: { + string arg = cmd.getArg(0); + if (arg.empty()) + arg = "Standard"; + return new InsetCaption(buf, arg); + } case LFUN_INDEX_PRINT: { InsetCommandParams icp(INDEX_PRINT_CODE); @@ -203,18 +261,20 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) return new InsetPrintNomencl(buf, icp); } - case LFUN_TOC_INSERT: - return new InsetTOC(buf, InsetCommandParams(TOC_CODE)); - case LFUN_INFO_INSERT: { InsetInfo * inset = new InsetInfo(buf, to_utf8(cmd.argument())); - inset->updateInfo(); return inset; } case LFUN_PREVIEW_INSERT: return new InsetPreview(buf); + case LFUN_SCRIPT_INSERT: { + InsetScriptParams isp; + InsetScript::string2params("script script " + to_utf8(cmd.argument()), isp); + return new InsetScript(buf, isp); + } + case LFUN_INSET_INSERT: { string const name = cmd.getArg(0); InsetCode code = insetCode(name); @@ -222,106 +282,118 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) case NO_CODE: lyxerr << "No such inset '" << name << "'."; return 0; - + case BIBITEM_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetBibitem(buf, icp); } - + case BIBTEX_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetBibtex(buf, icp); } - + case CITE_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetCitation(buf, icp); } - + case ERT_CODE: { return new InsetERT(buf, InsetERT::string2params(to_utf8(cmd.argument()))); } - - case LISTINGS_CODE: { - InsetListingsParams par; - InsetListings::string2params(to_utf8(cmd.argument()), par); - return new InsetListings(buf, par); - } - + case EXTERNAL_CODE: { InsetExternalParams iep; InsetExternal::string2params(to_utf8(cmd.argument()), *buf, iep); - auto_ptr inset(new InsetExternal(buf)); + auto inset = make_unique(buf); inset->setBuffer(*buf); inset->setParams(iep); return inset.release(); } - + case GRAPHICS_CODE: { InsetGraphicsParams igp; InsetGraphics::string2params(to_utf8(cmd.argument()), *buf, igp); - auto_ptr inset(new InsetGraphics(buf)); + auto inset = make_unique(buf); inset->setParams(igp); return inset.release(); } - + case HYPERLINK_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetHyperlink(buf, icp); } - + case INCLUDE_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetInclude(buf, icp); } - + case INDEX_CODE: { docstring arg = cmd.argument(); return new InsetIndex(buf, InsetIndexParams(arg)); } - + case INDEX_PRINT_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetPrintIndex(buf, icp); } - - case NOMENCL_CODE: { - InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetNomencl(buf, icp); - } - + case LABEL_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetLabel(buf, icp); } - + + case LINE_CODE: { + InsetCommandParams icp(code); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetLine(buf, icp); + } + + case LISTINGS_CODE: { + InsetListingsParams par; + InsetListings::string2params(to_utf8(cmd.argument()), par); + return new InsetListings(buf, par); + } + + case NOMENCL_CODE: { + InsetCommandParams icp(code); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetNomencl(buf, icp); + } + case REF_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetRef(buf, icp); } + case SCRIPT_CODE: { + InsetScriptParams isp; + InsetScript::string2params(to_utf8(cmd.argument()), isp); + return new InsetScript(buf, isp); + } + case SPACE_CODE: { InsetSpaceParams isp; InsetSpace::string2params(to_utf8(cmd.argument()), isp); return new InsetSpace(isp); } - + case TOC_CODE: { InsetCommandParams icp(code); - InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); return new InsetTOC(buf, icp); } - + case VSPACE_CODE: { VSpace vspace; InsetVSpace::string2params(to_utf8(cmd.argument()), vspace); @@ -330,12 +402,12 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) case PREVIEW_CODE: return new InsetPreview(buf); - + default: lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT." << endl; return 0; - + } } //end LFUN_INSET_INSERT @@ -352,6 +424,8 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) isp.kind = InsetSpaceParams::NORMAL; else if (name == "protected") isp.kind = InsetSpaceParams::PROTECTED; + else if (name == "visible") + isp.kind = InsetSpaceParams::VISIBLE; else if (name == "thin") isp.kind = InsetSpaceParams::THIN; else if (isp.math && name == "med") @@ -368,9 +442,9 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) isp.kind = InsetSpaceParams::ENSKIP; else if (name == "negthinspace") isp.kind = InsetSpaceParams::NEGTHIN; - else if (isp.math && name == "negmedspace") + else if (name == "negmedspace") isp.kind = InsetSpaceParams::NEGMEDIUM; - else if (isp.math && name == "negthickspace") + else if (name == "negthickspace") isp.kind = InsetSpaceParams::NEGTHICK; else if (name == "hfill") isp.kind = InsetSpaceParams::HFILL; @@ -440,13 +514,13 @@ Inset * readInset(Lexer & lex, Buffer * buf) if (lex.getString() != "\\begin_inset") LYXERR0("Buffer::readInset: Consistency check failed."); - auto_ptr inset; + unique_ptr inset; string tmptok; lex >> tmptok; // test the different insets - + // 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 @@ -458,15 +532,15 @@ Inset * readInset(Lexer & lex, Buffer * buf) lex.next(); 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); + inscmd.Read(lex, buf); switch (code) { case BIBITEM_CODE: @@ -475,7 +549,7 @@ Inset * readInset(Lexer & lex, Buffer * buf) case BIBTEX_CODE: inset.reset(new InsetBibtex(buf, inscmd)); break; - case CITE_CODE: + case CITE_CODE: inset.reset(new InsetCitation(buf, inscmd)); break; case HYPERLINK_CODE: @@ -490,6 +564,9 @@ Inset * readInset(Lexer & lex, Buffer * buf) case LABEL_CODE: inset.reset(new InsetLabel(buf, inscmd)); break; + case LINE_CODE: + inset.reset(new InsetLine(buf, inscmd)); + break; case NOMENCL_CODE: inset.reset(new InsetNomencl(buf, inscmd)); break; @@ -513,19 +590,22 @@ Inset * readInset(Lexer & lex, Buffer * buf) return 0; } inset->setBuffer(*buf); - } 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. + } 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(buf)); } else if (tmptok == "External") { inset.reset(new InsetExternal(buf)); } else if (tmptok == "FormulaMacro") { - inset.reset(new MathMacroTemplate(buf)); + inset.reset(new InsetMathMacroTemplate(buf)); } else if (tmptok == "Formula") { inset.reset(new InsetMathHull(buf)); } else if (tmptok == "Graphics") { @@ -546,6 +626,8 @@ Inset * readInset(Lexer & lex, Buffer * buf) inset.reset(new InsetERT(buf)); } else if (tmptok == "listings") { inset.reset(new InsetListings(buf)); + } else if (tmptok == "script") { + inset.reset(new InsetScript(buf)); } else if (tmptok == "space") { inset.reset(new InsetSpace); } else if (tmptok == "Tabular") { @@ -562,22 +644,30 @@ Inset * readInset(Lexer & lex, Buffer * buf) inset.reset(new InsetNewpage); } else if (tmptok == "Newline") { inset.reset(new InsetNewline); + } else if (tmptok == "Separator") { + inset.reset(new InsetSeparator); } else if (tmptok == "Argument") { - inset.reset(new InsetArgument(buf)); + inset.reset(new InsetArgument(buf, tmptok)); } else if (tmptok == "Float") { inset.reset(new InsetFloat(buf, string())); } else if (tmptok == "Wrap") { lex.next(); - string tmptok = lex.getString(); - inset.reset(new InsetWrap(buf, tmptok)); + string tmptok2 = lex.getString(); + inset.reset(new InsetWrap(buf, tmptok2)); } else if (tmptok == "Caption") { - inset.reset(new InsetCaption(buf)); + lex.eatLine(); + string s = lex.getString(); + inset.reset(new InsetCaption(buf, s)); } else if (tmptok == "Index") { inset.reset(new InsetIndex(buf, InsetIndexParams())); } else if (tmptok == "FloatList") { inset.reset(new InsetFloatList(buf)); } else if (tmptok == "Info") { inset.reset(new InsetInfo(buf)); + } else if (tmptok == "IPA") { + inset.reset(new InsetIPA(buf)); + } else if (tmptok == "IPADeco") { + inset.reset(new InsetIPADeco(buf, tmptok)); } else if (tmptok == "Preview") { inset.reset(new InsetPreview(buf)); } else { @@ -589,7 +679,7 @@ Inset * readInset(Lexer & lex, Buffer * buf) } // Set the buffer reference for proper parsing of some insets - // (InsetCollapsable for example) + // (InsetCollapsible for example) inset->setBuffer(*buf); inset->read(lex); // Set again the buffer for insets that are created inside this inset