X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffactory.cpp;h=eba16dcc30bf7782fa4838363e8c1032b6feba0f;hb=cca78e3c8ae27431323746abd64f9d7db017099d;hp=8a8616b02ab6e58faf43ef469ccb7663a2d481c2;hpb=9d0ea8aeff32833a90b3fe64df0c5518a9e241be;p=lyx.git diff --git a/src/factory.cpp b/src/factory.cpp index 8a8616b02a..eba16dcc30 100644 --- a/src/factory.cpp +++ b/src/factory.cpp @@ -25,7 +25,6 @@ #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,7 +32,6 @@ #include "insets/InsetFloatList.h" #include "insets/InsetFoot.h" #include "insets/InsetGraphics.h" -#include "insets/InsetHFill.h" #include "insets/InsetInclude.h" #include "insets/InsetIndex.h" #include "insets/InsetInfo.h" @@ -41,6 +39,8 @@ #include "insets/InsetLabel.h" #include "insets/InsetLine.h" #include "insets/InsetMarginal.h" +#include "insets/InsetNewline.h" +#include "insets/InsetNewpage.h" #include "insets/InsetNote.h" #include "insets/InsetBox.h" #include "insets/InsetBranch.h" @@ -63,108 +63,98 @@ #include "support/lstrings.h" #include "support/ExceptionMessage.h" -#include -#include +#include "support/lassert.h" #include -using std::auto_ptr; -using std::endl; -using std::string; - +using namespace std; +using namespace lyx::support; namespace lyx { namespace Alert = frontend::Alert; -using support::compare_ascii_no_case; - -Inset * createInset(Buffer & buf, FuncRequest const & cmd) +Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd) { BufferParams const & params = buf.params(); try { switch (cmd.action) { - case LFUN_HFILL_INSERT: - return new InsetHFill; case LFUN_LINE_INSERT: return new InsetLine; - case LFUN_NEWPAGE_INSERT: - return new InsetNewpage; - - case LFUN_PAGEBREAK_INSERT: - return new InsetPagebreak; - - case LFUN_CLEARPAGE_INSERT: - return new InsetClearPage; - - case LFUN_CLEARDOUBLEPAGE_INSERT: - return new InsetClearDoublePage; + case LFUN_NEWPAGE_INSERT: { + string const name = cmd.getArg(0); + InsetNewpageParams inp; + if (name.empty() || name == "newpage") + inp.kind = InsetNewpageParams::NEWPAGE; + else if (name == "pagebreak") + inp.kind = InsetNewpageParams::PAGEBREAK; + else if (name == "clearpage") + inp.kind = InsetNewpageParams::CLEARPAGE; + else if (name == "cleardoublepage") + inp.kind = InsetNewpageParams::CLEARDOUBLEPAGE; + return new InsetNewpage(inp); + } case LFUN_FLEX_INSERT: { string s = cmd.getArg(0); - TextClass const & tclass = params.getTextClass(); - InsetLayout const & il = tclass.insetlayout(from_utf8(s)); - return new InsetFlex(params, il); + return new InsetFlex(buf, s); } case LFUN_NOTE_INSERT: { string arg = cmd.getArg(0); if (arg.empty()) arg = "Note"; - return new InsetNote(params, arg); + return new InsetNote(buf, arg); } case LFUN_BOX_INSERT: { string arg = cmd.getArg(0); if (arg.empty()) arg = "Boxed"; - return new InsetBox(params, arg); + return new InsetBox(buf, arg); } case LFUN_BRANCH_INSERT: { docstring arg = cmd.argument(); if (arg.empty()) arg = from_ascii("none"); - return new InsetBranch(params, InsetBranchParams(arg)); + return new InsetBranch(buf, InsetBranchParams(arg)); } case LFUN_ERT_INSERT: - return new InsetERT(params); + return new InsetERT(buf); case LFUN_LISTING_INSERT: - return new InsetListings(params); + return new InsetListings(buf); case LFUN_FOOTNOTE_INSERT: - return new InsetFoot(params); + return new InsetFoot(buf); case LFUN_MARGINALNOTE_INSERT: - return new InsetMarginal(params); + return new InsetMarginal(buf); case LFUN_OPTIONAL_INSERT: - return new InsetOptArg(params); - - case LFUN_BIBITEM_INSERT: - return new InsetBibitem(InsetCommandParams(BIBITEM_CODE)); + return new InsetOptArg(buf); case LFUN_FLOAT_INSERT: { // check if the float type exists string const argument = to_utf8(cmd.argument()); - if (params.getTextClass().floats().typeExist(argument)) - return new InsetFloat(params, argument); + if (buf.params().documentClass().floats().typeExist(argument)) + return new InsetFloat(buf, argument); lyxerr << "Non-existent float type: " << argument << endl; } case LFUN_FLOAT_WIDE_INSERT: { // check if the float type exists string const argument = to_utf8(cmd.argument()); - if (params.getTextClass().floats().typeExist(argument)) { - auto_ptr p(new InsetFloat(params, argument)); - p->wide(true, params); + if (params.documentClass().floats().typeExist(argument)) { + auto_ptr p(new InsetFloat(buf, argument)); + p->setWide(true, params); return p.release(); } lyxerr << "Non-existent float type: " << argument << endl; @@ -174,13 +164,13 @@ Inset * createInset(Buffer & buf, FuncRequest const & cmd) case LFUN_WRAP_INSERT: { string const argument = to_utf8(cmd.argument()); if (argument == "figure" || argument == "table") - return new InsetWrap(params, argument); + return new InsetWrap(buf, argument); lyxerr << "Non-existent wrapfig type: " << argument << endl; return 0; } case LFUN_INDEX_INSERT: - return new InsetIndex(params); + return new InsetIndex(buf); case LFUN_NOMENCL_INSERT: { InsetCommandParams icp(NOMENCL_CODE); @@ -191,7 +181,7 @@ Inset * createInset(Buffer & buf, FuncRequest const & cmd) case LFUN_TABULAR_INSERT: { if (cmd.argument().empty()) return 0; - std::istringstream ss(to_utf8(cmd.argument())); + istringstream ss(to_utf8(cmd.argument())); int r = 0, c = 0; ss >> r >> c; if (r <= 0) @@ -201,13 +191,8 @@ Inset * createInset(Buffer & buf, FuncRequest const & cmd) return new InsetTabular(buf, r, c); } - case LFUN_CAPTION_INSERT: { - auto_ptr inset(new InsetCaption(params)); - inset->setAutoBreakRows(true); - inset->setDrawFrame(true); - inset->setFrameColor(Color_captionframe); - return inset.release(); - } + case LFUN_CAPTION_INSERT: + return new InsetCaption(buf); case LFUN_INDEX_PRINT: return new InsetPrintIndex(InsetCommandParams(INDEX_PRINT_CODE)); @@ -218,15 +203,11 @@ Inset * createInset(Buffer & buf, FuncRequest const & cmd) case LFUN_TOC_INSERT: 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_THEOREM_INSERT: - return new InsetTheorem; -#endif + case LFUN_INFO_INSERT: { + InsetInfo * inset = new InsetInfo(buf, to_utf8(cmd.argument())); + inset->updateInfo(); + return inset; + } case LFUN_INSET_INSERT: { string const name = cmd.getArg(0); @@ -238,125 +219,164 @@ Inset * createInset(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(name, 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(name, to_utf8(cmd.argument()), icp); + return new InsetBibtex(buf, icp); } case CITE_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); return new InsetCitation(icp); } case ERT_CODE: { - InsetCollapsable::CollapseStatus st; - InsetERTMailer::string2params(to_utf8(cmd.argument()), st); - return new InsetERT(params, st); + return new InsetERT(buf, + InsetERT::string2params(to_utf8(cmd.argument()))); } case LISTINGS_CODE: { InsetListingsParams par; - InsetListingsMailer::string2params(to_utf8(cmd.argument()), par); - return new InsetListings(params, par); + InsetListings::string2params(to_utf8(cmd.argument()), par); + return new InsetListings(buf, par); } case EXTERNAL_CODE: { InsetExternalParams iep; - InsetExternalMailer::string2params(to_utf8(cmd.argument()), buf, iep); - auto_ptr inset(new InsetExternal); - inset->setParams(iep, buf); + InsetExternal::string2params(to_utf8(cmd.argument()), buf, iep); + auto_ptr inset(new InsetExternal(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); + InsetGraphics::string2params(to_utf8(cmd.argument()), buf, igp); + auto_ptr inset(new InsetGraphics(buf)); inset->setParams(igp); return inset.release(); } case HYPERLINK_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::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); + InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); return new InsetInclude(icp); } case INDEX_CODE: - return new InsetIndex(params); + return new InsetIndex(buf); case NOMENCL_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()), icp); + InsetCommand::string2params(name, lyx::to_utf8(cmd.argument()), icp); return new InsetNomencl(icp); } case LABEL_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); + InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); return new InsetLabel(icp); } case REF_CODE: { InsetCommandParams icp(code); - InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp); - return new InsetRef(icp, buf); + InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); + return new InsetRef(buf, icp); + } + + case SPACE_CODE: { + InsetSpaceParams 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); + InsetCommand::string2params(name, to_utf8(cmd.argument()), icp); return new InsetTOC(icp); } case VSPACE_CODE: { VSpace vspace; - InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace); + InsetVSpace::string2params(to_utf8(cmd.argument()), vspace); return new InsetVSpace(vspace); } default: lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT." - << std::endl; + << endl; return 0; } } //end LFUN_INSET_INSERT case LFUN_SPACE_INSERT: { - string const name = to_utf8(cmd.argument()); + string const name = cmd.getArg(0); + string const len = cmd.getArg(1); + if (name.empty()) { + lyxerr << "LyX function 'space-insert' needs an argument." << endl; + break; + } + InsetSpaceParams isp; if (name == "normal") - return new InsetSpace(InsetSpace::NORMAL); - if (name == "protected") - return new InsetSpace(InsetSpace::PROTECTED); - if (name == "thin") - return new InsetSpace(InsetSpace::THIN); - if (name == "quad") - return new InsetSpace(InsetSpace::QUAD); - if (name == "qquad") - return new InsetSpace(InsetSpace::QQUAD); - if (name == "enspace") - return new InsetSpace(InsetSpace::ENSPACE); - if (name == "enskip") - return new InsetSpace(InsetSpace::ENSKIP); - if (name == "negthinspace") - return new InsetSpace(InsetSpace::NEGTHIN); - if (name.empty()) - lyxerr << "LyX function 'space' needs an argument." << endl; - else - lyxerr << "Wrong argument for LyX function 'space'." << endl; + isp.kind = InsetSpaceParams::NORMAL; + else if (name == "protected") + isp.kind = InsetSpaceParams::PROTECTED; + else if (name == "thin") + isp.kind = InsetSpaceParams::THIN; + else if (name == "quad") + isp.kind = InsetSpaceParams::QUAD; + else if (name == "qquad") + isp.kind = InsetSpaceParams::QQUAD; + else if (name == "enspace") + isp.kind = InsetSpaceParams::ENSPACE; + else if (name == "enskip") + isp.kind = InsetSpaceParams::ENSKIP; + else if (name == "negthinspace") + isp.kind = InsetSpaceParams::NEGTHIN; + else if (name == "hfill") + isp.kind = InsetSpaceParams::HFILL; + else if (name == "hfill*") + isp.kind = InsetSpaceParams::HFILL_PROTECTED; + else if (name == "dotfill") + isp.kind = InsetSpaceParams::DOTFILL; + else if (name == "hrulefill") + isp.kind = InsetSpaceParams::HRULEFILL; + else if (name == "hspace") { + if (len.empty() || !isValidLength(len)) { + lyxerr << "LyX function 'space-insert hspace' " + << "needs a valid length argument." << endl; + break; + } + isp.kind = InsetSpaceParams::CUSTOM; + isp.length = Length(len); + } + else if (name == "hspace*") { + if (len.empty() || !isValidLength(len)) { + lyxerr << "LyX function 'space-insert hspace*' " + << "needs a valid length argument." << endl; + break; + } + isp.kind = InsetSpaceParams::CUSTOM_PROTECTED; + isp.length = Length(len); + } + else { + lyxerr << "Wrong argument for LyX function 'space-insert'." << endl; + break; + } + return new InsetSpace(isp); } break; @@ -364,46 +384,50 @@ Inset * createInset(Buffer & buf, FuncRequest const & cmd) break; } - } catch (support::ExceptionMessage const & message) { - if (message.type_ == support::ErrorException) { + } catch (ExceptionMessage const & message) { + if (message.type_ == ErrorException) { + // This should never happen! Alert::error(message.title_, message.details_); - LyX::cref().emergencyCleanup(); - abort(); - } else if (message.type_ == support::WarningException) { + 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 * inset = createInsetHelper(buf, cmd); + if (inset) + inset->setBuffer(buf); + return inset; +} + + Inset * readInset(Lexer & lex, Buffer const & 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; - TextClass const & tclass = buf.params().getTextClass(); - - 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(); @@ -420,10 +444,10 @@ Inset * readInset(Lexer & lex, Buffer const & 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)); @@ -447,8 +471,9 @@ Inset * readInset(Lexer & lex, Buffer const & buf) inset.reset(new InsetPrintNomencl(inscmd)); break; case REF_CODE: - if (!inscmd["name"].empty() || !inscmd["reference"].empty()) - inset.reset(new InsetRef(inscmd, buf)); + if (inscmd["name"].empty() && inscmd["reference"].empty()) + return 0; + inset.reset(new InsetRef(buf, inscmd)); break; case TOC_CODE: inset.reset(new InsetTOC(inscmd)); @@ -456,11 +481,12 @@ Inset * readInset(Lexer & lex, Buffer const & buf) case NO_CODE: default: lyxerr << "unknown CommandInset '" << insetType - << "'" << std::endl; + << "'" << endl; while (lex.isOK() && lex.getString() != "\\end_inset") 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 @@ -471,77 +497,77 @@ Inset * readInset(Lexer & lex, Buffer const & buf) if (tmptok == "Quotes") { inset.reset(new InsetQuotes); } else if (tmptok == "External") { - inset.reset(new InsetExternal); + inset.reset(new InsetExternal(const_cast(buf))); } else if (tmptok == "FormulaMacro") { inset.reset(new MathMacroTemplate); } else if (tmptok == "Formula") { inset.reset(new InsetMathHull); } else if (tmptok == "Graphics") { - inset.reset(new InsetGraphics); + inset.reset(new InsetGraphics(const_cast(buf))); } else if (tmptok == "Note") { - inset.reset(new InsetNote(buf.params(), tmptok)); + inset.reset(new InsetNote(buf, tmptok)); } else if (tmptok == "Box") { - inset.reset(new InsetBox(buf.params(), tmptok)); + inset.reset(new InsetBox(buf, tmptok)); } else if (tmptok == "Flex") { lex.next(); string s = lex.getString(); - InsetLayout const & il = tclass.insetlayout(from_utf8(s)); - inset.reset(new InsetFlex(buf.params(), il)); + inset.reset(new InsetFlex(buf, s)); } else if (tmptok == "Branch") { - inset.reset(new InsetBranch(buf.params(), - InsetBranchParams())); - } else if (tmptok == "Environment") { - lex.next(); - inset.reset(new InsetEnvironment(buf.params(), lex.getDocString())); + inset.reset(new InsetBranch(buf, InsetBranchParams())); } else if (tmptok == "ERT") { - inset.reset(new InsetERT(buf.params())); + inset.reset(new InsetERT(buf)); } else if (tmptok == "listings") { - inset.reset(new InsetListings(buf.params())); - } else if (tmptok == "InsetSpace") { + inset.reset(new InsetListings(buf)); + } else if (tmptok == "space") { inset.reset(new InsetSpace); } else if (tmptok == "Tabular") { - inset.reset(new InsetTabular(buf)); + inset.reset(new InsetTabular(const_cast(buf))); } else if (tmptok == "Text") { - inset.reset(new InsetText(buf.params())); + inset.reset(new InsetText(buf)); } else if (tmptok == "VSpace") { inset.reset(new InsetVSpace); } else if (tmptok == "Foot") { - inset.reset(new InsetFoot(buf.params())); + inset.reset(new InsetFoot(buf)); } else if (tmptok == "Marginal") { - inset.reset(new InsetMarginal(buf.params())); + inset.reset(new InsetMarginal(buf)); + } else if (tmptok == "Newpage") { + inset.reset(new InsetNewpage); + } else if (tmptok == "Newline") { + inset.reset(new InsetNewline); } else if (tmptok == "OptArg") { - inset.reset(new InsetOptArg(buf.params())); + inset.reset(new InsetOptArg(buf)); } else if (tmptok == "Float") { lex.next(); string tmptok = lex.getString(); - inset.reset(new InsetFloat(buf.params(), tmptok)); + inset.reset(new InsetFloat(buf, tmptok)); } else if (tmptok == "Wrap") { lex.next(); string tmptok = lex.getString(); - inset.reset(new InsetWrap(buf.params(), tmptok)); -#if 0 - } else if (tmptok == "Theorem") { - inset.reset(new InsetList); -#endif + inset.reset(new InsetWrap(buf, tmptok)); } else if (tmptok == "Caption") { - inset.reset(new InsetCaption(buf.params())); + inset.reset(new InsetCaption(buf)); } else if (tmptok == "Index") { - inset.reset(new InsetIndex(buf.params())); + inset.reset(new InsetIndex(buf)); } else if (tmptok == "FloatList") { inset.reset(new InsetFloatList); } else if (tmptok == "Info") { - inset.reset(new InsetInfo(buf.params())); + inset.reset(new InsetInfo(buf)); } else { lyxerr << "unknown Inset type '" << tmptok - << "'" << std::endl; + << "'" << endl; while (lex.isOK() && lex.getString() != "\\end_inset") lex.next(); return 0; } - inset->read(buf, lex); + // Set the buffer reference for proper parsing of some insets + // (InsetCollapsable for example) + inset->setBuffer(const_cast(buf)); + inset->read(lex); + // Set again the buffer for insets that are created inside this inset + // (InsetMathHull for example). + inset->setBuffer(const_cast(buf)); } - return inset.release(); }