#include "Layout.h"
#include "Length.h"
+#include "support/assert.h"
#include "support/convert.h"
#include "support/FileName.h"
#include "support/filetools.h"
#include "support/lstrings.h"
-#include <boost/assert.hpp>
-
#include <algorithm>
#include <iostream>
#include <map>
char const * const known_sizes[] = { "tiny", "scriptsize", "footnotesize",
"small", "normalsize", "large", "Large", "LARGE", "huge", "Huge", 0};
-/// the same as known_sizes with .lyx names
+/// the same as known_sizes with .lyx names plus a default entry
char const * const known_coded_sizes[] = { "default", "tiny", "scriptsize", "footnotesize",
-"small", "normal", "large", "larger", "largest", "huge", "giant", 0};
+"small", "normal", "large", "larger", "largest", "huge", "giant", 0};
/// LaTeX 2.09 names for font families
char const * const known_old_font_families[] = { "rm", "sf", "tt", 0};
}
-LayoutPtr findLayout(TextClass const & textclass, string const & name)
+Layout const * findLayout(TextClass const & textclass, string const & name)
{
DocumentClass::const_iterator lit = textclass.begin();
DocumentClass::const_iterator len = textclass.end();
for (; lit != len; ++lit)
if (lit->latexname() == name)
return &*lit;
- return LayoutPtr();
+ return 0;
}
void eat_whitespace(Parser &, ostream &, Context &, bool);
+Layout * captionlayout()
+{
+ static Layout * lay = 0;
+ if (!lay) {
+ lay = new Layout;
+ lay->name_ = from_ascii("Caption");
+ lay->latexname_ = "caption";
+ lay->latextype = LATEX_COMMAND;
+ lay->optionalargs = 1;
+ }
+ return lay;
+}
+
+
void output_command_layout(ostream & os, Parser & p, bool outer,
Context & parent_context,
- LayoutPtr newlayout)
+ Layout const * newlayout)
{
parent_context.check_end_layout(os);
Context context(true, parent_context.textclass, newlayout,
void parse_environment(Parser & p, ostream & os, bool outer,
Context & parent_context)
{
- LayoutPtr newlayout;
+ Layout const * newlayout;
string const name = p.getArg('{', '}');
const bool is_starred = suffixIs(name, '*');
string const unstarred_name = rtrim(name, "*");
parse_text_in_inset(p, os, FLAG_END, outer, parent_context);
end_inset(os);
p.skip_spaces();
+ skip_braces(p); // eat {} that might by set by LyX behind comments
}
else if (name == "lyxgreyedout") {
parse_unknown_environment(p, name, os, FLAG_END, outer,
parent_context);
- // Alignment settings
- else if (name == "center" || name == "flushleft" || name == "flushright" ||
- name == "centering" || name == "raggedright" || name == "raggedleft") {
+ // Alignment and spacing settings
+ // FIXME (bug xxxx): These settings can span multiple paragraphs and
+ // therefore are totally broken!
+ // Note that \centering, raggedright, and raggedleft cannot be handled, as
+ // they are commands not environments. They are furthermore switches that
+ // can be ended by another switches, but also by commands like \footnote or
+ // \parbox. So the only safe way is to leave them untouched.
+ else if (name == "center" || name == "flushleft" || name == "flushright") {
eat_whitespace(p, os, parent_context, false);
// We must begin a new paragraph if not already done
if (! parent_context.atParagraphStart()) {
parent_context.check_end_layout(os);
parent_context.new_paragraph(os);
}
- if (name == "flushleft" || name == "raggedright")
+ if (name == "flushleft")
parent_context.add_extra_stuff("\\align left\n");
- else if (name == "flushright" || name == "raggedleft")
+ else if (name == "flushright")
parent_context.add_extra_stuff("\\align right\n");
- else
+ else if (name == "center")
parent_context.add_extra_stuff("\\align center\n");
parse_text(p, os, FLAG_END, outer, parent_context);
- // Just in case the environment is empty ..
+ // Just in case the environment is empty
parent_context.extra_stuff.erase();
// We must begin a new paragraph to reset the alignment
parent_context.new_paragraph(os);
/// parses a comment and outputs it to \p os.
void parse_comment(Parser & p, ostream & os, Token const & t, Context & context)
{
- BOOST_ASSERT(t.cat() == catComment);
+ LASSERT(t.cat() == catComment, return);
if (!t.cs().empty()) {
context.check_layout(os);
handle_comment(os, '%' + t.cs(), context);
void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
Context & context)
{
- LayoutPtr newlayout;
+ Layout const * newlayout = 0;
// store the current selectlanguage to be used after \foreignlanguage
string selectlang;
// Store the latest bibliographystyle (needed for bibtex inset)
os << "\\bibitem ";
os << p.getOpt();
os << '{' << p.verbatim_item() << '}' << "\n";
+ }
+
+ else if(t.cs() == "global") {
+ // skip global which can appear in front of e.g. "def"
}
-
+
else if (t.cs() == "def") {
context.check_layout(os);
eat_whitespace(p, os, context, false);
eat_whitespace(p, os, context, true);
}
+ // Starred section headings
// Must attempt to parse "Section*" before "Section".
else if ((p.next_token().asInput() == "*") &&
context.new_layout_allowed &&
- // The single '=' is meant here.
(newlayout = findLayout(context.textclass, t.cs() + '*')) &&
- newlayout->isCommand()) {
+ newlayout->isCommand()) {
+ TeXFont const oldFont = context.font;
+ // save the current font size
+ string const size = oldFont.size;
+ // reset the font size to default, because the font size switches don't
+ // affect section headings and the like
+ context.font.size = known_coded_sizes[0];
+ output_font_change(os, oldFont, context.font);
+ // write the layout
p.get_token();
output_command_layout(os, p, outer, context, newlayout);
+ // set the font size to the original value
+ context.font.size = size;
+ output_font_change(os, oldFont, context.font);
p.skip_spaces();
}
- // The single '=' is meant here.
+ // Section headings and the like
else if (context.new_layout_allowed &&
(newlayout = findLayout(context.textclass, t.cs())) &&
newlayout->isCommand()) {
+ TeXFont const oldFont = context.font;
+ // save the current font size
+ string const size = oldFont.size;
+ // reset the font size to default, because the font size switches don't
+ // affect section headings and the like
+ context.font.size = known_coded_sizes[0];
+ output_font_change(os, oldFont, context.font);
+ // write the layout
output_command_layout(os, p, outer, context, newlayout);
+ // set the font size to the original value
+ context.font.size = size;
+ output_font_change(os, oldFont, context.font);
p.skip_spaces();
}
// Special handling for \caption
// FIXME: remove this when InsetCaption is supported.
else if (context.new_layout_allowed &&
- t.cs() == captionlayout->latexname()) {
+ t.cs() == captionlayout()->latexname()) {
output_command_layout(os, p, outer, context,
- captionlayout);
+ captionlayout());
p.skip_spaces();
}
eat_whitespace(p, os, context, false);
}
+ else if (t.cs() == "textcolor") {
+ // scheme is \textcolor{color name}{text}
+ string const color = p.verbatim_item();
+ // we only support the predefined colors of the color package
+ if (color == "black" || color == "blue" || color == "cyan"
+ || color == "green" || color == "magenta" || color == "red"
+ || color == "white" || color == "yellow") {
+ context.check_layout(os);
+ os << "\n\\color " << color << "\n";
+ parse_text_snippet(p, os, FLAG_ITEM, outer, context);
+ context.check_layout(os);
+ os << "\n\\color inherit\n";
+ } else
+ // for custom defined colors
+ handle_ert(os, t.asInput() + "{" + color + "}", context);
+ }
+
else if (t.cs() == "underbar") {
// Do NOT handle \underline.
// \underbar cuts through y, g, q, p etc.,
os << "\n\\" << t.cs() << " default\n";
}
+ else if (t.cs() == "lyxline") {
+ context.check_layout(os);
+ os << "\\lyxline";
+ }
+
else if (use_natbib &&
is_known(t.cs(), known_natbib_commands) &&
((t.cs() != "citefullauthor" &&
char const * const * where = is_known(t.cs(), known_sizes);
context.check_layout(os);
TeXFont const oldFont = context.font;
- context.font.size = known_coded_sizes[where - known_sizes];
+ // the font size index differs by 1, because the known_coded_sizes
+ // has additionally a "default" entry
+ context.font.size = known_coded_sizes[where - known_sizes + 1];
output_font_change(os, oldFont, context.font);
eat_whitespace(p, os, context, false);
}
else if (t.cs() == "parbox")
parse_box(p, os, FLAG_ITEM, outer, context, true);
+
+ //\makebox() is part of the picture environment and different from \makebox{}
+ //\makebox{} will be parsed by parse_box when bug 2956 is fixed
+ else if (t.cs() == "makebox") {
+ string arg = t.asInput();
+ if (p.next_token().character() == '(')
+ //the syntax is: \makebox(x,y)[position]{content}
+ arg += p.getFullParentheseArg();
+ else
+ //the syntax is: \makebox[width][position]{content}
+ arg += p.getFullOpt();
+ handle_ert(os, arg + p.getFullOpt(), context);
+ }
else if (t.cs() == "smallskip" ||
t.cs() == "medskip" ||
else if (is_known(t.cs(), known_spaces)) {
char const * const * where = is_known(t.cs(), known_spaces);
context.check_layout(os);
- begin_inset(os, "InsetSpace ");
+ os << "\\InsetSpace ";
os << '\\' << known_coded_spaces[where - known_spaces]
<< '\n';
// LaTeX swallows whitespace after all spaces except
os << "\n" << ert;
end_inset(os);
}
+
+ else if (t.cs() == "newcommandx" ||
+ t.cs() == "renewcommandx") {
+ // \newcommandx{\foo}[2][usedefault, addprefix=\global,1=default]{#1,#2}
+
+ // get command name
+ string command;
+ if (p.next_token().cat() == catBegin)
+ command = p.verbatim_item();
+ else
+ command = "\\" + p.get_token().cs();
+
+ // get arity, we do not check that it fits to the given
+ // optional parameters here.
+ string const opt1 = p.getOpt();
+
+ // get options and default values for optional parameters
+ std::vector<string> optionalValues;
+ int optionalsNum = 0;
+ if (p.next_token().character() == '[') {
+ // skip '['
+ p.get_token();
+
+ // handle 'opt=value' options, separated by ','.
+ eat_whitespace(p, os, context, false);
+ while (p.next_token().character() != ']' && p.good()) {
+ char_type nextc = p.next_token().character();
+ if (nextc >= '1' && nextc <= '9') {
+ // optional value -> get parameter number
+ int n = p.getChar() - '0';
+
+ // skip '='
+ if (p.next_token().character() != '=') {
+ cerr << "'=' expected after numeral option of \\newcommandx" << std::endl;
+ // try to find ] or ,
+ while (p.next_token().character() != ','
+ && p.next_token().character() != ']')
+ p.get_token();
+ continue;
+ } else
+ p.get_token();
+
+ // get value
+ optionalValues.resize(max(size_t(n), optionalValues.size()));
+ optionalValues[n - 1].clear();
+ while (p.next_token().character() != ']'
+ && p.next_token().character() != ',')
+ optionalValues[n - 1] += p.verbatim_item();
+ optionalsNum = max(n, optionalsNum);
+ } else if (p.next_token().cat() == catLetter) {
+ // we in fact ignore every non-optional
+ // parameters
+
+ // get option name
+ docstring opt;
+ while (p.next_token().cat() == catLetter)
+ opt += p.getChar();
+
+ // value?
+ eat_whitespace(p, os, context, false);
+ if (p.next_token().character() == '=') {
+ p.get_token();
+ while (p.next_token().character() != ']'
+ && p.next_token().character() != ',')
+ p.verbatim_item();
+ }
+ } else
+ return;
+
+ // skip komma
+ eat_whitespace(p, os, context, false);
+ if (p.next_token().character() == ',') {
+ p.getChar();
+ eat_whitespace(p, os, context, false);
+ } else if (p.next_token().character() != ']')
+ continue;
+ }
+
+ // skip ']'
+ p.get_token();
+ }
+
+ // concat the default values to the optionals string
+ string optionals;
+ for (unsigned i = 0; i < optionalValues.size(); ++i)
+ optionals += "[" + optionalValues[i] + "]";
+
+ // register and output command
+ add_known_command(command, opt1, optionalsNum);
+ string const ert = "\\newcommand{" + command + '}' + opt1
+ + optionals + '{' + p.verbatim_item() + '}';
+
+ context.check_layout(os);
+ begin_inset(os, "FormulaMacro");
+ os << "\n" << ert;
+ end_inset(os);
+ }
else if (t.cs() == "vspace") {
bool starred = false;
}
}
}
-
if (known_unit || known_vspace) {
// Literal length or known variable
context.check_layout(os);
}
}
+ else if (t.cs() == "hspace") {
+ bool starred = false;
+ if (p.next_token().asInput() == "*") {
+ p.get_token();
+ starred = true;
+ }
+ string const length = p.verbatim_item();
+ string unit;
+ string valstring;
+ bool valid = splitLatexLength(length, valstring, unit);
+ bool known_unit = false;
+ bool fill = false;
+ double value;
+ if (valid) {
+ istringstream iss(valstring);
+ iss >> value;
+ if (value == 1.0)
+ if (unit == "\\fill") {
+ known_unit = true;
+ fill = true;
+ }
+ switch (unitFromString(unit)) {
+ case Length::SP:
+ case Length::PT:
+ case Length::BP:
+ case Length::DD:
+ case Length::MM:
+ case Length::PC:
+ case Length::CC:
+ case Length::CM:
+ case Length::IN:
+ case Length::EX:
+ case Length::EM:
+ case Length::MU:
+ known_unit = true;
+ break;
+ default:
+ break;
+ }
+ }
+ if (known_unit) {
+ // Literal length or known variable
+ context.check_layout(os);
+ begin_inset(os, "Space ");
+ if (known_unit) {
+ os << "\\hspace";
+ if (starred)
+ os << '*';
+ if (fill)
+ os << "{" + unit + "}";
+ else {
+ os << "{}\n";
+ os << "\\length " << value << unit;
+ }
+ }
+ end_inset(os);
+ } else {
+ // LyX can't handle other length variables in Inset HSpace
+ string name = t.asInput();
+ if (starred)
+ name += '*';
+ if (valid) {
+ if (value == 1.0)
+ handle_ert(os, name + '{' + unit + '}', context);
+ else if (value == -1.0)
+ handle_ert(os, name + "{-" + unit + '}', context);
+ else
+ handle_ert(os, name + '{' + valstring + unit + '}', context);
+ } else
+ handle_ert(os, name + '{' + length + '}', context);
+ }
+ }
+
else {
//cerr << "#: " << t << " mode: " << mode << endl;
// heuristic: read up to next non-nested space
projects / lyx.git / blobdiff