X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffactory.C;h=19092859965d9c53a562103e3f8a4a8322488d1f;hb=80328d2053869dc089c23c25adbed4167d7bf0b1;hp=11340acb54cd9e9e8f5518a40ecdf0c4835663c2;hpb=ec4ab8ce18418999b547368d1d2bbf546bec1e7b;p=lyx.git

diff --git a/src/factory.C b/src/factory.C
index 11340acb54..1909285996 100644
--- 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"
@@ -53,18 +54,20 @@
 #include "insets/insetvspace.h"
 #include "insets/insetwrap.h"
 
-#include "mathed/formulamacro.h"
-#include "mathed/math_hullinset.h"
-
-#include "frontends/Dialogs.h"
-#include "frontends/LyXView.h"
+#include "mathed/MathMacroTemplate.h"
+#include "mathed/InsetMathHull.h"
 
 #include "support/lstrings.h"
-#include "support/std_sstream.h"
 
 #include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+
+#include <sstream>
+
 
-using lyx::support::compare_ascii_no_case;
+namespace lyx {
+
+using support::compare_ascii_no_case;
 
 using std::auto_ptr;
 using std::endl;
@@ -76,139 +79,151 @@ 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_CLEARPAGE_INSERT:
+		return new InsetClearPage;
+
+	case LFUN_CLEARDOUBLEPAGE_INSERT:
+		return new InsetClearDoublePage;
+
+	case LFUN_CHARSTYLE_INSERT: {
 		string s = cmd.getArg(0);
-		CharStyles::iterator found_cs = params.getLyXTextClass().charstyle(s);
-		return new InsetCharStyle(params, found_cs);
+		LyXTextClass tclass = params.getLyXTextClass();
+		CharStyles::iterator found_cs = tclass.charstyle(s);
+		if (found_cs != tclass.charstyles().end())
+			return new InsetCharStyle(params, found_cs);
+		else
+			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: {
-		string arg = cmd.getArg(0);
+	case LFUN_BRANCH_INSERT: {
+		docstring arg = cmd.argument();
 		if (arg.empty())
-			arg = "none";
+			arg = from_ascii("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 = 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 = 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 = 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() ?
-			bv->getLyXText()->getStringToIndex(bv->cursor()) :
-			cmd.argument;
-		icp.setContents(contents);
-
-		string data = InsetCommandMailer::params2string("index", icp);
-		LyXView * lv = bv->owner();
+		icp["name"] = cmd.argument().empty() ?
+			bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
+			cmd.argument();
+		return new InsetIndex(icp);
+	}
 
-		if (icp.getContents().empty()) {
-			lv->getDialogs().show("index", data, 0);
-		} else {
-			lv->dispatch(FuncRequest(LFUN_INSET_APPLY, data));
-		}
-		return 0;
+	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()) {
-			std::istringstream ss(cmd.argument);
-			int r = 0, c = 0;
-			ss >> r >> c;
-			if (r <= 0) r = 2;
-			if (c <= 0) c = 2;
-			return new InsetTabular(*bv->buffer(), r, c);
-		}
-		bv->owner()->getDialogs().show("tabularcreate");
-		return 0;
+	case LFUN_TABULAR_INSERT: {
+		if (cmd.argument().empty())
+			return 0;
+		std::istringstream ss(to_utf8(cmd.argument()));
+		int r = 0, c = 0;
+		ss >> r >> c;
+		if (r <= 0)
+			r = 2;
+		if (c <= 0)
+			c = 2;
+		return new InsetTabular(*bv->buffer(), r, c);
+	}
 
-	case LFUN_INSET_CAPTION: {
-		UpdatableInset * up = bv->cursor().inset()
-			? bv->cursor().inset()->asUpdatableInset() : 0;
-		if (!up) {
-			auto_ptr<InsetCaption> inset(new InsetCaption(params));
-			inset->setOwner(up);
-			inset->setAutoBreakRows(true);
-			inset->setDrawFrame(InsetText::LOCKED);
-			inset->setFrameColor(LColor::captionframe);
-			return inset.release();
-		}
-		return 0;
+	case LFUN_CAPTION_INSERT: {
+		auto_ptr<InsetCaption> inset(new InsetCaption(params));
+		inset->setAutoBreakRows(true);
+		inset->setDrawFrame(true);
+		inset->setFrameColor(LColor::captionframe);
+		return inset.release();
 	}
 
 	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, cmd.argument);
+		return new InsetEnvironment(params, 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
 
@@ -216,32 +231,32 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 		string const name = cmd.getArg(0);
 
 		if (name == "bibitem") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp(name);
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetBibitem(icp);
 
 		} else if (name == "bibtex") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp(name);
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetBibtex(icp);
 
 		} else if (name == "citation") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp("cite");
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetCitation(icp);
 
 		} else if (name == "ert") {
 			InsetCollapsable::CollapseStatus st;
-			InsetERTMailer::string2params(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(cmd.argument,
+			InsetExternalMailer::string2params(to_utf8(cmd.argument()),
 							   buffer, iep);
 			auto_ptr<InsetExternal> inset(new InsetExternal);
 			inset->setParams(iep, buffer);
@@ -250,56 +265,62 @@ InsetBase * createInset(BufferView * bv, FuncRequest const & cmd)
 		} else if (name == "graphics") {
 			Buffer const & buffer = *bv->buffer();
 			InsetGraphicsParams igp;
-			InsetGraphicsMailer::string2params(cmd.argument,
+			InsetGraphicsMailer::string2params(to_utf8(cmd.argument()),
 							   buffer, igp);
 			auto_ptr<InsetGraphics> inset(new InsetGraphics);
 			inset->setParams(igp);
 			return inset.release();
 
 		} else if (name == "include") {
-			InsetCommandParams iip;
-			InsetIncludeMailer::string2params(cmd.argument, iip);
+			InsetCommandParams iip(name);
+			InsetIncludeMailer::string2params(to_utf8(cmd.argument()), iip);
 			return new InsetInclude(iip);
 
 		} else if (name == "index") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp(name);
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetIndex(icp);
 
+		} 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;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp(name);
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetLabel(icp);
 
 		} else if (name == "ref") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp(name);
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetRef(icp, *bv->buffer());
 
 		} else if (name == "toc") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp("tableofcontents");
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetTOC(icp);
 
 		} else if (name == "url") {
-			InsetCommandParams icp;
-			InsetCommandMailer::string2params(name, cmd.argument,
+			InsetCommandParams icp(name);
+			InsetCommandMailer::string2params(name, to_utf8(cmd.argument()),
 							  icp);
 			return new InsetUrl(icp);
 
 		} else if (name == "vspace") {
 			VSpace vspace;
-			InsetVSpaceMailer::string2params(cmd.argument, vspace);
+			InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
 			return new InsetVSpace(vspace);
 		}
 	}
 
 	case LFUN_SPACE_INSERT: {
-		string const name = cmd.argument;
+		string const name = to_utf8(cmd.argument());
 		if (name == "normal")
 			return new InsetSpace(InsetSpace::NORMAL);
 		else if (name == "protected")
@@ -343,28 +364,37 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
 	auto_ptr<InsetBase> inset;
 
 	LyXTextClass tclass = buf.params().getLyXTextClass();
-		
+
 	lex.next();
 	string tmptok = lex.getString();
 
 	// test the different insets
 	if (tmptok == "LatexCommand") {
-		InsetCommandParams inscmd;
-		inscmd.read(lex);
+		lex.next();
+		string const cmdName = lex.getString();
+		lex.pushToken(cmdName);
 
-		string const cmdName = inscmd.getCmdName();
+		InsetCommandParams inscmd(cmdName);
+		inscmd.read(lex);
 
 		// This strange command allows LyX to recognize "natbib" style
 		// citations: citet, citep, Citet etc.
+		// FIXME: We already have partial support for \\fullcite and
+		// the various \\footcite commands. We should increase the
+		// file format number and read these commands here, too.
+		// Then we should use is_possible_cite_command() in
+		// src/frontends/controllers/biblio.C to test for valid cite
+		// commands.
 		if (compare_ascii_no_case(cmdName.substr(0,4), "cite") == 0) {
 			inset.reset(new InsetCitation(inscmd));
 		} else if (cmdName == "bibitem") {
-			lex.printError("Wrong place for bibitem");
 			inset.reset(new InsetBibitem(inscmd));
 		} else if (cmdName == "bibtex") {
 			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") {
@@ -378,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") {
@@ -392,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;
@@ -405,9 +437,9 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
 		} else if (tmptok == "External") {
 			inset.reset(new InsetExternal);
 		} else if (tmptok == "FormulaMacro") {
-			inset.reset(new InsetFormulaMacro);
+			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") {
@@ -418,12 +450,17 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
 			lex.next();
 			string s = lex.getString();
 			CharStyles::iterator found_cs = tclass.charstyle(s);
-			inset.reset(new InsetCharStyle(buf.params(), found_cs));
+			if (found_cs != tclass.charstyles().end())
+				inset.reset(new InsetCharStyle(buf.params(), found_cs));
+			else {
+				// "Undefined" inset
+				inset.reset(new InsetCharStyle(buf.params(), s));
+			}
 		} else if (tmptok == "Branch") {
 			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();
@@ -471,7 +508,24 @@ InsetBase * readInset(LyXLex & lex, Buffer const & buf)
 		}
 
 		inset->read(buf, lex);
+
+#ifdef WITH_WARNINGS
+#warning hack..
+#endif
+		if (inset->lyxCode() == InsetBase::MATHMACRO_CODE) {
+			MathMacroTemplate const * tmpl =
+				static_cast<MathMacroTemplate*>(inset.get());
+			MacroTable::globalMacros().insert
+				(tmpl->name(), tmpl->asMacroData());
+			lyxerr[Debug::DEBUG]
+				<< BOOST_CURRENT_FUNCTION
+				<< ": creating local macro " << to_utf8(tmpl->name())
+				<< endl;
+		}
 	}
 
 	return inset.release();
 }
+
+
+} // namespace lyx