* src/insets/insetcommand.C: fix plaintext() output

[lyx.git] / src / factory.C

diff --git a/src/factory.C b/src/factory.C
index 22f8fa9d57a8671f9b5677174ec9c4ccd88cc10a..19092859965d9c53a562103e3f8a4a8322488d1f 100644 (file)
--- a/src/factory.C
+++ b/src/factory.C
@@ -37,6 +37,7 @@
 #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"
@@ -63,7 +64,10 @@
 
 #include <sstream>
 
-using lyx::support::compare_ascii_no_case;
+
+namespace lyx {
+
+using support::compare_ascii_no_case;
 
 using std::auto_ptr;
 using std::endl;
@@ -84,6 +88,12 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
        case LFUN_PAGEBREAK_INSERT:
                return new InsetPagebreak;
 
+       case LFUN_CLEARPAGE_INSERT:
+               return new InsetClearPage;
+
+       case LFUN_CLEARDOUBLEPAGE_INSERT:
+               return new InsetClearDoublePage;
+
        case LFUN_CHARSTYLE_INSERT: {
                string s = cmd.getArg(0);
                LyXTextClass tclass = params.getLyXTextClass();
@@ -109,9 +119,9 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
        }
 
        case LFUN_BRANCH_INSERT: {
-               string arg = cmd.getArg(0);
+               docstring arg = cmd.argument();
                if (arg.empty())
-                       arg = "none";
+                       arg = from_ascii("none");
                return new InsetBranch(params, InsetBranchParams(arg));
        }
 
@@ -132,7 +142,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 
        case LFUN_FLOAT_INSERT: {
                // check if the float type exists
-               string const argument = lyx::to_utf8(cmd.argument());
+               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;
@@ -141,7 +151,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 
        case LFUN_FLOAT_WIDE_INSERT: {
                // check if the float type exists
-               string const argument = lyx::to_utf8(cmd.argument());
+               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);
@@ -152,7 +162,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
        }
 
        case LFUN_WRAP_INSERT: {
-               string const argument = lyx::to_utf8(cmd.argument());
+               string const argument = to_utf8(cmd.argument());
                if (argument == "figure")
                        return new InsetWrap(params, argument);
                lyxerr << "Non-existent floatflt type: " << argument << endl;
@@ -162,17 +172,24 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
        case LFUN_INDEX_INSERT: {
                // Try and generate a valid index entry.
                InsetCommandParams icp("index");
-               string const contents = cmd.argument().empty() ?
-                       bv->getLyXText()->getStringToIndex(bv->cursor()) :
-                       lyx::to_utf8(cmd.argument());
-               icp.setContents(contents);
+               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);
+       }
+
        case LFUN_TABULAR_INSERT: {
                if (cmd.argument().empty())
                        return 0;
-               std::istringstream ss(lyx::to_utf8(cmd.argument()));
+               std::istringstream ss(to_utf8(cmd.argument()));
                int r = 0, c = 0;
                ss >> r >> c;
                if (r <= 0)
@@ -193,11 +210,14 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
        case LFUN_INDEX_PRINT:
                return new InsetPrintIndex(InsetCommandParams("printindex"));
 
+       case LFUN_NOMENCL_PRINT:
+               return new InsetPrintNomencl(InsetCommandParams("printnomenclature"));
+
        case LFUN_TOC_INSERT:
                return new InsetTOC(InsetCommandParams("tableofcontents"));
 
        case LFUN_ENVIRONMENT_INSERT:
-               return new InsetEnvironment(params, lyx::to_utf8(cmd.argument()));
+               return new InsetEnvironment(params, to_utf8(cmd.argument()));
 
 #if 0
        case LFUN_LIST_INSERT:
@@ -212,31 +232,31 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 
                if (name == "bibitem") {
                        InsetCommandParams icp(name);
-                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetBibitem(icp);
 
                } else if (name == "bibtex") {
                        InsetCommandParams icp(name);
-                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetBibtex(icp);
 
                } else if (name == "citation") {
                        InsetCommandParams icp("cite");
-                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetCitation(icp);
 
                } else if (name == "ert") {
                        InsetCollapsable::CollapseStatus st;
-                       InsetERTMailer::string2params(lyx::to_utf8(cmd.argument()), 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(lyx::to_utf8(cmd.argument()),
+                       InsetExternalMailer::string2params(to_utf8(cmd.argument()),
                                                           buffer, iep);
                        auto_ptr<InsetExternal> inset(new InsetExternal);
                        inset->setParams(iep, buffer);
@@ -245,7 +265,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
                } else if (name == "graphics") {
                        Buffer const & buffer = *bv->buffer();
                        InsetGraphicsParams igp;
-                       InsetGraphicsMailer::string2params(lyx::to_utf8(cmd.argument()),
+                       InsetGraphicsMailer::string2params(to_utf8(cmd.argument()),
                                                           buffer, igp);
                        auto_ptr<InsetGraphics> inset(new InsetGraphics);
                        inset->setParams(igp);
@@ -253,48 +273,54 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 
                } else if (name == "include") {
                        InsetCommandParams iip(name);
-                       InsetIncludeMailer::string2params(lyx::to_utf8(cmd.argument()), iip);
+                       InsetIncludeMailer::string2params(to_utf8(cmd.argument()), iip);
                        return new InsetInclude(iip);
 
                } else if (name == "index") {
                        InsetCommandParams icp(name);
-                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetIndex(icp);
 
-               } else if (name == "label") {
+               } 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, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetRef(icp, *bv->buffer());
 
                } else if (name == "toc") {
                        InsetCommandParams icp("tableofcontents");
-                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetTOC(icp);
 
                } else if (name == "url") {
                        InsetCommandParams icp(name);
-                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
+                       InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetUrl(icp);
 
                } else if (name == "vspace") {
                        VSpace vspace;
-                       InsetVSpaceMailer::string2params(lyx::to_utf8(cmd.argument()), vspace);
+                       InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
                        return new InsetVSpace(vspace);
                }
        }
 
        case LFUN_SPACE_INSERT: {
-               string const name = lyx::to_utf8(cmd.argument());
+               string const name = to_utf8(cmd.argument());
                if (name == "normal")
                        return new InsetSpace(InsetSpace::NORMAL);
                else if (name == "protected")
@@ -367,6 +393,8 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                        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") {
@@ -380,8 +408,8 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                           || 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") {
@@ -394,6 +422,8 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                        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;
@@ -430,7 +460,7 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                        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();
@@ -489,10 +519,13 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                                (tmpl->name(), tmpl->asMacroData());
                        lyxerr[Debug::DEBUG]
                                << BOOST_CURRENT_FUNCTION
-                               << ": creating local macro " << tmpl->name()
+                               << ": creating local macro " << to_utf8(tmpl->name())
                                << endl;
                }
        }
 
        return inset.release();
 }
+
+
+} // namespace lyx