Allow using \binom without amsmath and add support for \brace and \brack

[lyx.git] / src / factory.cpp

diff --git a/src/factory.cpp b/src/factory.cpp
index dde7c68baf7c6b20b1487c6cfbfa85e2e58adc7a..b50b64abd1ad9fc60dba30682eaf7e45b55e07cc 100644 (file)
--- a/src/factory.cpp
+++ b/src/factory.cpp
@@ -158,7 +158,7 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
                        string const argument = to_utf8(cmd.argument());
                        if (params.documentClass().floats().typeExist(argument)) {
                                auto_ptr<InsetFloat> p(new InsetFloat(buf, argument));
-                               p->wide(true, params);
+                               p->setWide(true, params);
                                return p.release();
                        }
                        lyxerr << "Non-existent float type: " << argument << endl;
@@ -223,37 +223,36 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
                        
                        case BIBITEM_CODE: {
                                InsetCommandParams icp(code);
-                               InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+                               InsetCommand::string2params(name, to_utf8(cmd.argument()), icp);
                                return new InsetBibitem(icp);
                        }
                        
                        case BIBTEX_CODE: {
                                InsetCommandParams icp(code);
-                               InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+                               InsetCommand::string2params(name, to_utf8(cmd.argument()), icp);
                                return new InsetBibtex(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;
-                               InsetERT::string2params(to_utf8(cmd.argument()), st);
-                               return new InsetERT(buf, st);
+                               return new InsetERT(buf,
+                                       InsetERT::string2params(to_utf8(cmd.argument())));
                        }
                                
                        case LISTINGS_CODE: {
                                InsetListingsParams par;
-                               InsetListingsMailer::string2params(to_utf8(cmd.argument()), 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);
+                               InsetExternal::string2params(to_utf8(cmd.argument()), buf, iep);
                                auto_ptr<InsetExternal> inset(new InsetExternal(buf));
                                inset->setBuffer(buf);
                                inset->setParams(iep);
@@ -262,7 +261,7 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
                        
                        case GRAPHICS_CODE: {
                                InsetGraphicsParams igp;
-                               InsetGraphicsMailer::string2params(to_utf8(cmd.argument()), buf, igp);
+                               InsetGraphics::string2params(to_utf8(cmd.argument()), buf, igp);
                                auto_ptr<InsetGraphics> inset(new InsetGraphics(buf));
                                inset->setParams(igp);
                                return inset.release();
@@ -270,13 +269,13 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
                        
                        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);
                        }
                        
@@ -285,31 +284,31 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
                        
                        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);
+                               InsetCommand::string2params(name, to_utf8(cmd.argument()), icp);
                                return new InsetRef(buf, icp);
                        }
 
                        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);
+                               InsetCommand::string2params(name, to_utf8(cmd.argument()), icp);
                                return new InsetTOC(icp);
                        }
                        
@@ -400,10 +399,10 @@ Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
                }
        }
 
-
        return 0;
 }
 
+
 Inset * createInset(Buffer & buf, FuncRequest const & cmd)
 {
        Inset * inset = createInsetHelper(buf, cmd);
@@ -412,13 +411,12 @@ Inset * createInset(Buffer & buf, FuncRequest const & cmd)
        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> inset;
 
@@ -427,13 +425,13 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 
        // 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();