lyx_mirror/src/LaTeXFeatures.cpp

1732 lines
51 KiB
C++
Raw Normal View History

/**
* \file LaTeXFeatures.cpp
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author José Matos
* \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author Jürgen Vigna
* \author André Pönitz
*
* Full author contact details are available in file CREDITS.
*/
#include <config.h>
#include "LaTeXFeatures.h"
#include "Buffer.h"
#include "BufferParams.h"
#include "ColorSet.h"
#include "Converter.h"
#include "Encoding.h"
#include "Floating.h"
#include "FloatList.h"
#include "Language.h"
#include "LaTeXFonts.h"
#include "LaTeXPackages.h"
#include "Layout.h"
#include "Lexer.h"
#include "LyXRC.h"
#include "TextClass.h"
#include "insets/InsetLayout.h"
#include "support/debug.h"
#include "support/docstream.h"
#include "support/FileName.h"
#include "support/filetools.h"
#include "support/gettext.h"
#include "support/lstrings.h"
#include "support/regex.h"
#include <algorithm>
using namespace std;
using namespace lyx::support;
namespace lyx {
/////////////////////////////////////////////////////////////////////
//
// Strings
//
/////////////////////////////////////////////////////////////////////
//\NeedsTeXFormat{LaTeX2e}
//\ProvidesPackage{lyx}[1996/01/11 LLE v0.2 (LyX LaTeX Extensions)]
//\message{LyX LaTeX Extensions (LLE v0.2) of 11-Jan-1996.}
static docstring const lyx_def = from_ascii(
"\\providecommand{\\LyX}{L\\kern-.1667em\\lower.25em\\hbox{Y}\\kern-.125emX\\@}");
static docstring const lyx_hyperref_def = from_ascii(
"\\providecommand{\\LyX}{\\texorpdfstring%\n"
" {L\\kern-.1667em\\lower.25em\\hbox{Y}\\kern-.125emX\\@}\n"
" {LyX}}");
static docstring const noun_def = from_ascii(
"\\newcommand{\\noun}[1]{\\textsc{#1}}");
static docstring const lyxarrow_def = from_ascii(
"\\DeclareRobustCommand*{\\lyxarrow}{%\n"
"\\@ifstar\n"
"{\\leavevmode\\,$\\triangleleft$\\,\\allowbreak}\n"
"{\\leavevmode\\,$\\triangleright$\\,\\allowbreak}}");
// for quotes without babel. This does not give perfect results, but
// anybody serious about non-english quotes should use babel (JMarc).
static docstring const quotedblbase_def = from_ascii(
"\\ProvideTextCommandDefault{\\quotedblbase}{%\n"
" \\raisebox{-1.4ex}[1ex][.5ex]{\\textquotedblright}%\n"
" \\penalty10000\\hskip0em\\relax%\n"
"}");
static docstring const quotesinglbase_def = from_ascii(
"\\ProvideTextCommandDefault{\\quotesinglbase}{%\n"
" \\raisebox{-1.4ex}[1ex][.5ex]{\\textquoteright}%\n"
" \\penalty10000\\hskip0em\\relax%\n"
"}");
static docstring const guillemotleft_def = from_ascii(
"\\ProvideTextCommandDefault{\\guillemotleft}{%\n"
" {\\usefont{U}{lasy}{m}{n}\\char'50\\kern-.15em\\char'50}%\n"
"\\penalty10000\\hskip0pt\\relax%\n"
"}");
static docstring const guillemotright_def = from_ascii(
"\\ProvideTextCommandDefault{\\guillemotright}{%\n"
" \\penalty10000\\hskip0pt%\n"
" {\\usefont{U}{lasy}{m}{n}\\char'51\\kern-.15em\\char'51}%\n"
"}");
static docstring const guilsinglleft_def = from_ascii(
"\\ProvideTextCommandDefault{\\guilsinglleft}{%\n"
" {\\usefont{U}{lasy}{m}{n}\\char'50}%\n"
" \\penalty10000\\hskip0pt\\relax%\n"
"}");
static docstring const guilsinglright_def = from_ascii(
"\\ProvideTextCommandDefault{\\guilsinglright}{%\n"
" \\penalty10000\\hskip0pt%\n"
" {\\usefont{U}{lasy}{m}{n}\\char'51}%\n"
"}");
static docstring const paragraphleftindent_def = from_ascii(
"\\newenvironment{LyXParagraphLeftIndent}[1]%\n"
"{\n"
" \\begin{list}{}{%\n"
" \\setlength{\\topsep}{0pt}%\n"
" \\addtolength{\\leftmargin}{#1}\n"
// ho hum, yet more things commented out with no hint as to why they
// weren't just removed
// "%% \\addtolength{\\leftmargin}{#1\\textwidth}\n"
// "%% \\setlength{\\textwidth}{#2\\textwidth}\n"
// "%% \\setlength\\listparindent\\parindent%\n"
// "%% \\setlength\\itemindent\\parindent%\n"
" \\setlength{\\parsep}{0pt plus 1pt}%\n"
" }\n"
" \\item[]\n"
"}\n"
"{\\end{list}}\n");
static docstring const floatingfootnote_def = from_ascii(
"%% Special footnote code from the package 'stblftnt.sty'\n"
"%% Author: Robin Fairbairns -- Last revised Dec 13 1996\n"
"\\let\\SF@@footnote\\footnote\n"
"\\def\\footnote{\\ifx\\protect\\@typeset@protect\n"
" \\expandafter\\SF@@footnote\n"
" \\else\n"
" \\expandafter\\SF@gobble@opt\n"
" \\fi\n"
"}\n"
"\\expandafter\\def\\csname SF@gobble@opt \\endcsname{\\@ifnextchar[%]\n"
" \\SF@gobble@twobracket\n"
" \\@gobble\n"
"}\n"
"\\edef\\SF@gobble@opt{\\noexpand\\protect\n"
" \\expandafter\\noexpand\\csname SF@gobble@opt \\endcsname}\n"
"\\def\\SF@gobble@twobracket[#1]#2{}\n");
static docstring const binom_def = from_ascii(
"%% Binom macro for standard LaTeX users\n"
"\\newcommand{\\binom}[2]{{#1 \\choose #2}}\n");
static docstring const mathcircumflex_def = from_ascii(
"%% For printing a cirumflex inside a formula\n"
"\\newcommand{\\mathcircumflex}[0]{\\mbox{\\^{}}}\n");
static docstring const tabularnewline_def = from_ascii(
"%% Because html converters don't know tabularnewline\n"
"\\providecommand{\\tabularnewline}{\\\\}\n");
static docstring const lyxgreyedout_def = from_ascii(
"%% The greyedout annotation environment\n"
Introduce a wrapper class for odocstream to help ensuring that no blank lines may be inadvertently output. This is achieved by using two special iomanip-like variables (breakln and safebreakln) in the lyx:: namespace. When they are inserted in the stream, a newline is output only if not already at the beginning of a line. The difference between breakln and safebreakln is that, if needed, the former outputs '\n' and the latter "%\n". In future, the new class will also be used for counting the number of newlines issued. Even if the infractrure for doing that is already in place, the counting is essentially still done the old way. There are still places in the code where the functionality of the class could be used, most probably. ATM, it is used for InsetTabular, InsetListings, InsetFloat, and InsetText. The Comment and GreyedOut insets required a special treatment and a new InsetLayout parameter (Display) has been introduced. The default for Display is "true", meaning that the corresponding latex environment is of "display" type, i.e., it stands on its own, whereas "false" means that the contents appear inline with the text. The latter is the case for both Comment and GreyedOut insets. Mostly, the only visible effects on latex exports should be the disappearing of some redundant % chars and the appearing/disappearing of null {} latex groups after a comment or lyxgreyedout environments (they are related to the presence or absence of a space immediately after those environments), as well as the fact that math environments are now started on their own lines. As a last thing, only the latex code between \begin{document} and \end{document} goes through the new class, the preamble being directly output through odocstream, as usual. git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@37360 a592a061-630c-0410-9148-cb99ea01b6c8
2011-01-29 02:41:13 +00:00
"\\newenvironment{lyxgreyedout}\n"
" {\\textcolor{note_fontcolor}\\bgroup\\ignorespaces}\n"
" {\\ignorespacesafterend\\egroup}\n");
// We want to omit the file extension for includegraphics, but this does not
// work when the filename contains other dots.
// Idea from http://www.tex.ac.uk/cgi-bin/texfaq2html?label=unkgrfextn
static docstring const lyxdot_def = from_ascii(
"%% A simple dot to overcome graphicx limitations\n"
"\\newcommand{\\lyxdot}{.}\n");
static docstring const changetracking_dvipost_def = from_ascii(
"%% Change tracking with dvipost\n"
"\\dvipostlayout\n"
"\\dvipost{osstart color push Red}\n"
"\\dvipost{osend color pop}\n"
"\\dvipost{cbstart color push Blue}\n"
"\\dvipost{cbend color pop}\n"
"\\DeclareRobustCommand{\\lyxadded}[3]{\\changestart#3\\changeend}\n"
"\\DeclareRobustCommand{\\lyxdeleted}[3]{%\n"
"\\changestart\\overstrikeon#3\\overstrikeoff\\changeend}\n");
static docstring const changetracking_xcolor_ulem_def = from_ascii(
"%% Change tracking with ulem\n"
"\\DeclareRobustCommand{\\lyxadded}[3]{{\\color{lyxadded}{}#3}}\n"
"\\DeclareRobustCommand{\\lyxdeleted}[3]{{\\color{lyxdeleted}\\sout{#3}}}\n");
static docstring const changetracking_xcolor_ulem_hyperref_def = from_ascii(
"%% Change tracking with ulem\n"
"\\DeclareRobustCommand{\\lyxadded}[3]{{\\texorpdfstring{\\color{lyxadded}{}}{}#3}}\n"
"\\DeclareRobustCommand{\\lyxdeleted}[3]{{\\texorpdfstring{\\color{lyxdeleted}\\sout{#3}}{}}}\n");
static docstring const changetracking_none_def = from_ascii(
"\\newcommand{\\lyxadded}[3]{#3}\n"
"\\newcommand{\\lyxdeleted}[3]{}\n");
static docstring const textgreek_def = from_ascii(
"\\DeclareRobustCommand{\\greektext}{%\n"
" \\fontencoding{LGR}\\selectfont\\def\\encodingdefault{LGR}}\n"
"\\DeclareRobustCommand{\\textgreek}[1]{\\leavevmode{\\greektext #1}}\n"
"\\DeclareFontEncoding{LGR}{}{}\n"
"\\DeclareTextSymbol{\\~}{LGR}{126}");
static docstring const textcyr_def = from_ascii(
"\\DeclareRobustCommand{\\cyrtext}{%\n"
" \\fontencoding{T2A}\\selectfont\\def\\encodingdefault{T2A}}\n"
"\\DeclareRobustCommand{\\textcyr}[1]{\\leavevmode{\\cyrtext #1}}\n"
"\\AtBeginDocument{\\DeclareFontEncoding{T2A}{}{}}\n");
static docstring const lyxmathsym_def = from_ascii(
"\\newcommand{\\lyxmathsym}[1]{\\ifmmode\\begingroup\\def\\b@ld{bold}\n"
" \\text{\\ifx\\math@version\\b@ld\\bfseries\\fi#1}\\endgroup\\else#1\\fi}\n");
static docstring const papersizedvi_def = from_ascii(
"\\special{papersize=\\the\\paperwidth,\\the\\paperheight}\n");
static docstring const papersizepdf_def = from_ascii(
"\\pdfpageheight\\paperheight\n"
"\\pdfpagewidth\\paperwidth\n");
static docstring const cedilla_def = from_ascii(
"\\newcommand{\\docedilla}[2]{\\underaccent{#1\\mathchar'30}{#2}}\n"
"\\newcommand{\\cedilla}[1]{\\mathpalette\\docedilla{#1}}\n");
static docstring const subring_def = from_ascii(
"\\newcommand{\\dosubring}[2]{\\underaccent{#1\\mathchar'27}{#2}}\n"
"\\newcommand{\\subring}[1]{\\mathpalette\\dosubring{#1}}\n");
static docstring const subdot_def = from_ascii(
"\\newcommand{\\dosubdot}[2]{\\underaccent{#1.}{#2}}\n"
"\\newcommand{\\subdot}[1]{\\mathpalette\\dosubdot{#1}}\n");
static docstring const subhat_def = from_ascii(
"\\newcommand{\\dosubhat}[2]{\\underaccent{#1\\mathchar'136}{#2}}\n"
"\\newcommand{\\subhat}[1]{\\mathpalette\\dosubhat{#1}}\n");
static docstring const subtilde_def = from_ascii(
"\\newcommand{\\dosubtilde}[2]{\\underaccent{#1\\mathchar'176}{#2}}\n"
"\\newcommand{\\subtilde}[1]{\\mathpalette\\dosubtilde{#1}}\n");
static docstring const dacute_def = from_ascii(
"\\DeclareMathAccent{\\dacute}{\\mathalpha}{operators}{'175}\n");
static docstring const tipasymb_def = from_ascii(
"\\DeclareFontEncoding{T3}{}{}\n"
"\\DeclareSymbolFont{tipasymb}{T3}{cmr}{m}{n}\n");
static docstring const dgrave_def = from_ascii(
"\\DeclareMathAccent{\\dgrave}{\\mathord}{tipasymb}{'15}\n");
static docstring const rcap_def = from_ascii(
"\\DeclareMathAccent{\\rcap}{\\mathord}{tipasymb}{'20}\n");
static docstring const ogonek_def = from_ascii(
"\\newcommand{\\doogonek}[2]{\\setbox0=\\hbox{$#1#2$}\\underaccent{#1\\mkern-6mu\n"
" \\ifx#2O\\hskip0.5\\wd0\\else\\ifx#2U\\hskip0.5\\wd0\\else\\hskip\\wd0\\fi\\fi\n"
" \\ifx#2o\\mkern-2mu\\else\\ifx#2e\\mkern-1mu\\fi\\fi\n"
" \\mathchar\"0\\hexnumber@\\symtipasymb0C}{#2}}\n"
"\\newcommand{\\ogonek}[1]{\\mathpalette\\doogonek{#1}}\n");
static docstring const lyxref_def = from_ascii(
"\\RS@ifundefined{subref}\n"
" {\\def\\RSsubtxt{section~}\\newref{sub}{name = \\RSsubtxt}}\n"
" {}\n"
"\\RS@ifundefined{thmref}\n"
" {\\def\\RSthmtxt{theorem~}\\newref{thm}{name = \\RSthmtxt}}\n"
" {}\n"
"\\RS@ifundefined{lemref}\n"
" {\\def\\RSlemtxt{lemma~}\\newref{lem}{name = \\RSlemtxt}}\n"
" {}\n");
// Make sure the columns are also outputed as rtl
static docstring const rtloutputdblcol_def = from_ascii(
"\\def\\@outputdblcol{%\n"
" \\if@firstcolumn\n"
" \\global \\@firstcolumnfalse\n"
" \\global \\setbox\\@leftcolumn \\box\\@outputbox\n"
" \\else\n"
" \\global \\@firstcolumntrue\n"
" \\setbox\\@outputbox \\vbox {%\n"
" \\hb@xt@\\textwidth {%\n"
" \\kern\\textwidth \\kern-\\columnwidth %**\n"
" \\hb@xt@\\columnwidth {%\n"
" \\box\\@leftcolumn \\hss}%\n"
" \\kern-\\textwidth %**\n"
" \\hfil\n"
" {\\normalcolor\\vrule \\@width\\columnseprule}%\n"
" \\hfil\n"
" \\kern-\\textwidth %**\n"
" \\hb@xt@\\columnwidth {%\n"
" \\box\\@outputbox \\hss}%\n"
" \\kern-\\columnwidth \\kern\\textwidth %**\n"
" }%\n"
" }%\n"
" \\@combinedblfloats\n"
" \\@outputpage\n"
" \\begingroup\n"
" \\@dblfloatplacement\n"
" \\@startdblcolumn\n"
" \\@whilesw\\if@fcolmade \\fi\n"
" {\\@outputpage\n"
" \\@startdblcolumn}%\n"
" \\endgroup\n"
" \\fi\n"
"}\n"
"\\@mparswitchtrue\n");
/////////////////////////////////////////////////////////////////////
//
// LyXHTML strings
//
/////////////////////////////////////////////////////////////////////
static docstring const lyxnoun_style = from_ascii(
"dfn.lyxnoun {\n"
" font-variant: small-caps;\n"
"}\n");
// this is how it normally renders, but it might not always do so.
static docstring const lyxstrikeout_style = from_ascii(
"del.strikeout {\n"
" text-decoration: line-through;\n"
"}\n");
/////////////////////////////////////////////////////////////////////
//
// LaTeXFeatures
//
/////////////////////////////////////////////////////////////////////
LaTeXFeatures::LaTeXFeatures(Buffer const & b, BufferParams const & p,
OutputParams const & r)
: buffer_(&b), params_(p), runparams_(r), in_float_(false)
{}
LaTeXFeatures::LangPackage LaTeXFeatures::langPackage() const
{
string const local_lp = bufferParams().lang_package;
// Locally, custom is just stored as a string
// in bufferParams().lang_package.
if (local_lp != "auto"
&& local_lp != "babel"
&& local_lp != "default"
&& local_lp != "none")
return LANG_PACK_CUSTOM;
if (local_lp == "none")
return LANG_PACK_NONE;
/* If "auto" is selected, we load polyglossia if required,
* else we select babel.
* If babel is selected (either directly or via the "auto"
* mechanism), we really do only require it if we have
* a language that needs it.
*/
bool const polyglossia_required =
isRequired("polyglossia")
&& isAvailable("polyglossia")
&& !isProvided("babel")
&& this->hasOnlyPolyglossiaLanguages();
bool const babel_required =
!bufferParams().language->babel().empty()
|| !this->getBabelLanguages().empty();
if (local_lp == "auto") {
// polyglossia requirement has priority over babel
if (polyglossia_required)
return LANG_PACK_POLYGLOSSIA;
else if (babel_required)
return LANG_PACK_BABEL;
}
if (local_lp == "babel") {
if (babel_required)
return LANG_PACK_BABEL;
}
if (local_lp == "default") {
switch (lyxrc.language_package_selection) {
case LyXRC::LP_AUTO:
// polyglossia requirement has priority over babel
if (polyglossia_required)
return LANG_PACK_POLYGLOSSIA;
else if (babel_required)
return LANG_PACK_BABEL;
2012-08-08 09:27:37 +00:00
break;
case LyXRC::LP_BABEL:
if (babel_required)
return LANG_PACK_BABEL;
2012-08-08 09:27:37 +00:00
break;
case LyXRC::LP_CUSTOM:
return LANG_PACK_CUSTOM;
case LyXRC::LP_NONE:
return LANG_PACK_NONE;
}
}
return LANG_PACK_NONE;
}
void LaTeXFeatures::require(string const & name)
{
features_.insert(name);
}
void LaTeXFeatures::require(set<string> const & names)
{
features_.insert(names.begin(), names.end());
}
void LaTeXFeatures::useLayout(docstring const & layoutname)
{
useLayout(layoutname, 0);
}
void LaTeXFeatures::useLayout(docstring const & layoutname, int level)
{
// Some code to avoid loops in dependency definition
const int maxlevel = 30;
if (level > maxlevel) {
lyxerr << "LaTeXFeatures::useLayout: maximum level of "
<< "recursion attained by layout "
<< to_utf8(layoutname) << endl;
return;
}
DocumentClass const & tclass = params_.documentClass();
if (tclass.hasLayout(layoutname)) {
// Is this layout already in usedLayouts?
if (find(usedLayouts_.begin(), usedLayouts_.end(), layoutname)
!= usedLayouts_.end())
return;
Layout const & layout = tclass[layoutname];
require(layout.requires());
if (!layout.depends_on().empty()) {
useLayout(layout.depends_on(), level + 1);
}
usedLayouts_.push_back(layoutname);
} else {
lyxerr << "LaTeXFeatures::useLayout: layout `"
<< to_utf8(layoutname) << "' does not exist in this class"
<< endl;
}
}
void LaTeXFeatures::useInsetLayout(InsetLayout const & lay)
{
docstring const & lname = lay.name();
DocumentClass const & tclass = params_.documentClass();
// this is a default inset layout, nothing useful here
if (!tclass.hasInsetLayout(lname))
return;
// Is this layout already in usedInsetLayouts?
if (find(usedInsetLayouts_.begin(), usedInsetLayouts_.end(), lname)
!= usedInsetLayouts_.end())
return;
require(lay.requires());
usedInsetLayouts_.push_back(lname);
}
bool LaTeXFeatures::isRequired(string const & name) const
{
return features_.find(name) != features_.end();
}
bool LaTeXFeatures::isProvided(string const & name) const
{
if (params_.useNonTeXFonts)
return params_.documentClass().provides(name);
bool const ot1 = (params_.font_encoding() == "default"
|| params_.font_encoding() == "OT1");
bool const complete = (params_.fonts_sans == "default")
&& (params_.fonts_typewriter == "default");
bool const nomath = (params_.fonts_math == "default");
return params_.documentClass().provides(name)
|| theLaTeXFonts().getLaTeXFont(
from_ascii(params_.fonts_roman)).provides(name, ot1,
complete,
nomath)
|| theLaTeXFonts().getLaTeXFont(
from_ascii(params_.fonts_sans)).provides(name, ot1,
complete,
nomath)
|| theLaTeXFonts().getLaTeXFont(
from_ascii(params_.fonts_typewriter)).provides(name, ot1,
2012-09-23 15:40:44 +00:00
complete,
nomath)
|| theLaTeXFonts().getLaTeXFont(
from_ascii(params_.fonts_math)).provides(name, ot1,
complete,
nomath);
}
bool LaTeXFeatures::mustProvide(string const & name) const
{
return isRequired(name) && !isProvided(name);
}
bool LaTeXFeatures::isAvailable(string const & name)
{
string::size_type const i = name.find("->");
if (i != string::npos) {
string const from = name.substr(0,i);
string const to = name.substr(i+2);
//LYXERR0("from=[" << from << "] to=[" << to << "]");
return theConverters().isReachable(from, to);
}
return LaTeXPackages::isAvailable(name);
}
void LaTeXFeatures::addPreambleSnippet(string const & preamble)
{
SnippetList::const_iterator begin = preamble_snippets_.begin();
SnippetList::const_iterator end = preamble_snippets_.end();
if (find(begin, end, preamble) == end)
preamble_snippets_.push_back(preamble);
}
void LaTeXFeatures::addCSSSnippet(std::string const & snippet)
{
SnippetList::const_iterator begin = css_snippets_.begin();
SnippetList::const_iterator end = css_snippets_.end();
if (find(begin, end, snippet) == end)
css_snippets_.push_back(snippet);
}
void LaTeXFeatures::useFloat(string const & name, bool subfloat)
{
if (!usedFloats_[name])
usedFloats_[name] = subfloat;
if (subfloat)
require("subfig");
// We only need float.sty if we use non builtin floats, or if we
// use the "H" modifier. This includes modified table and
// figure floats. (Lgb)
Floating const & fl = params_.documentClass().floats().getType(name);
if (!fl.floattype().empty() && fl.usesFloatPkg()) {
require("float");
}
}
void LaTeXFeatures::useLanguage(Language const * lang)
{
if (!lang->babel().empty() || !lang->polyglossia().empty())
UsedLanguages_.insert(lang);
2012-06-09 09:32:34 +00:00
if (!lang->requires().empty())
require(lang->requires());
// CJK languages do not have a babel name.
// They use the CJK package
if (lang->encoding()->package() == Encoding::CJK)
require("CJK");
// japanese package is special
if (lang->encoding()->package() == Encoding::japanese)
require("japanese");
}
void LaTeXFeatures::includeFile(docstring const & key, string const & name)
{
IncludedFiles_[key] = name;
}
bool LaTeXFeatures::hasLanguages() const
{
return !UsedLanguages_.empty();
}
bool LaTeXFeatures::hasOnlyPolyglossiaLanguages() const
{
// first the main language
if (params_.language->polyglossia().empty())
return false;
// now the secondary languages
LanguageList::const_iterator const begin = UsedLanguages_.begin();
for (LanguageList::const_iterator cit = begin;
cit != UsedLanguages_.end();
++cit) {
if ((*cit)->polyglossia().empty())
return false;
}
return true;
}
bool LaTeXFeatures::hasPolyglossiaExclusiveLanguages() const
{
// first the main language
if (params_.language->isPolyglossiaExclusive())
return true;
// now the secondary languages
LanguageList::const_iterator const begin = UsedLanguages_.begin();
for (LanguageList::const_iterator cit = begin;
cit != UsedLanguages_.end();
++cit) {
if ((*cit)->isPolyglossiaExclusive())
return true;
}
return false;
}
string LaTeXFeatures::getBabelLanguages() const
{
ostringstream languages;
bool first = true;
LanguageList::const_iterator const begin = UsedLanguages_.begin();
for (LanguageList::const_iterator cit = begin;
cit != UsedLanguages_.end();
++cit) {
if ((*cit)->babel().empty())
continue;
if (!first)
languages << ',';
else
first = false;
languages << (*cit)->babel();
}
return languages.str();
}
std::map<std::string, std::string> LaTeXFeatures::getPolyglossiaLanguages() const
{
std::map<std::string, std::string> languages;
LanguageList::const_iterator const begin = UsedLanguages_.begin();
for (LanguageList::const_iterator cit = begin;
cit != UsedLanguages_.end();
++cit) {
languages[(*cit)->polyglossia()] = (*cit)->polyglossiaOpts();
}
return languages;
}
set<string> LaTeXFeatures::getEncodingSet(string const & doc_encoding) const
{
// This does only find encodings of languages supported by babel, but
// that does not matter since we don't have a language with an
// encoding supported by inputenc but without babel support.
set<string> encodings;
LanguageList::const_iterator it = UsedLanguages_.begin();
LanguageList::const_iterator end = UsedLanguages_.end();
for (; it != end; ++it)
if ((*it)->encoding()->latexName() != doc_encoding &&
((*it)->encoding()->package() == Encoding::inputenc
|| (*it)->encoding()->package() == Encoding::japanese))
encodings.insert((*it)->encoding()->latexName());
return encodings;
}
namespace {
char const * simplefeatures[] = {
// note that the package order here will be the same in the LaTeX-output
"array",
"verbatim",
"longtable",
"rotating",
"latexsym",
"pifont",
// subfig is handled in BufferParams.cpp
"varioref",
"prettyref",
"refstyle",
/*For a successful cooperation of the `wrapfig' package with the
`float' package you should load the `wrapfig' package *after*
the `float' package. See the caption package documentation
for explanation.*/
"float",
"rotfloat",
"wrapfig",
"booktabs",
"dvipost",
"fancybox",
"calc",
"units",
"framed",
"soul",
"textcomp",
"pmboxdraw",
"bbding",
"ifsym",
"marvosym",
"txfonts",
"pxfonts",
"mathdesign",
"mathrsfs",
"mathabx",
"mathtools",
// "cancel",
"ascii",
"url",
"covington",
"csquotes",
"enumitem",
"endnotes",
"hhline",
"ifthen",
// listings is handled in BufferParams.cpp
"bm",
"pdfpages",
"amscd",
"slashed",
"multicol",
"multirow",
"tfrupee",
"shapepar",
"rsphrase",
"algorithm2e",
"sectionbox",
"tcolorbox",
"pdfcomment"
};
char const * bibliofeatures[] = {
// Known bibliography packages (will be loaded before natbib)
"achicago",
"apacite",
"apalike",
"astron",
"authordate1-4",
"babelbib",
"bibgerm",
"chicago",
"chscite",
"harvard",
"mslapa",
"named"
};
int const nb_bibliofeatures = sizeof(bibliofeatures) / sizeof(char const *);
int const nb_simplefeatures = sizeof(simplefeatures) / sizeof(char const *);
}
string const LaTeXFeatures::getColorOptions() const
{
ostringstream colors;
// Handling the color packages separately is needed to be able to load them
// before babel when hyperref is loaded with the colorlinks option
// for more info see Bufferparams.cpp
// [x]color.sty
if (mustProvide("color") || mustProvide("xcolor")) {
string const package =
(mustProvide("xcolor") ? "xcolor" : "color");
if (params_.graphics_driver == "default"
|| params_.graphics_driver == "none")
colors << "\\usepackage{" << package << "}\n";
else
colors << "\\usepackage["
<< params_.graphics_driver
<< "]{" << package << "}\n";
}
// pdfcolmk must be loaded after color
if (mustProvide("pdfcolmk"))
colors << "\\usepackage{pdfcolmk}\n";
// the following 3 color commands must be set after color
// is loaded and before pdfpages, therefore add the command
// here define the set color
if (mustProvide("pagecolor")) {
colors << "\\definecolor{page_backgroundcolor}{rgb}{";
colors << outputLaTeXColor(params_.backgroundcolor) << "}\n";
// set the page color
colors << "\\pagecolor{page_backgroundcolor}\n";
}
if (mustProvide("fontcolor")) {
colors << "\\definecolor{document_fontcolor}{rgb}{";
colors << outputLaTeXColor(params_.fontcolor) << "}\n";
// set the color
colors << "\\color{document_fontcolor}\n";
}
if (mustProvide("lyxgreyedout")) {
colors << "\\definecolor{note_fontcolor}{rgb}{";
colors << outputLaTeXColor(params_.notefontcolor) << "}\n";
// the color will be set together with the definition of
// the lyxgreyedout environment (see lyxgreyedout_def)
}
// color for shaded boxes
if (isRequired("framed") && mustProvide("color")) {
colors << "\\definecolor{shadecolor}{rgb}{";
colors << outputLaTeXColor(params_.boxbgcolor) << "}\n";
// this color is automatically used by the LaTeX-package "framed"
}
return colors.str();
}
string const LaTeXFeatures::getPackages() const
{
ostringstream packages;
// FIXME: currently, we can only load packages and macros known
// to LyX.
// However, with the Require tag of layouts/custom insets,
// also unknown packages can be requested. They are silently
// swallowed now. We should change this eventually.
// Output all the package option stuff we have been asked to do.
2013-05-23 13:39:16 +00:00
map<string, string>::const_iterator it =
params_.documentClass().packageOptions().begin();
2013-05-23 13:39:16 +00:00
map<string, string>::const_iterator en =
params_.documentClass().packageOptions().end();
for (; it != en; ++it)
if (mustProvide(it->first))
2013-05-23 13:39:16 +00:00
packages << "\\PassOptionsToPackage{" << it->second << "}"
<< "{" << it->first << "}\n";
// These are all the 'simple' includes. i.e
// packages which we just \usepackage{package}
for (int i = 0; i < nb_simplefeatures; ++i) {
if (mustProvide(simplefeatures[i]))
packages << "\\usepackage{" << simplefeatures[i] << "}\n";
}
// The rest of these packages are somewhat more complicated
// than those above.
2013-12-14 14:09:23 +00:00
// The tipa package and its extensions (tipx, tone) must not
// be loaded with non-TeX fonts, since fontspec includes the
// respective macros
if (mustProvide("tipa") && !params_.useNonTeXFonts)
packages << "\\usepackage{tipa}\n";
if (mustProvide("tipx") && !params_.useNonTeXFonts)
packages << "\\usepackage{tipx}\n";
if (mustProvide("tone") && !params_.useNonTeXFonts)
packages << "\\usepackage{tone}\n";
// if fontspec or newtxmath is used, AMS packages have to be loaded
// before fontspec (in BufferParams)
string const amsPackages = loadAMSPackages();
bool const ot1 = (params_.font_encoding() == "default" || params_.font_encoding() == "OT1");
bool const use_newtxmath =
theLaTeXFonts().getLaTeXFont(from_ascii(params_.fonts_math)).getUsedPackage(
ot1, false, false) == "newtxmath";
if (!params_.useNonTeXFonts && !use_newtxmath && !amsPackages.empty())
packages << amsPackages;
// fixltx2e must be loaded after amsthm, since amsthm produces an error with
// the redefined \[ command (bug 7233). Load it as early as possible, since
// other packages might profit from it.
if (mustProvide("fixltx2e"))
packages << "\\usepackage{fixltx2e}\n";
if (mustProvide("cancel") &&
params_.use_package("cancel") != BufferParams::package_off)
packages << "\\usepackage{cancel}\n";
// accents must be loaded after amsmath
if (mustProvide("accents") &&
params_.use_package("accents") != BufferParams::package_off)
packages << "\\usepackage{accents}\n";
// mathdots must be loaded after amsmath
if (mustProvide("mathdots") &&
params_.use_package("mathdots") != BufferParams::package_off)
packages << "\\usepackage{mathdots}\n";
// yhmath must be loaded after amsmath
if (mustProvide("yhmath") &&
params_.use_package("yhmath") != BufferParams::package_off)
packages << "\\usepackage{yhmath}\n";
// stmaryrd must be loaded after amsmath
if (mustProvide("stmaryrd") &&
params_.use_package("stmaryrd") != BufferParams::package_off)
packages << "\\usepackage{stmaryrd}\n";
if (mustProvide("stackrel") &&
params_.use_package("stackrel") != BufferParams::package_off)
packages << "\\usepackage{stackrel}\n";
if (mustProvide("undertilde") &&
params_.use_package("undertilde") != BufferParams::package_off)
packages << "\\usepackage{undertilde}\n";
// [x]color and pdfcolmk are handled in getColorOptions() above
// makeidx.sty
if (isRequired("makeidx") || isRequired("splitidx")) {
if (!isProvided("makeidx") && !isRequired("splitidx"))
packages << "\\usepackage{makeidx}\n";
if (mustProvide("splitidx"))
packages << "\\usepackage{splitidx}\n";
packages << "\\makeindex\n";
}
// graphicx.sty
if (mustProvide("graphicx") && params_.graphics_driver != "none") {
if (params_.graphics_driver == "default")
packages << "\\usepackage{graphicx}\n";
else
packages << "\\usepackage["
<< params_.graphics_driver
<< "]{graphicx}\n";
}
// lyxskak.sty --- newer chess support based on skak.sty
if (mustProvide("chess"))
packages << "\\usepackage[ps,mover]{lyxskak}\n";
// setspace.sty
if (mustProvide("setspace") && !isProvided("SetSpace"))
packages << "\\usepackage{setspace}\n";
// we need to assure that mhchem is loaded before esint and every other
// package that redefines command of amsmath because mhchem loads amlatex
// (this info is from the author of mhchem from June 2013)
if (mustProvide("mhchem") &&
params_.use_package("mhchem") != BufferParams::package_off)
packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
"\\usepackage{mhchem}\n";
// wasysym is a simple feature, but it must be after amsmath if both
// are used
// wasysym redefines some integrals (e.g. iint) from amsmath. That
// leads to inconsistent integrals. We only load this package if
// the document does not contain integrals (then isRequired("esint")
// is false) or if esint is used, since esint redefines all relevant
// integral symbols from wasysym and amsmath.
// See http://www.lyx.org/trac/ticket/1942
if (mustProvide("wasysym") &&
params_.use_package("wasysym") != BufferParams::package_off &&
(params_.use_package("esint") != BufferParams::package_off || !isRequired("esint")))
packages << "\\usepackage{wasysym}\n";
// esint must be after amsmath (and packages requiring amsmath, like mhchem)
// and wasysym, since it will redeclare inconsistent integral symbols
if (mustProvide("esint") &&
params_.use_package("esint") != BufferParams::package_off)
Add support for the esint package * src/LaTeXFeatures.C (LaTeXFeatures::getPackages): handle esint and wasysym * src/mathed/MathMacroTable.[Ch] (requires_): New member: tell the feature this macro requires (MacroTable::insert): take new requires arg * src/mathed/MathMacroTemplate.C (MathMacroTemplate::asMacroData): adjust to change above * src/mathed/MathSupport.C (fontinfos): add esint10 font * src/mathed/InsetMathHull.C (InsetMathHull::doDispatch): AMS_ON -> package_on * src/mathed/MathMacroTable.h * src/mathed/MathFactory.C (initSymbols): read and store requires field for symbols * src/mathed/InsetMathSymbol.C (InsetMathSymbol::metrics): handle esint (InsetMathSymbol::takesLimits): ditto * src/buffer.C (LYX_FORMAT): update format (Buffer::validate): handle esint, AMS_ON -> package_on * src/bufferparams.C: (AMSTranslator): Rename to PackageTranslator (BufferParams::readToken): Read \use_esint (BufferParams::writeFile): Write \use_esint * src/frontends/qt4/QDocumentDialog.C: handle esint * src/frontends/qt4/ui/MathsUi.ui : add esint checkboxes * src/frontends/qt4/GuiFontLoader.C (symbol_fonts: Add esint10 font (symbolFamily): handle esint10 font (isChosenFont): Add comment * src/frontends/controllers/ControlMath.C (latex_varsz): Add new integral symbols * src/support/fontutils.C (win_fonts_truetype): Add esint10 font * src/bufferparams.h (enum AMS): rename to enum Package (use_esint): new parameter * src/lyxfont.[Ch]: Add esint font * lib/symbols: Add new integral symbols * lib/lyx2lyx/LyX.py (format_relation): Update format * lib/lyx2lyx/lyx_1_5.py: handle new format * lib/chkconfig.ltx: Test esint package * lib/images/math/oiintop.xpm * lib/images/math/sqintop.xpm * lib/images/math/sqint.xpm * lib/images/math/ointctrclockwiseop.xpm * lib/images/math/ointctrclockwise.xpm * lib/images/math/iiintop.xpm * lib/images/math/iintop.xpm * lib/images/math/sqiint.xpm * lib/images/math/iiint.xpm * lib/images/math/ointclockwiseop.xpm * lib/images/math/oiint.xpm * lib/images/math/dotsintop.xpm * lib/images/math/sqiintop.xpm * lib/images/math/ointclockwise.xpm * lib/images/math/iiiintop.xpm * lib/images/math/dotsint.xpm * lib/images/math/iiiint.xpm * lib/images/math/iint.xpm: new icons * lib/doc/LaTeXConfig.lyx.in: Add docs for esint package * lib/doc/UserGuide.lyx: Add short documentation of integral symbols * lib/Makefile.am: Add new files * development/scons/scons_manifest.py: ditto git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@15907 a592a061-630c-0410-9148-cb99ea01b6c8
2006-11-13 17:35:18 +00:00
packages << "\\usepackage{esint}\n";
// Known bibliography packages (simple \usepackage{package})
for (int i = 0; i < nb_bibliofeatures; ++i) {
if (mustProvide(bibliofeatures[i]))
packages << "\\usepackage{"
<< bibliofeatures[i] << "}\n";
}
// Compatibility between achicago and natbib
if (mustProvide("achicago") && mustProvide("natbib"))
packages << "\\let\\achicagobib\\thebibliography\n";
// natbib.sty
// Some classes load natbib themselves, but still allow (or even require)
// plain numeric citations (ReVTeX is such a case, see bug 5182).
// This special case is indicated by the "natbib-internal" key.
if (mustProvide("natbib") && !isProvided("natbib-internal")) {
packages << "\\usepackage[";
if (params_.citeEngineType() == ENGINE_TYPE_NUMERICAL)
packages << "numbers";
else
packages << "authoryear";
packages << "]{natbib}\n";
}
// Compatibility between achicago and natbib
if (mustProvide("achicago") && mustProvide("natbib")) {
packages << "\\let\\thebibliography\\achicagobib\n";
packages << "\\let\\SCcite\\astroncite\n";
packages << "\\let\\UnexpandableProtect\\protect\n";
}
// jurabib -- we need version 0.6 at least.
if (mustProvide("jurabib"))
packages << "\\usepackage{jurabib}[2004/01/25]\n";
// opcit -- we pass custombst as we output \bibliographystyle ourselves
if (mustProvide("opcit")) {
if (isRequired("hyperref"))
packages << "\\usepackage[custombst,hyperref]{opcit}\n";
else
packages << "\\usepackage[custombst]{opcit}\n";
}
// xargs -- we need version 1.09 at least
if (mustProvide("xargs"))
packages << "\\usepackage{xargs}[2008/03/08]\n";
if (mustProvide("xy"))
packages << "\\usepackage[all]{xy}\n";
if (mustProvide("feyn"))
packages << "\\usepackage{feyn}\n"; //Diagram
if (mustProvide("ulem"))
packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
"\\usepackage{ulem}\n";
if (mustProvide("nomencl")) {
// Make it work with the new and old version of the package,
// but don't use the compatibility option since it is
// incompatible to other packages.
packages << "\\usepackage{nomencl}\n"
"% the following is useful when we have the old nomencl.sty package\n"
"\\providecommand{\\printnomenclature}{\\printglossary}\n"
"\\providecommand{\\makenomenclature}{\\makeglossary}\n"
"\\makenomenclature\n";
New nomenclature inset from Ugras * src/LyXAction.C (LyXAction::init): Add LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT * src/insets/insetbase.C (build_translator): ditto * src/LaTeXFeatures.C (LaTeXFeatures::getPackages): Add nomencl * src/insets/insetnomencl.[Ch]: new insets InsetNomencl and InsetPrintNomencl * src/insets/insetbase.h: Add NOMENCL_CODE and NOMENCL_PRINT_CODE * src/insets/insetcommandparams.C (InsetCommandParams::findInfo): Add nomenclature and printnomenclature (InsetCommandParams::getCommand): Extend end of command protection to cover commands with only optional arguments like printnomenclature * src/insets/insetert.C (InsetERT::getStatus): disable LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT * src/insets/Makefile.am: Add new files * src/frontends/qt4/Makefile.dialogs: ditto * src/frontends/qt4/Makefile.am: ditto * src/factory.C (createInset): Handle InsetNomencl and InsetPrintNomencl (readInset): ditto * src/buffer.C (LYX_FORMAT): increase * src/lyxfunc.C (LyXFunc::dispatch): Handle nomenclature * src/LaTeX.C (LaTeX::deleteFilesOnError): Delete .nls file (LaTeX::run): Run makeindex for nomenclature (LaTeX::runMakeIndex): handle nomenclature options (LaTeX::deplog): Recognize nomenclature file * src/frontends/qt4/QNomenclDialog.[Ch]: new * src/frontends/qt4/QNomencl.[Ch]: ditto * src/frontends/qt4/ui/QNomenclUi.ui: ditto * src/frontends/qt4/Dialogs.C (Dialogs::build): handle nomenclature dialog * src/text3.C (LyXText::dispatch): Handle LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT (LyXText::getStatus): Ditto * src/lfuns.h (kb_action): Add LFUN_NOMENCL_INSERT and LFUN_NOMENCL_PRINT * lib/lyx2lyx/LyX.py (format_relation): Update 1.5 format range * lib/lyx2lyx/lyx_1_5.py (revert_nomenclature): New (revert_printnomenclature): ditto * lib/chkconfig.ltx: Test for nomencl package * lib/doc/LaTeXConfig.lyx.in: Add nomencl package * lib/doc/Extended.lyx: Add documentation for nomencl * lib/ui/stdtoolbars.ui (Toolbar "extra" "Extra"): Add nomencl-insert * lib/ui/classic.ui: Add nomencl-insert and nomencl-print * lib/ui/stdmenus.ui: ditto * development/scons/scons_manifest.py: Add new files * development/FORMAT: Describe new format git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@15739 a592a061-630c-0410-9148-cb99ea01b6c8
2006-11-04 17:55:36 +00:00
}
Add support for listings package. Two listings command \lstinline, \lstinputlisting and an environment \lstlisting are supported, along with preamble \lstset. \lstinputlisting is implemented through Include dialog, and the other two are implemented with a new inset listings, along with its dialog. * src/LyXAction.cpp: listing-insert action * src/insets/Inset.h,cpp: LISTINGS_CODE * src/insets/InsetInclude.cpp: handle \lstinputlisting * src/insets/InsetListings.h,cpp: new listings inset * src/insets/InsetListingsParams.h,cpp: parameters from listings package * src/insets/InsetCommandParams.h,cpp: handle lstinputlisting option * src/Bidi.cpp: handle LISTINGS_CODE * src/frontends/qt4/ui/TextLayoutUi.ui: update UI * src/frontends/qt4/ui/ListingsUi.ui: new dialog * src/frontends/qt4/ui/IncludeUi.ui: update UI * src/frontends/qt4/QInclude.h,cpp: add lstinputlisting * src/frontends/qt4/QDocument.h,cpp: add textedit for preamble listings_params * src/frontends/qt4/QListings.h,cpp: new listings inset * src/frontends/qt4/Dialogs.cpp: new listings dialog * src/frontends/controllers/ControlInclude.h,cpp: add lstinputlisting * src/frontends/controllers/ControlListings.h,cpp: new listings inset * src/LyXFunc.cpp: handle LISTING_CODE * src/Paragraph.cpp: handle LISTING_CODE * src/factory.cpp: new listings inset * src/CutAndPaste.cpp: handle LISTINGS_CODE * src/LaTeXFeatures.cpp: require listings * src/Text3.cpp: Handle LISTINGS_CODE * src/lfuns.h: add LFUN_LISTING_INSERT * src/Buffer.cpp: change lyx file format to 269 * src/BufferParams.h,cpp: add listings_params to preamble * lib/lyx2lyx/LyX.py: lyx2lyx * lib/lyx2lyx/lyx_1_5.py: lyx2lyx * lib/ui/stdmenus.inc: new menu item (no shortcut!) * src/insets/Makefile.am: update autotools * src/frontends/controllers/Makefile.am * src/frontends/qt4/Makefile.dialogs * src/frontends/qt4/Makefile.am * po/POTFILES.in: a few more translatable files. * development/scons/scons_manifest.py: scons build system * development/FORMAT: document format changes git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@18243 a592a061-630c-0410-9148-cb99ea01b6c8
2007-05-09 19:11:42 +00:00
// fixltx2e provides subscript
if (mustProvide("subscript") && !isRequired("fixltx2e"))
packages << "\\usepackage{subscript}\n";
return packages.str();
}
string LaTeXFeatures::getPreambleSnippets() const
{
ostringstream snip;
SnippetList::const_iterator pit = preamble_snippets_.begin();
SnippetList::const_iterator pend = preamble_snippets_.end();
for (; pit != pend; ++pit)
snip << *pit << '\n';
return snip.str();
}
std::string LaTeXFeatures::getCSSSnippets() const
{
ostringstream snip;
SnippetList::const_iterator pit = css_snippets_.begin();
SnippetList::const_iterator pend = css_snippets_.end();
for (; pit != pend; ++pit)
snip << *pit << '\n';
return snip.str();
}
docstring const LaTeXFeatures::getMacros() const
{
odocstringstream macros;
if (!preamble_snippets_.empty()) {
macros << '\n';
macros << from_utf8(getPreambleSnippets());
}
if (mustProvide("papersize")) {
if (runparams_.flavor == OutputParams::LATEX)
macros << papersizedvi_def << '\n';
else
macros << papersizepdf_def << '\n';
}
if (mustProvide("LyX")) {
if (isRequired("hyperref"))
macros << lyx_hyperref_def << '\n';
else
macros << lyx_def << '\n';
}
if (mustProvide("noun"))
macros << noun_def << '\n';
if (mustProvide("lyxarrow"))
macros << lyxarrow_def << '\n';
if (!usePolyglossia() && mustProvide("textgreek")) {
// Avoid a LaTeX error if times fonts are used and the grtimes
// package is installed but actual fonts are not (bug 6469).
if (params_.fonts_roman == "times")
macros << subst(textgreek_def,
from_ascii("\\greektext #1"),
from_ascii("%\n \\IfFileExists"
"{grtm10.tfm}{}{\\fontfamily"
"{cmr}}\\greektext #1"))
<< '\n';
else
macros << textgreek_def << '\n';
}
if (!usePolyglossia() && mustProvide("textcyr"))
macros << textcyr_def << '\n';
if (mustProvide("lyxmathsym"))
macros << lyxmathsym_def << '\n';
if (mustProvide("cedilla"))
macros << cedilla_def << '\n';
if (mustProvide("subring"))
macros << subring_def << '\n';
if (mustProvide("subdot"))
macros << subdot_def << '\n';
if (mustProvide("subhat"))
macros << subhat_def << '\n';
if (mustProvide("subtilde"))
macros << subtilde_def << '\n';
if (mustProvide("dacute"))
macros << dacute_def << '\n';
if (mustProvide("tipasymb"))
macros << tipasymb_def << '\n';
if (mustProvide("dgrave"))
macros << dgrave_def << '\n';
if (mustProvide("rcap"))
macros << rcap_def << '\n';
if (mustProvide("ogonek"))
macros << ogonek_def << '\n';
// quotes.
if (mustProvide("quotesinglbase"))
macros << quotesinglbase_def << '\n';
if (mustProvide("quotedblbase"))
macros << quotedblbase_def << '\n';
if (mustProvide("guilsinglleft"))
macros << guilsinglleft_def << '\n';
if (mustProvide("guilsinglright"))
macros << guilsinglright_def << '\n';
if (mustProvide("guillemotleft"))
macros << guillemotleft_def << '\n';
if (mustProvide("guillemotright"))
macros << guillemotright_def << '\n';
// Math mode
if (mustProvide("binom") && !isRequired("amsmath"))
macros << binom_def << '\n';
if (mustProvide("mathcircumflex"))
macros << mathcircumflex_def << '\n';
// other
if (mustProvide("ParagraphLeftIndent"))
macros << paragraphleftindent_def;
if (mustProvide("NeedLyXFootnoteCode"))
macros << floatingfootnote_def;
// some problems with tex->html converters
if (mustProvide("NeedTabularnewline"))
macros << tabularnewline_def;
// greyed-out environment (note inset)
// the color is specified in the routine
// getColorOptions() to avoid LaTeX-package clashes
if (mustProvide("lyxgreyedout"))
macros << lyxgreyedout_def;
if (mustProvide("lyxdot"))
macros << lyxdot_def << '\n';
// floats
getFloatDefinitions(macros);
if (mustProvide("refstyle"))
macros << lyxref_def << '\n';
// change tracking
if (mustProvide("ct-dvipost"))
macros << changetracking_dvipost_def;
if (mustProvide("ct-xcolor-ulem")) {
streamsize const prec = macros.precision(2);
RGBColor cadd = rgbFromHexName(lcolor.getX11Name(Color_addedtext));
macros << "\\providecolor{lyxadded}{rgb}{"
<< cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
RGBColor cdel = rgbFromHexName(lcolor.getX11Name(Color_deletedtext));
macros << "\\providecolor{lyxdeleted}{rgb}{"
<< cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
macros.precision(prec);
if (isRequired("hyperref"))
macros << changetracking_xcolor_ulem_hyperref_def;
else
macros << changetracking_xcolor_ulem_def;
}
if (mustProvide("ct-none"))
macros << changetracking_none_def;
if (mustProvide("rtloutputdblcol"))
macros << rtloutputdblcol_def;
return macros.str();
}
string const LaTeXFeatures::getBabelPresettings() const
{
ostringstream tmp;
LanguageList::const_iterator it = UsedLanguages_.begin();
LanguageList::const_iterator end = UsedLanguages_.end();
for (; it != end; ++it)
if (!(*it)->babel_presettings().empty())
tmp << (*it)->babel_presettings() << '\n';
if (!params_.language->babel_presettings().empty())
tmp << params_.language->babel_presettings() << '\n';
if (!contains(tmp.str(), '@'))
return tmp.str();
return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
}
string const LaTeXFeatures::getBabelPostsettings() const
{
ostringstream tmp;
LanguageList::const_iterator it = UsedLanguages_.begin();
LanguageList::const_iterator end = UsedLanguages_.end();
for (; it != end; ++it)
if (!(*it)->babel_postsettings().empty())
tmp << (*it)->babel_postsettings() << '\n';
if (!params_.language->babel_postsettings().empty())
tmp << params_.language->babel_postsettings() << '\n';
if (!contains(tmp.str(), '@'))
return tmp.str();
return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
}
bool LaTeXFeatures::needBabelLangOptions() const
{
if (!lyxrc.language_global_options || params_.language->asBabelOptions())
return true;
LanguageList::const_iterator it = UsedLanguages_.begin();
LanguageList::const_iterator end = UsedLanguages_.end();
for (; it != end; ++it)
if ((*it)->asBabelOptions())
return true;
return false;
}
string const LaTeXFeatures::loadAMSPackages() const
{
ostringstream tmp;
if (mustProvide("amsthm"))
tmp << "\\usepackage{amsthm}\n";
if (mustProvide("amsmath")
&& params_.use_package("amsmath") != BufferParams::package_off) {
tmp << "\\usepackage{amsmath}\n";
} else {
// amsbsy and amstext are already provided by amsmath
if (mustProvide("amsbsy"))
tmp << "\\usepackage{amsbsy}\n";
if (mustProvide("amstext"))
tmp << "\\usepackage{amstext}\n";
}
if (mustProvide("amssymb")
&& params_.use_package("amssymb") != BufferParams::package_off)
tmp << "\\usepackage{amssymb}\n";
return tmp.str();
}
docstring const LaTeXFeatures::getTClassPreamble() const
{
// the text class specific preamble
DocumentClass const & tclass = params_.documentClass();
odocstringstream tcpreamble;
tcpreamble << tclass.preamble();
list<docstring>::const_iterator cit = usedLayouts_.begin();
list<docstring>::const_iterator end = usedLayouts_.end();
for (; cit != end; ++cit)
tcpreamble << tclass[*cit].preamble();
cit = usedInsetLayouts_.begin();
end = usedInsetLayouts_.end();
TextClass::InsetLayouts const & ils = tclass.insetLayouts();
for (; cit != end; ++cit) {
TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
if (it == ils.end())
continue;
tcpreamble << it->second.preamble();
}
return tcpreamble.str();
}
docstring const LaTeXFeatures::getTClassHTMLPreamble() const
{
DocumentClass const & tclass = params_.documentClass();
odocstringstream tcpreamble;
tcpreamble << tclass.htmlpreamble();
list<docstring>::const_iterator cit = usedLayouts_.begin();
list<docstring>::const_iterator end = usedLayouts_.end();
for (; cit != end; ++cit)
tcpreamble << tclass[*cit].htmlpreamble();
cit = usedInsetLayouts_.begin();
end = usedInsetLayouts_.end();
TextClass::InsetLayouts const & ils = tclass.insetLayouts();
for (; cit != end; ++cit) {
TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
if (it == ils.end())
continue;
tcpreamble << it->second.htmlpreamble();
}
return tcpreamble.str();
}
docstring const LaTeXFeatures::getTClassHTMLStyles() const
{
DocumentClass const & tclass = params_.documentClass();
odocstringstream tcpreamble;
if (mustProvide("noun"))
tcpreamble << lyxnoun_style;
// this isn't exact, but it won't hurt that much if it
// wasn't for this.
if (mustProvide("ulem"))
tcpreamble << lyxstrikeout_style;
tcpreamble << tclass.htmlstyles();
list<docstring>::const_iterator cit = usedLayouts_.begin();
list<docstring>::const_iterator end = usedLayouts_.end();
for (; cit != end; ++cit)
tcpreamble << tclass[*cit].htmlstyle();
cit = usedInsetLayouts_.begin();
end = usedInsetLayouts_.end();
TextClass::InsetLayouts const & ils = tclass.insetLayouts();
for (; cit != end; ++cit) {
TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
if (it == ils.end())
continue;
tcpreamble << it->second.htmlstyle();
}
return tcpreamble.str();
}
namespace {
docstring const getFloatI18nPreamble(docstring const & type,
docstring const & name, Language const * lang,
Encoding const & enc, bool const polyglossia)
{
// Check whether name can be encoded in the buffer encoding
bool encodable = true;
for (size_t i = 0; i < name.size(); ++i) {
if (!enc.encodable(name[i])) {
encodable = false;
break;
}
}
docstring const language = polyglossia ? from_ascii(lang->polyglossia())
: from_ascii(lang->babel());
docstring const langenc = from_ascii(lang->encoding()->iconvName());
docstring const texenc = from_ascii(lang->encoding()->latexName());
docstring const bufenc = from_ascii(enc.iconvName());
docstring const s1 = docstring(1, 0xF0000);
docstring const s2 = docstring(1, 0xF0001);
docstring const translated = encodable ? name
: from_ascii("\\inputencoding{") + texenc + from_ascii("}")
+ s1 + langenc + s2 + name + s1 + bufenc + s2;
odocstringstream os;
os << "\\addto\\captions" << language
<< "{\\renewcommand{\\" << type << "name}{" << translated << "}}\n";
return os.str();
}
docstring const i18npreamble(docstring const & templ, Language const * lang,
Encoding const & enc, bool const polyglossia)
{
if (templ.empty())
return templ;
string preamble = polyglossia ?
subst(to_utf8(templ), "$$lang", lang->polyglossia()) :
subst(to_utf8(templ), "$$lang", lang->babel());
string const langenc = lang->encoding()->iconvName();
string const texenc = lang->encoding()->latexName();
string const bufenc = enc.iconvName();
// First and second character of plane 15 (Private Use Area)
string const s1 = "\xf3\xb0\x80\x80"; // U+F0000
string const s2 = "\xf3\xb0\x80\x81"; // U+F0001
// FIXME UNICODE
// lyx::regex is not unicode-safe.
// Should use QRegExp or (boost::u32regex, but that requires ICU)
static regex const reg("_\\(([^\\)]+)\\)");
smatch sub;
while (regex_search(preamble, sub, reg)) {
string const key = sub.str(1);
docstring const name = lang->translateLayout(key);
// Check whether name can be encoded in the buffer encoding
bool encodable = true;
for (size_t i = 0; i < name.size(); ++i) {
if (!enc.encodable(name[i])) {
encodable = false;
break;
}
}
string const translated = encodable ? to_utf8(name)
: "\\inputencoding{" + texenc + "}"
+ s1 + langenc + s2 + to_utf8(name)
+ s1 + bufenc + s2;
preamble = subst(preamble, sub.str(), translated);
}
return from_utf8(preamble);
}
}
docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel, bool use_polyglossia) const
{
DocumentClass const & tclass = params_.documentClass();
// collect preamble snippets in a set to prevent multiple identical
// commands (would happen if e.g. both theorem and theorem* are used)
set<docstring> snippets;
typedef LanguageList::const_iterator lang_it;
lang_it const lbeg = UsedLanguages_.begin();
lang_it const lend = UsedLanguages_.end();
list<docstring>::const_iterator cit = usedLayouts_.begin();
list<docstring>::const_iterator end = usedLayouts_.end();
for (; cit != end; ++cit) {
// language dependent commands (once per document)
snippets.insert(i18npreamble(tclass[*cit].langpreamble(),
buffer().language(),
buffer().params().encoding(),
use_polyglossia));
// commands for language changing (for multilanguage documents)
if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
snippets.insert(i18npreamble(
tclass[*cit].babelpreamble(),
buffer().language(),
buffer().params().encoding(),
use_polyglossia));
for (lang_it lit = lbeg; lit != lend; ++lit)
snippets.insert(i18npreamble(
tclass[*cit].babelpreamble(),
*lit,
buffer().params().encoding(),
use_polyglossia));
}
}
if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
FloatList const & floats = params_.documentClass().floats();
UsedFloats::const_iterator fit = usedFloats_.begin();
UsedFloats::const_iterator fend = usedFloats_.end();
for (; fit != fend; ++fit) {
Floating const & fl = floats.getType(fit->first);
// we assume builtin floats are translated
if (fl.isPredefined())
continue;
docstring const type = from_ascii(fl.floattype());
docstring const flname = from_utf8(fl.name());
docstring name = buffer().language()->translateLayout(fl.name());
// only request translation if we have a real translation
// (that differs from the source)
if (flname != name)
snippets.insert(getFloatI18nPreamble(
type, name, buffer().language(),
buffer().params().encoding(),
use_polyglossia));
for (lang_it lit = lbeg; lit != lend; ++lit) {
string const code = (*lit)->code();
name = (*lit)->translateLayout(fl.name());
// we assume we have a suitable translation if
// either the language is English (we need to
// translate into English if English is a secondary
// language) or if translateIfPossible returns
// something different to the English source.
bool const have_translation =
(flname != name || contains(code, "en"));
if (have_translation)
snippets.insert(getFloatI18nPreamble(
type, name, *lit,
buffer().params().encoding(),
use_polyglossia));
}
}
}
cit = usedInsetLayouts_.begin();
end = usedInsetLayouts_.end();
TextClass::InsetLayouts const & ils = tclass.insetLayouts();
for (; cit != end; ++cit) {
TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
if (it == ils.end())
continue;
// language dependent commands (once per document)
snippets.insert(i18npreamble(it->second.langpreamble(),
buffer().language(),
buffer().params().encoding(),
use_polyglossia));
// commands for language changing (for multilanguage documents)
if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
snippets.insert(i18npreamble(
it->second.babelpreamble(),
buffer().language(),
buffer().params().encoding(),
use_polyglossia));
for (lang_it lit = lbeg; lit != lend; ++lit)
snippets.insert(i18npreamble(
it->second.babelpreamble(),
*lit,
buffer().params().encoding(),
use_polyglossia));
}
}
odocstringstream tcpreamble;
set<docstring>::const_iterator const send = snippets.end();
set<docstring>::const_iterator it = snippets.begin();
for (; it != send; ++it)
tcpreamble << *it;
return tcpreamble.str();
}
docstring const LaTeXFeatures::getLyXSGMLEntities() const
{
// Definition of entities used in the document that are LyX related.
odocstringstream entities;
if (mustProvide("lyxarrow")) {
entities << "<!ENTITY lyxarrow \"-&gt;\">" << '\n';
}
return entities.str();
}
docstring const LaTeXFeatures::getIncludedFiles(string const & fname) const
{
odocstringstream sgmlpreamble;
// FIXME UNICODE
docstring const basename(from_utf8(onlyPath(fname)));
FileMap::const_iterator end = IncludedFiles_.end();
for (FileMap::const_iterator fi = IncludedFiles_.begin();
fi != end; ++fi)
// FIXME UNICODE
sgmlpreamble << "\n<!ENTITY " << fi->first
<< (isSGMLFileName(fi->second) ? " SYSTEM \"" : " \"")
<< makeRelPath(from_utf8(fi->second), basename) << "\">";
return sgmlpreamble.str();
}
void LaTeXFeatures::showStruct() const
{
lyxerr << "LyX needs the following commands when LaTeXing:"
<< "\n***** Packages:" << getPackages()
<< "\n***** Macros:" << to_utf8(getMacros())
<< "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
<< "\n***** done." << endl;
}
Buffer const & LaTeXFeatures::buffer() const
{
return *buffer_;
}
void LaTeXFeatures::setBuffer(Buffer const & buffer)
{
buffer_ = &buffer;
}
BufferParams const & LaTeXFeatures::bufferParams() const
{
return params_;
}
void LaTeXFeatures::getFloatDefinitions(odocstream & os) const
{
FloatList const & floats = params_.documentClass().floats();
// Here we will output the code to create the needed float styles.
// We will try to do this as minimal as possible.
// \floatstyle{ruled}
// \newfloat{algorithm}{htbp}{loa}
// \providecommand{\algorithmname}{Algorithm}
// \floatname{algorithm}{\protect\algorithmname}
UsedFloats::const_iterator cit = usedFloats_.begin();
UsedFloats::const_iterator end = usedFloats_.end();
for (; cit != end; ++cit) {
Floating const & fl = floats.getType(cit->first);
// For builtin floats we do nothing.
if (fl.isPredefined())
continue;
// We have to special case "table" and "figure"
if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
// Output code to modify "table" or "figure"
// but only if builtin == false
// and that have to be true at this point in the
// function.
docstring const type = from_ascii(fl.floattype());
docstring const placement = from_ascii(fl.placement());
docstring const style = from_ascii(fl.style());
if (!style.empty()) {
os << "\\floatstyle{" << style << "}\n"
<< "\\restylefloat{" << type << "}\n";
}
if (!placement.empty()) {
os << "\\floatplacement{" << type << "}{"
<< placement << "}\n";
}
} else {
// The other non builtin floats.
docstring const type = from_ascii(fl.floattype());
docstring const placement = from_ascii(fl.placement());
docstring const ext = from_ascii(fl.ext());
docstring const within = from_ascii(fl.within());
docstring const style = from_ascii(fl.style());
docstring const name =
buffer().language()->translateLayout(fl.name());
os << "\\floatstyle{" << style << "}\n"
<< "\\newfloat{" << type << "}{" << placement
<< "}{" << ext << '}';
if (!within.empty())
os << '[' << within << ']';
os << '\n'
<< "\\providecommand{\\" << type << "name}{"
<< name << "}\n"
<< "\\floatname{" << type << "}{\\protect\\"
<< type << "name}\n";
// What missing here is to code to minimalize the code
// output so that the same floatstyle will not be
// used several times, when the same style is still in
// effect. (Lgb)
}
if (cit->second)
2013-10-13 09:45:59 +00:00
// The subfig package is loaded later
os << "\n\\AtBeginDocument{\\newsubfloat{" << from_ascii(fl.floattype()) << "}}\n";
}
}
void LaTeXFeatures::resolveAlternatives()
{
for (Features::iterator it = features_.begin(); it != features_.end();) {
if (contains(*it, '|')) {
vector<string> const alternatives = getVectorFromString(*it, "|");
vector<string>::const_iterator const end = alternatives.end();
vector<string>::const_iterator ita = alternatives.begin();
for (; ita != end; ++ita) {
if (isRequired(*ita))
break;
}
if (ita == end)
require(alternatives.front());
features_.erase(it);
it = features_.begin();
} else
++it;
}
}
} // namespace lyx