X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffactory.cpp;h=9fdc37da625b8432861c2ce93b19c0d926762c2d;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=dde7c68baf7c6b20b1487c6cfbfa85e2e58adc7a;hpb=241575ed863d0e791420c25ffdb6a169f303101c;p=lyx.git diff --git a/src/factory.cpp b/src/factory.cpp index dde7c68baf..9fdc37da62 100644 --- a/src/factory.cpp +++ b/src/factory.cpp @@ -3,7 +3,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ @@ -22,10 +22,11 @@ #include "insets/InsetBibitem.h" #include "insets/InsetBibtex.h" +#include "insets/InsetBox.h" +#include "insets/InsetBranch.h" #include "insets/InsetCaption.h" #include "insets/InsetCitation.h" #include "insets/InsetFlex.h" -#include "insets/InsetEnvironment.h" #include "insets/InsetERT.h" #include "insets/InsetListings.h" #include "insets/InsetExternal.h" @@ -33,25 +34,28 @@ #include "insets/InsetFloatList.h" #include "insets/InsetFoot.h" #include "insets/InsetGraphics.h" +#include "insets/InsetHyperlink.h" #include "insets/InsetInclude.h" #include "insets/InsetIndex.h" #include "insets/InsetInfo.h" -#include "insets/InsetNomencl.h" +#include "insets/InsetIPA.h" +#include "insets/InsetIPAMacro.h" #include "insets/InsetLabel.h" #include "insets/InsetLine.h" #include "insets/InsetMarginal.h" #include "insets/InsetNewline.h" #include "insets/InsetNewpage.h" +#include "insets/InsetNomencl.h" #include "insets/InsetNote.h" -#include "insets/InsetBox.h" -#include "insets/InsetBranch.h" -#include "insets/InsetOptArg.h" -#include "insets/InsetNewpage.h" +#include "insets/InsetArgument.h" +#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/InsetHyperlink.h" #include "insets/InsetVSpace.h" #include "insets/InsetWrap.h" @@ -61,13 +65,14 @@ #include "frontends/alert.h" #include "support/debug.h" -#include "support/lstrings.h" #include "support/ExceptionMessage.h" - -#include +#include "support/lassert.h" +#include "support/lstrings.h" +#include "support/unique_ptr.h" #include + using namespace std; using namespace lyx::support; @@ -76,16 +81,11 @@ namespace lyx { namespace Alert = frontend::Alert; -Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) +Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd) { - BufferParams const & params = buf.params(); - try { - switch (cmd.action) { - - case LFUN_LINE_INSERT: - return new InsetLine; + switch (cmd.action()) { case LFUN_NEWPAGE_INSERT: { string const name = cmd.getArg(0); @@ -101,9 +101,25 @@ 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, buf.params().documentClassPtr(), s); + return new InsetFlex(buf, s); } case LFUN_NOTE_INSERT: { @@ -127,6 +143,23 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) return new InsetBranch(buf, InsetBranchParams(arg)); } + case LFUN_PHANTOM_INSERT: { + string arg = cmd.getArg(0); + if (arg.empty()) + arg = "Phantom"; + 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); @@ -139,30 +172,39 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) case LFUN_MARGINALNOTE_INSERT: return new InsetMarginal(buf); - case LFUN_OPTIONAL_INSERT: - return new InsetOptArg(buf); - - case LFUN_BIBITEM_INSERT: - return new InsetBibitem(InsetCommandParams(BIBITEM_CODE)); + 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: { - // check if the float type exists - string const argument = to_utf8(cmd.argument()); - if (buf.params().documentClass().floats().typeExist(argument)) - return new InsetFloat(buf, argument); - lyxerr << "Non-existent float type: " << argument << endl; + 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: { - // check if the float type exists - string const argument = to_utf8(cmd.argument()); - if (params.documentClass().floats().typeExist(argument)) { - auto_ptr p(new InsetFloat(buf, argument)); - p->wide(true, params); - return p.release(); + string argument = to_utf8(cmd.argument()); + if (!argument.empty()) { + if (!contains(argument, "sideways")) { + if (!contains(argument, "wide")) + argument += "\nwide true"; + argument += "\nsideways false"; + } } - lyxerr << "Non-existent float type: " << argument << endl; - return 0; + InsetFloat * fl = new InsetFloat(buf, argument); + fl->setWide(true); + return fl; } case LFUN_WRAP_INSERT: { @@ -173,13 +215,18 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) return 0; } - case LFUN_INDEX_INSERT: - return new InsetIndex(buf); + case LFUN_INDEX_INSERT: { + docstring arg = cmd.argument(); + 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(); - return new InsetNomencl(icp); + return new InsetNomencl(buf, icp); } case LFUN_TABULAR_INSERT: { @@ -195,23 +242,39 @@ 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: - return new InsetPrintIndex(InsetCommandParams(INDEX_PRINT_CODE)); + case LFUN_INDEX_PRINT: { + InsetCommandParams icp(INDEX_PRINT_CODE); + icp["type"] = cmd.argument(); + return new InsetPrintIndex(buf, icp); + } - case LFUN_NOMENCL_PRINT: - return new InsetPrintNomencl(InsetCommandParams(NOMENCL_PRINT_CODE)); + case LFUN_NOMENCL_PRINT: { + InsetCommandParams icp(NOMENCL_PRINT_CODE); + icp["set_width"] = from_ascii("auto"); + return new InsetPrintNomencl(buf, icp); + } - case LFUN_TOC_INSERT: - return new InsetTOC(InsetCommandParams(TOC_CODE)); + case LFUN_INFO_INSERT: { + InsetInfo * inset = new InsetInfo(buf, to_utf8(cmd.argument())); + inset->updateInfo(); + return inset; + } - case LFUN_ENVIRONMENT_INSERT: - return new InsetEnvironment(buf, cmd.argument()); + case LFUN_PREVIEW_INSERT: + return new InsetPreview(buf); - case LFUN_INFO_INSERT: - return new InsetInfo(buf, to_utf8(cmd.argument())); + 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); @@ -223,94 +286,113 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) case BIBITEM_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetBibitem(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetBibitem(buf, icp); } case BIBTEX_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetBibtex(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetBibtex(buf, icp); } case CITE_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetCitation(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetCitation(buf, icp); } case ERT_CODE: { - InsetCollapsable::CollapseStatus st; - InsetERT::string2params(to_utf8(cmd.argument()), st); - return new InsetERT(buf, st); - } - - case LISTINGS_CODE: { - InsetListingsParams par; - InsetListingsMailer::string2params(to_utf8(cmd.argument()), par); - return new InsetListings(buf, par); + return new InsetERT(buf, + InsetERT::string2params(to_utf8(cmd.argument()))); } case EXTERNAL_CODE: { InsetExternalParams iep; - InsetExternalMailer::string2params(to_utf8(cmd.argument()), buf, iep); - auto_ptr inset(new InsetExternal(buf)); - inset->setBuffer(buf); + InsetExternal::string2params(to_utf8(cmd.argument()), *buf, iep); + auto inset = make_unique(buf); + inset->setBuffer(*buf); inset->setParams(iep); return inset.release(); } case GRAPHICS_CODE: { InsetGraphicsParams igp; - InsetGraphicsMailer::string2params(to_utf8(cmd.argument()), buf, igp); - auto_ptr inset(new InsetGraphics(buf)); + InsetGraphics::string2params(to_utf8(cmd.argument()), *buf, igp); + auto inset = make_unique(buf); inset->setParams(igp); return inset.release(); } case HYPERLINK_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetHyperlink(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetHyperlink(buf, icp); } case INCLUDE_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetInclude(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetInclude(buf, icp); } - case INDEX_CODE: - return new InsetIndex(buf); + case INDEX_CODE: { + docstring arg = cmd.argument(); + return new InsetIndex(buf, InsetIndexParams(arg)); + } - case NOMENCL_CODE: { + case INDEX_PRINT_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()), icp); - return new InsetNomencl(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetPrintIndex(buf, icp); } case LABEL_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetLabel(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); - InsetCommandMailer::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; - InsetSpaceMailer::string2params(to_utf8(cmd.argument()), isp); + InsetSpace::string2params(to_utf8(cmd.argument()), isp); return new InsetSpace(isp); } case TOC_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetTOC(icp); + InsetCommand::string2params(to_utf8(cmd.argument()), icp); + return new InsetTOC(buf, icp); } case VSPACE_CODE: { @@ -318,6 +400,9 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) InsetVSpace::string2params(to_utf8(cmd.argument()), vspace); return new InsetVSpace(vspace); } + + case PREVIEW_CODE: + return new InsetPreview(buf); default: lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT." @@ -325,7 +410,7 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) return 0; } - } //end LFUN_INSET_INSERT + } //end LFUN_INSET_INSERT case LFUN_SPACE_INSERT: { string const name = cmd.getArg(0); @@ -335,12 +420,19 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) break; } InsetSpaceParams isp; + // The tests for isp.math might be disabled after a file format change if (name == "normal") 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") + isp.kind = InsetSpaceParams::MEDIUM; + else if (isp.math && name == "thick") + isp.kind = InsetSpaceParams::THICK; else if (name == "quad") isp.kind = InsetSpaceParams::QUAD; else if (name == "qquad") @@ -351,6 +443,10 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) isp.kind = InsetSpaceParams::ENSKIP; else if (name == "negthinspace") isp.kind = InsetSpaceParams::NEGTHIN; + else if (name == "negmedspace") + isp.kind = InsetSpaceParams::NEGMEDIUM; + else if (name == "negthickspace") + isp.kind = InsetSpaceParams::NEGTHICK; else if (name == "hfill") isp.kind = InsetSpaceParams::HFILL; else if (name == "hfill*") @@ -360,22 +456,22 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) else if (name == "hrulefill") isp.kind = InsetSpaceParams::HRULEFILL; else if (name == "hspace") { - if (len.empty() || !isValidLength(len)) { + if (len.empty() || !isValidGlueLength(len)) { lyxerr << "LyX function 'space-insert hspace' " << "needs a valid length argument." << endl; break; } isp.kind = InsetSpaceParams::CUSTOM; - isp.length = Length(len); + isp.length = GlueLength(len); } else if (name == "hspace*") { - if (len.empty() || !isValidLength(len)) { + if (len.empty() || !isValidGlueLength(len)) { lyxerr << "LyX function 'space-insert hspace*' " << "needs a valid length argument." << endl; break; } isp.kind = InsetSpaceParams::CUSTOM_PROTECTED; - isp.length = Length(len); + isp.length = GlueLength(len); } else { lyxerr << "Wrong argument for LyX function 'space-insert'." << endl; @@ -393,47 +489,46 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) if (message.type_ == ErrorException) { // This should never happen! Alert::error(message.title_, message.details_); - LyX::cref().exit(1); + lyx_exit(1); } else if (message.type_ == WarningException) { Alert::warning(message.title_, message.details_); return 0; } } - return 0; } -Inset * createInset(Buffer & buf, FuncRequest const & cmd) + +Inset * createInset(Buffer * buf, FuncRequest const & cmd) { Inset * inset = createInsetHelper(buf, cmd); if (inset) - inset->setBuffer(buf); + inset->setBuffer(*buf); return inset; } -Inset * readInset(Lexer & lex, Buffer const & buf) + +Inset * readInset(Lexer & lex, Buffer * buf) { // consistency check - if (lex.getString() != "\\begin_inset") { - lyxerr << "Buffer::readInset: Consistency check failed." - << endl; - } + if (lex.getString() != "\\begin_inset") + LYXERR0("Buffer::readInset: Consistency check failed."); - auto_ptr inset; + unique_ptr inset; - lex.next(); - string tmptok = lex.getString(); + 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 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. + // 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 insetType = lex.getString(); @@ -446,42 +541,46 @@ Inset * readInset(Lexer & lex, Buffer const & buf) //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: - inset.reset(new InsetBibitem(inscmd)); + inset.reset(new InsetBibitem(buf, inscmd)); break; case BIBTEX_CODE: - inset.reset(new InsetBibtex(inscmd)); + inset.reset(new InsetBibtex(buf, inscmd)); break; case CITE_CODE: - inset.reset(new InsetCitation(inscmd)); + inset.reset(new InsetCitation(buf, inscmd)); break; case HYPERLINK_CODE: - inset.reset(new InsetHyperlink(inscmd)); + inset.reset(new InsetHyperlink(buf, inscmd)); break; case INCLUDE_CODE: - inset.reset(new InsetInclude(inscmd)); + inset.reset(new InsetInclude(buf, inscmd)); break; case INDEX_PRINT_CODE: - inset.reset(new InsetPrintIndex(inscmd)); + inset.reset(new InsetPrintIndex(buf, inscmd)); break; case LABEL_CODE: - inset.reset(new InsetLabel(inscmd)); + inset.reset(new InsetLabel(buf, inscmd)); + break; + case LINE_CODE: + inset.reset(new InsetLine(buf, inscmd)); break; case NOMENCL_CODE: - inset.reset(new InsetNomencl(inscmd)); + inset.reset(new InsetNomencl(buf, inscmd)); break; case NOMENCL_PRINT_CODE: - inset.reset(new InsetPrintNomencl(inscmd)); + inset.reset(new InsetPrintNomencl(buf, inscmd)); break; case REF_CODE: - if (!inscmd["name"].empty() || !inscmd["reference"].empty()) - inset.reset(new InsetRef(buf, inscmd)); + if (inscmd["name"].empty() && inscmd["reference"].empty()) + return 0; + inset.reset(new InsetRef(buf, inscmd)); break; case TOC_CODE: - inset.reset(new InsetTOC(inscmd)); + inset.reset(new InsetTOC(buf, inscmd)); break; case NO_CODE: default: @@ -491,44 +590,46 @@ Inset * readInset(Lexer & lex, Buffer const & buf) lex.next(); return 0; } - inset->setBuffer(const_cast(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. + 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. if (tmptok == "Quotes") { - inset.reset(new InsetQuotes); + inset.reset(new InsetQuotes(buf)); } else if (tmptok == "External") { - inset.reset(new InsetExternal(const_cast(buf))); + inset.reset(new InsetExternal(buf)); } else if (tmptok == "FormulaMacro") { - inset.reset(new MathMacroTemplate); + inset.reset(new MathMacroTemplate(buf)); } else if (tmptok == "Formula") { - inset.reset(new InsetMathHull); + inset.reset(new InsetMathHull(buf)); } else if (tmptok == "Graphics") { - inset.reset(new InsetGraphics(const_cast(buf))); + inset.reset(new InsetGraphics(buf)); } else if (tmptok == "Note") { inset.reset(new InsetNote(buf, tmptok)); } else if (tmptok == "Box") { inset.reset(new InsetBox(buf, tmptok)); } else if (tmptok == "Flex") { - lex.next(); + lex.eatLine(); string s = lex.getString(); - inset.reset(new InsetFlex(buf, - buf.params().documentClassPtr(), s)); + inset.reset(new InsetFlex(buf, s)); } else if (tmptok == "Branch") { - inset.reset(new InsetBranch(buf, - InsetBranchParams())); - } else if (tmptok == "Environment") { - lex.next(); - inset.reset(new InsetEnvironment(buf, lex.getDocString())); + inset.reset(new InsetBranch(buf, InsetBranchParams())); + } else if (tmptok == "Phantom") { + inset.reset(new InsetPhantom(buf, tmptok)); } else if (tmptok == "ERT") { inset.reset(new InsetERT(buf)); } else if (tmptok == "listings") { inset.reset(new InsetListings(buf)); - } else if (tmptok == "Space") { + } else if (tmptok == "script") { + inset.reset(new InsetScript(buf)); + } else if (tmptok == "space") { inset.reset(new InsetSpace); } else if (tmptok == "Tabular") { inset.reset(new InsetTabular(buf)); @@ -544,28 +645,32 @@ Inset * readInset(Lexer & lex, Buffer const & buf) inset.reset(new InsetNewpage); } else if (tmptok == "Newline") { inset.reset(new InsetNewline); - } else if (tmptok == "OptArg") { - inset.reset(new InsetOptArg(buf)); + } else if (tmptok == "Separator") { + inset.reset(new InsetSeparator); + } else if (tmptok == "Argument") { + inset.reset(new InsetArgument(buf, tmptok)); } else if (tmptok == "Float") { - lex.next(); - string tmptok = lex.getString(); - inset.reset(new InsetFloat(buf, tmptok)); + inset.reset(new InsetFloat(buf, string())); } else if (tmptok == "Wrap") { lex.next(); string tmptok = lex.getString(); inset.reset(new InsetWrap(buf, tmptok)); -#if 0 - } else if (tmptok == "Theorem") { - inset.reset(new InsetList); -#endif } 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)); + inset.reset(new InsetIndex(buf, InsetIndexParams())); } else if (tmptok == "FloatList") { - inset.reset(new InsetFloatList); + 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 { lyxerr << "unknown Inset type '" << tmptok << "'" << endl; @@ -576,11 +681,11 @@ Inset * readInset(Lexer & lex, Buffer const & buf) // Set the buffer reference for proper parsing of some insets // (InsetCollapsable for example) - inset->setBuffer(const_cast(buf)); + inset->setBuffer(*buf); inset->read(lex); // Set again the buffer for insets that are created inside this inset // (InsetMathHull for example). - inset->setBuffer(const_cast(buf)); + inset->setBuffer(*buf); } return inset.release(); }