X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetSpecialChar.cpp;h=1294d1791efa92899534776e0bb053bc1266cc5e;hb=e30db1e44474ee379bedb0d1c752297541156497;hp=b8a75669733f7a29c6c3f37f8dc444e33e98c201;hpb=150cf11651ad92090a452bb9e6cb72d7eea886d5;p=lyx.git

diff --git a/src/insets/InsetSpecialChar.cpp b/src/insets/InsetSpecialChar.cpp
index b8a7566973..1294d1791e 100644
--- a/src/insets/InsetSpecialChar.cpp
+++ b/src/insets/InsetSpecialChar.cpp
@@ -5,7 +5,7 @@
  *
  * \author Asger Alstrup Nielsen
  * \author Jean-Marc Lasgouttes
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -14,25 +14,26 @@
 
 #include "InsetSpecialChar.h"
 
-#include "debug.h"
 #include "Dimension.h"
+#include "Font.h"
 #include "LaTeXFeatures.h"
 #include "Lexer.h"
 #include "MetricsInfo.h"
+#include "output_xhtml.h"
 
 #include "frontends/FontMetrics.h"
 #include "frontends/Painter.h"
 
+#include "support/debug.h"
 #include "support/docstream.h"
 
-namespace lyx {
+using namespace std;
 
-using std::string;
-using std::ostream;
+namespace lyx {
 
 
 InsetSpecialChar::InsetSpecialChar(Kind k)
-	: kind_(k)
+	: Inset(0), kind_(k)
 {}
 
 
@@ -42,30 +43,168 @@ InsetSpecialChar::Kind InsetSpecialChar::kind() const
 }
 
 
+namespace {
+
+int logoWidth(FontInfo const & font, InsetSpecialChar::Kind kind) {
+	frontend::FontMetrics const & fm = theFontMetrics(font);
+	double const em = fm.width('M');
+	int width = 0;
+	// See drawlogo() below to understand what this does.
+	switch (kind) {
+	case InsetSpecialChar::PHRASE_LYX:
+		width = fm.width(from_ascii("L")) - 0.16667 * em
+			+ fm.width(from_ascii("Y")) - 0.125 * em
+			+ fm.width(from_ascii("X"));
+		break;
+
+	case InsetSpecialChar::PHRASE_TEX:
+		width = fm.width(from_ascii("T")) - 0.16667 * em
+			+ fm.width(from_ascii("E")) - 0.125 * em
+			+ fm.width(from_ascii("X"));
+		break;
+
+	case InsetSpecialChar::PHRASE_LATEX2E:
+		width = logoWidth(font, InsetSpecialChar::PHRASE_LATEX)
+			+ 0.15 * em
+			+ fm.width(from_ascii("2") + char_type(0x03b5));
+		break;
+	case InsetSpecialChar::PHRASE_LATEX: {
+		FontInfo smaller = font;
+		smaller.decSize().decSize();
+		width = fm.width(from_ascii("L")) - 0.36 * em
+			+ theFontMetrics(smaller).width(from_ascii("A")) - 0.15 * em
+			+ logoWidth(font, InsetSpecialChar::PHRASE_TEX);
+		break;
+	}
+	default:
+		LYXERR0("No information for computing width of logo " << kind);
+	}
+
+	return width;
+}
+
+}
+
+
 void InsetSpecialChar::metrics(MetricsInfo & mi, Dimension & dim) const
 {
 	frontend::FontMetrics const & fm =
 		theFontMetrics(mi.base.font);
 	dim.asc = fm.maxAscent();
 	dim.des = fm.maxDescent();
+	dim.wid = 0;
 
-	string s;
+	docstring s;
 	switch (kind_) {
-		case LIGATURE_BREAK:      s = "|";     break;
-		case END_OF_SENTENCE:     s = ".";     break;
-		case LDOTS:               s = ". . ."; break;
-		case MENU_SEPARATOR:      s = " x ";   break;
-		case HYPHENATION:      s = "-";   break;
+		case LIGATURE_BREAK:
+			s = from_ascii("|");
+			break;
+		case END_OF_SENTENCE:
+			s = from_ascii(".");
+			break;
+		case LDOTS:
+			s = from_ascii(". . .");
+			break;
+		case MENU_SEPARATOR:
+			s = from_ascii(" x ");
+			break;
+		case HYPHENATION:
+			dim.wid = fm.width(from_ascii("-"));
+			if (dim.wid > 5)
+				dim.wid -= 2; // to make it look shorter
+			break;
+		case SLASH:
+			s = from_ascii("/");
+			break;
+		case NOBREAKDASH:
+			s = from_ascii("-");
+			break;
+		case PHRASE_LYX:
+		case PHRASE_TEX:
+		case PHRASE_LATEX2E:
+		case PHRASE_LATEX:
+			dim.wid = logoWidth(mi.base.font, kind_);
+			break;
 	}
-	docstring ds(s.begin(), s.end());
-	dim.wid = fm.width(ds);
-	if (kind_ == HYPHENATION && dim.wid > 5)
-		dim.wid -= 2; // to make it look shorter
-	
+	if (dim.wid == 0)
+		dim.wid = fm.width(s);
+
 	setDimCache(mi, dim);
 }
 
 
+namespace {
+
+void drawLogo(PainterInfo & pi, InsetSpecialChar::Kind kind, int & x, int & y) {
+	FontInfo const & font = pi.base.font;
+	// FIXME: this definition of em is bogus, but there is a need
+	// for a big refactoring of the code around this issue anyway.
+	double const em = theFontMetrics(font).width('M');
+	switch (kind) {
+	case InsetSpecialChar::PHRASE_LYX:
+		/** Reference macro:
+		 *  \providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\\@};
+		 */
+		x += pi.pain.text(x, y, from_ascii("L"), font);
+		x -= 0.16667 * em;
+		x += pi.pain.text(x, y + 0.25 * em, from_ascii("Y"), font);
+		x -= 0.125 * em;
+		x += pi.pain.text(x, y, from_ascii("X"), font);
+		break;
+
+	case InsetSpecialChar::PHRASE_TEX: {
+		/** Reference macro:
+		 *  \def\TeX{T\kern-.1667em\lower.5ex\hbox{E}\kern-.125emX\@}
+		 */
+		double const ex = theFontMetrics(font).ascent('x');
+		x += pi.pain.text(x, y, from_ascii("T"), font);
+		x -= 0.16667 * em;
+		x += pi.pain.text(x, y + 0.5 * ex, from_ascii("E"), font);
+		x -= 0.125 * em;
+		x += pi.pain.text(x, y, from_ascii("X"), font);
+		break;
+	}
+	case InsetSpecialChar::PHRASE_LATEX2E:
+		/** Reference macro:
+		 *  \DeclareRobustCommand{\LaTeXe}{\mbox{\m@th
+		 *    \if b\expandafter\@car\f@series\@nil\boldmath\fi
+		 *    \LaTeX\kern.15em2$_{\textstyle\varepsilon}$}}
+		 */
+		drawLogo(pi, InsetSpecialChar::PHRASE_LATEX, x, y);
+		x += 0.15 * em;
+		x += pi.pain.text(x, y, from_ascii("2"), font);
+		x += pi.pain.text(x, y + 0.25 * em, char_type(0x03b5), font);
+		break;
+
+	case InsetSpecialChar::PHRASE_LATEX: {
+		/** Reference macro:
+		 * \DeclareRobustCommand{\LaTeX}{L\kern-.36em%
+		 *        {\sbox\z@ T%
+		 *         \vbox to\ht\z@{\hbox{\check@mathfonts
+		 *                              \fontsize\sf@size\z@
+		 *                              \math@fontsfalse\selectfont
+		 *                              A}%
+		 *                        \vss}%
+		 *        }%
+		 *        \kern-.15em%
+		 *        \TeX}
+		 */
+		x += pi.pain.text(x, y, from_ascii("L"), font);
+		x -= 0.36 * em;
+		FontInfo smaller = font;
+		smaller.decSize().decSize();
+		x += pi.pain.text(x, y - 0.2 * em, from_ascii("A"), smaller);
+		x -= 0.15 * em;
+		drawLogo(pi, InsetSpecialChar::PHRASE_TEX, x, y);
+		break;
+	}
+	default:
+		LYXERR0("No information for drawing logo " << kind);
+	}
+}
+
+}
+
 void InsetSpecialChar::draw(PainterInfo & pi, int x, int y) const
 {
 	FontInfo font = pi.base.font;
@@ -116,12 +255,30 @@ void InsetSpecialChar::draw(PainterInfo & pi, int x, int y) const
 		pi.pain.lines(xp, yp, 4, Color_special);
 		break;
 	}
+	case SLASH:
+	{
+		font.setColor(Color_special);
+		pi.pain.text(x, y, char_type('/'), font);
+		break;
+	}
+	case NOBREAKDASH:
+	{
+		font.setColor(Color_latex);
+		pi.pain.text(x, y, char_type('-'), font);
+		break;
+	}
+	case PHRASE_LYX:
+	case PHRASE_TEX:
+	case PHRASE_LATEX2E:
+	case PHRASE_LATEX:
+		drawLogo(pi, kind_, x, y);
+		break;
 	}
 }
 
 
 // In lyxf3 this will be just LaTeX
-void InsetSpecialChar::write(Buffer const &, ostream & os) const
+void InsetSpecialChar::write(ostream & os) const
 {
 	string command;
 	switch (kind_) {
@@ -140,13 +297,31 @@ void InsetSpecialChar::write(Buffer const &, ostream & os) const
 	case MENU_SEPARATOR:
 		command = "\\menuseparator";
 		break;
+	case SLASH:
+		command = "\\slash{}";
+		break;
+	case NOBREAKDASH:
+		command = "\\nobreakdash-";
+		break;
+	case PHRASE_LYX:
+		command = "\\LyX";
+		break;
+	case PHRASE_TEX:
+		command = "\\TeX";
+		break;
+	case PHRASE_LATEX2E:
+		command = "\\LaTeX2e";
+		break;
+	case PHRASE_LATEX:
+		command = "\\LaTeX";
+		break;
 	}
 	os << "\\SpecialChar " << command << "\n";
 }
 
 
 // This function will not be necessary when lyx3
-void InsetSpecialChar::read(Buffer const &, Lexer & lex)
+void InsetSpecialChar::read(Lexer & lex)
 {
 	lex.next();
 	string const command = lex.getString();
@@ -161,13 +336,25 @@ void InsetSpecialChar::read(Buffer const &, Lexer & lex)
 		kind_ = LDOTS;
 	else if (command == "\\menuseparator")
 		kind_ = MENU_SEPARATOR;
+	else if (command == "\\slash{}")
+		kind_ = SLASH;
+	else if (command == "\\nobreakdash-")
+		kind_ = NOBREAKDASH;
+	else if (command == "\\LyX")
+		kind_ = PHRASE_LYX;
+	else if (command == "\\TeX")
+		kind_ = PHRASE_TEX;
+	else if (command == "\\LaTeX2e")
+		kind_ = PHRASE_LATEX2E;
+	else if (command == "\\LaTeX")
+		kind_ = PHRASE_LATEX;
 	else
 		lex.printError("InsetSpecialChar: Unknown kind: `$$Token'");
 }
 
 
-int InsetSpecialChar::latex(Buffer const &, odocstream & os,
-			    OutputParams const &) const
+void InsetSpecialChar::latex(otexstream & os,
+			     OutputParams const & rp) const
 {
 	switch (kind_) {
 	case HYPHENATION:
@@ -183,36 +370,86 @@ int InsetSpecialChar::latex(Buffer const &, odocstream & os,
 		os << "\\ldots{}";
 		break;
 	case MENU_SEPARATOR:
-		os << "\\lyxarrow{}";
+		if (rp.local_font->isRightToLeft())
+			os << "\\lyxarrow*{}";
+		else
+			os << "\\lyxarrow{}";
+		break;
+	case SLASH:
+		os << "\\slash{}";
+		break;
+	case NOBREAKDASH:
+		if (rp.moving_arg)
+			os << "\\protect";
+		os << "\\nobreakdash-";
+		break;
+	case PHRASE_LYX:
+		if (rp.moving_arg)
+			os << "\\protect";
+		os << "\\LyX{}";
+		break;
+	case PHRASE_TEX:
+		if (rp.moving_arg)
+			os << "\\protect";
+		os << "\\TeX{}";
+		break;
+	case PHRASE_LATEX2E:
+		if (rp.moving_arg)
+			os << "\\protect";
+		os << "\\LaTeX2e{}";
+		break;
+	case PHRASE_LATEX:
+		if (rp.moving_arg)
+			os << "\\protect";
+		os << "\\LaTeX{}";
 		break;
 	}
-	return 0;
 }
 
 
-int InsetSpecialChar::plaintext(Buffer const &, odocstream & os,
-				OutputParams const &) const
+int InsetSpecialChar::plaintext(odocstringstream & os,
+        OutputParams const &, size_t) const
 {
 	switch (kind_) {
 	case HYPHENATION:
-	case LIGATURE_BREAK:
 		return 0;
+	case LIGATURE_BREAK:
+		os.put(0x200c);
+		return 1;
 	case END_OF_SENTENCE:
 		os << '.';
 		return 1;
 	case LDOTS:
-		os << "...";
-		return 3;
+		os.put(0x2026);
+		return 1;
 	case MENU_SEPARATOR:
 		os << "->";
 		return 2;
+	case SLASH:
+		os << '/';
+		return 1;
+	case NOBREAKDASH:
+		os.put(0x2011);
+		return 1;
+	case PHRASE_LYX:
+		os << "LyX";
+		return 3;
+	case PHRASE_TEX:
+		os << "TeX";
+		return 3;
+	case PHRASE_LATEX2E:
+		os << "LaTeX2";
+		os.put(0x03b5);
+		return 7;
+	case PHRASE_LATEX:
+		os << "LaTeX";
+		return 5;
 	}
 	return 0;
 }
 
 
-int InsetSpecialChar::docbook(Buffer const &, odocstream & os,
-			      OutputParams const &) const
+int InsetSpecialChar::docbook(odocstream & os, OutputParams const &) const
 {
 	switch (kind_) {
 	case HYPHENATION:
@@ -222,45 +459,114 @@ int InsetSpecialChar::docbook(Buffer const &, odocstream & os,
 		os << '.';
 		break;
 	case LDOTS:
-		os << "...";
+		os << "&hellip;";
 		break;
 	case MENU_SEPARATOR:
 		os << "&lyxarrow;";
 		break;
+	case SLASH:
+		os << '/';
+		break;
+	case NOBREAKDASH:
+		os << '-';
+		break;
+	case PHRASE_LYX:
+		os << "LyX";
+		break;
+	case PHRASE_TEX:
+		os << "TeX";
+		break;
+	case PHRASE_LATEX2E:
+		os << "LaTeX2";
+		os.put(0x03b5);
+		break;
+	case PHRASE_LATEX:
+		os << "LaTeX";
+		break;
 	}
 	return 0;
 }
 
 
-int InsetSpecialChar::textString(Buffer const & buf, odocstream & os,
-		       OutputParams const & op) const
+docstring InsetSpecialChar::xhtml(XHTMLStream & xs, OutputParams const &) const
 {
-	return plaintext(buf, os, op);
+	switch (kind_) {
+	case HYPHENATION:
+		break;
+	case LIGATURE_BREAK:
+		xs << XHTMLStream::ESCAPE_NONE << "&#8204;";
+		break;
+	case END_OF_SENTENCE:
+		xs << '.';
+		break;
+	case LDOTS:
+		xs << XHTMLStream::ESCAPE_NONE << "&hellip;";
+		break;
+	case MENU_SEPARATOR:
+		xs << XHTMLStream::ESCAPE_NONE << "&rArr;";
+		break;
+	case SLASH:
+		xs << XHTMLStream::ESCAPE_NONE << "&frasl;";
+		break;
+	case NOBREAKDASH:
+		xs << XHTMLStream::ESCAPE_NONE << "&#8209;";
+		break;
+	case PHRASE_LYX:
+		xs << "LyX";
+		break;
+	case PHRASE_TEX:
+		xs << "TeX";
+		break;
+	case PHRASE_LATEX2E:
+		xs << "LaTeX2" << XHTMLStream::ESCAPE_NONE << "&#x3b5;";
+		break;
+	case PHRASE_LATEX:
+		xs << "LaTeX";
+		break;
+	}
+	return docstring();
 }
 
 
-Inset * InsetSpecialChar::clone() const
+void InsetSpecialChar::toString(odocstream & os) const
 {
-	return new InsetSpecialChar(kind_);
+	switch (kind_) {
+	case LIGATURE_BREAK:
+		// Do not output ZERO WIDTH NON JOINER here
+		// Spell checker would choke on it.
+		return;
+	default:
+		break;
+	}
+	odocstringstream ods;
+	plaintext(ods, OutputParams(0));
+	os << ods.str();
 }
 
 
-void InsetSpecialChar::validate(LaTeXFeatures & features) const
+void InsetSpecialChar::forOutliner(docstring & os, size_t) const
 {
-	if (kind_ == MENU_SEPARATOR)
-		features.require("lyxarrow");
+	odocstringstream ods;
+	plaintext(ods, OutputParams(0));
+	os += ods.str();
 }
 
 
-bool InsetSpecialChar::isChar() const
+void InsetSpecialChar::validate(LaTeXFeatures & features) const
 {
-	return true;
+	if (kind_ == MENU_SEPARATOR)
+		features.require("lyxarrow");
+	if (kind_ == NOBREAKDASH)
+		features.require("amsmath");
+	if (kind_ == PHRASE_LYX)
+		features.require("LyX");
 }
 
 
 bool InsetSpecialChar::isLetter() const
 {
-	return kind_ == HYPHENATION || kind_ == LIGATURE_BREAK;
+	return kind_ == HYPHENATION || kind_ == LIGATURE_BREAK
+		|| kind_ == NOBREAKDASH;
 }
 
 
@@ -271,7 +577,8 @@ bool InsetSpecialChar::isLineSeparator() const
 	// Paragraph::stripLeadingSpaces nukes the characters which
 	// have this property. I leave the code here, since it should
 	// eventually be made to work. (JMarc 20020327)
-	return kind_ == HYPHENATION || kind_ == MENU_SEPARATOR;
+	return kind_ == HYPHENATION || kind_ == MENU_SEPARATOR
+		|| kind_ == SLASH;
 #else
 	return false;
 #endif