X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetnote.C;h=b840955032cdb0b16831769f57f38ed2e1158825;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=778917944e3d58d6ceaac2fdeb8468cae7de827e;hpb=340b7d232c0b26df175ba93f7d830467dd06e91e;p=lyx.git

diff --git a/src/insets/insetnote.C b/src/insets/insetnote.C
index 778917944e..b840955032 100644
--- a/src/insets/insetnote.C
+++ b/src/insets/insetnote.C
@@ -7,33 +7,112 @@
  * \author Martin Vermeer
  * \author Jürgen Spitzmüller
  *
- * Full author contact details are available in file CREDITS
+ * Full author contact details are available in file CREDITS.
  */
 
 #include <config.h>
 
-#include "Lsstream.h"
-
 #include "insetnote.h"
-#include "gettext.h"
-#include "lyxfont.h"
-#include "language.h"
-#include "buffer.h"
+
 #include "BufferView.h"
-#include "lyxlex.h"
-#include "lyxtext.h"
-#include "insets/insettext.h"
-#include "support/LOstream.h"
-#include "support/lstrings.h"
+#include "cursor.h"
 #include "debug.h"
+#include "dispatchresult.h"
+#include "exporter.h"
+#include "funcrequest.h"
+#include "FuncStatus.h"
+#include "gettext.h"
+#include "LaTeXFeatures.h"
+#include "LColor.h"
+#include "lyxlex.h"
+#include "metricsinfo.h"
+#include "outputparams.h"
+#include "paragraph.h"
 
-using std::ostream;
+#include "support/lyxalgo.h"
+#include "support/translator.h"
+
+#include <sstream>
+
+
+namespace lyx {
+
+using std::string;
 using std::auto_ptr;
+using std::istringstream;
+using std::ostream;
+using std::ostringstream;
+
+
+namespace {
+
+typedef Translator<std::string, InsetNoteParams::Type> NoteTranslator;
+typedef Translator<docstring, InsetNoteParams::Type> NoteTranslatorLoc;
+
+NoteTranslator const init_notetranslator()
+{
+	NoteTranslator translator("Note", InsetNoteParams::Note);
+	translator.addPair("Comment", InsetNoteParams::Comment);
+	translator.addPair("Greyedout", InsetNoteParams::Greyedout);
+	translator.addPair("Framed", InsetNoteParams::Framed);
+	translator.addPair("Shaded", InsetNoteParams::Shaded);
+	return translator;
+}
+
+
+NoteTranslatorLoc const init_notetranslator_loc()
+{
+	NoteTranslatorLoc translator(_("Note"), InsetNoteParams::Note);
+	translator.addPair(_("Comment"), InsetNoteParams::Comment);
+	translator.addPair(_("Greyed out"), InsetNoteParams::Greyedout);
+	translator.addPair(_("Framed"), InsetNoteParams::Framed);
+	translator.addPair(_("Shaded"), InsetNoteParams::Shaded);
+	return translator;
+}
+
+
+NoteTranslator const & notetranslator()
+{
+	static NoteTranslator translator = init_notetranslator();
+	return translator;
+}
+
+
+NoteTranslatorLoc const & notetranslator_loc()
+{
+	static NoteTranslatorLoc translator = init_notetranslator_loc();
+	return translator;
+}
+
+} // anon
+
+
+
+
+InsetNoteParams::InsetNoteParams()
+	: type(Note)
+{}
+
+
+void InsetNoteParams::write(ostream & os) const
+{
+	string const label = notetranslator().find(type);
+	os << "Note " << label << "\n";
+}
+
+
+void InsetNoteParams::read(LyXLex & lex)
+{
+	string label;
+	lex >> label;
+	if (lex)
+		type = notetranslator().find(label);
+}
 
 
 void InsetNote::init()
 {
-	setInsetName("Note");
+	setInsetName(from_ascii("Note"));
 	setButtonLabel();
 }
 
@@ -41,9 +120,8 @@ void InsetNote::init()
 InsetNote::InsetNote(BufferParams const & bp, string const & label)
 	: InsetCollapsable(bp)
 {
-	params_.type = label;
+	params_.type = notetranslator().find(label);
 	init();
-	setButtonLabel();
 }
 
 
@@ -54,34 +132,34 @@ InsetNote::InsetNote(InsetNote const & in)
 }
 
 
-InsetNote::~InsetNote() // MV
+InsetNote::~InsetNote()
 {
-	InsetNoteMailer mailer("note", *this);
-	mailer.hideDialog();
+	InsetNoteMailer(*this).hideDialog();
 }
 
 
-auto_ptr<InsetBase> InsetNote::clone() const
+auto_ptr<InsetBase> InsetNote::doClone() const
 {
 	return auto_ptr<InsetBase>(new InsetNote(*this));
 }
 
 
-string const InsetNote::editMessage() const
+docstring const InsetNote::editMessage() const
 {
 	return _("Opened Note Inset");
 }
 
 
-void InsetNote::write(Buffer const * buf, ostream & os) const
+void InsetNote::write(Buffer const & buf, ostream & os) const
 {
 	params_.write(os);
 	InsetCollapsable::write(buf, os);
 }
 
 
-void InsetNote::read(Buffer const * buf, LyXLex & lex)
+void InsetNote::read(Buffer const & buf, LyXLex & lex)
 {
+	params_.read(lex);
 	InsetCollapsable::read(buf, lex);
 	setButtonLabel();
 }
@@ -89,22 +167,34 @@ void InsetNote::read(Buffer const * buf, LyXLex & lex)
 
 void InsetNote::setButtonLabel()
 {
+	docstring const label = notetranslator_loc().find(params_.type);
+	setLabel(label);
+
 	LyXFont font(LyXFont::ALL_SANE);
 	font.decSize();
 	font.decSize();
 
-	if (params_.type == "Note") {
-		setLabel(_("LyX Note"));
+	switch (params_.type) {
+	case InsetNoteParams::Note:
 		font.setColor(LColor::note);
 		setBackgroundColor(LColor::notebg);
-	} else if (params_.type == "Comment") {
-		setLabel(_("Comment"));
+		break;
+	case InsetNoteParams::Comment:
 		font.setColor(LColor::comment);
 		setBackgroundColor(LColor::commentbg);
-	} else {
-		setLabel(_("Greyed Out"));
+		break;
+	case InsetNoteParams::Greyedout:
 		font.setColor(LColor::greyedout);
 		setBackgroundColor(LColor::greyedoutbg);
+		break;
+	case InsetNoteParams::Framed:
+		font.setColor(LColor::greyedout);
+		setBackgroundColor(LColor::greyedoutbg);
+		break;
+	case InsetNoteParams::Shaded:
+		font.setColor(LColor::greyedout);
+		setBackgroundColor(LColor::shadedbg);
+		break;
 	}
 	setLabelFont(font);
 }
@@ -112,192 +202,212 @@ void InsetNote::setButtonLabel()
 
 bool InsetNote::showInsetDialog(BufferView * bv) const
 {
-	InsetNoteMailer("note", const_cast<InsetNote &>(*this)).showDialog(bv);
+	InsetNoteMailer(const_cast<InsetNote &>(*this)).showDialog(bv);
 	return true;
 }
 
 
-dispatch_result InsetNote::localDispatch(FuncRequest const & cmd)
+void InsetNote::doDispatch(LCursor & cur, FuncRequest & cmd)
 {
-	BufferView * bv = cmd.view();
-
 	switch (cmd.action) {
 
-	case LFUN_INSET_MODIFY: {
-		InsetNoteParams params;
-		InsetNoteMailer::string2params(cmd.argument, params);
-		params_.type = params.type;
+	case LFUN_INSET_MODIFY:
+		InsetNoteMailer::string2params(to_utf8(cmd.argument()), params_);
 		setButtonLabel();
-		bv->updateInset();
-		return DISPATCHED;
-	}
-
-	case LFUN_INSET_EDIT:
-		if (cmd.button() == mouse_button::button3)
-			return UNDISPATCHED;
-		return InsetCollapsable::localDispatch(cmd);
+		break;
 
 	case LFUN_INSET_DIALOG_UPDATE:
-		InsetNoteMailer("note", *this).updateDialog(bv);
-		return DISPATCHED;
+		InsetNoteMailer(*this).updateDialog(&cur.bv());
+		break;
 
 	case LFUN_MOUSE_RELEASE:
-		if (cmd.button() == mouse_button::button3 && hitButton(cmd)) {
-			InsetNoteMailer("note", *this).showDialog(bv);
-			return DISPATCHED;
-		}
-		// fallthrough:
+		if (cmd.button() == mouse_button::button3 && hitButton(cmd))
+			InsetNoteMailer(*this).showDialog(&cur.bv());
+		else
+			InsetCollapsable::doDispatch(cur, cmd);
+		break;
 
 	default:
-		return InsetCollapsable::localDispatch(cmd);
+		InsetCollapsable::doDispatch(cur, cmd);
+		break;
 	}
 }
 
 
-int InsetNote::latex(Buffer const * buf, ostream & os,
-				                LatexRunParams const & runparams) const
+bool InsetNote::getStatus(LCursor & cur, FuncRequest const & cmd,
+		FuncStatus & flag) const
 {
-	string const pt = params_.type;
-
-	int i = 0;
-	if (pt == "Comment")
-		 // verbatim
-		os << "%\n\\begin{comment}\n";
-	else if (pt == "Greyedout")
-		 // we roll our own macro
-		os << "%\n\\begin{lyxgreyedout}\n";
-
-	if (pt != "Note")
-		i = inset.latex(buf, os, runparams);
-
-	if (pt == "Comment") {
-		os << "%\n\\end{comment}\n";
-		i += 3;
-	} else if (pt == "Greyedout") {
-		os << "%\n\\end{lyxgreyedout}\n";
-		i += 2;
+	switch (cmd.action) {
+
+	case LFUN_INSET_MODIFY:
+	case LFUN_INSET_DIALOG_UPDATE:
+		flag.enabled(true);
+		return true;
+
+	default:
+		return InsetCollapsable::getStatus(cur, cmd, flag);
 	}
-	return i;
 }
 
 
-int InsetNote::linuxdoc(Buffer const * buf, std::ostream & os) const
+int InsetNote::latex(Buffer const & buf, odocstream & os,
+		     OutputParams const & runparams_in) const
 {
-	string const pt = params_.type;
-
-	int i = 0;
-	if (pt == "Comment")
-		os << "<comment>\n";
-
-	if (pt != "Note")
-		i = inset.linuxdoc(buf, os);
-
-	if (pt == "Comment") {
-		os << "\n</comment>\n";
-		i += 3;
-	}
-	return i;
+	if (params_.type == InsetNoteParams::Note)
+		return 0;
+
+	OutputParams runparams(runparams_in);
+	string type;
+	if (params_.type == InsetNoteParams::Comment) {
+		type = "comment";
+		runparams.inComment = true;
+		// Ignore files that are exported inside a comment
+		runparams.exportdata.reset(new ExportData);
+	} else if (params_.type == InsetNoteParams::Greyedout)
+		type = "lyxgreyedout";
+	else if (params_.type == InsetNoteParams::Framed)
+		type = "framed";
+	else if (params_.type == InsetNoteParams::Shaded)
+		type = "shaded";
+
+	odocstringstream ss;
+	ss << "%\n\\begin{" << from_ascii(type) << "}\n";
+	InsetText::latex(buf, ss, runparams);
+	ss << "\n\\end{" << from_ascii(type) << "}\n";
+	// the space after the comment in 'a[comment] b' will be eaten by the
+	// comment environment since the space before b is ignored with the
+	// following latex output:
+	//
+	// a%
+	// \begin{comment}
+	// comment
+	// \end{comment}
+	//  b
+	//
+	// Adding {} before ' b' fixes this.
+	if (params_.type == InsetNoteParams::Comment)
+		ss << "{}";
+
+	docstring const str = ss.str();
+	os << str;
+	// Return how many newlines we issued.
+	return int(lyx::count(str.begin(), str.end(), '\n'));
 }
 
 
-int InsetNote::docbook(Buffer const * buf, std::ostream & os, bool mixcont) const
+int InsetNote::docbook(Buffer const & buf, odocstream & os,
+		       OutputParams const & runparams_in) const
 {
-	string const pt = params_.type;
+	if (params_.type == InsetNoteParams::Note)
+		return 0;
 
-	int i = 0;
-	if (pt == "Comment")
+	OutputParams runparams(runparams_in);
+	if (params_.type == InsetNoteParams::Comment) {
 		os << "<remark>\n";
+		runparams.inComment = true;
+		// Ignore files that are exported inside a comment
+		runparams.exportdata.reset(new ExportData);
+	}
 
-	if (pt != "Note")
-		i = inset.docbook(buf, os, mixcont);
+	int const n = InsetText::docbook(buf, os, runparams);
 
-	if (pt == "Comment") {
+	if (params_.type == InsetNoteParams::Comment)
 		os << "\n</remark>\n";
-		i += 3;
-	}
-	return i;
+
+	// Return how many newlines we issued.
+	//return int(count(str.begin(), str.end(), '\n'));
+        return n + 1 + 2;
 }
 
 
-int InsetNote::ascii(Buffer const * buf, std::ostream & os, int ll) const
+int InsetNote::plaintext(Buffer const & buf, odocstream & os,
+			 OutputParams const & runparams_in) const
 {
-	int i = 0;
-	string const pt = params_.type;
-	if (pt != "Note") {
-		os << "[";
-		i = inset.ascii(buf, os, ll);
-		os << "]";
+	if (params_.type == InsetNoteParams::Note)
+		return 0;
+
+	OutputParams runparams(runparams_in);
+	if (params_.type == InsetNoteParams::Comment) {
+		runparams.inComment = true;
+		// Ignore files that are exported inside a comment
+		runparams.exportdata.reset(new ExportData);
 	}
-	return i;
+	os << "[";
+	int const nlines = InsetText::plaintext(buf, os, runparams);
+	os << "]";
+
+	// Return how many newlines we issued.
+	return nlines;
 }
 
 
 void InsetNote::validate(LaTeXFeatures & features) const
 {
-	if (params_.type == "Comment")
+	if (params_.type == InsetNoteParams::Comment)
 		features.require("verbatim");
-	if (params_.type == "Greyedout") {
+	if (params_.type == InsetNoteParams::Greyedout) {
 		features.require("color");
 		features.require("lyxgreyedout");
 	}
-	inset.validate(features);
+	if (params_.type == InsetNoteParams::Shaded) {
+		features.require("color");
+		features.require("framed");
+	}
+	if (params_.type == InsetNoteParams::Framed)
+		features.require("framed");
+	InsetText::validate(features);
 }
 
 
 
-InsetNoteMailer::InsetNoteMailer(string const & name,
-						InsetNote & inset)
-	: name_(name), inset_(inset)
-{
-}
+string const InsetNoteMailer::name_("note");
+
+InsetNoteMailer::InsetNoteMailer(InsetNote & inset)
+	: inset_(inset)
+{}
 
 
 string const InsetNoteMailer::inset2string(Buffer const &) const
 {
-	return params2string(name_, inset_.params());
+	return params2string(inset_.params());
 }
 
 
-string const InsetNoteMailer::params2string(string const & name,
-				InsetNoteParams const & params)
+string const InsetNoteMailer::params2string(InsetNoteParams const & params)
 {
 	ostringstream data;
-	data << name << ' ';
+	data << name_ << ' ';
 	params.write(data);
-	return STRCONV(data.str());
+	return data.str();
 }
 
 
 void InsetNoteMailer::string2params(string const & in,
-				     InsetNoteParams & params)
+				    InsetNoteParams & params)
 {
 	params = InsetNoteParams();
 
 	if (in.empty())
 		return;
 
-	istringstream data(STRCONV(in));
+	istringstream data(in);
 	LyXLex lex(0,0);
 	lex.setStream(data);
-	params.read(lex);
-}
 
+	string name;
+	lex >> name;
+	if (!lex || name != name_)
+		return print_mailer_error("InsetNoteMailer", in, 1, name_);
 
-void InsetNoteParams::write(ostream & os) const
-{
-	os << type << "\n";
-}
+	// This is part of the inset proper that is usually swallowed
+	// by LyXText::readInset
+	string id;
+	lex >> id;
+	if (!lex || id != "Note")
+		return print_mailer_error("InsetBoxMailer", in, 2, "Note");
 
+	params.read(lex);
+}
 
-void InsetNoteParams::read(LyXLex & lex)
-{
-	if (lex.isOK()) {
-		lex.next();
-		string token = lex.getString();
-	}
 
-	if (lex.isOK()) {
-		lex.next();
-		type = lex.getString();
-	}
-}
+} // namespace lyx