X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetert.C;h=15e936c5d201310f9aa7f5b120d24ff2615ae09a;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=b0f96d24973d2b8d7a28cd86202eab7c0833a002;hpb=8aff4a15305479bba3000a0cd91bc40d1529a229;p=lyx.git

diff --git a/src/insets/insetert.C b/src/insets/insetert.C
index b0f96d2497..15e936c5d2 100644
--- a/src/insets/insetert.C
+++ b/src/insets/insetert.C
@@ -6,102 +6,99 @@
  * \author Jürgen Vigna
  * \author Lars Gullik Bjønnes
  *
- * Full author contact details are available in file CREDITS
+ * Full author contact details are available in file CREDITS.
  */
+
 #include <config.h>
 
 #include "insetert.h"
-#include "insettext.h"
 
 #include "buffer.h"
+#include "bufferparams.h"
 #include "BufferView.h"
+#include "cursor.h"
 #include "debug.h"
+#include "dispatchresult.h"
 #include "funcrequest.h"
+#include "FuncStatus.h"
 #include "gettext.h"
 #include "language.h"
-#include "lyxfont.h"
+#include "LColor.h"
+#include "LyXAction.h"
 #include "lyxlex.h"
-#include "lyxrow.h"
-#include "lyxtext.h"
-#include "WordLangTuple.h"
+#include "lyxtextclass.h"
+#include "metricsinfo.h"
+#include "ParagraphParameters.h"
+#include "paragraph.h"
 
 #include "frontends/Alert.h"
-#include "frontends/Dialogs.h"
-#include "frontends/LyXView.h"
 
-#include "support/LOstream.h"
-#include "support/LAssert.h"
-#include "support/tostr.h"
+#include <sstream>
 
-using namespace lyx::support;
 
-using std::ostream;
-using std::min;
+namespace lyx {
+
+using support::token;
+
 using std::endl;
+using std::min;
 
-using lyx::pos_type;
+using std::auto_ptr;
+using std::istringstream;
+using std::ostream;
+using std::ostringstream;
+using std::string;
 
 
 void InsetERT::init()
 {
 	setButtonLabel();
-	labelfont = LyXFont(LyXFont::ALL_SANE);
-	labelfont.decSize();
-	labelfont.decSize();
-	labelfont.setColor(LColor::latex);
-	setInsetName("ERT");
+
+	LyXFont font(LyXFont::ALL_SANE);
+	font.decSize();
+	font.decSize();
+	font.setColor(LColor::latex);
+	setLabelFont(font);
+	text_.current_font.setLanguage(latex_language);
+	text_.real_current_font.setLanguage(latex_language);
+
+	setInsetName(from_ascii("ERT"));
 }
 
 
-InsetERT::InsetERT(BufferParams const & bp, bool collapsed)
-	: InsetCollapsable(bp, collapsed)
+InsetERT::InsetERT(BufferParams const & bp, CollapseStatus status)
+	: InsetCollapsable(bp, status)
 {
-	if (collapsed)
-		status_ = Collapsed;
-	else
-		status_ = Open;
 	init();
 }
 
 
 InsetERT::InsetERT(InsetERT const & in)
-	: InsetCollapsable(in), status_(in.status_)
+	: InsetCollapsable(in)
 {
 	init();
 }
 
 
-InsetBase * InsetERT::clone() const
+auto_ptr<InsetBase> InsetERT::doClone() const
 {
-	return new InsetERT(*this);
+	return auto_ptr<InsetBase>(new InsetERT(*this));
 }
 
 
+#if 0
 InsetERT::InsetERT(BufferParams const & bp,
-		   Language const * l, string const & contents, bool collapsed)
-	: InsetCollapsable(bp, collapsed)
+		   Language const *, string const & contents, CollapseStatus status)
+	: InsetCollapsable(bp, status)
 {
-	if (collapsed)
-		status_ = Collapsed;
-	else
-		status_ = Open;
-
-	LyXFont font(LyXFont::ALL_INHERIT, l);
-#ifdef SET_HARD_FONT
-	font.setFamily(LyXFont::TYPEWRITER_FAMILY);
-	font.setColor(LColor::latex);
-#endif
+	LyXFont font(LyXFont::ALL_INHERIT, latex_language);
+	paragraphs().begin()->insert(0, contents, font);
 
-	string::const_iterator cit = contents.begin();
-	string::const_iterator end = contents.end();
-	pos_type pos = 0;
-	for (; cit != end; ++cit) {
-		inset.paragraphs.begin()->insertChar(pos++, *cit, font);
-	}
 	// the init has to be after the initialization of the paragraph
 	// because of the label settings (draw_label for ert insets).
 	init();
 }
+#endif
 
 
 InsetERT::~InsetERT()
@@ -110,239 +107,58 @@ InsetERT::~InsetERT()
 }
 
 
-void InsetERT::read(Buffer const * buf, LyXLex & lex)
+void InsetERT::write(Buffer const & buf, ostream & os) const
 {
-	bool token_found = false;
-	if (lex.isOK()) {
-		lex.next();
-		string const token = lex.getString();
-		if (token == "status") {
-			lex.next();
-			string const tmp_token = lex.getString();
-
-			if (tmp_token == "Inlined") {
-				status(0, Inlined);
-			} else if (tmp_token == "Collapsed") {
-				status(0, Collapsed);
-			} else {
-				// leave this as default!
-				status(0, Open);
-			}
-
-			token_found = true;
-		} else {
-			lyxerr << "InsetERT::Read: Missing 'status'-tag!"
-				   << endl;
-			// take countermeasures
-			lex.pushToken(token);
-		}
-	}
-#if 0
-#warning this should be really short lived only for compatibility to
-#warning files written 07/08/2001 so this has to go before 1.2.0! (Jug)
-	if (lex.isOK()) {
-		lex.next();
-		string const token = lex.getString();
-		if (token == "collapsed") {
-			lex.next();
-			collapsed_ = lex.getBool();
-		} else {
-			// Take countermeasures
-			lex.pushToken(token);
-		}
-	}
-#endif
-	inset.read(buf, lex);
-
-#ifdef SET_HARD_FONT
-	LyXFont font(LyXFont::ALL_INHERIT, latex_language);
-	font.setFamily(LyXFont::TYPEWRITER_FAMILY);
-	font.setColor(LColor::latex);
-
-	ParagraphList::iterator pit = inset.paragraphs.begin();
-	ParagraphList::iterator pend = inset.paragraphs.end();
-	for (; pit != pend; ++pit) {
-		pos_type siz = pit->size();
-		for (pos_type i = 0; i < siz; ++i) {
-			pit->setFont(i, font);
-		}
-	}
-#endif
-
-	if (!token_found) {
-		if (collapsed_) {
-			status(0, Collapsed);
-		} else {
-			status(0, Open);
-		}
-	}
-	setButtonLabel();
+	os << "ERT" << "\n";
+	InsetCollapsable::write(buf, os);
 }
 
 
-void InsetERT::write(Buffer const * buf, ostream & os) const
+void InsetERT::read(Buffer const & buf, LyXLex & lex)
 {
-	string st;
-
-	switch (status_) {
-	case Open:
-		st = "Open";
-		break;
-	case Collapsed:
-		st = "Collapsed";
-		break;
-	case Inlined:
-		st = "Inlined";
-		break;
-	}
-
-	os << getInsetName() << "\n"
-	   << "status "<< st << "\n";
+	InsetCollapsable::read(buf, lex);
 
-	//inset.writeParagraphData(buf, os);
-	string const layout(buf->params.getLyXTextClass().defaultLayoutName());
-	ParagraphList::iterator par = inset.paragraphs.begin();
-	ParagraphList::iterator end = inset.paragraphs.end();
-	for (; par != end; ++par) {
-		os << "\n\\layout " << layout << "\n";
+	// Force default font
+	// This avoids paragraphs in buffer language that would have a
+	// foreign language after a document langauge change, and it ensures
+	// that all new text in ERT gets the "latex" language, since new text
+	// inherits the language from the last position of the existing text.
+	// As a side effect this makes us also robust against bugs in LyX
+	// that might lead to font changes in ERT in .lyx files.
+	LyXFont font(LyXFont::ALL_INHERIT, latex_language);
+	ParagraphList::iterator par = paragraphs().begin();
+	ParagraphList::iterator const end = paragraphs().end();
+	while (par != end) {
 		pos_type siz = par->size();
-		for (pos_type i = 0; i < siz; ++i) {
-			Paragraph::value_type c = par->getChar(i);
-			switch (c) {
-			case Paragraph::META_INSET:
-				if (par->getInset(i)->lyxCode() != Inset::NEWLINE_CODE) {
-					lyxerr << "Element is not allowed in insertERT"
-					       << endl;
-				} else {
-					par->getInset(i)->write(buf, os);
-				}
-				break;
-
-			case '\\':
-				os << "\n\\backslash \n";
-				break;
-			default:
-				os << c;
-				break;
-			}
+		for (pos_type i = 0; i <= siz; ++i) {
+			par->setFont(i, font);
 		}
+		++par;
 	}
 }
 
 
-string const InsetERT::editMessage() const
+docstring const InsetERT::editMessage() const
 {
 	return _("Opened ERT Inset");
 }
 
 
-bool InsetERT::insertInset(BufferView *, Inset *)
-{
-	return false;
-}
-
-
-void InsetERT::setFont(BufferView *, LyXFont const &, bool, bool selectall)
-{
-#ifdef WITH_WARNINGS
-#warning FIXME. More UI stupidity...
-#endif
-	// if selectall is activated then the fontchange was an outside general
-	// fontchange and this messages is not needed
-	if (!selectall)
-		Alert::error(_("Cannot change font"),
-			   _("You cannot change font settings inside TeX code."));
-}
-
-
-void InsetERT::updateStatus(BufferView * bv, bool swap) const
-{
-	if (status_ != Inlined) {
-		if (collapsed_) {
-			status(bv, swap ? Open : Collapsed);
-		} else {
-			status(bv, swap ? Collapsed : Open);
-		}
-	}
-}
-
-
-Inset::EDITABLE InsetERT::editable() const
-{
-	if (status_ == Collapsed)
-		return IS_EDITABLE;
-	return HIGHLY_EDITABLE;
-}
-
-
-void InsetERT::lfunMousePress(FuncRequest const & cmd)
-{
-	if (status_ == Inlined)
-		inset.localDispatch(cmd);
-	else
-		InsetCollapsable::localDispatch(cmd);
-}
-
-
-bool InsetERT::lfunMouseRelease(FuncRequest const & cmd)
-{
-	BufferView * bv = cmd.view();
-
-	if (cmd.button() == mouse_button::button3) {
-		showInsetDialog(bv);
-		return true;
-	}
-
-	if (status_ != Inlined && (cmd.x >= 0) && (cmd.x < button_length) &&
-	    (cmd.y >= button_top_y) && (cmd.y <= button_bottom_y)) {
-		updateStatus(bv, true);
-	} else {
-		LyXFont font(LyXFont::ALL_SANE);
-		FuncRequest cmd1 = cmd;
-		cmd1.y = ascent(bv, font) + cmd.y - inset.ascent(bv, font);
-
-		// inlined is special - the text appears above
-		// button_bottom_y
-		if (status_ == Inlined)
-			inset.localDispatch(cmd1);
-		else if (!collapsed_ && (cmd.y > button_bottom_y)) {
-			cmd1.y -= height_collapsed();
-			inset.localDispatch(cmd1);
-		}
-	}
-	return false;
-}
-
-
-void InsetERT::lfunMouseMotion(FuncRequest const & cmd)
+int InsetERT::latex(Buffer const &, odocstream & os,
+		    OutputParams const &) const
 {
-	if (status_ == Inlined)
-		inset.localDispatch(cmd);
-	else
-		InsetCollapsable::localDispatch(cmd);
-}
-
-
-int InsetERT::latex(Buffer const *, ostream & os,
-		    LatexRunParams const &) const
-{
-	ParagraphList::iterator par = inset.paragraphs.begin();
-	ParagraphList::iterator end = inset.paragraphs.end();
+	ParagraphList::const_iterator par = paragraphs().begin();
+	ParagraphList::const_iterator end = paragraphs().end();
 
 	int lines = 0;
 	while (par != end) {
 		pos_type siz = par->size();
 		for (pos_type i = 0; i < siz; ++i) {
 			// ignore all struck out text
-			if (isDeletedText(*par, i))
+			if (par->isDeleted(i))
 				continue;
 
-			if (par->isNewline(i)) {
-				os << '\n';
-				++lines;
-			} else {
-				os << par->getChar(i);
-			}
+			os.put(par->getChar(i));
 		}
 		++par;
 		if (par != end) {
@@ -355,59 +171,28 @@ int InsetERT::latex(Buffer const *, ostream & os,
 }
 
 
-int InsetERT::ascii(Buffer const *, ostream &, int /*linelen*/) const
+int InsetERT::plaintext(Buffer const &, odocstream &,
+		    OutputParams const & /*runparams*/) const
 {
 	return 0;
 }
 
 
-int InsetERT::linuxdoc(Buffer const *, ostream & os) const
-{
-	ParagraphList::iterator par = inset.paragraphs.begin();
-	ParagraphList::iterator end = inset.paragraphs.end();
-
-	int lines = 0;
-	while (par != end) {
-		pos_type siz = par->size();
-		for (pos_type i = 0; i < siz; ++i) {
-			if (par->isNewline(i)) {
-				os << '\n';
-				++lines;
-			} else {
-				os << par->getChar(i);
-			}
-		}
-		++par;
-		if (par != end) {
-			os << "\n";
-			lines ++;
-		}
-	}
-
-	return lines;
-}
-
-
-int InsetERT::docbook(Buffer const *, ostream & os, bool) const
+int InsetERT::docbook(Buffer const &, odocstream & os,
+		      OutputParams const &) const
 {
-	ParagraphList::iterator par = inset.paragraphs.begin();
-	ParagraphList::iterator end = inset.paragraphs.end();
+	ParagraphList::const_iterator par = paragraphs().begin();
+	ParagraphList::const_iterator end = paragraphs().end();
 
 	int lines = 0;
 	while (par != end) {
 		pos_type siz = par->size();
-		for (pos_type i = 0; i < siz; ++i) {
-			if (par->isNewline(i)) {
-				os << '\n';
-				++lines;
-			} else {
-				os << par->getChar(i);
-			}
-		}
+		for (pos_type i = 0; i < siz; ++i)
+			os.put(par->getChar(i));
 		++par;
 		if (par != end) {
 			os << "\n";
-			lines ++;
+			++lines;
 		}
 	}
 
@@ -415,193 +200,223 @@ int InsetERT::docbook(Buffer const *, ostream & os, bool) const
 }
 
 
-Inset::RESULT InsetERT::localDispatch(FuncRequest const & cmd)
+void InsetERT::doDispatch(LCursor & cur, FuncRequest & cmd)
 {
-	Inset::RESULT result = UNDISPATCHED;
-	BufferView * bv = cmd.view();
-
-	if (inset.paragraphs.begin()->empty()) {
-		set_latex_font(bv);
-	}
-
+	//lyxerr << "\nInsetERT::doDispatch (begin): cmd: " << cmd << endl;
 	switch (cmd.action) {
 
-	case LFUN_INSET_EDIT:
-		if (cmd.button() == mouse_button::button3)
-			break;
-		if (status_ == Inlined) {
-			if (!bv->lockInset(this))
-				break;
-			result = inset.localDispatch(cmd);
-		} else {
-			result = InsetCollapsable::localDispatch(cmd);
-		}
-		set_latex_font(bv);
-		updateStatus(bv);
+	case LFUN_QUOTE_INSERT: {
+		// We need to bypass the fancy quotes in LyXText
+		FuncRequest f(LFUN_SELF_INSERT, "\"");
+		dispatch(cur, f);
 		break;
-
-	case LFUN_INSET_MODIFY: {
-		InsetERT::ERTStatus status_;
-		InsetERTMailer::string2params(cmd.argument, status_);
-
-		status(bv, status_);
-
-		/* FIXME: I refuse to believe we have to live
-		 * with ugliness like this ! Note that this
-		 * rebreak *is* needed. Consider a change from
-		 * Open (needfullrow) to Inlined (only the space
-		 * taken by the text).
-		 */
-		inset.getLyXText(cmd.view())->fullRebreak();
-		inset.update(cmd.view(), true);
-		bv->updateInset(this);
-		result = DISPATCHED;
 	}
-	break;
-
-	case LFUN_MOUSE_PRESS:
-		lfunMousePress(cmd);
-		result = DISPATCHED;
-		break;
-
-	case LFUN_MOUSE_MOTION:
-		lfunMouseMotion(cmd);
-		result = DISPATCHED;
-		break;
-
-	case LFUN_MOUSE_RELEASE:
-		lfunMouseRelease(cmd);
-		result = DISPATCHED;
-		break;
-
-	case LFUN_LAYOUT:
-		bv->owner()->setLayout(inset.paragraphs.begin()->layout()->name());
-		result = DISPATCHED_NOUPDATE;
+	case LFUN_INSET_MODIFY: {
+		InsetCollapsable::CollapseStatus st;
+		InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
+		setStatus(cur, st);
 		break;
-
-	default:
-		result = InsetCollapsable::localDispatch(cmd);
 	}
-
-	switch (cmd.action) {
-	case LFUN_BREAKPARAGRAPH:
-	case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
-	case LFUN_BACKSPACE:
-	case LFUN_BACKSPACE_SKIP:
-	case LFUN_DELETE:
-	case LFUN_DELETE_SKIP:
-	case LFUN_DELETE_LINE_FORWARD:
-	case LFUN_CUT:
-		set_latex_font(bv);
+	case LFUN_PASTE:
+	case LFUN_CLIPBOARD_PASTE:
+	case LFUN_PRIMARY_SELECTION_PASTE: {
+		InsetCollapsable::doDispatch(cur, cmd);
+
+		// Since we can only store plain text, we must reset all
+		// attributes.
+		// FIXME: Change only the pasted paragraphs
+
+		BufferParams const & bp = cur.buffer().params();
+		LyXLayout_ptr const layout =
+			bp.getLyXTextClass().defaultLayout();
+		LyXFont font = layout->font;
+		// ERT contents has always latex_language
+		font.setLanguage(latex_language);
+		ParagraphList::iterator const end = paragraphs().end();
+		for (ParagraphList::iterator par = paragraphs().begin();
+		     par != end; ++par) {
+			// in case par had a manual label
+			par->setBeginOfBody();
+			pos_type const siz = par->size();
+			for (pos_type i = 0; i < siz; ++i) {
+				par->setFont(i, font);
+			}
+			par->params().clear();
+		}
 		break;
-
+	}
 	default:
+		// Force any new text to latex_language
+		// FIXME: This should only be necessary in init(), but
+		// new paragraphs that are created by pressing enter at the
+		// start of an existing paragraph get the buffer language
+		// and not latex_language, so we take this brute force
+		// approach.
+		text_.current_font.setLanguage(latex_language);
+		text_.real_current_font.setLanguage(latex_language);
+
+		InsetCollapsable::doDispatch(cur, cmd);
 		break;
 	}
-	return result;
 }
 
 
-string const InsetERT::get_new_label() const
+bool InsetERT::getStatus(LCursor & cur, FuncRequest const & cmd,
+	FuncStatus & status) const
 {
-	string la;
-	pos_type const max_length = 15;
-	pos_type const p_siz = inset.paragraphs.begin()->size();
-	pos_type const n = min(max_length, p_siz);
-	pos_type i = 0;
-	pos_type j = 0;
-	for(; i < n && j < p_siz; ++j) {
-		if (inset.paragraphs.begin()->isInset(j))
-			continue;
-		la += inset.paragraphs.begin()->getChar(j);
-		++i;
-	}
-	if (p_siz > 1 || (i > 0 && j < p_siz)) {
-		la += "...";
-	}
-	if (la.empty()) {
-		la = _("ERT");
-	}
-	return la;
-}
-
+	switch (cmd.action) {
+		// suppress these
+		case LFUN_ACCENT_ACUTE:
+		case LFUN_ACCENT_BREVE:
+		case LFUN_ACCENT_CARON:
+		case LFUN_ACCENT_CEDILLA:
+		case LFUN_ACCENT_CIRCLE:
+		case LFUN_ACCENT_CIRCUMFLEX:
+		case LFUN_ACCENT_DOT:
+		case LFUN_ACCENT_GRAVE:
+		case LFUN_ACCENT_HUNGARIAN_UMLAUT:
+		case LFUN_ACCENT_MACRON:
+		case LFUN_ACCENT_OGONEK:
+		case LFUN_ACCENT_SPECIAL_CARON:
+		case LFUN_ACCENT_TIE:
+		case LFUN_ACCENT_TILDE:
+		case LFUN_ACCENT_UMLAUT:
+		case LFUN_ACCENT_UNDERBAR:
+		case LFUN_ACCENT_UNDERDOT:
+		case LFUN_APPENDIX:
+		case LFUN_BREAK_LINE:
+		case LFUN_CAPTION_INSERT:
+		case LFUN_DEPTH_DECREMENT:
+		case LFUN_DEPTH_INCREMENT:
+		case LFUN_DOTS_INSERT:
+		case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
+		case LFUN_ENVIRONMENT_INSERT:
+		case LFUN_ERT_INSERT:
+		case LFUN_FILE_INSERT:
+		case LFUN_FLOAT_INSERT:
+		case LFUN_FLOAT_WIDE_INSERT:
+		case LFUN_WRAP_INSERT:
+		case LFUN_FONT_BOLD:
+		case LFUN_FONT_CODE:
+		case LFUN_FONT_DEFAULT:
+		case LFUN_FONT_EMPH:
+		case LFUN_FONT_FREE_APPLY:
+		case LFUN_FONT_FREE_UPDATE:
+		case LFUN_FONT_NOUN:
+		case LFUN_FONT_ROMAN:
+		case LFUN_FONT_SANS:
+		case LFUN_FONT_FRAK:
+		case LFUN_FONT_ITAL:
+		case LFUN_FONT_SIZE:
+		case LFUN_FONT_STATE:
+		case LFUN_FONT_UNDERLINE:
+		case LFUN_FOOTNOTE_INSERT:
+		case LFUN_HFILL_INSERT:
+		case LFUN_HTML_INSERT:
+		case LFUN_HYPHENATION_POINT_INSERT:
+		case LFUN_LIGATURE_BREAK_INSERT:
+		case LFUN_INDEX_INSERT:
+		case LFUN_INDEX_PRINT:
+		case LFUN_LABEL_INSERT:
+		case LFUN_OPTIONAL_INSERT:
+		case LFUN_BIBITEM_INSERT:
+		case LFUN_LINE_INSERT:
+		case LFUN_PAGEBREAK_INSERT:
+		case LFUN_CLEARPAGE_INSERT:
+		case LFUN_CLEARDOUBLEPAGE_INSERT:
+		case LFUN_LANGUAGE:
+		case LFUN_LAYOUT:
+		case LFUN_LAYOUT_PARAGRAPH:
+		case LFUN_LAYOUT_TABULAR:
+		case LFUN_MARGINALNOTE_INSERT:
+		case LFUN_MATH_DISPLAY:
+		case LFUN_MATH_INSERT:
+		case LFUN_MATH_MATRIX:
+		case LFUN_MATH_MODE:
+		case LFUN_MENU_OPEN:
+		case LFUN_MENU_SEPARATOR_INSERT:
+		case LFUN_BRANCH_INSERT:
+		case LFUN_CHARSTYLE_INSERT:
+		case LFUN_NOTE_INSERT:
+		case LFUN_BOX_INSERT:
+		case LFUN_NOTE_NEXT:
+		case LFUN_PARAGRAPH_SPACING:
+		case LFUN_LABEL_GOTO:
+		case LFUN_REFERENCE_NEXT:
+		case LFUN_SPACE_INSERT:
+		case LFUN_SERVER_GOTO_FILE_ROW:
+		case LFUN_SERVER_NOTIFY:
+		case LFUN_SERVER_SET_XY:
+		case LFUN_TABULAR_INSERT:
+		case LFUN_TOC_INSERT:
+		case LFUN_URL_INSERT:
+		case LFUN_FLOAT_LIST:
+		case LFUN_INSET_INSERT:
+		case LFUN_PARAGRAPH_PARAMS_APPLY:
+		case LFUN_PARAGRAPH_UPDATE:
+		case LFUN_NOMENCL_INSERT:
+		case LFUN_NOMENCL_PRINT:
+		case LFUN_NOACTION:
+			status.enabled(false);
+			return true;
+
+		case LFUN_QUOTE_INSERT:
+		case LFUN_INSET_MODIFY:
+		case LFUN_PASTE:
+		case LFUN_CLIPBOARD_PASTE:
+		case LFUN_PRIMARY_SELECTION_PASTE:
+			status.enabled(true);
+			return true;
+
+		// this one is difficult to get right. As a half-baked
+		// solution, we consider only the first action of the sequence
+		case LFUN_COMMAND_SEQUENCE: {
+			// argument contains ';'-terminated commands
+			string const firstcmd = token(to_utf8(cmd.argument()), ';', 0);
+			FuncRequest func(lyxaction.lookupFunc(firstcmd));
+			func.origin = cmd.origin;
+			return getStatus(cur, func, status);
+		}
 
-void InsetERT::setButtonLabel() const
-{
-	if (status_ == Collapsed) {
-		setLabel(get_new_label());
-	} else {
-		setLabel(_("ERT"));
+		default:
+			return InsetCollapsable::getStatus(cur, cmd, status);
 	}
 }
 
 
-bool InsetERT::checkInsertChar(LyXFont & /* font */)
-{
-#ifdef SET_HARD_FONT
-	LyXFont f(LyXFont::ALL_INHERIT, latex_language);
-	font = f;
-	font.setFamily(LyXFont::TYPEWRITER_FAMILY);
-	font.setColor(LColor::latex);
-#endif
-	return true;
-}
-
-
-void InsetERT::metrics(MetricsInfo & mi, Dimension & dim) const
+void InsetERT::setButtonLabel()
 {
-	if (inlined())
-		inset.metrics(mi, dim);
-	else
-		InsetCollapsable::metrics(mi, dim);
+	// FIXME UNICODE
+	setLabel(isOpen() ?  _("ERT") : getNewLabel(_("ERT")));
 }
 
 
-void InsetERT::draw(PainterInfo & pi, int x, int y) const
+bool InsetERT::insetAllowed(InsetBase::Code /* code */) const
 {
-	InsetCollapsable::draw(pi, x, y, inlined());
+	return false;
 }
 
 
-void InsetERT::set_latex_font(BufferView * /* bv */)
+bool InsetERT::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-#ifdef SET_HARD_FONT
-	LyXFont font(LyXFont::ALL_INHERIT, latex_language);
-
-	font.setFamily(LyXFont::TYPEWRITER_FAMILY);
-	font.setColor(LColor::latex);
-
-	inset.getLyXText(bv)->setFont(bv, font, false);
-#endif
+	LyXFont tmpfont = mi.base.font;
+	getDrawFont(mi.base.font);
+	mi.base.font.realize(tmpfont);
+	InsetCollapsable::metrics(mi, dim);
+	mi.base.font = tmpfont;
+	bool const changed = dim_ != dim;
+	dim_ = dim;
+	return changed;
 }
 
 
-// attention this function can be called with bv == 0
-void InsetERT::status(BufferView * bv, ERTStatus const st) const
+void InsetERT::draw(PainterInfo & pi, int x, int y) const
 {
-	if (st != status_) {
-		status_ = st;
-		switch (st) {
-		case Inlined:
-			if (bv)
-				inset.setUpdateStatus(InsetText::INIT);
-			break;
-		case Open:
-			collapsed_ = false;
-			setButtonLabel();
-			break;
-		case Collapsed:
-			collapsed_ = true;
-			setButtonLabel();
-			if (bv)
-				bv->unlockInset(const_cast<InsetERT *>(this));
-			break;
-		}
-		if (bv) {
-			bv->updateInset(const_cast<InsetERT *>(this));
-			bv->buffer()->markDirty();
-		}
-	}
+	LyXFont tmpfont = pi.base.font;
+	getDrawFont(pi.base.font);
+	pi.base.font.realize(tmpfont);
+	InsetCollapsable::draw(pi, x, y);
+	pi.base.font = tmpfont;
 }
 
 
@@ -612,67 +427,14 @@ bool InsetERT::showInsetDialog(BufferView * bv) const
 }
 
 
-void InsetERT::open(BufferView * bv)
-{
-	if (!collapsed_)
-		return;
-	status(bv, Open);
-}
-
-
-void InsetERT::close(BufferView * bv) const
-{
-	if (status_ == Collapsed || status_ == Inlined)
-		return;
-
-	status(bv, Collapsed);
-}
-
-
-WordLangTuple const
-InsetERT::selectNextWordToSpellcheck(BufferView * bv, float &) const
-{
-	bv->unlockInset(const_cast<InsetERT *>(this));
-	return WordLangTuple();
-}
-
-
 void InsetERT::getDrawFont(LyXFont & font) const
 {
-	LyXFont f(LyXFont::ALL_INHERIT, latex_language);
-	font = f;
+	font = LyXFont(LyXFont::ALL_INHERIT, latex_language);
 	font.setFamily(LyXFont::TYPEWRITER_FAMILY);
 	font.setColor(LColor::latex);
 }
 
 
-int InsetERT::getMaxWidth(BufferView * bv, UpdatableInset const * in) const
-{
-	int w = InsetCollapsable::getMaxWidth(bv, in);
-	if (status_ != Inlined || w < 0)
-		return w;
-	LyXText * text = inset.getLyXText(bv);
-	int rw = text->rows().begin()->width();
-	if (!rw)
-		rw = w;
-	rw += 40;
-	if (text->rows().size() == 1 && rw < w)
-		return -1;
-	return w;
-}
-
-
-void InsetERT::update(BufferView * bv, bool reinit)
-{
-	if (inset.need_update & InsetText::INIT ||
-	    inset.need_update & InsetText::FULL) {
-		setButtonLabel();
-	}
-
-	InsetCollapsable::update(bv, reinit);
-}
-
-
 string const InsetERTMailer::name_("ert");
 
 InsetERTMailer::InsetERTMailer(InsetERT & inset)
@@ -680,29 +442,42 @@ InsetERTMailer::InsetERTMailer(InsetERT & inset)
 {}
 
 
-string const InsetERTMailer::inset2string() const
+string const InsetERTMailer::inset2string(Buffer const &) const
 {
 	return params2string(inset_.status());
 }
 
 
 void InsetERTMailer::string2params(string const & in,
-				   InsetERT::ERTStatus & status)
+				   InsetCollapsable::CollapseStatus & status)
 {
-	status = InsetERT::Collapsed;
+	status = InsetCollapsable::Collapsed;
+	if (in.empty())
+		return;
 
-	string name;
-	string body = split(in, name, ' ');
+	istringstream data(in);
+	LyXLex lex(0,0);
+	lex.setStream(data);
 
-	if (body.empty())
-		return;
+	string name;
+	lex >> name;
+	if (name != name_)
+		return print_mailer_error("InsetERTMailer", in, 1, name_);
 
-	status = static_cast<InsetERT::ERTStatus>(strToInt(body));
+	int s;
+	lex >> s;
+	if (lex)
+		status = static_cast<InsetCollapsable::CollapseStatus>(s);
 }
 
 
 string const
-InsetERTMailer::params2string(InsetERT::ERTStatus status)
+InsetERTMailer::params2string(InsetCollapsable::CollapseStatus status)
 {
-	return name_ + ' ' + tostr(status);
+	ostringstream data;
+	data << name_ << ' ' << status;
+	return data.str();
 }
+
+
+} // namespace lyx