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

diff --git a/src/insets/insetnote.C b/src/insets/insetnote.C
index e7536783bf..b840955032 100644
--- a/src/insets/insetnote.C
+++ b/src/insets/insetnote.C
@@ -4,33 +4,115 @@
  * Licence details can be found in the file COPYING.
  *
  * \author Angus Leeming
+ * \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"
 
+#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();
 }
 
@@ -38,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();
-	setLabel(label);
 }
 
 
@@ -51,34 +132,34 @@ InsetNote::InsetNote(InsetNote const & in)
 }
 
 
-InsetNote::~InsetNote() // MV
+InsetNote::~InsetNote()
 {
-	InsetNoteMailer mailer("note", *this);
-	mailer.hideDialog();
+	InsetNoteMailer(*this).hideDialog();
 }
 
 
-InsetBase * InsetNote::clone() const
+auto_ptr<InsetBase> InsetNote::doClone() const
 {
-	return new InsetNote(*this);
+	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();
 }
@@ -86,174 +167,247 @@ 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();
 
-	setLabel(params_.type);
-	if (params_.type == "Note" || params_.type == "Comment") {
+	switch (params_.type) {
+	case InsetNoteParams::Note:
 		font.setColor(LColor::note);
 		setBackgroundColor(LColor::notebg);
-	} else {
-		font.setColor(LColor::red);
-		setBackgroundColor(LColor::background);
+		break;
+	case InsetNoteParams::Comment:
+		font.setColor(LColor::comment);
+		setBackgroundColor(LColor::commentbg);
+		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);
 }
 
 
-dispatch_result InsetNote::localDispatch(FuncRequest const & cmd)
+bool InsetNote::showInsetDialog(BufferView * bv) const
 {
-	BufferView * bv = cmd.view();
+	InsetNoteMailer(const_cast<InsetNote &>(*this)).showDialog(bv);
+	return true;
+}
+
 
+void InsetNote::doDispatch(LCursor & cur, FuncRequest & cmd)
+{
 	switch (cmd.action) {
+
 	case LFUN_INSET_MODIFY:
-		{
-		InsetNoteParams params;
-		InsetNoteMailer::string2params(cmd.argument, params);
-		params_.type = params.type;
+		InsetNoteMailer::string2params(to_utf8(cmd.argument()), params_);
 		setButtonLabel();
-		bv->updateInset(this);
-		return DISPATCHED;
-		}
-	case LFUN_INSET_EDIT:
-		if (cmd.button() != mouse_button::button3) 
-			return InsetCollapsable::localDispatch(cmd);
-		return UNDISPATCHED;
+		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 && cmd.x < button_length 
-					&& cmd.y >= button_top_y && cmd.y <= button_bottom_y) {
-			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;
+	switch (cmd.action) {
 
-	int i = 0;
-	if (pt == "Comment") os << "%\n\\begin{comment}\n"; // remember to validate
-	if (pt == "Greyedout") os << "%\n\\textcolor[gray]{0.8}{";
-	if (pt != "Note") {
-		i = inset.latex(buf, os, runparams);
-	}
-	if (pt == "Comment") {
-		os << "%\n\\end{comment}\n";
- 		i += 3;
-	}
-	if (pt == "Greyedout") { 
-		os << "%\n}";
-		i += 2;
+	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 *, std::ostream &) const
-{ 
-	return 0; 
+int InsetNote::latex(Buffer const & buf, odocstream & os,
+		     OutputParams const & runparams_in) const
+{
+	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
 {
-	int i = 0;
-	string const pt = params_.type;
-	// incomplete, untested - MV
-	if (pt != "Note") 
-		i = inset.docbook(buf, os, mixcont);
-	return i; 
+	if (params_.type == InsetNoteParams::Note)
+		return 0;
+
+	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);
+	}
+
+	int const n = InsetText::docbook(buf, os, runparams);
+
+	if (params_.type == InsetNoteParams::Comment)
+		os << "\n</remark>\n";
+
+	// 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");
+	}
+	if (params_.type == InsetNoteParams::Shaded) {
 		features.require("color");
-	inset.validate(features);
+		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() const
+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";
-}
-
-
-void InsetNoteParams::read(LyXLex & lex)
-{
-	if (lex.isOK()) {
-		lex.next();
-		string token = lex.getString();
-	}
+	// 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");
 
-	if (lex.isOK()) {
-		lex.next();
-		type = lex.getString();
-	}
+	params.read(lex);
 }
 
+
+} // namespace lyx