#include "buffer.h"
#include "bufferlist.h"
#include "lyx_main.h"
-#include "lyx_gui_misc.h"
#include "LyXAction.h"
#include "lyxrc.h"
#include "lyxlex.h"
#include "insets/insettoc.h"
#include "insets/insetparent.h"
#include "insets/insetspecialchar.h"
-#include "insets/figinset.h"
#include "insets/insettext.h"
#include "insets/insetert.h"
#include "insets/insetgraphics.h"
#include "support/filetools.h"
#include "support/path.h"
#include "support/os.h"
-#include "support/syscall.h"
#include "support/lyxlib.h"
#include "support/FileInfo.h"
#include "support/lyxmanip.h"
using std::list;
using lyx::pos_type;
-using lyx::layout_type;
using lyx::textclass_type;
// all these externs should eventually be removed.
Buffer::Buffer(string const & file, bool ronly)
- : paragraph(0), lyx_clean(true), bak_clean(true),
+ : paragraph(0), niceFile(true), lyx_clean(true), bak_clean(true),
unnamed(false), dep_clean(0), read_only(ronly),
filename_(file), users(0)
{
ErtComp ert_comp;
#endif
+#ifdef WITH_WARNINGS
#warning And _why_ is this here? (Lgb)
+#endif
int unknown_layouts;
int unknown_tokens;
if (!par) {
par = new Paragraph;
+ par->layout(textclasslist[params.textclass].defaultLayoutName());
} else {
// We are inserting into an existing document
users->text->breakParagraph(users);
if (!ert_comp.contents.empty()) {
lyxerr[Debug::INSETS] << "ERT contents:\n'"
<< ert_comp.contents << "'" << endl;
- Inset * inset = new InsetERT(ert_comp.contents, true);
+ Inset * inset = new InsetERT(params, params.language,
+ ert_comp.contents, true);
par->insertInset(pos++, inset, ert_comp.font);
ert_comp.contents.erase();
}
static int call_depth;
++call_depth;
bool checkminipage = false;
- static Paragraph * minipar;
+ static Paragraph * minipar = 0;
static Paragraph * parBeforeMinipage;
#endif
#endif
insertErtContents(par, pos);
#endif
lex.eatLine();
- string const layoutname = lex.getString();
- //lyxerr << "Looking for layout '"
- // << layoutname << "'!" << endl;
+ string layoutname = lex.getString();
- pair<bool, layout_type> pp
- = textclasslist.NumberOfLayout(params.textclass, layoutname);
+ LyXTextClass const & tclass = textclasslist[params.textclass];
- //lyxerr << "Result: " << pp.first << "/" << pp.second << endl;
+ if (layoutname.empty()) {
+ layoutname = tclass.defaultLayoutName();
+ }
+
+ bool hasLayout = tclass.hasLayout(layoutname);
+ if (!hasLayout) {
+ lyxerr << "Layout '" << layoutname << "' does not"
+ << " exist in textclass '" << tclass.name()
+ << "'." << endl;
+ lyxerr << "Trying to use default layout instead."
+ << endl;
+ layoutname = tclass.defaultLayoutName();
+ }
#ifndef NO_COMPABILITY
if (compare_no_case(layoutname, "latex") == 0) {
first_par = par;
else {
par = new Paragraph(par);
+ par->layout(textclasslist[params.textclass].defaultLayoutName());
}
pos = 0;
- if (pp.first) {
- par->layout = pp.second;
-#ifndef NO_COMPABILITY
- } else if (ert_comp.active) {
- par->layout = 0;
-#endif
- } else {
- // layout not found
- // use default layout "Standard" (0)
- //lyxerr << "Layout '" << layoutname
- // << "' was not found!" << endl;
-
- par->layout = 0;
- ++unknown_layouts;
- string const s = _("Layout had to be changed from\n")
- + layoutname + _(" to ")
- + textclasslist.NameOfLayout(params.textclass, par->layout);
- InsetError * new_inset = new InsetError(s);
- par->insertInset(0, new_inset,
- LyXFont(LyXFont::ALL_INHERIT,
- params.language));
- }
+ par->layout(layoutname);
// Test whether the layout is obsolete.
LyXLayout const & layout =
- textclasslist.Style(params.textclass,
- par->layout);
+ textclasslist[params.textclass][par->layout()];
if (!layout.obsoleted_by().empty())
- par->layout = textclasslist
- .NumberOfLayout(params.textclass,
- layout.obsoleted_by())
- .second;
+ par->layout(layout.obsoleted_by());
par->params().depth(depth);
font = LyXFont(LyXFont::ALL_INHERIT, params.language);
if (file_format < 216
stringstream old_float;
if (tmptok == "footnote") {
- inset = new InsetFoot;
+ inset = new InsetFoot(params);
old_float << "collapsed true\n";
} else if (tmptok == "margin") {
- inset = new InsetMarginal;
+ inset = new InsetMarginal(params);
old_float << "collapsed true\n";
} else if (tmptok == "fig") {
- inset = new InsetFloat("figure");
+ inset = new InsetFloat(params, "figure");
old_float << "placement htbp\n"
<< "wide false\n"
<< "collapsed false\n";
} else if (tmptok == "tab") {
- inset = new InsetFloat("table");
+ inset = new InsetFloat(params, "table");
old_float << "placement htbp\n"
<< "wide false\n"
<< "collapsed false\n";
} else if (tmptok == "alg") {
- inset = new InsetFloat("algorithm");
+ inset = new InsetFloat(params, "algorithm");
old_float << "placement htbp\n"
<< "wide false\n"
<< "collapsed false\n";
} else if (tmptok == "wide-fig") {
- inset = new InsetFloat("figure");
+ inset = new InsetFloat(params, "figure");
//InsetFloat * tmp = new InsetFloat("figure");
//tmp->wide(true);
//inset = tmp;
<< "wide true\n"
<< "collapsed false\n";
} else if (tmptok == "wide-tab") {
- inset = new InsetFloat("table");
+ inset = new InsetFloat(params, "table");
//InsetFloat * tmp = new InsetFloat("table");
//tmp->wide(true);
//inset = tmp;
string(_("LyX will not be able to produce output correctly.")));
params.textclass = 0;
}
- if (!textclasslist.Load(params.textclass)) {
+ if (!textclasslist[params.textclass].load()) {
// if the textclass wasn't loaded properly
// we need to either substitute another
// or stop loading the file.
// stop loading... ideas?? ARRae980418
Alert::alert(_("Textclass Loading Error!"),
string(_("Can't load textclass ")) +
- textclasslist.NameOfClass(params.textclass),
+ textclasslist[params.textclass].name(),
_("-- substituting default"));
params.textclass = 0;
}
}
} else if (token == "\\added_space_top") {
lex.nextToken();
- par->params().spaceTop(VSpace(lex.getString()));
+ VSpace value = VSpace(lex.getString());
+ if ((value.length().len().value() != 0) ||
+ (value.kind() != VSpace::LENGTH))
+ par->params().spaceTop(value);
} else if (token == "\\added_space_bottom") {
lex.nextToken();
- par->params().spaceBottom(VSpace(lex.getString()));
+ VSpace value = VSpace(lex.getString());
+ if ((value.length().len().value() != 0) ||
+ (value.kind() != VSpace::LENGTH))
+ par->params().spaceBottom(value);
#ifndef NO_COMPABILITY
#ifndef NO_PEXTRA_REALLY
} else if (token == "\\pextra_type") {
#endif
} else if (token == "\\SpecialChar") {
LyXLayout const & layout =
- textclasslist.Style(params.textclass,
- par->getLayout());
+ textclasslist[params.textclass][par->layout()];
// Insets don't make sense in a free-spacing context! ---Kayvan
if (layout.free_spacing || par->isFreeSpacing()) {
// Remove it later some time...introduced with fileformat
// 2.16. (Lgb)
LyXLayout const & layout =
- textclasslist.Style(params.textclass,
- par->getLayout());
+ textclasslist[params.textclass][par->layout()];
if (layout.free_spacing || par->isFreeSpacing()) {
par->insertChar(pos, ' ', font);
the_end_read = true;
#ifndef NO_COMPABILITY
#ifndef NO_PEXTRA_REALLY
+ if (minipar == par)
+ par = 0;
minipar = parBeforeMinipage = 0;
#endif
#endif
if (checkminipage && (call_depth == 1)) {
checkminipage = false;
if (minipar && (minipar != par) &&
- (par->params().pextraType()==Paragraph::PEXTRA_MINIPAGE))
+ (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE))
{
lyxerr << "minipages in a row" << endl;
if (par->params().pextraStartMinipage()) {
// create a new paragraph to insert the
// minipages in the following case
if (par->params().pextraStartMinipage() &&
- !par->params().pextraHfill())
- {
+ !par->params().pextraHfill()) {
Paragraph * p = new Paragraph;
- p->layout = 0;
+ p->layout(textclasslist[params.textclass].defaultLayoutName());
+
p->previous(parBeforeMinipage);
parBeforeMinipage->next(p);
p->next(0);
p->params().depth(parBeforeMinipage->params().depth());
parBeforeMinipage = p;
}
- InsetMinipage * mini = new InsetMinipage;
+ InsetMinipage * mini = new InsetMinipage(params);
mini->pos(static_cast<InsetMinipage::Position>(par->params().pextraAlignment()));
mini->pageWidth(LyXLength(par->params().pextraWidth()));
if (!par->params().pextraWidthp().empty()) {
lyxerr << "WP:" << mini->pageWidth().asString() << endl;
- mini->pageWidth(LyXLength((par->params().pextraWidthp())+"%"));
+ mini->pageWidth(LyXLength((par->params().pextraWidthp())+"p%"));
}
Paragraph * op = mini->firstParagraph();
mini->inset.paragraph(par);
// a sequence of minipages
// in its own paragraph.
Paragraph * p = new Paragraph;
- p->layout = 0;
+ p->layout(textclasslist[params.textclass].defaultLayoutName());
p->previous(par->previous());
p->next(0);
p->params().depth(depth);
if (!first_par || (first_par == par))
first_par = p;
- InsetMinipage * mini = new InsetMinipage;
+ InsetMinipage * mini = new InsetMinipage(params);
mini->pos(static_cast<InsetMinipage::Position>(minipar->params().pextraAlignment()));
mini->pageWidth(LyXLength(minipar->params().pextraWidth()));
if (!par->params().pextraWidthp().empty()) {
lyxerr << "WP:" << mini->pageWidth().asString() << endl;
- mini->pageWidth(LyXLength((par->params().pextraWidthp())+"%"));
+ mini->pageWidth(LyXLength((par->params().pextraWidthp())+"p%"));
}
+
+ Paragraph * op = mini->firstParagraph();
mini->inset.paragraph(minipar);
+ //
+ // and free the old ones!
+ //
+ while(op) {
+ Paragraph * pp = op->next();
+ delete op;
+ op = pp;
+ }
// Insert the minipage last in the
// previous paragraph.
void Buffer::insertStringAsLines(Paragraph *& par, pos_type & pos,
LyXFont const & fn,string const & str) const
{
- LyXLayout const & layout = textclasslist.Style(params.textclass,
- par->getLayout());
+ LyXLayout const & layout =
+ textclasslist[params.textclass][par->layout()];
LyXFont font = fn;
- (void)par->checkInsertChar(font);
+ par->checkInsertChar(font);
// insert the string, don't insert doublespace
bool space_inserted = true;
for(string::const_iterator cit = str.begin();
true);
alreadyread = true;
} else if (tmptok == "Note") {
- inset = new InsetNote;
+ inset = new InsetNote(params);
} else if (tmptok == "Include") {
- InsetCommandParams p( "Include" );
+ InsetCommandParams p("Include");
inset = new InsetInclude(p, *this);
} else if (tmptok == "ERT") {
- inset = new InsetERT;
+ inset = new InsetERT(params);
} else if (tmptok == "Tabular") {
inset = new InsetTabular(*this);
} else if (tmptok == "Text") {
- inset = new InsetText;
+ inset = new InsetText(params);
} else if (tmptok == "Foot") {
- inset = new InsetFoot;
+ inset = new InsetFoot(params);
} else if (tmptok == "Marginal") {
- inset = new InsetMarginal;
+ inset = new InsetMarginal(params);
} else if (tmptok == "Minipage") {
- inset = new InsetMinipage;
+ inset = new InsetMinipage(params);
} else if (tmptok == "Float") {
lex.next();
string tmptok = lex.getString();
- inset = new InsetFloat(tmptok);
+ inset = new InsetFloat(params, tmptok);
#if 0
} else if (tmptok == "List") {
inset = new InsetList;
inset = new InsetList;
#endif
} else if (tmptok == "Caption") {
- inset = new InsetCaption;
+ inset = new InsetCaption(params);
} else if (tmptok == "FloatList") {
inset = new InsetFloatList;
}
}
+namespace {
+
+pair<int, string> const addDepth(int depth, int ldepth)
+{
+ int d = depth * 2;
+ if (ldepth > depth)
+ d += (ldepth - depth) * 2;
+ return make_pair(d, string(d, ' '));
+}
+
+}
+
+
string const Buffer::asciiParagraph(Paragraph const * par,
unsigned int linelen,
bool noparbreak) const
{
ostringstream buffer;
- ostringstream word;
Paragraph::depth_type depth = 0;
int ltype = 0;
Paragraph::depth_type ltype_depth = 0;
- string::size_type currlinelen = 0;
bool ref_printed = false;
// if (!par->previous()) {
#if 0
#endif
// First write the layout
- string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout);
- if (tmp == "Itemize") {
+ string const & tmp = par->layout();
+ if (compare_no_case(tmp, "itemize") == 0) {
ltype = 1;
ltype_depth = depth + 1;
- } else if (tmp == "Enumerate") {
+ } else if (compare_no_case(tmp, "enumerate") == 0) {
ltype = 2;
ltype_depth = depth + 1;
- } else if (contains(tmp, "ection")) {
+ } else if (contains(lowercase(tmp), "ection")) {
ltype = 3;
ltype_depth = depth + 1;
- } else if (contains(tmp, "aragraph")) {
+ } else if (contains(lowercase(tmp), "aragraph")) {
ltype = 4;
ltype_depth = depth + 1;
- } else if (tmp == "Description") {
+ } else if (compare_no_case(tmp, "description") == 0) {
ltype = 5;
ltype_depth = depth + 1;
- } else if (tmp == "Abstract") {
+ } else if (compare_no_case(tmp, "abstract") == 0) {
ltype = 6;
ltype_depth = 0;
- } else if (tmp == "Bibliography") {
+ } else if (compare_no_case(tmp, "bibliography") == 0) {
ltype = 7;
ltype_depth = 0;
} else {
// }
// linelen <= 0 is special and means we don't have pargraph breaks
+
+ string::size_type currlinelen = 0;
+
if (!noparbreak) {
if (linelen > 0)
buffer << "\n\n";
- for (Paragraph::depth_type j = 0; j < depth; ++j)
- buffer << " ";
- currlinelen = depth * 2;
+
+ buffer << string(depth * 2, ' ');
+ currlinelen += depth * 2;
+
//--
// we should probably change to the paragraph language in the
// gettext here (if possible) so that strings are outputted in
case 5: // Description
break;
case 6: // Abstract
- if (linelen > 0)
+ if (linelen > 0) {
buffer << _("Abstract") << "\n\n";
- else
- buffer << _("Abstract: ");
+ currlinelen = 0;
+ } else {
+ string const abst = _("Abstract: ");
+ buffer << abst;
+ currlinelen += abst.length();
+ }
break;
case 7: // Bibliography
if (!ref_printed) {
- if (linelen > 0)
+ if (linelen > 0) {
buffer << _("References") << "\n\n";
- else
- buffer << _("References: ");
+ currlinelen = 0;
+ } else {
+ string const refs = _("References: ");
+ buffer << refs;
+ currlinelen += refs.length();
+ }
+
ref_printed = true;
}
break;
default:
- buffer << par->params().labelString() << " ";
- break;
+ {
+ string const parlab = par->params().labelString();
+ buffer << parlab << " ";
+ currlinelen += parlab.length() + 1;
+ }
+ break;
+
}
}
- string s = buffer.str();
- if (s.rfind('\n') != string::npos) {
- string dummy;
- s = rsplit(buffer.str().c_str(), dummy, '\n');
- }
- currlinelen = s.length();
+
if (!currlinelen) {
- for (Paragraph::depth_type j = 0; j < depth; ++j)
- buffer << " ";
- currlinelen = depth * 2;
- if (ltype_depth > depth) {
- for (Paragraph::depth_type j = ltype_depth;
- j > depth; --j)
- {
- buffer << " ";
- }
- currlinelen += (ltype_depth-depth)*2;
- }
+ pair<int, string> p = addDepth(depth, ltype_depth);
+ buffer << p.second;
+ currlinelen += p.first;
}
- // this is to change the linebreak to do it by word a bit more intelligent
- // hopefully! (only in the case where we have a max linelenght!) (Jug)
+
+ // this is to change the linebreak to do it by word a bit more
+ // intelligent hopefully! (only in the case where we have a
+ // max linelenght!) (Jug)
+
+ string word;
+
for (pos_type i = 0; i < par->size(); ++i) {
char c = par->getUChar(params, i);
switch (c) {
Inset const * inset = par->getInset(i);
if (inset) {
if (linelen > 0) {
- buffer << word.str();
- word.str("");
+ buffer << word;
+ currlinelen += word.length();
+ word.erase();
}
if (inset->ascii(this, buffer, linelen)) {
// to be sure it breaks paragraph
currlinelen += linelen;
}
-#if 0
- else {
- string dummy;
- string const s =
- rsplit(buffer.str().c_str(),
- dummy, '\n');
- currlinelen = s.length();
- }
-#endif
}
}
break;
case Paragraph::META_NEWLINE:
if (linelen > 0) {
- buffer << word.str() << "\n";
- word.str("");
- for (Paragraph::depth_type j = 0;
- j < depth; ++j)
- buffer << " ";
- currlinelen = depth * 2;
- if (ltype_depth > depth) {
- for (Paragraph::depth_type j = ltype_depth;
- j > depth; --j)
- buffer << " ";
- currlinelen += (ltype_depth - depth) * 2;
- }
+ buffer << word << "\n";
+ word.erase();
+
+ pair<int, string> p = addDepth(depth,
+ ltype_depth);
+ buffer << p.second;
+ currlinelen = p.first;
}
break;
case Paragraph::META_HFILL:
- buffer << word.str() << "\t";
- currlinelen += word.str().length() + 1;
- word.str("");
+ buffer << word << "\t";
+ currlinelen += word.length() + 1;
+ word.erase();
break;
default:
if (c == ' ') {
- buffer << word.str() << ' ';
- currlinelen += word.str().length() + 1;
- word.str("");
+ if (linelen > 0 &&
+ currlinelen + word.length() > linelen - 10) {
+ buffer << "\n";
+ pair<int, string> p =
+ addDepth(depth, ltype_depth);
+ buffer << p.second;
+ currlinelen = p.first;
+ }
+
+ buffer << word << ' ';
+ currlinelen += word.length() + 1;
+ word.erase();
+
} else {
if (c != '\0') {
- word << c;
+ word.push_back(c);
} else {
lyxerr[Debug::INFO] <<
"writeAsciiFile: NULL char in structure." << endl;
}
if ((linelen > 0) &&
- (currlinelen+word.str().length()) > linelen)
+ (currlinelen + word.length()) > linelen)
{
buffer << "\n";
- for (Paragraph::depth_type j = 0; j < depth; ++j)
- buffer << " ";
- currlinelen = depth * 2;
- if (ltype_depth > depth) {
- for (Paragraph::depth_type j = ltype_depth;
- j > depth; --j)
- {
- buffer << " ";
- }
- currlinelen += (ltype_depth-depth)*2;
- }
+
+ pair<int, string> p =
+ addDepth(depth, ltype_depth);
+ buffer << p.second;
+ currlinelen = p.first;
}
}
break;
}
}
- buffer << word.str();
+ buffer << word;
return buffer.str().c_str();
}
{
lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl;
- niceFile = nice; // this will be used by Insetincludes.
-
- tex_code_break_column = lyxrc.ascii_linelen;
-
- LyXTextClass const & tclass =
- textclasslist.TextClass(params.textclass);
-
ofstream ofs(fname.c_str());
if (!ofs) {
Alert::err_alert(_("Error: Cannot open file: "), fname);
return;
}
+ niceFile = nice; // this will be used by Insetincludes.
+
+ tex_code_break_column = lyxrc.ascii_linelen;
+
// validate the buffer.
lyxerr[Debug::LATEX] << " Validating buffer..." << endl;
- LaTeXFeatures features(params, tclass.numLayouts());
+ LaTeXFeatures features(params);
validate(features);
lyxerr[Debug::LATEX] << " Buffer validation done." << endl;
// original_path is set. This is done for usual tex-file, but not
// for nice-latex-file. (Matthias 250696)
if (!only_body) {
- if (!nice){
+ if (!nice) {
// code for usual, NOT nice-latex-file
ofs << "\\batchmode\n"; // changed
// from \nonstopmode
texrow.newline();
}
if (!original_path.empty()) {
+ string inputpath = os::external_path(original_path);
+ subst(inputpath, "~", "\\string~");
ofs << "\\makeatletter\n"
<< "\\def\\input@path{{"
- << os::external_path(original_path) << "/}}\n"
+ << inputpath << "/}}\n"
<< "\\makeatother\n";
texrow.newline();
texrow.newline();
ofs << "\\documentclass";
+ LyXTextClass const & tclass = textclasslist[params.textclass];
+
ostringstream options; // the document class options.
if (tokenPos(tclass.opt_fontsize(),
}
string strOptions(options.str().c_str());
- if (!strOptions.empty()){
+ if (!strOptions.empty()) {
strOptions = strip(strOptions, ',');
ofs << '[' << strOptions << ']';
}
- ofs << '{'
- << textclasslist.LatexnameOfClass(params.textclass)
- << "}\n";
+ ofs << '{' << tclass.latexname() << "}\n";
texrow.newline();
// end of \documentclass defs
lyxerr[Debug::INFO] << "Finished making latex file." << endl;
lyxerr[Debug::INFO] << "Row count was " << texrow.rows()-1 << "." << endl;
+
+ // we want this to be true outside previews (for insetexternal)
+ niceFile = true;
}
// any environment other then "Standard" to be valid!
if ((in == 0) || !in->forceDefaultParagraphs(in)) {
LyXLayout const & layout =
- textclasslist.Style(params.textclass, par->layout);
+ textclasslist[params.textclass][par->layout()];
if (layout.intitle) {
if (already_title) {
bool Buffer::isLatex() const
{
- return textclasslist.TextClass(params.textclass).outputType() == LATEX;
+ return textclasslist[params.textclass].outputType() == LATEX;
}
bool Buffer::isLinuxDoc() const
{
- return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC;
+ return textclasslist[params.textclass].outputType() == LINUXDOC;
}
bool Buffer::isLiterate() const
{
- return textclasslist.TextClass(params.textclass).outputType() == LITERATE;
+ return textclasslist[params.textclass].outputType() == LITERATE;
}
bool Buffer::isDocBook() const
{
- return textclasslist.TextClass(params.textclass).outputType() == DOCBOOK;
+ return textclasslist[params.textclass].outputType() == DOCBOOK;
}
bool Buffer::isSGML() const
{
- return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC ||
- textclasslist.TextClass(params.textclass).outputType() == DOCBOOK;
+ LyXTextClass const & tclass = textclasslist[params.textclass];
+
+ return tclass.outputType() == LINUXDOC ||
+ tclass.outputType() == DOCBOOK;
}
-void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type depth,
+void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type,
string const & latexname) const
{
if (!latexname.empty() && latexname != "!-- --")
//os << "<!-- " << depth << " -->" << "<" << latexname << ">";
- os << string(depth, ' ') << "<" << latexname << ">\n";
+ os << "<" << latexname << ">";
}
-void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type depth,
+void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type,
string const & latexname) const
{
if (!latexname.empty() && latexname != "!-- --")
//os << "<!-- " << depth << " -->" << "</" << latexname << ">\n";
- os << string(depth, ' ') << "</" << latexname << ">\n";
+ os << "</" << latexname << ">";
}
niceFile = nice; // this will be used by included files.
- LyXTextClass const & tclass =
- textclasslist.TextClass(params.textclass);
-
- LaTeXFeatures features(params, tclass.numLayouts());
+ LaTeXFeatures features(params);
+
validate(features);
texrow.reset();
- string top_element = textclasslist.LatexnameOfClass(params.textclass);
+ LyXTextClass const & tclass = textclasslist[params.textclass];
+
+ string top_element = tclass.latexname();
if (!body_only) {
ofs << "<!doctype linuxdoc system";
string preamble = params.preamble;
- preamble += features.getIncludedFiles(fname);
+ const string name = nice ? ChangeExtension(filename_, ".sgml")
+ : fname;
+ preamble += features.getIncludedFiles(name);
preamble += features.getLyXSGMLEntities();
if (!preamble.empty()) {
vector<string> environment_stack(5);
while (par) {
- LyXLayout const & style =
- textclasslist.Style(params.textclass,
- par->layout);
+ LyXLayout const & style = tclass[par->layout()];
// treat <toc> as a special case for compatibility with old code
if (par->isInset(0)) {
Inset * inset = par->getInset(0);
Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code == Inset::TOC_CODE){
+ if (lyx_code == Inset::TOC_CODE) {
string const temp = "toc";
sgmlOpenTag(ofs, depth, temp);
_("Error : Wrong depth for"
" LatexType Command.\n"));
- if (!environment_stack[depth].empty()){
+ if (!environment_stack[depth].empty()) {
sgmlCloseTag(ofs, depth,
environment_stack[depth]);
ofs << "</p>";
ofs.close();
// How to check for successful close
+
+ // we want this to be true outside previews (for insetexternal)
+ niceFile = true;
}
inline
void reset(PAR_TAG & p1, PAR_TAG const & p2)
{
- p1 = static_cast<PAR_TAG>( p1 & ~p2);
+ p1 = static_cast<PAR_TAG>(p1 & ~p2);
}
} // namespace anon
Paragraph * par,
Paragraph::depth_type /*depth*/)
{
- LyXLayout const & style = textclasslist.Style(params.textclass,
- par->getLayout());
+ LyXLayout const & style =
+ textclasslist[params.textclass][par->layout()];
string::size_type char_line_count = 5; // Heuristic choice ;-)
// gets paragraph main font
}
list < PAR_TAG > temp;
- while (!tag_state.empty() && tag_close ) {
+ while (!tag_state.empty() && tag_close) {
PAR_TAG k = tag_state.top();
tag_state.pop();
os << "</" << tag_name(k) << ">";
niceFile = nice; // this will be used by Insetincludes.
- LyXTextClass const & tclass =
- textclasslist.TextClass(params.textclass);
-
- LaTeXFeatures features(params, tclass.numLayouts());
+ LaTeXFeatures features(params);
validate(features);
texrow.reset();
- string top_element = textclasslist.LatexnameOfClass(params.textclass);
+ LyXTextClass const & tclass = textclasslist[params.textclass];
+ string top_element = tclass.latexname();
if (!only_body) {
ofs << "<!DOCTYPE " << top_element
<< " PUBLIC \"-//OASIS//DTD DocBook V4.1//EN\"";
string preamble = params.preamble;
- preamble += features.getIncludedFiles(fname);
+ const string name = nice ? ChangeExtension(filename_, ".sgml")
+ : fname;
+ preamble += features.getIncludedFiles(name);
preamble += features.getLyXSGMLEntities();
if (!preamble.empty()) {
string c_params;
int desc_on = 0; // description mode
- LyXLayout const & style =
- textclasslist.Style(params.textclass,
- par->layout);
+ LyXLayout const & style = tclass[par->layout()];
// environment tag closing
for (; depth > par->params().depth(); --depth) {
if (par->isInset(0)) {
Inset * inset = par->getInset(0);
Inset::Code lyx_code = inset->lyxCode();
- if (lyx_code == Inset::LABEL_CODE){
+ if (lyx_code == Inset::LABEL_CODE) {
command_name += " id=\"";
command_name += (static_cast<InsetCommand *>(inset))->getContents();
command_name += "\"";
}
if (environment_stack[depth] != style.latexname()) {
- if(environment_stack.size() == depth + 1) {
+ if (environment_stack.size() == depth + 1) {
environment_stack.push_back("!-- --");
environment_inner.push_back("!-- --");
}
if (style.latextype == LATEX_ENVIRONMENT) {
if (!style.latexparam().empty()) {
- if(style.latexparam() == "CDATA")
+ if (style.latexparam() == "CDATA")
ofs << "<![CDATA[";
else
sgmlOpenTag(ofs, depth + command_depth,
break;
case LATEX_ENVIRONMENT:
if (!style.latexparam().empty()) {
- if(style.latexparam() == "CDATA")
+ if (style.latexparam() == "CDATA")
ofs << "]]>";
else
sgmlCloseTag(ofs, depth + command_depth,
ofs.close();
// How to check for successful close
+
+ // we want this to be true outside previews (for insetexternal)
+ niceFile = true;
}
{
bool emph_flag = false;
- LyXLayout const & style = textclasslist.Style(params.textclass,
- par->getLayout());
+ LyXLayout const & style =
+ textclasslist[params.textclass][par->layout()];
LyXFont font_old = style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
if (font.emph() == LyXFont::ON) {
os << "<emphasis>";
emph_flag = true;
- }else if(i) {
+ } else if (i) {
os << "</emphasis>";
emph_flag = false;
}
}
- if ( par->isInset(i) ) {
+ if (par->isInset(i)) {
Inset * inset = par->getInset(i);
// don't print the inset in position 0 if desc_on == 3 (label)
- if ( i || desc_on != 3)
+ if ( i || desc_on != 3) {
+ if(style.latexparam() == "CDATA")
+ os << "]]>";
inset->docbook(this, os);
+ if(style.latexparam() == "CDATA")
+ os << "<![CDATA[";
+ }
} else {
char c = par->getChar(i);
string sgml_string;
if (style.pass_thru) {
os << c;
- } else if(style.free_spacing || par->isFreeSpacing() || c != ' ') {
+ } else if (style.free_spacing || par->isFreeSpacing() || c != ' ') {
os << sgml_string;
} else if (desc_on ==1) {
++char_line_count;
// resets description flag correctly
if (desc_on == 1) {
// <term> not closed...
- os << "</term>";
+ os << "</term>\n<listitem><para> </para>";
}
- if(style.free_spacing) os << '\n';
+ if (style.free_spacing) os << '\n';
}
// if we removed error insets before we ran chktex or if we inserted
// error insets after we ran chktex, this must be run:
- if (removedErrorInsets || res){
+ if (removedErrorInsets || res) {
users->redraw();
users->fitCursor();
}
void Buffer::validate(LaTeXFeatures & features) const
{
Paragraph * par = paragraph;
- LyXTextClass const & tclass =
- textclasslist.TextClass(params.textclass);
+ LyXTextClass const & tclass = textclasslist[params.textclass];
// AMS Style is at document level
if (params.use_amsmath || tclass.provides(LyXTextClass::amsmath))
Lists l;
Paragraph * par = paragraph;
-#if 1
- std::pair<bool, textclass_type> const tmp =
- textclasslist.NumberOfLayout(params.textclass, "Caption");
- bool const found = tmp.first;
- textclass_type const cap = tmp.second;
-
-#else
- // This is the prefered way to to this, but boost::tie can break
- // some compilers
- bool found;
- textclass_type cap;
- boost::tie(found, cap) = textclasslist
- .NumberOfLayout(params.textclass, "Caption");
-#endif
+ LyXTextClass const & textclass = textclasslist[params.textclass];
+ bool found = textclass.hasLayout("Caption");
+ string const layout("Caption");
while (par) {
- char const labeltype =
- textclasslist.Style(params.textclass,
- par->getLayout()).labeltype;
+ char const labeltype = textclass[par->layout()].labeltype;
if (labeltype >= LABEL_COUNTER_CHAPTER
&& labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) {
SingleList & item = l["TOC"];
int depth = max(0,
labeltype -
- textclasslist.TextClass(params.textclass).maxcounter());
+ textclass.maxcounter());
item.push_back(TocItem(par, depth, par->asString(this, true)));
}
// For each paragrph, traverse its insets and look for
// the inset...
Paragraph * tmp = il->inset.paragraph();
while (tmp) {
- if (tmp->layout == cap) {
+ if (tmp->layout() == layout) {
SingleList & item = l[type];
string const str =
tostr(item.size()+1) + ". " + tmp->asString(this, false);
}
}
} else {
- lyxerr << "caption not found" << endl;
+ lyxerr << "Caption not found" << endl;
}
par = par->next();
projects / lyx.git / blobdiff