]> git.lyx.org Git - lyx.git/blobdiff - src/factory.C
cleanup after svn hang-up, #undef CursorShape. Should be compilable ganin now.
[lyx.git] / src / factory.C
index f642f4bd83d9d99a70904cde355b3676540710fe..10efffa57f6b60f829e458280a33299c6cbeb359 100644 (file)
@@ -53,8 +53,8 @@
 #include "insets/insetvspace.h"
 #include "insets/insetwrap.h"
 
-#include "mathed/math_macrotemplate.h"
-#include "mathed/math_hullinset.h"
+#include "mathed/MathMacroTemplate.h"
+#include "mathed/InsetMathHull.h"
 
 #include "support/lstrings.h"
 
@@ -75,16 +75,16 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
        BufferParams const & params = bv->buffer()->params();
 
        switch (cmd.action) {
-       case LFUN_HFILL:
+       case LFUN_HFILL_INSERT:
                return new InsetHFill;
 
-       case LFUN_INSERT_LINE:
+       case LFUN_LINE_INSERT:
                return new InsetLine;
 
-       case LFUN_INSERT_PAGEBREAK:
+       case LFUN_PAGEBREAK_INSERT:
                return new InsetPagebreak;
 
-       case LFUN_INSERT_CHARSTYLE: {
+       case LFUN_CHARSTYLE_INSERT: {
                string s = cmd.getArg(0);
                LyXTextClass tclass = params.getLyXTextClass();
                CharStyles::iterator found_cs = tclass.charstyle(s);
@@ -94,79 +94,85 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
                        return new InsetCharStyle(params, s);
        }
 
-       case LFUN_INSERT_NOTE: {
+       case LFUN_NOTE_INSERT: {
                string arg = cmd.getArg(0);
                if (arg.empty())
                        arg = "Note";
                return new InsetNote(params, arg);
        }
 
-       case LFUN_INSERT_BOX: {
+       case LFUN_BOX_INSERT: {
                string arg = cmd.getArg(0);
                if (arg.empty())
                        arg = "Boxed";
                return new InsetBox(params, arg);
        }
 
-       case LFUN_INSERT_BRANCH: {
+       case LFUN_BRANCH_INSERT: {
                string arg = cmd.getArg(0);
                if (arg.empty())
                        arg = "none";
                return new InsetBranch(params, InsetBranchParams(arg));
        }
 
-       case LFUN_INSET_ERT:
+       case LFUN_ERT_INSERT:
                return new InsetERT(params);
 
-       case LFUN_INSET_FOOTNOTE:
+       case LFUN_FOOTNOTE_INSERT:
                return new InsetFoot(params);
 
-       case LFUN_INSET_MARGINAL:
+       case LFUN_MARGINALNOTE_INSERT:
                return new InsetMarginal(params);
 
-       case LFUN_INSET_OPTARG:
+       case LFUN_OPTIONAL_INSERT:
                return new InsetOptArg(params);
 
-       case LFUN_INSERT_BIBITEM:
+       case LFUN_BIBITEM_INSERT:
                return new InsetBibitem(InsetCommandParams("bibitem"));
 
-       case LFUN_INSET_FLOAT:
+       case LFUN_FLOAT_INSERT: {
                // check if the float type exists
-               if (params.getLyXTextClass().floats().typeExist(cmd.argument))
-                       return new InsetFloat(params, cmd.argument);
-               lyxerr << "Non-existent float type: " << cmd.argument << endl;
+               string const argument = lyx::to_utf8(cmd.argument());
+               if (params.getLyXTextClass().floats().typeExist(argument))
+                       return new InsetFloat(params, argument);
+               lyxerr << "Non-existent float type: " << argument << endl;
                return 0;
+       }
 
-       case LFUN_INSET_WIDE_FLOAT:
+       case LFUN_FLOAT_WIDE_INSERT: {
                // check if the float type exists
-               if (params.getLyXTextClass().floats().typeExist(cmd.argument)) {
-                       auto_ptr<InsetFloat> p(new InsetFloat(params, cmd.argument));
+               string const argument = lyx::to_utf8(cmd.argument());
+               if (params.getLyXTextClass().floats().typeExist(argument)) {
+                       auto_ptr<InsetFloat> p(new InsetFloat(params, argument));
                        p->wide(true, params);
                        return p.release();
                }
-               lyxerr << "Non-existent float type: " << cmd.argument << endl;
+               lyxerr << "Non-existent float type: " << argument << endl;
                return 0;
+       }
 
-       case LFUN_INSET_WRAP:
-               if (cmd.argument == "figure")
-                       return new InsetWrap(params, cmd.argument);
-               lyxerr << "Non-existent floatflt type: " << cmd.argument << endl;
+       case LFUN_WRAP_INSERT: {
+               string const argument = lyx::to_utf8(cmd.argument());
+               if (argument == "figure")
+                       return new InsetWrap(params, argument);
+               lyxerr << "Non-existent floatflt type: " << argument << endl;
                return 0;
+       }
 
        case LFUN_INDEX_INSERT: {
                // Try and generate a valid index entry.
                InsetCommandParams icp("index");
-               string const contents = cmd.argument.empty() ?
+               string const contents = cmd.argument().empty() ?
                        bv->getLyXText()->getStringToIndex(bv->cursor()) :
-                       cmd.argument;
+                       lyx::to_utf8(cmd.argument());
                icp.setContents(contents);
                return new InsetIndex(icp);
        }
 
        case LFUN_TABULAR_INSERT: {
-               if (cmd.argument.empty()) 
+               if (cmd.argument().empty())
                        return 0;
-               std::istringstream ss(cmd.argument);
+               std::istringstream ss(lyx::to_utf8(cmd.argument()));
                int r = 0, c = 0;
                ss >> r >> c;
                if (r <= 0)
@@ -176,7 +182,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
                return new InsetTabular(*bv->buffer(), r, c);
        }
 
-       case LFUN_INSET_CAPTION: {
+       case LFUN_CAPTION_INSERT: {
                auto_ptr<InsetCaption> inset(new InsetCaption(params));
                inset->setAutoBreakRows(true);
                inset->setDrawFrame(true);
@@ -191,13 +197,13 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
                return new InsetTOC(InsetCommandParams("tableofcontents"));
 
        case LFUN_ENVIRONMENT_INSERT:
-               return new InsetEnvironment(params, cmd.argument);
+               return new InsetEnvironment(params, lyx::to_utf8(cmd.argument()));
 
 #if 0
-       case LFUN_INSET_LIST:
+       case LFUN_LIST_INSERT:
                return new InsetList;
 
-       case LFUN_INSET_THEOREM:
+       case LFUN_THEOREM_INSERT:
                return new InsetTheorem;
 #endif
 
@@ -206,31 +212,31 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 
                if (name == "bibitem") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetBibitem(icp);
 
                } else if (name == "bibtex") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetBibtex(icp);
 
                } else if (name == "citation") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetCitation(icp);
 
                } else if (name == "ert") {
                        InsetCollapsable::CollapseStatus st;
-                       InsetERTMailer::string2params(cmd.argument, st);
+                       InsetERTMailer::string2params(lyx::to_utf8(cmd.argument()), st);
                        return new InsetERT(params, st);
 
                } else if (name == "external") {
                        Buffer const & buffer = *bv->buffer();
                        InsetExternalParams iep;
-                       InsetExternalMailer::string2params(cmd.argument,
+                       InsetExternalMailer::string2params(lyx::to_utf8(cmd.argument()),
                                                           buffer, iep);
                        auto_ptr<InsetExternal> inset(new InsetExternal);
                        inset->setParams(iep, buffer);
@@ -239,7 +245,7 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
                } else if (name == "graphics") {
                        Buffer const & buffer = *bv->buffer();
                        InsetGraphicsParams igp;
-                       InsetGraphicsMailer::string2params(cmd.argument,
+                       InsetGraphicsMailer::string2params(lyx::to_utf8(cmd.argument()),
                                                           buffer, igp);
                        auto_ptr<InsetGraphics> inset(new InsetGraphics);
                        inset->setParams(igp);
@@ -247,48 +253,48 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 
                } else if (name == "include") {
                        InsetCommandParams iip;
-                       InsetIncludeMailer::string2params(cmd.argument, iip);
+                       InsetIncludeMailer::string2params(lyx::to_utf8(cmd.argument()), iip);
                        return new InsetInclude(iip);
 
                } else if (name == "index") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetIndex(icp);
 
                } else if (name == "label") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetLabel(icp);
 
                } else if (name == "ref") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetRef(icp, *bv->buffer());
 
                } else if (name == "toc") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetTOC(icp);
 
                } else if (name == "url") {
                        InsetCommandParams icp;
-                       InsetCommandMailer::string2params(name, cmd.argument,
+                       InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()),
                                                          icp);
                        return new InsetUrl(icp);
 
                } else if (name == "vspace") {
                        VSpace vspace;
-                       InsetVSpaceMailer::string2params(cmd.argument, vspace);
+                       InsetVSpaceMailer::string2params(lyx::to_utf8(cmd.argument()), vspace);
                        return new InsetVSpace(vspace);
                }
        }
 
        case LFUN_SPACE_INSERT: {
-               string const name = cmd.argument;
+               string const name = lyx::to_utf8(cmd.argument());
                if (name == "normal")
                        return new InsetSpace(InsetSpace::NORMAL);
                else if (name == "protected")
@@ -396,7 +402,7 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                } else if (tmptok == "FormulaMacro") {
                        inset.reset(new MathMacroTemplate);
                } else if (tmptok == "Formula") {
-                       inset.reset(new MathHullInset);
+                       inset.reset(new InsetMathHull);
                } else if (tmptok == "Graphics") {
                        inset.reset(new InsetGraphics);
                } else if (tmptok == "Note") {
@@ -475,9 +481,9 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
                        MacroTable::globalMacros().insert
                                (tmpl->name(), tmpl->asMacroData());
                        lyxerr[Debug::DEBUG]
-                                << BOOST_CURRENT_FUNCTION
-                                << ": creating local macro " << tmpl->name()
-                                << endl;
+                               << BOOST_CURRENT_FUNCTION
+                               << ": creating local macro " << tmpl->name()
+                               << endl;
                }
        }