Natbib authoryear uses (Ref1; Ref2) by default.

[lyx.git] / src / factory.cpp

diff --git a/src/factory.cpp b/src/factory.cpp
index d763e52f5becb22227881dd8c4b3e52e61f41672..2ffa85018c1666ab32b1a8b57d688aec03ed2433 100644 (file)
--- a/src/factory.cpp
+++ b/src/factory.cpp
@@ -38,6 +38,8 @@
 #include "insets/InsetInclude.h"
 #include "insets/InsetIndex.h"
 #include "insets/InsetInfo.h"
+#include "insets/InsetIPA.h"
+#include "insets/InsetIPAMacro.h"
 #include "insets/InsetLabel.h"
 #include "insets/InsetLine.h"
 #include "insets/InsetMarginal.h"
@@ -130,6 +132,16 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
                        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);
 
@@ -142,14 +154,37 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
                case LFUN_MARGINALNOTE_INSERT:
                        return new InsetMarginal(buf);
 
-               case LFUN_ARGUMENT_INSERT:
-                       return new InsetArgument(buf);
+               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:
-                       return new InsetFloat(buf, to_utf8(cmd.argument()));
+               case LFUN_FLOAT_INSERT: {
+                       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: {
-                       InsetFloat * fl = new InsetFloat(buf, to_utf8(cmd.argument()));
+                       string argument = to_utf8(cmd.argument());
+                       if (!argument.empty()) {
+                               if (!contains(argument, "sideways")) {
+                                       if (!contains(argument, "wide"))
+                                               argument += "\nwide true";
+                                       argument += "\nsideways false";
+                               }
+                       }
+                       InsetFloat * fl = new InsetFloat(buf, argument);
                        fl->setWide(true);
                        return fl;
                }
@@ -167,6 +202,9 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
                        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();
@@ -186,8 +224,12 @@ 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:  {
                        InsetCommandParams icp(INDEX_PRINT_CODE);
@@ -210,6 +252,12 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
                case LFUN_PREVIEW_INSERT:
                        return new InsetPreview(buf);
 
+               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);
                        InsetCode code = insetCode(name);
@@ -359,6 +407,8 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
                                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")
@@ -375,9 +425,9 @@ Inset * createInsetHelper(Buffer * buf, FuncRequest const & cmd)
                                isp.kind = InsetSpaceParams::ENSKIP;
                        else if (name == "negthinspace")
                                isp.kind = InsetSpaceParams::NEGTHIN;
-                       else if (isp.math && name == "negmedspace")
+                       else if (name == "negmedspace")
                                isp.kind = InsetSpaceParams::NEGMEDIUM;
-                       else if (isp.math && name == "negthickspace")
+                       else if (name == "negthickspace")
                                isp.kind = InsetSpaceParams::NEGTHICK;
                        else if (name == "hfill")
                                isp.kind = InsetSpaceParams::HFILL;
@@ -524,12 +574,15 @@ Inset * readInset(Lexer & lex, Buffer * buf)
                }
                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.
+               // 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(buf));
                } else if (tmptok == "External") {
@@ -575,7 +628,7 @@ Inset * readInset(Lexer & lex, Buffer * buf)
                } else if (tmptok == "Newline") {
                        inset.reset(new InsetNewline);
                } else if (tmptok == "Argument") {
-                       inset.reset(new InsetArgument(buf));
+                       inset.reset(new InsetArgument(buf, tmptok));
                } else if (tmptok == "Float") {
                        inset.reset(new InsetFloat(buf, string()));
                } else if (tmptok == "Wrap") {
@@ -583,13 +636,19 @@ Inset * readInset(Lexer & lex, Buffer * buf)
                        string tmptok = lex.getString();
                        inset.reset(new InsetWrap(buf, tmptok));
                } 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, InsetIndexParams()));
                } else if (tmptok == "FloatList") {
                        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 {