#include "FloatList.h"
#include "LaTeXPackages.h"
#include "Layout.h"
-#include "Length.h"
#include "Preamble.h"
#include "insets/ExternalTemplate.h"
#include "support/convert.h"
#include "support/FileName.h"
#include "support/filetools.h"
+#include "support/Length.h"
#include "support/lstrings.h"
#include "support/lyxtime.h"
namespace {
-void output_arguments(ostream &, Parser &, bool, bool, string, Context &,
+void output_arguments(ostream &, Parser &, bool, bool, const string &, Context &,
Layout::LaTeXArgMap const &);
}
void parse_text_in_inset(Parser & p, ostream & os, unsigned flags, bool outer,
Context const & context, InsetLayout const * layout,
- string const rdelim)
+ string const & rdelim)
{
bool const forcePlainLayout =
layout ? layout->forcePlainLayout() : false;
void parse_text_in_inset(Parser & p, ostream & os, unsigned flags, bool outer,
Context const & context, string const & name,
- string const rdelim = string())
+ string const & rdelim = string())
{
InsetLayout const * layout = 0;
DocumentClass::InsetLayouts::const_iterator it =
/// spaces known by InsetSpace
char const * const known_spaces[] = { " ", "space", ",",
"thinspace", "quad", "qquad", "enspace", "enskip",
-"negthinspace", "negmedspace", "negthickspace", "textvisiblespace",
-"hfill", "dotfill", "hrulefill", "leftarrowfill", "rightarrowfill",
-"upbracefill", "downbracefill", 0};
+"medspace", "thickspace", "negthinspace", "negmedspace", "negthickspace",
+"textvisiblespace", "hfill", "dotfill", "hrulefill", "leftarrowfill",
+"rightarrowfill", "upbracefill", "downbracefill", 0};
/// the same as known_spaces with .lyx names
char const * const known_coded_spaces[] = { "space{}", "space{}",
"thinspace{}", "thinspace{}", "quad{}", "qquad{}", "enspace{}", "enskip{}",
-"negthinspace{}", "negmedspace{}", "negthickspace{}", "textvisiblespace{}",
-"hfill{}", "dotfill{}", "hrulefill{}", "leftarrowfill{}", "rightarrowfill{}",
-"upbracefill{}", "downbracefill{}", 0};
+"medspace{}", "thickspace{}", "negthinspace{}", "negmedspace{}", "negthickspace{}",
+"textvisiblespace{}", "hfill{}", "dotfill{}", "hrulefill{}", "leftarrowfill{}",
+"rightarrowfill{}", "upbracefill{}", "downbracefill{}", 0};
/// known TIPA combining diacritical marks
char const * const known_tipa_marks[] = {"textsubwedge", "textsubumlaut",
/// If we have ambiguous quotation marks, make a smart guess
/// based on main quote style
-string guessQuoteStyle(string in, bool const opening)
+string guessQuoteStyle(string const & in, bool const opening)
{
string res = in;
if (prefixIs(in, "qr")) {// straight quote
}
-string const fromPolyglossiaEnvironment(string const s)
+string const fromPolyglossiaEnvironment(string const & s)
{
// Since \arabic is taken by the LaTeX kernel,
// the Arabic polyglossia environment is upcased
}
-string uncapitalize(string const s)
+string uncapitalize(string const & s)
{
docstring in = from_ascii(s);
char_type t = lowercase(s[0]);
}
-bool isCapitalized(string const s)
+bool isCapitalized(string const & s)
{
docstring in = from_ascii(s);
char_type t = uppercase(s[0]);
/// try to convert \p s to a valid InsetCommand argument
/// without trying to recode macros.
-string convert_literate_command_inset_arg(string s)
+string convert_literate_command_inset_arg(string const & s)
{
// LyX cannot handle newlines in a latex command
return subst(s, "\n", " ");
void output_ert(ostream & os, string const & s, Context & context)
{
context.check_layout(os);
- for (string::const_iterator it = s.begin(), et = s.end(); it != et; ++it) {
- if (*it == '\\')
+ for (char const c : s) {
+ if (c == '\\')
os << "\n\\backslash\n";
- else if (*it == '\n') {
+ else if (c == '\n') {
context.new_paragraph(os);
context.check_layout(os);
} else
- os << *it;
+ os << c;
}
context.check_end_layout(os);
}
}
-void output_arguments(ostream & os, Parser & p, bool outer, bool need_layout, string const prefix,
+void output_arguments(ostream & os, Parser & p, bool outer, bool need_layout, string const & prefix,
Context & context, Layout::LaTeXArgMap const & latexargs)
{
if (context.layout->latextype != LATEX_ITEM_ENVIRONMENT || !prefix.empty()) {
*
* 2. could be used to suppress as many spaces as possible. This has two effects:
* - Reimporting LyX generated LaTeX files changes almost no whitespace
- * - Superflous whitespace from non LyX generated LaTeX files is removed.
+ * - Superfluous whitespace from non LyX generated LaTeX files is removed.
* The drawback is that the logic inside the function becomes
* complicated, and that is the reason why it is not implemented.
*/
os << "use_makebox " << (inner_type == "makebox") << '\n';
if (outer_type == "mbox" || (outer_type == "fbox" && inner_type.empty()))
os << "width \"\"\n";
- // for values like "1.5\width" LyX uses "1.5in" as width ad sets "width" as sepecial
+ // for values like "1.5\width" LyX uses "1.5in" as width and sets "width" as special
else if (contains(width_unit, '\\'))
os << "width \"" << width_value << "in" << "\"\n";
else
break;
}
- // We need to use fromPolyglossiaEnvironment die to Arabic > arabic
+ // We need to use fromPolyglossiaEnvironment due to Arabic > arabic
if (is_known(fromPolyglossiaEnvironment(name), preamble.polyglossia_languages)) {
// We must begin a new paragraph if not already done
- if (! parent_context.atParagraphStart()) {
+ if (!parent_context.atParagraphStart()) {
parent_context.check_end_layout(os);
parent_context.new_paragraph(os);
}
- // save the language in the context so that it is
+ // store previous language because we must reset it at the end
+ string const lang_old = parent_context.font.language;
+ // save new language in context so that it is
// handled by parse_text
parent_context.font.language =
preamble.polyglossia2lyx(fromPolyglossiaEnvironment(name));
parse_text(p, os, FLAG_END, outer, parent_context);
+ // reset previous language
+ parent_context.font.language = lang_old;
// Just in case the environment is empty
parent_context.extra_stuff.erase();
// We must begin a new paragraph to reset the language
}
switch (context.layout->latextype) {
case LATEX_LIST_ENVIRONMENT:
+ context.in_list_preamble =
+ !context.layout->listpreamble().empty()
+ && p.hasListPreamble(context.layout->itemcommand());
context.add_par_extra_stuff("\\labelwidthstring "
+ p.verbatim_item() + '\n');
p.skip_spaces();
output_arguments(os, p, outer, false, string(), context,
context.layout->latexargs());
else if (context.layout->latextype == LATEX_ITEM_ENVIRONMENT) {
+ context.in_list_preamble =
+ !context.layout->listpreamble().empty()
+ && p.hasListPreamble(context.layout->itemcommand());
ostringstream oss;
output_arguments(oss, p, outer, false, string(), context,
context.layout->latexargs());
context.list_extra_stuff = oss.str();
}
+ if (context.in_list_preamble) {
+ // Collect the stuff between \begin and first \item
+ context.list_preamble =
+ parse_text_snippet(p, FLAG_END, outer, context);
+ context.in_list_preamble = false;
+ }
parse_text(p, os, FLAG_END, outer, context);
if (context.layout->latextype == LATEX_ENVIRONMENT)
output_arguments(os, p, outer, false, "post", context,
p.skip_spaces();
if (!preamble.titleLayoutFound())
preamble.titleLayoutFound(newlayout->intitle);
- set<string> const & req = newlayout->requires();
+ set<string> const & req = newlayout->required();
set<string>::const_iterator it = req.begin();
set<string>::const_iterator en = req.end();
for (; it != en; ++it)
if (known_environments.find(name) != known_environments.end()) {
vector<ArgumentType> arguments = known_environments[name];
- // The last "argument" denotes wether we may translate the
+ // The last "argument" denotes whether we may translate the
// environment contents to LyX
// The default required if no argument is given makes us
// compatible with the reLyXre environment.
}
-void copy_file(FileName const & src, string dstname)
+void copy_file(FileName const & src, string const & dstname)
{
if (!copyFiles())
return;
void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
- Context & context, string const rdelim)
+ Context & context, string const & rdelim)
{
Layout const * newlayout = 0;
InsetLayout const * newinsetlayout = 0;
debugToken(cerr, t, flags);
#endif
+ if (context.in_list_preamble
+ && p.next_token().cs() == context.layout->itemcommand()) {
+ // We are parsing a list preamble. End before first \item.
+ flags |= FLAG_LEAVE;
+ context.in_list_preamble = false;
+ }
+
if (flags & FLAG_ITEM) {
if (t.cat() == catSpace)
continue;
if (context.layout->labeltype != LABEL_MANUAL)
output_arguments(os, p, outer, false, "item", context,
context.layout->itemargs());
+ if (!context.list_preamble.empty()) {
+ // We have a list preamble. Output it here.
+ begin_inset(os, "Argument listpreamble:1");
+ os << "\nstatus collapsed\n\n"
+ << "\\begin_layout Plain Layout\n\n"
+ << rtrim(context.list_preamble)
+ << "\n\\end_layout";
+ end_inset(os);
+ context.list_preamble.clear();
+ }
if (!context.list_extra_stuff.empty()) {
os << context.list_extra_stuff;
context.list_extra_stuff.clear();
parse_text_snippet(p, os, FLAG_ITEM, outer, context);
if (!preamble.titleLayoutFound())
preamble.titleLayoutFound(newlayout->intitle);
- set<string> const & req = newlayout->requires();
+ set<string> const & req = newlayout->required();
set<string>::const_iterator it = req.begin();
set<string>::const_iterator en = req.end();
for (; it != en; ++it)
p.skip_spaces();
if (!preamble.titleLayoutFound())
preamble.titleLayoutFound(newlayout->intitle);
- set<string> const & req = newlayout->requires();
+ set<string> const & req = newlayout->required();
for (set<string>::const_iterator it = req.begin(); it != req.end(); ++it)
preamble.registerAutomaticallyLoadedPackage(*it);
continue;
p.skip_spaces();
if (!preamble.titleLayoutFound())
preamble.titleLayoutFound(newlayout->intitle);
- set<string> const & req = newlayout->requires();
+ set<string> const & req = newlayout->required();
for (set<string>::const_iterator it = req.begin(); it != req.end(); ++it)
preamble.registerAutomaticallyLoadedPackage(*it);
continue;
p.skip_spaces();
if (!preamble.titleLayoutFound())
preamble.titleLayoutFound(newlayout->intitle);
- set<string> const & req = newlayout->requires();
+ set<string> const & req = newlayout->required();
for (set<string>::const_iterator it = req.begin(); it != req.end(); ++it)
preamble.registerAutomaticallyLoadedPackage(*it);
continue;
if (opts.find("width") != opts.end())
os << "\twidth "
<< translate_len(opts["width"]) << '\n';
- if (opts.find("height") != opts.end())
+ if (opts.find("totalheight") != opts.end())
os << "\theight "
- << translate_len(opts["height"]) << '\n';
+ << translate_len(opts["totalheight"]) << '\n';
if (opts.find("scale") != opts.end()) {
istringstream iss(opts["scale"]);
double val;
vector<string>::const_iterator s =
find(keys.begin(), keys.end(), "width");
if (s == keys.end())
- s = find(keys.begin(), keys.end(), "height");
+ s = find(keys.begin(), keys.end(), "totalheight");
if (s == keys.end())
s = find(keys.begin(), keys.end(), "scale");
if (s != keys.end() && distance(s, a) > 0)
special << "trim,";
if (opts.find("viewport") != opts.end())
special << "viewport=" << opts["viewport"] << ',';
- if (opts.find("totalheight") != opts.end())
- special << "totalheight=" << opts["totalheight"] << ',';
+ if (opts.find("height") != opts.end())
+ special << "height=" << opts["height"] << ',';
if (opts.find("type") != opts.end())
special << "type=" << opts["type"] << ',';
if (opts.find("ext") != opts.end())
if (t.cs() == "listof") {
p.skip_spaces(true);
- string const name = p.get_token().cs();
+ string const name = p.verbatim_item();
if (context.textclass.floats().typeExist(name)) {
context.check_layout(os);
begin_inset(os, "FloatList ");
os << name << "\n";
end_inset(os);
- p.get_token(); // swallow second arg
+ p.verbatim_item(); // swallow second arg
} else
output_ert_inset(os, "\\listof{" + name + "}", context);
continue;
}
+ if (t.cs() == "theendnotes"
+ || (t.cs() == "printendnotes"
+ && p.next_token().asInput() != "*"
+ && !p.hasOpt())) {
+ context.check_layout(os);
+ begin_inset(os, "FloatList endnote\n");
+ end_inset(os);
+ skip_spaces_braces(p);
+ continue;
+ }
+
if ((where = is_known(t.cs(), known_text_font_families))) {
parse_text_attributes(p, os, FLAG_ITEM, outer,
context, "\\family", context.font.family,
continue;
}
- if (t.cs() == "lyxadded" || t.cs() == "lyxdeleted") {
+ if (t.cs() == "lyxadded" || t.cs() == "lyxdeleted" || t.cs() == "lyxobjdeleted"
+ || t.cs() == "lyxdisplayobjdeleted" || t.cs() == "lyxudisplayobjdeleted") {
context.check_layout(os);
+ string initials;
+ if (p.hasOpt()) {
+ initials = p.getArg('[', ']');
+ }
string name = p.getArg('{', '}');
string localtime = p.getArg('{', '}');
- preamble.registerAuthor(name);
+ preamble.registerAuthor(name, initials);
Author const & author = preamble.getAuthor(name);
// from_asctime_utc() will fail if LyX decides to output the
// time in the text language.
os << "\n\\change_deleted ";
os << author.bufferId() << ' ' << ptime << '\n';
parse_text_snippet(p, os, FLAG_ITEM, outer, context);
- bool dvipost = LaTeXPackages::isAvailable("dvipost");
bool xcolorulem = LaTeXPackages::isAvailable("ulem") &&
LaTeXPackages::isAvailable("xcolor");
// No need to test for luatex, since luatex comes in
preamble.registerAutomaticallyLoadedPackage("pdfcolmk");
}
} else {
- if (dvipost) {
- preamble.registerAutomaticallyLoadedPackage("dvipost");
- } else if (xcolorulem) {
+ if (xcolorulem) {
preamble.registerAutomaticallyLoadedPackage("ulem");
preamble.registerAutomaticallyLoadedPackage("xcolor");
}
}
string keys, pretextlist, posttextlist;
if (qualified) {
- map<string, string> pres, posts, preslit, postslit;
+ vector<pair<string, string>> pres, posts, preslit, postslit;
vector<string> lkeys;
// text before the citation
string lbefore, lbeforelit;
// text after the citation
string lafter, lafterlit;
- string lkey;
+ string lkey;
pair<bool, string> laft, lbef;
while (true) {
get_cite_arguments(p, true, lbefore, lafter);
laft = convert_latexed_command_inset_arg(lafter);
literal |= !laft.first;
lafter = laft.second;
- lafterlit = subst(lbefore, "\n", " ");
+ lafterlit = subst(lafter, "\n", " ");
}
if (!lbefore.empty()) {
lbefore.erase(0, 1);
lkey = p.getArg('{', '}');
if (lkey.empty())
break;
- if (!lbefore.empty()) {
- pres.insert(make_pair(lkey, lbefore));
- preslit.insert(make_pair(lkey, lbeforelit));
- }
- if (!lafter.empty()) {
- posts.insert(make_pair(lkey, lafter));
- postslit.insert(make_pair(lkey, lafterlit));
- }
+ pres.push_back(make_pair(lkey, lbefore));
+ preslit.push_back(make_pair(lkey, lbeforelit));
+ posts.push_back(make_pair(lkey, lafter));
+ postslit.push_back(make_pair(lkey, lafterlit));
lkeys.push_back(lkey);
}
keys = convert_literate_command_inset_arg(getStringFromVector(lkeys));
for (auto const & ptl : pres) {
if (!pretextlist.empty())
pretextlist += '\t';
- pretextlist += ptl.first + " " + ptl.second;
+ pretextlist += ptl.first;
+ if (!ptl.second.empty())
+ pretextlist += " " + ptl.second;
}
for (auto const & potl : posts) {
if (!posttextlist.empty())
posttextlist += '\t';
- posttextlist += potl.first + " " + potl.second;
+ posttextlist += potl.first;
+ if (!potl.second.empty())
+ posttextlist += " " + potl.second;
}
} else
keys = convert_literate_command_inset_arg(p.verbatim_item());
if (t.cs() == "newpage" ||
(t.cs() == "pagebreak" && !p.hasOpt()) ||
t.cs() == "clearpage" ||
- t.cs() == "cleardoublepage") {
+ t.cs() == "cleardoublepage" ||
+ t.cs() == "nopagebreak") {
context.check_layout(os);
begin_inset(os, "Newpage ");
os << t.cs();
} else if (unit == "\\bigskipamount") {
unit = "bigskip";
known_vspace = true;
+ } else if (length == "\\baselineskip") {
+ unit = "fullline";
+ known_vspace = true;
} else if (unit == "\\fill") {
unit = "vfill";
known_vspace = true;
}
}
}
+ if (value == 0.5 && t.cs()[0] != 'h' && unit == "\\baselineskip") {
+ unit = "halfline";
+ known_vspace = true;
+ }
if (!known_hspace && !known_vspace) {
switch (unitFromString(unit)) {
case Length::SP:
projects / lyx.git / blobdiff