X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffactory.cpp;h=f259883615c4235e50bbfe57852974f65e6e4929;hb=e995e8556bd670c7183bab7e105073a5f4ccfbc0;hp=61887ed3484af1dae39c904faed84d1478a1d95a;hpb=4e9609f183f6e70ab018328b034f411acc13a742;p=lyx.git

diff --git a/src/factory.cpp b/src/factory.cpp
index 61887ed348..f259883615 100644
--- a/src/factory.cpp
+++ b/src/factory.cpp
@@ -13,14 +13,12 @@
 #include "factory.h"
 
 #include "Buffer.h"
-#include "BufferView.h"
 #include "BufferParams.h"
-#include "debug.h"
 #include "FloatList.h"
 #include "FuncRequest.h"
-#include "Color.h"
 #include "Lexer.h"
 #include "LyX.h"
+#include "TextClass.h"
 
 #include "insets/InsetBibitem.h"
 #include "insets/InsetBibtex.h"
@@ -35,7 +33,6 @@
 #include "insets/InsetFloatList.h"
 #include "insets/InsetFoot.h"
 #include "insets/InsetGraphics.h"
-#include "insets/InsetHFill.h"
 #include "insets/InsetInclude.h"
 #include "insets/InsetIndex.h"
 #include "insets/InsetInfo.h"
@@ -47,7 +44,7 @@
 #include "insets/InsetBox.h"
 #include "insets/InsetBranch.h"
 #include "insets/InsetOptArg.h"
-#include "insets/InsetPagebreak.h"
+#include "insets/InsetNewpage.h"
 #include "insets/InsetRef.h"
 #include "insets/InsetSpace.h"
 #include "insets/InsetTabular.h"
@@ -61,39 +58,36 @@
 
 #include "frontends/alert.h"
 
+#include "support/debug.h"
 #include "support/lstrings.h"
 #include "support/ExceptionMessage.h"
 
 #include <boost/assert.hpp>
-#include <boost/current_function.hpp>
 
 #include <sstream>
 
-using std::auto_ptr;
-using std::endl;
-using std::string;
-
+using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 
 namespace Alert = frontend::Alert;
 
-using support::compare_ascii_no_case;
-
 
-Inset * createInset(BufferView * bv, FuncRequest const & cmd)
+Inset * createInsetHelper(Buffer & buf, FuncRequest const & cmd)
 {
-	BufferParams const & params = bv->buffer().params();
+	BufferParams const & params = buf.params();
 
 	try {
 
 		switch (cmd.action) {
-		case LFUN_HFILL_INSERT:
-			return new InsetHFill;
 
 		case LFUN_LINE_INSERT:
 			return new InsetLine;
 
+		case LFUN_NEWPAGE_INSERT:
+			return new InsetNewpage;
+
 		case LFUN_PAGEBREAK_INSERT:
 			return new InsetPagebreak;
 
@@ -105,64 +99,61 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 
 		case LFUN_FLEX_INSERT: {
 			string s = cmd.getArg(0);
-			TextClass tclass = params.getTextClass();
-			InsetLayout il = tclass.insetlayout(from_utf8(s));
-			return new InsetFlex(params, il);
+			return new InsetFlex(buf, buf.params().documentClassPtr(), s);
 		}
 
 		case LFUN_NOTE_INSERT: {
 			string arg = cmd.getArg(0);
 			if (arg.empty())
 				arg = "Note";
-			return new InsetNote(params, arg);
+			return new InsetNote(buf, arg);
 		}
 
 		case LFUN_BOX_INSERT: {
 			string arg = cmd.getArg(0);
 			if (arg.empty())
 				arg = "Boxed";
-			return new InsetBox(params, arg);
+			return new InsetBox(buf, arg);
 		}
 
 		case LFUN_BRANCH_INSERT: {
 			docstring arg = cmd.argument();
 			if (arg.empty())
 				arg = from_ascii("none");
-			return new InsetBranch(params, InsetBranchParams(arg));
+			return new InsetBranch(buf, InsetBranchParams(arg));
 		}
 
 		case LFUN_ERT_INSERT:
-			return new InsetERT(params);
+			return new InsetERT(buf);
 
 		case LFUN_LISTING_INSERT:
-			return new InsetListings(params);
+			return new InsetListings(buf);
 
 		case LFUN_FOOTNOTE_INSERT:
-			return new InsetFoot(params);
+			return new InsetFoot(buf);
 
 		case LFUN_MARGINALNOTE_INSERT:
-			return new InsetMarginal(params);
+			return new InsetMarginal(buf);
 
 		case LFUN_OPTIONAL_INSERT:
-			return new InsetOptArg(params);
+			return new InsetOptArg(buf);
 
 		case LFUN_BIBITEM_INSERT:
-			return new InsetBibitem(InsetCommandParams("bibitem"));
+			return new InsetBibitem(InsetCommandParams(BIBITEM_CODE));
 
 		case LFUN_FLOAT_INSERT: {
 			// check if the float type exists
 			string const argument = to_utf8(cmd.argument());
-			if (params.getTextClass().floats().typeExist(argument))
-				return new InsetFloat(params, argument);
+			if (buf.params().documentClass().floats().typeExist(argument))
+				return new InsetFloat(buf, argument);
 			lyxerr << "Non-existent float type: " << argument << endl;
-			return 0;
 		}
 
 		case LFUN_FLOAT_WIDE_INSERT: {
 			// check if the float type exists
 			string const argument = to_utf8(cmd.argument());
-			if (params.getTextClass().floats().typeExist(argument)) {
-				auto_ptr<InsetFloat> p(new InsetFloat(params, argument));
+			if (params.documentClass().floats().typeExist(argument)) {
+				auto_ptr<InsetFloat> p(new InsetFloat(buf, argument));
 				p->wide(true, params);
 				return p.release();
 			}
@@ -173,61 +164,50 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 		case LFUN_WRAP_INSERT: {
 			string const argument = to_utf8(cmd.argument());
 			if (argument == "figure" || argument == "table")
-				return new InsetWrap(params, argument);
+				return new InsetWrap(buf, argument);
 			lyxerr << "Non-existent wrapfig type: " << argument << endl;
 			return 0;
 		}
 
 		case LFUN_INDEX_INSERT:
-			return new InsetIndex(params);
+			return new InsetIndex(buf);
 
 		case LFUN_NOMENCL_INSERT: {
-			InsetCommandParams icp("nomenclature");
-			icp["symbol"] = cmd.argument().empty() ?
-				bv->cursor().innerText()->getStringToIndex(bv->cursor()) :
-				cmd.argument();
+			InsetCommandParams icp(NOMENCL_CODE);
+			icp["symbol"] = cmd.argument();
 			return new InsetNomencl(icp);
 		}
 
 		case LFUN_TABULAR_INSERT: {
 			if (cmd.argument().empty())
 				return 0;
-			std::istringstream ss(to_utf8(cmd.argument()));
+			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);
+			return new InsetTabular(buf, r, c);
 		}
 
-		case LFUN_CAPTION_INSERT: {
-			auto_ptr<InsetCaption> inset(new InsetCaption(params));
-			inset->setAutoBreakRows(true);
-			inset->setDrawFrame(true);
-			inset->setFrameColor(Color::captionframe);
-			return inset.release();
-		}
+		case LFUN_CAPTION_INSERT:
+			return new InsetCaption(buf);
 
 		case LFUN_INDEX_PRINT:
-			return new InsetPrintIndex(InsetCommandParams("index_print"));
+			return new InsetPrintIndex(InsetCommandParams(INDEX_PRINT_CODE));
 
 		case LFUN_NOMENCL_PRINT:
-			return new InsetPrintNomencl(InsetCommandParams("nomencl_print"));
+			return new InsetPrintNomencl(InsetCommandParams(NOMENCL_PRINT_CODE));
 
 		case LFUN_TOC_INSERT:
-			return new InsetTOC(InsetCommandParams("toc"));
+			return new InsetTOC(InsetCommandParams(TOC_CODE));
 
 		case LFUN_ENVIRONMENT_INSERT:
-			return new InsetEnvironment(params, cmd.argument());
+			return new InsetEnvironment(buf, cmd.argument());
 
 		case LFUN_INFO_INSERT:
-			return new InsetInfo(params, to_utf8(cmd.argument()));
-#if 0
-		case LFUN_THEOREM_INSERT:
-			return new InsetTheorem;
-#endif
+			return new InsetInfo(buf, to_utf8(cmd.argument()));
 
 		case LFUN_INSET_INSERT: {
 			string const name = cmd.getArg(0);
@@ -237,128 +217,166 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 				lyxerr << "No such inset '" << name << "'.";
 				return 0;
 			
-				case BIBITEM_CODE: {
-					InsetCommandParams icp(name);
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetBibitem(icp);
-				}
-		
-				case BIBTEX_CODE: {
-					InsetCommandParams icp(name);
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetBibtex(icp);
-				}
-
-				case CITE_CODE: {
-					InsetCommandParams icp("citation");
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetCitation(icp);
-				}
-		
-				case ERT_CODE: {
-					InsetCollapsable::CollapseStatus st;
-					InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
-					return new InsetERT(params, st);
-				}
-
-				case LISTINGS_CODE: {
-					InsetListingsParams par;
-					InsetListingsMailer::string2params(to_utf8(cmd.argument()), par);
-					return new InsetListings(params, par);
-				}
-
-				case EXTERNAL_CODE: {
-					Buffer const & buffer = bv->buffer();
-					InsetExternalParams iep;
-					InsetExternalMailer::string2params(to_utf8(cmd.argument()), buffer, iep);
-					auto_ptr<InsetExternal> inset(new InsetExternal);
-					inset->setParams(iep, buffer);
-					return inset.release();
-				}
-
-				case GRAPHICS_CODE: {
-					Buffer const & buffer = bv->buffer();
-					InsetGraphicsParams igp;
-					InsetGraphicsMailer::string2params(to_utf8(cmd.argument()), buffer, igp);
-					auto_ptr<InsetGraphics> inset(new InsetGraphics);
-					inset->setParams(igp);
-					return inset.release();
-				}
-
-				case HYPERLINK_CODE: {
-					InsetCommandParams icp(name);
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetHyperlink(icp);
-				}
-
-				case INCLUDE_CODE: {
-					InsetCommandParams iip(name);
-					InsetIncludeMailer::string2params(to_utf8(cmd.argument()), iip);
-					return new InsetInclude(iip);
-				}
-
+			case BIBITEM_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::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);
+				return new InsetBibtex(icp);
+			}
+			
+			case CITE_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+				return new InsetCitation(icp);
+			}
+			
+			case ERT_CODE: {
+				InsetCollapsable::CollapseStatus st;
+				InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
+				return new InsetERT(buf, st);
+			}
+				
+			case LISTINGS_CODE: {
+				InsetListingsParams par;
+				InsetListingsMailer::string2params(to_utf8(cmd.argument()), par);
+				return new InsetListings(buf, par);
+			}
+			
+			case EXTERNAL_CODE: {
+				InsetExternalParams iep;
+				InsetExternalMailer::string2params(to_utf8(cmd.argument()), buf, iep);
+				auto_ptr<InsetExternal> inset(new InsetExternal);
+				inset->setParams(iep);
+				return inset.release();
+			}
+			
+			case GRAPHICS_CODE: {
+				InsetGraphicsParams igp;
+				InsetGraphicsMailer::string2params(to_utf8(cmd.argument()), buf, igp);
+				auto_ptr<InsetGraphics> inset(new InsetGraphics);
+				inset->setParams(igp);
+				return inset.release();
+			}
+			
+			case HYPERLINK_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::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);
+				return new InsetInclude(icp);
+			}
+			
 			case INDEX_CODE:
-				return new InsetIndex(params);
-
-				case NOMENCL_CODE: {
-					InsetCommandParams icp(name);
-					InsetCommandMailer::string2params(name, lyx::to_utf8(cmd.argument()), icp);
-					return new InsetNomencl(icp);
-				}
-
-				case LABEL_CODE: {
-					InsetCommandParams icp(name);
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetLabel(icp);
-				}
-
-				case REF_CODE: {
-					InsetCommandParams icp(name);
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetRef(icp, bv->buffer());
-				}
-
-				case TOC_CODE: {
-					InsetCommandParams icp("toc");
-					InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
-					return new InsetTOC(icp);
-				}
+				return new InsetIndex(buf);
+			
+			case NOMENCL_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::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);
+				return new InsetLabel(icp);
+			}
+			
+			case REF_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+				return new InsetRef(buf, icp);
+			}
 
-				case VSPACE_CODE: {
-					VSpace vspace;
-					InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
-					return new InsetVSpace(vspace);
-				}
-		
-				default:
-					lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT."
-							<< std::endl;
-					return 0;
+			case SPACE_CODE: {
+				InsetSpaceParams isp;
+				InsetSpaceMailer::string2params(to_utf8(cmd.argument()), isp);
+				return new InsetSpace(isp);
+			}
+			
+			case TOC_CODE: {
+				InsetCommandParams icp(code);
+				InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
+				return new InsetTOC(icp);
+			}
+			
+			case VSPACE_CODE: {
+				VSpace vspace;
+				InsetVSpaceMailer::string2params(to_utf8(cmd.argument()), vspace);
+				return new InsetVSpace(vspace);
+			}
+			
+			default:
+				lyxerr << "Inset '" << name << "' not permitted with LFUN_INSET_INSERT."
+						<< endl;
+				return 0;
+			
 			}
 			} //end LFUN_INSET_INSERT
 
 		case LFUN_SPACE_INSERT: {
-			string const name = to_utf8(cmd.argument());
+			string const name = cmd.getArg(0);
+			string const len = cmd.getArg(1);
+			if (name.empty()) {
+				lyxerr << "LyX function 'space-insert' needs an argument." << endl;
+				break;
+			}
+			InsetSpaceParams isp;
 			if (name == "normal")
-				return new InsetSpace(InsetSpace::NORMAL);
+				isp.kind = InsetSpaceParams::NORMAL;
 			else if (name == "protected")
-				return new InsetSpace(InsetSpace::PROTECTED);
+				isp.kind = InsetSpaceParams::PROTECTED;
 			else if (name == "thin")
-				return new InsetSpace(InsetSpace::THIN);
+				isp.kind = InsetSpaceParams::THIN;
 			else if (name == "quad")
-				return new InsetSpace(InsetSpace::QUAD);
+				isp.kind = InsetSpaceParams::QUAD;
 			else if (name == "qquad")
-				return new InsetSpace(InsetSpace::QQUAD);
+				isp.kind = InsetSpaceParams::QQUAD;
 			else if (name == "enspace")
-				return new InsetSpace(InsetSpace::ENSPACE);
+				isp.kind = InsetSpaceParams::ENSPACE;
 			else if (name == "enskip")
-				return new InsetSpace(InsetSpace::ENSKIP);
+				isp.kind = InsetSpaceParams::ENSKIP;
 			else if (name == "negthinspace")
-				return new InsetSpace(InsetSpace::NEGTHIN);
-			else if (name.empty())
-				lyxerr << "LyX function 'space' needs an argument." << endl;
-			else
-				lyxerr << "Wrong argument for LyX function 'space'." << endl;
+				isp.kind = InsetSpaceParams::NEGTHIN;
+			else if (name == "hfill")
+				isp.kind = InsetSpaceParams::HFILL;
+			else if (name == "hfill*")
+				isp.kind = InsetSpaceParams::HFILL_PROTECTED;
+			else if (name == "dotfill")
+				isp.kind = InsetSpaceParams::DOTFILL;
+			else if (name == "hrulefill")
+				isp.kind = InsetSpaceParams::HRULEFILL;
+			else if (name == "hspace") {
+				if (len.empty() || !isValidLength(len)) {
+					lyxerr << "LyX function 'space-insert hspace' "
+					       << "needs a valid length argument." << endl;
+					break;
+				}
+				isp.kind = InsetSpaceParams::CUSTOM;
+				isp.length = Length(len);
+			}
+			else if (name == "hspace*") {
+				if (len.empty() || !isValidLength(len)) {
+					lyxerr << "LyX function 'space-insert hspace*' "
+					       << "needs a valid length argument." << endl;
+					break;
+				}
+				isp.kind = InsetSpaceParams::CUSTOM_PROTECTED;
+				isp.length = Length(len);
+			}
+			else {
+				lyxerr << "Wrong argument for LyX function 'space-insert'." << endl;
+				break;
+			}
+			return new InsetSpace(isp);
 		}
 		break;
 
@@ -366,12 +384,12 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 			break;
 		}
 
-	} catch (support::ExceptionMessage const & message) {
-		if (message.type_ == support::ErrorException) {
+	} catch (ExceptionMessage const & message) {
+		if (message.type_ == ErrorException) {
+			// This should never happen!
 			Alert::error(message.title_, message.details_);
-			LyX::cref().emergencyCleanup();
-			abort();
-		} else if (message.type_ == support::WarningException) {
+			LyX::cref().exit(1);
+		} else if (message.type_ == WarningException) {
 			Alert::warning(message.title_, message.details_);
 			return 0;
 		}
@@ -381,6 +399,13 @@ Inset * createInset(BufferView * bv, FuncRequest const & cmd)
 	return 0;
 }
 
+Inset * createInset(Buffer & buf, FuncRequest const & cmd)
+{
+	Inset * inset = createInsetHelper(buf, cmd);
+	if (inset)
+		inset->setBuffer(buf);
+	return inset;
+}
 
 Inset * readInset(Lexer & lex, Buffer const & buf)
 {
@@ -392,8 +417,6 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 
 	auto_ptr<Inset> inset;
 
-	TextClass tclass = buf.params().getTextClass();
-
 	lex.next();
 	string tmptok = lex.getString();
 
@@ -417,7 +440,7 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 		//we do not know in advance that we're dealing with a command inset.
 		//Worst case, we could put it in each case below. Better, we could
 		//pass the lexer to the constructor and let the params be built there.
-		InsetCommandParams inscmd(insetType);
+		InsetCommandParams inscmd(code);
 		inscmd.read(lex);
 
 		switch (code) {
@@ -433,14 +456,9 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 			case HYPERLINK_CODE:
 				inset.reset(new InsetHyperlink(inscmd));
 				break;
-			// FIXME Currently non-functional, since InsetInclude
-			// does not write itself as a CommandInset.
 			case INCLUDE_CODE:
 				inset.reset(new InsetInclude(inscmd));
 				break;
-			case INDEX_CODE:
-				inset.reset(new InsetIndex(buf.params()));
-				break;
 			case INDEX_PRINT_CODE:
 				inset.reset(new InsetPrintIndex(inscmd));
 				break;
@@ -455,7 +473,7 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 				break;
 			case REF_CODE:
 				if (!inscmd["name"].empty() || !inscmd["reference"].empty())
-					inset.reset(new InsetRef(inscmd, buf));
+					inset.reset(new InsetRef(buf, inscmd));
 				break;
 			case TOC_CODE:
 				inset.reset(new InsetTOC(inscmd));
@@ -463,11 +481,12 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 			case NO_CODE:
 			default:
 				lyxerr << "unknown CommandInset '" << insetType
-							<< "'" << std::endl;
+							<< "'" << endl;
 				while (lex.isOK() && lex.getString() != "\\end_inset")
 					lex.next();
 				return 0;
 		}
+		inset->setBuffer(const_cast<Buffer &>(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
@@ -486,85 +505,74 @@ Inset * readInset(Lexer & lex, Buffer const & buf)
 		} else if (tmptok == "Graphics") {
 			inset.reset(new InsetGraphics);
 		} else if (tmptok == "Note") {
-			inset.reset(new InsetNote(buf.params(), tmptok));
+			inset.reset(new InsetNote(buf, tmptok));
 		} else if (tmptok == "Box") {
-			inset.reset(new InsetBox(buf.params(), tmptok));
+			inset.reset(new InsetBox(buf, tmptok));
 		} else if (tmptok == "Flex") {
 			lex.next();
 			string s = lex.getString();
-			InsetLayout il = tclass.insetlayout(from_utf8(s));
-			inset.reset(new InsetFlex(buf.params(), il));
+			inset.reset(new InsetFlex(buf, 
+				buf.params().documentClassPtr(), s));
 		} else if (tmptok == "Branch") {
-			inset.reset(new InsetBranch(buf.params(),
+			inset.reset(new InsetBranch(buf,
 						    InsetBranchParams()));
-		} else if (tmptok == "Include") {
-			//FIXME
-			InsetCommandParams p("include");
-			inset.reset(new InsetInclude(p));
 		} else if (tmptok == "Environment") {
 			lex.next();
-			inset.reset(new InsetEnvironment(buf.params(), lex.getDocString()));
+			inset.reset(new InsetEnvironment(buf, lex.getDocString()));
 		} else if (tmptok == "ERT") {
-			inset.reset(new InsetERT(buf.params()));
+			inset.reset(new InsetERT(buf));
 		} else if (tmptok == "listings") {
-			inset.reset(new InsetListings(buf.params()));
-		} else if (tmptok == "InsetSpace") {
+			inset.reset(new InsetListings(buf));
+		} else if (tmptok == "Space") {
 			inset.reset(new InsetSpace);
 		} else if (tmptok == "Tabular") {
 			inset.reset(new InsetTabular(buf));
 		} else if (tmptok == "Text") {
-			inset.reset(new InsetText(buf.params()));
+			inset.reset(new InsetText(buf));
 		} else if (tmptok == "VSpace") {
 			inset.reset(new InsetVSpace);
 		} else if (tmptok == "Foot") {
-			inset.reset(new InsetFoot(buf.params()));
+			inset.reset(new InsetFoot(buf));
 		} else if (tmptok == "Marginal") {
-			inset.reset(new InsetMarginal(buf.params()));
+			inset.reset(new InsetMarginal(buf));
 		} else if (tmptok == "OptArg") {
-			inset.reset(new InsetOptArg(buf.params()));
+			inset.reset(new InsetOptArg(buf));
 		} else if (tmptok == "Float") {
 			lex.next();
 			string tmptok = lex.getString();
-			inset.reset(new InsetFloat(buf.params(), tmptok));
+			inset.reset(new InsetFloat(buf, tmptok));
 		} else if (tmptok == "Wrap") {
 			lex.next();
 			string tmptok = lex.getString();
-			inset.reset(new InsetWrap(buf.params(), tmptok));
+			inset.reset(new InsetWrap(buf, tmptok));
 #if 0
 		} else if (tmptok == "Theorem") {
 			inset.reset(new InsetList);
 #endif
 		} else if (tmptok == "Caption") {
-			inset.reset(new InsetCaption(buf.params()));
+			inset.reset(new InsetCaption(buf));
 		} else if (tmptok == "Index") {
-			inset.reset(new InsetIndex(buf.params()));
+			inset.reset(new InsetIndex(buf));
 		} else if (tmptok == "FloatList") {
 			inset.reset(new InsetFloatList);
 		} else if (tmptok == "Info") {
-			inset.reset(new InsetInfo(buf.params()));
+			inset.reset(new InsetInfo(buf));
 		} else {
 			lyxerr << "unknown Inset type '" << tmptok
-			       << "'" << std::endl;
+			       << "'" << endl;
 			while (lex.isOK() && lex.getString() != "\\end_inset")
 				lex.next();
 			return 0;
 		}
 
-		inset->read(buf, lex);
-
-// FIXME: hack..
-		if (inset->lyxCode() == 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;
-		}
+		// Set the buffer reference for proper parsing of some insets
+		// (InsetCollapsable for example)
+		inset->setBuffer(const_cast<Buffer &>(buf));
+		inset->read(lex);
+		// Set again the buffer for insets that are created inside this inset
+		// (InsetMathHull for example).
+		inset->setBuffer(const_cast<Buffer &>(buf));
 	}
-
 	return inset.release();
 }