#include "insets/insetindex.h"
#include "insets/insetinclude.h"
#include "insets/insettoc.h"
-#include "insets/insetlof.h"
-#include "insets/insetlot.h"
-#include "insets/insetloa.h"
#include "insets/insetparent.h"
#include "insets/insetspecialchar.h"
#include "insets/figinset.h"
#include "insets/insetfloat.h"
#include "insets/insetlist.h"
#include "insets/insettabular.h"
+#include "insets/insettheorem.h"
+#include "insets/insetcaption.h"
#include "support/filetools.h"
#include "support/path.h"
#include "LaTeX.h"
#include "language.h"
#include "lyx_gui_misc.h" // WarnReadonly()
#include "frontends/Dialogs.h"
+#include "encoding.h"
+#include "exporter.h"
using std::ostream;
using std::ofstream;
using std::pair;
using std::vector;
using std::max;
+using std::set;
+#ifdef HAVE_SSTREAM
+using std::istringstream;
+#endif
// all these externs should eventually be removed.
extern BufferList bufferlist;
+#ifndef NEW_EXPORT
extern void MenuExport(Buffer *, string const &);
+#endif
extern LyXAction lyxaction;
-static const float LYX_FORMAT = 2.16;
+static const float LYX_FORMAT = 2.17;
extern int tex_code_break_column;
bak_clean = true;
dep_clean = 0;
read_only = ronly;
+ unnamed = false;
users = 0;
lyxvc.buffer(this);
if (read_only || (lyxrc.use_tempdir)) {
// if par = 0 normal behavior
// else insert behavior
// Returns false if "\the_end" is not read for formats >= 2.13. (Asger)
-#define USE_PARSE_FUNCTION 1
-//#define USE_TABULAR_INSETS 1
bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par)
{
string tmptok;
int pos = 0;
char depth = 0; // signed or unsigned?
+#ifndef NEW_INSETS
LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE;
+#endif
bool the_end_read = false;
LyXParagraph * return_par = 0;
continue;
the_end_read = parseSingleLyXformat2Token(lex, par, return_par,
token, pos, depth,
- font, footnoteflag,
- footnotekind);
+ font
+#ifndef NEW_INSETS
+ , footnoteflag,
+ footnotekind
+#endif
+ );
}
if (!return_par)
}
+// We'll remove this later. (Lgb)
+static string last_inset_read;
+
+
bool
Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
LyXParagraph *& return_par,
string const & token, int & pos,
- char & depth, LyXFont & font,
- LyXParagraph::footnote_flag & footnoteflag,
- LyXParagraph::footnote_kind & footnotekind)
+ char & depth, LyXFont & font
+#ifndef NEW_INSETS
+ , LyXParagraph::footnote_flag & footnoteflag,
+ LyXParagraph::footnote_kind & footnotekind
+#endif
+ )
{
bool the_end_read = false;
-
+
if (token[0] != '\\') {
for (string::const_iterator cit = token.begin();
cit != token.end(); ++cit) {
par->layout =
textclasslist.NumberOfLayout(params.textclass,
layout.obsoleted_by()).second;
+#ifndef NEW_INSETS
par->footnoteflag = footnoteflag;
par->footnotekind = footnotekind;
+#endif
par->depth = depth;
font = LyXFont(LyXFont::ALL_INHERIT, params.language_info);
if (format < 2.16 && params.language == "hebrew")
//lyxerr << "old float: " << tmptok << endl;
Inset * inset = 0;
+ string old_float;
if (tmptok == "footnote") {
inset = new InsetFoot;
} else if (tmptok == "margin") {
inset = new InsetMarginal;
} else if (tmptok == "fig") {
- //inset = new InsetFigure;
+ inset = new InsetFloat("figure");
+ old_float += "placement htbp\n";
} else if (tmptok == "tab") {
- //inset = new InsetTable;
+ inset = new InsetFloat("table");
+ old_float += "placement htbp\n";
} else if (tmptok == "alg") {
- //inset = new InsetAlgorithm;
+ inset = new InsetFloat("algorithm");
+ old_float += "placement htbp\n";
} else if (tmptok == "wide-fig") {
- //inset = new InsetFigure(true);
+ InsetFloat * tmp = new InsetFloat("figure");
+ tmp->wide(true);
+ inset = tmp;
+ old_float += "placement htbp\n";
} else if (tmptok == "wide-tab") {
- //inset = new InsetTable(true);
+ InsetFloat * tmp = new InsetFloat("table");
+ tmp->wide(true);
+ inset = tmp;
+ old_float += "placement htbp\n";
}
if (!inset) return false; // no end read yet
- string old_float = "\ncollapsed true\n";
+ old_float += "collapsed true\n";
+
+ // Here we need to check for \end_deeper and handle that
+ // before we do the footnote parsing.
+ // This _is_ a hack! (Lgb)
+ while(true) {
+ lex.next();
+ string tmp = lex.GetString();
+ if (tmp == "\\end_deeper") {
+ lyxerr << "\\end_deeper caught!" << endl;
+ if (!depth) {
+ lex.printError("\\end_deeper: "
+ "depth is already null");
+ } else
+ --depth;
+
+ } else {
+ old_float += tmp;
+ old_float += ' ';
+ break;
+ }
+ }
+
old_float += lex.getLongString("\\end_float");
old_float += "\n\\end_inset\n";
- lyxerr << "float body: " << old_float << endl;
-
+ //lyxerr << "float body: " << old_float << endl;
+
+#ifdef HAVE_SSTREAM
+ istringstream istr(old_float);
+#else
istrstream istr(old_float.c_str());
+#endif
+
LyXLex nylex(0, 0);
nylex.setStream(istr);
if (pp.first) {
params.textclass = pp.second;
} else {
- lex.printError("Unknown textclass `$$Token'");
+ lex.printError("Unknown textclass `$$Token'");
params.textclass = 0;
}
if (!textclasslist.Load(params.textclass)) {
par->labelwidthstring = lex.GetString();
// do not delete this token, it is still needed!
} else if (token == "\\end_inset") {
+ lyxerr << "Solitary \\end_inset. Missing \\begin_inset?.\n"
+ << "Last inset read was: " << last_inset_read
+ << endl;
// Simply ignore this. The insets do not have
// to read this.
// But insets should read it, it is a part of
// the inset isn't it? Lgb.
} else if (token == "\\begin_inset") {
- // Should be moved out into its own function/method. (Lgb)
- lex.next();
- string tmptok = lex.GetString();
- // test the different insets
- if (tmptok == "Quotes") {
- Inset * inset = new InsetQuotes;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "External") {
- Inset * inset = new InsetExternal;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "FormulaMacro") {
- Inset * inset = new InsetFormulaMacro;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Formula") {
- Inset * inset = new InsetFormula;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Figure") {
- Inset * inset = new InsetFig(100, 100, this);
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Info") {
- Inset * inset = new InsetInfo;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Include") {
- Inset * inset = new InsetInclude(string(), this);
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "ERT") {
- Inset * inset = new InsetERT;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Tabular") {
- Inset * inset = new InsetTabular(this);
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Text") {
- Inset * inset = new InsetText;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Foot") {
- Inset * inset = new InsetFoot;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Marginal") {
- Inset * inset = new InsetMarginal;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Minipage") {
- Inset * inset = new InsetMinipage;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "Float") {
- Inset * inset = new InsetFloat;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "List") {
- Inset * inset = new InsetList;
- inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- ++pos;
- } else if (tmptok == "GRAPHICS") {
- Inset * inset = new InsetGraphics;
- //inset->Read(this, lex);
- par->InsertInset(pos, inset, font);
- } else if (tmptok == "LatexCommand") {
- InsetCommand inscmd;
- inscmd.Read(this, lex);
- Inset * inset = 0;
- if (inscmd.getCmdName() == "cite") {
- inset = new InsetCitation(inscmd.getContents(), inscmd.getOptions());
- } else if (inscmd.getCmdName() == "bibitem") {
- lex.printError("Wrong place for bibitem");
- inset = inscmd.Clone();
- } else if (inscmd.getCmdName() == "BibTeX") {
- inset = new InsetBibtex(inscmd.getContents(), inscmd.getOptions(), this);
- } else if (inscmd.getCmdName() == "index") {
- inset = new InsetIndex(inscmd.getContents());
- } else if (inscmd.getCmdName() == "include") {
- inset = new InsetInclude(inscmd.getContents(), this);
- } else if (inscmd.getCmdName() == "label") {
- inset = new InsetLabel(inscmd.getCommand());
- } else if (inscmd.getCmdName() == "url"
- || inscmd.getCmdName() == "htmlurl") {
- inset = new InsetUrl(inscmd.getCommand());
- } else if (inscmd.getCmdName() == "ref"
- || inscmd.getCmdName() == "pageref"
- || inscmd.getCmdName() == "vref"
- || inscmd.getCmdName() == "vpageref"
- || inscmd.getCmdName() == "prettyref") {
- if (!inscmd.getOptions().empty() || !inscmd.getContents().empty()) {
- inset = new InsetRef(inscmd, this);
- }
- } else if (inscmd.getCmdName() == "tableofcontents") {
- inset = new InsetTOC(this);
- } else if (inscmd.getCmdName() == "listoffigures") {
- inset = new InsetLOF(this);
- } else if (inscmd.getCmdName() == "listofalgorithms") {
- inset = new InsetLOA(this);
- } else if (inscmd.getCmdName() == "listoftables") {
- inset = new InsetLOT(this);
- } else if (inscmd.getCmdName() == "printindex") {
- inset = new InsetPrintIndex(this);
- } else if (inscmd.getCmdName() == "lyxparent") {
- inset = new InsetParent(inscmd.getContents(), this);
- }
-
- if (inset) {
- par->InsertInset(pos, inset, font);
- ++pos;
- }
- }
+ readInset(lex, par, pos, font);
} else if (token == "\\SpecialChar") {
LyXLayout const & layout =
textclasslist.Style(params.textclass,
// Insets don't make sense in a free-spacing context! ---Kayvan
if (layout.free_spacing) {
if (lex.IsOK()) {
- string next_token;
lex.next();
- next_token = lex.GetString();
+ string next_token = lex.GetString();
if (next_token == "\\-") {
par->InsertChar(pos, '-', font);
} else if (next_token == "\\protected_separator"
par->InsertChar(pos, LyXParagraph::META_NEWLINE, font);
++pos;
} else if (token == "\\LyXTable") {
-#ifdef USE_TABULAR_INSETS
+#ifdef NEW_TABULAR
Inset * inset = new InsetTabular(this);
inset->Read(this, lex);
par->InsertInset(pos, inset, font);
}
++pos;
} else if (token == "\\bibitem") { // ale970302
- if (!par->bibkey)
- par->bibkey = new InsetBibKey;
+ if (!par->bibkey) {
+ InsetCommandParams p( "bibitem" );
+ par->bibkey = new InsetBibKey(p);
+ }
par->bibkey->Read(this, lex);
- }else if (token == "\\backslash") {
+ } else if (token == "\\backslash") {
par->InsertChar(pos, '\\', font);
++pos;
- }else if (token == "\\the_end") {
+ } else if (token == "\\the_end") {
the_end_read = true;
} else {
// This should be insurance for the future: (Asger)
lex.printError("Unknown token `$$Token'. "
"Inserting as text.");
- for(string::const_iterator cit = token.begin();
- cit != token.end(); ++cit) {
+ string::const_iterator cit = token.begin();
+ string::const_iterator end = token.end();
+ for(; cit != end; ++cit) {
par->InsertChar(pos, (*cit), font);
++pos;
}
return the_end_read;
}
-bool Buffer::readFile(LyXLex & lex, LyXParagraph * par)
+
+void Buffer::readInset(LyXLex & lex, LyXParagraph *& par,
+ int & pos, LyXFont & font)
{
- string token;
+ // consistency check
+ if (lex.GetString() != "\\begin_inset") {
+ lyxerr << "Buffer::readInset: Consistency check failed."
+ << endl;
+ }
+
+ lex.next();
+ string tmptok = lex.GetString();
+ last_inset_read = tmptok;
+ // test the different insets
+ if (tmptok == "Quotes") {
+ Inset * inset = new InsetQuotes;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "External") {
+ Inset * inset = new InsetExternal;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "FormulaMacro") {
+ Inset * inset = new InsetFormulaMacro;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Formula") {
+ Inset * inset = new InsetFormula;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Figure") {
+ Inset * inset = new InsetFig(100, 100, this);
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Info") {
+ Inset * inset = new InsetInfo;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Include") {
+ InsetCommandParams p( "Include" );
+ Inset * inset = new InsetInclude(p, this);
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "ERT") {
+ Inset * inset = new InsetERT;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Tabular") {
+ Inset * inset = new InsetTabular(this);
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Text") {
+ Inset * inset = new InsetText;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Foot") {
+ Inset * inset = new InsetFoot;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Marginal") {
+ Inset * inset = new InsetMarginal;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Minipage") {
+ Inset * inset = new InsetMinipage;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Float") {
+ lex.next();
+ string tmptok = lex.GetString();
+ Inset * inset = new InsetFloat(tmptok);
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "List") {
+ Inset * inset = new InsetList;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Theorem") {
+ Inset * inset = new InsetList;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "Caption") {
+ Inset * inset = new InsetCaption;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "GRAPHICS") {
+ Inset * inset = new InsetGraphics;
+ inset->Read(this, lex);
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ } else if (tmptok == "LatexCommand") {
+ InsetCommandParams inscmd;
+ inscmd.Read(lex);
+ Inset * inset = 0;
+ if (inscmd.getCmdName() == "cite") {
+ inset = new InsetCitation(inscmd);
+ } else if (inscmd.getCmdName() == "bibitem") {
+ lex.printError("Wrong place for bibitem");
+ inset = new InsetBibKey(inscmd);
+ } else if (inscmd.getCmdName() == "BibTeX") {
+ inset = new InsetBibtex(inscmd, this);
+ } else if (inscmd.getCmdName() == "index") {
+ inset = new InsetIndex(inscmd);
+ } else if (inscmd.getCmdName() == "include") {
+ inset = new InsetInclude(inscmd, this);
+ } else if (inscmd.getCmdName() == "label") {
+ inset = new InsetLabel(inscmd);
+ } else if (inscmd.getCmdName() == "url"
+ || inscmd.getCmdName() == "htmlurl") {
+ inset = new InsetUrl(inscmd);
+ } else if (inscmd.getCmdName() == "ref"
+ || inscmd.getCmdName() == "pageref"
+ || inscmd.getCmdName() == "vref"
+ || inscmd.getCmdName() == "vpageref"
+ || inscmd.getCmdName() == "prettyref") {
+ if (!inscmd.getOptions().empty()
+ || !inscmd.getContents().empty()) {
+ inset = new InsetRef(inscmd);
+ }
+ } else if (inscmd.getCmdName() == "tableofcontents"
+ || inscmd.getCmdName() == "listofalgorithms"
+ || inscmd.getCmdName() == "listoffigures"
+ || inscmd.getCmdName() == "listoftables") {
+ inset = new InsetTOC(inscmd);
+ } else if (inscmd.getCmdName() == "printindex") {
+ inset = new InsetPrintIndex(inscmd);
+ } else if (inscmd.getCmdName() == "lyxparent") {
+ inset = new InsetParent(inscmd, this);
+ }
+
+ if (inset) {
+ par->InsertInset(pos, inset, font);
+ ++pos;
+ }
+ }
+}
+
+bool Buffer::readFile(LyXLex & lex, LyXParagraph * par)
+{
if (lex.IsOK()) {
lex.next();
- token = lex.GetString();
+ string token(lex.GetString());
if (token == "\\lyxformat") { // the first token _must_ be...
lex.next();
format = lex.GetFloat();
if (format > 1) {
if (LYX_FORMAT - format > 0.05) {
+
printf(_("Warning: need lyxformat %.2f but found %.2f\n"),
LYX_FORMAT, format);
}
if (writeFile(fileName(), false)) {
markLyxClean();
-
- // now delete the autosavefile
- string a = OnlyPath(fileName());
- a += '#';
- a += OnlyFilename(fileName());
- a += '#';
- FileInfo fileinfo(a);
- if (fileinfo.exist()) {
- if (::remove(a.c_str()) != 0) {
- WriteFSAlert(_("Could not delete "
- "auto-save file!"), a);
- }
- }
+ removeAutosaveFile(fileName());
} else {
// Saving failed, so backup is not backup
if (lyxrc.make_backup) {
char c, footnoteflag = 0, depth = 0;
string tmp;
LyXParagraph::size_type i;
- int j, h, ltype = 0, ltype_depth = 0,
- * clen = 0, actcell = 0, actpos = 0, cell = 0, cells = 0,
- currlinelen = 0;
+ int j;
+ int ltype = 0;
+ int ltype_depth = 0;
+ int actcell = 0;
+ int actpos = 0;
+#ifndef NEW_TABULAR
+ int h;
+ int * clen = 0;
+ int cell = 0;
+ int cells = 0;
+#endif
+ int currlinelen = 0;
long fpos = 0;
bool ref_printed = false;
while (par) {
int noparbreak = 0;
int islatex = 0;
- if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
- !par->previous ||
- par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){
-
+ if (
+#ifndef NEW_INSETS
+ par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
+#endif
+ !par->previous
+#ifndef NEW_INSETS
+ || par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE
+#endif
+ ){
+
+#ifndef NEW_INSETS
/* begins a footnote environment ? */
if (footnoteflag != par->footnoteflag) {
footnoteflag = par->footnoteflag;
currlinelen += j;
}
}
+#endif
/* begins or ends a deeper area ?*/
if (depth != par->depth) {
/* what about the alignment */
} else {
+#ifndef NEW_INSETS
/* dummy layout, that means a footnote ended */
footnoteflag = LyXParagraph::NO_FOOTNOTE;
ofs << ") ";
noparbreak = 1;
+#else
+ lyxerr << "Should this ever happen?" << endl;
+#endif
}
//LyXLayout const & layout =
string options; // the document class options.
- if (tokenPos(tclass.opt_fontsize(), '|', params.fontsize) >= 0) {
+ if (tokenPos(tclass.opt_fontsize(),
+ '|', params.fontsize) >= 0) {
// only write if existing in list (and not default)
options += params.fontsize;
options += "pt,";
// language should be a parameter to \documentclass
bool use_babel = false;
- if (params.language_info->RightToLeft()) // This seems necessary
+ if (params.language_info->lang() == "hebrew") // This seems necessary
features.UsedLanguages.insert(default_language);
if (params.language != "default" ||
!features.UsedLanguages.empty() ) {
<< "]{fontenc}\n";
texrow.newline();
}
- if (params.inputenc != "default") {
+
+ if (params.inputenc == "auto") {
+ string doc_encoding =
+ params.language_info->encoding()->LatexName();
+
+ // Create a list with all the input encodings used
+ // in the document
+ set<string> encodings;
+ for (LaTeXFeatures::LanguageList::const_iterator it =
+ features.UsedLanguages.begin();
+ it != features.UsedLanguages.end(); ++it)
+ if ((*it)->encoding()->LatexName() != doc_encoding)
+ encodings.insert((*it)->encoding()->LatexName());
+
+ ofs << "\\usepackage[";
+ for (set<string>::const_iterator it = encodings.begin();
+ it != encodings.end(); ++it)
+ ofs << *it << ",";
+ ofs << doc_encoding << "]{inputenc}\n";
+ texrow.newline();
+ } else if (params.inputenc != "default") {
ofs << "\\usepackage[" << params.inputenc
<< "]{inputenc}\n";
texrow.newline();
}
-
+
// At the very beginning the text parameters.
if (params.paperpackage != BufferParams::PACKAGE_NONE) {
switch (params.paperpackage) {
texrow.newline();
}
- if (tokenPos(tclass.opt_pagestyle(), '|', params.pagestyle) >= 0) {
+ if (tokenPos(tclass.opt_pagestyle(),
+ '|', params.pagestyle) >= 0) {
if (params.pagestyle == "fancy") {
ofs << "\\usepackage{fancyhdr}\n";
texrow.newline();
}
// Now insert the LyX specific LaTeX commands...
- string preamble, tmppreamble;
// The optional packages;
- preamble = features.getPackages();
+ string preamble(features.getPackages());
// this might be useful...
- preamble += "\n\\makeatletter\n\n";
+ preamble += "\n\\makeatletter\n";
// Some macros LyX will need
- tmppreamble = features.getMacros();
+ string tmppreamble(features.getMacros());
if (!tmppreamble.empty()) {
preamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
+ params.preamble + '\n';
}
- preamble += "\\makeatother\n\n";
+ preamble += "\\makeatother\n";
// Itemize bullet settings need to be last in case the user
// defines their own bullets that use a package included
ofs << preamble;
// make the body.
- ofs << "\\begin{document}\n\n";
- texrow.newline();
+ ofs << "\\begin{document}\n";
texrow.newline();
} // only_body
lyxerr.debug() << "preamble finished, now the body." << endl;
lyxerr.debug() << "Finished making latex file." << endl;
}
+
//
// LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end
//
-void Buffer::latexParagraphs(ostream & ofs, LyXParagraph *par,
- LyXParagraph *endpar, TexRow & texrow) const
+void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par,
+ LyXParagraph * endpar, TexRow & texrow) const
{
bool was_title = false;
bool already_title = false;
tmpholder = 0;
}
#endif
+#ifndef NEW_INSETS
if (par->IsDummy())
lyxerr[Debug::LATEX] << "Error in latexParagraphs."
<< endl;
+#endif
LyXLayout const & layout =
textclasslist.Style(params.textclass,
par->layout);
ftcount = -1;
if (layout.isEnvironment()
|| par->pextra_type != LyXParagraph::PEXTRA_NONE) {
- par = par->TeXEnvironment(this, params, ofs, texrow,
- ftnote, ft_texrow, ftcount);
+ par = par->TeXEnvironment(this, params, ofs, texrow
+#ifndef NEW_INSETS
+ ,ftnote, ft_texrow, ftcount
+#endif
+ );
} else {
- par = par->TeXOnePar(this, params, ofs, texrow, false,
- ftnote, ft_texrow, ftcount);
+ par = par->TeXOnePar(this, params, ofs, texrow, false
+#ifndef NEW_INSETS
+ ,
+ ftnote, ft_texrow, ftcount
+#endif
+ );
}
// Write out what we've generated...
}
}
+
bool Buffer::isLatex() const
{
return textclasslist.TextClass(params.textclass).outputType() == LATEX;
}
-void Buffer::makeLinuxDocFile(string const & fname, int column)
+void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
{
LyXParagraph * par = paragraph;
+ niceFile = nice; // this will be used by Insetincludes.
+
string top_element = textclasslist.LatexnameOfClass(params.textclass);
string environment_stack[10];
string item_name;
WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname);
return;
}
-
- tex_code_break_column = column;
+
+ LyXTextClass const & tclass =
+ textclasslist.TextClass(params.textclass);
+
+ LaTeXFeatures features(params, tclass.numLayouts());
+ validate(features);
+
+ //if(nice)
+ tex_code_break_column = lyxrc.ascii_linelen;
+ //else
+ //tex_code_break_column = 0;
+
texrow.reset();
-
- if (params.preamble.empty()) {
- ofs << "<!doctype linuxdoc system>\n\n";
- }
- else {
- ofs << "<!doctype linuxdoc system \n [ "
- << params.preamble << " \n]>\n\n";
+
+ if (!body_only) {
+ string sgml_includedfiles=features.getIncludedFiles();
+
+ if (params.preamble.empty() && sgml_includedfiles.empty()) {
+ ofs << "<!doctype linuxdoc system>\n\n";
+ } else {
+ ofs << "<!doctype linuxdoc system [ "
+ << params.preamble << sgml_includedfiles << " \n]>\n\n";
+ }
+
+ if(params.options.empty())
+ sgmlOpenTag(ofs, 0, top_element);
+ else {
+ string top = top_element;
+ top += " ";
+ top += params.options;
+ sgmlOpenTag(ofs, 0, top);
+ }
}
ofs << "<!-- " << LYX_DOCVERSION
<< " created this file. For more info see http://www.lyx.org/"
<< " -->\n";
- if(params.options.empty())
- sgmlOpenTag(ofs, 0, top_element);
- else {
- string top = top_element;
- top += " ";
- top += params.options;
- sgmlOpenTag(ofs, 0, top);
- }
-
while (par) {
int desc_on = 0; // description mode
LyXLayout const & style =
- textclasslist.Style(users->buffer()->params.textclass,
+ textclasslist.Style(params.textclass,
par->layout);
// treat <toc> as a special case for compatibility with old code
sgmlOpenTag(ofs, depth, temp);
par = par->next;
+#ifndef NEW_INSETS
linuxDocHandleFootnote(ofs, par, depth);
+#endif
continue;
}
}
break;
}
+#ifndef NEW_INSETS
do {
+#endif
SimpleLinuxDocOnePar(ofs, par, desc_on, depth);
par = par->next;
+#ifndef NEW_INSETS
linuxDocHandleFootnote(ofs, par, depth);
}
while(par && par->IsDummy());
+#endif
ofs << "\n";
// write closing SGML tags
if(!environment_stack[depth].empty())
sgmlCloseTag(ofs, depth, environment_stack[depth]);
- ofs << "\n\n";
- sgmlCloseTag(ofs, 0, top_element);
+ if (!body_only) {
+ ofs << "\n\n";
+ sgmlCloseTag(ofs, 0, top_element);
+ }
ofs.close();
// How to check for successful close
}
+#ifndef NEW_INSETS
void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par,
int const depth)
{
par = par->next;
}
}
+#endif
void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag,
LyXParagraph * & par)
{
LyXParagraph * tpar = par;
- while (tpar && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE) &&
- (tpar->layout != textclasslist.NumberOfLayout(params.textclass,
+ while (tpar
+#ifndef NEW_INSETS
+ && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+#endif
+ && (tpar->layout != textclasslist.NumberOfLayout(params.textclass,
"Caption").second))
tpar = tpar->next;
if (tpar &&
}
+#ifndef NEW_INSETS
void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
int const depth)
{
if(!extra_par.empty()) os << extra_par;
if(!tag.empty()) sgmlCloseTag(os, depth, tag);
}
+#endif
// push a tag in a style stack
i < par->size(); ++i) {
// handle quote tag
- if (i == main_body && !par->IsDummy()) {
+ if (i == main_body
+#ifndef NEW_INSETS
+ && !par->IsDummy()
+#endif
+ ) {
if (main_body > 0)
font1 = style.font;
}
case 0:
if (font2.family() == LyXFont::TYPEWRITER_FAMILY) {
push_tag(os, "tt", stack_num, stack);
- family_type= 1;
+ family_type = 1;
}
else if (font2.family() == LyXFont::SANS_FAMILY) {
push_tag(os, "sf", stack_num, stack);
- family_type= 2;
+ family_type = 2;
}
break;
case 1:
pop_tag(os, "tt", stack_num, stack);
if (font2.family() == LyXFont::SANS_FAMILY) {
push_tag(os, "sf", stack_num, stack);
- family_type= 2;
- }
- else {
- family_type= 0;
+ family_type = 2;
+ } else {
+ family_type = 0;
}
break;
case 2:
pop_tag(os, "sf", stack_num, stack);
if (font2.family() == LyXFont::TYPEWRITER_FAMILY) {
push_tag(os, "tt", stack_num, stack);
- family_type= 1;
- }
- else {
- family_type= 0;
+ family_type = 1;
+ } else {
+ family_type = 0;
}
}
}
if (font2.series() == LyXFont::BOLD_SERIES) {
push_tag(os, "bf", stack_num, stack);
is_bold = true;
- }
- else if (is_bold) {
+ } else if (is_bold) {
pop_tag(os, "bf", stack_num, stack);
is_bold = false;
}
case 0:
if (font2.shape() == LyXFont::ITALIC_SHAPE) {
push_tag(os, "it", stack_num, stack);
- shape_type= 1;
- }
- else if (font2.shape() == LyXFont::SLANTED_SHAPE) {
+ shape_type = 1;
+ } else if (font2.shape() == LyXFont::SLANTED_SHAPE) {
push_tag(os, "sl", stack_num, stack);
- shape_type= 2;
+ shape_type = 2;
}
break;
case 1:
pop_tag(os, "it", stack_num, stack);
if (font2.shape() == LyXFont::SLANTED_SHAPE) {
push_tag(os, "sl", stack_num, stack);
- shape_type= 2;
- }
- else {
- shape_type= 0;
+ shape_type = 2;
+ } else {
+ shape_type = 0;
}
break;
case 2:
pop_tag(os, "sl", stack_num, stack);
if (font2.shape() == LyXFont::ITALIC_SHAPE) {
push_tag(os, "it", stack_num, stack);
- shape_type= 1;
- }
- else {
- shape_type= 0;
+ shape_type = 1;
+ } else {
+ shape_type = 0;
}
}
}
}
c = par->GetChar(i);
-
+
+ if (c == LyXParagraph::META_INSET) {
+ inset = par->GetInset(i);
+ inset->Linuxdoc(this, os);
+ }
+
if (font2.latex() == LyXFont::ON) {
// "TeX"-Mode on == > SGML-Mode on.
if (c != '\0')
os << c; // see LaTeX-Generation...
++char_line_count;
- } else if (c == LyXParagraph::META_INSET) {
- inset = par->GetInset(i);
- inset->Linuxdoc(this, os);
} else {
string sgml_string;
if (par->linuxDocConvertChar(c, sgml_string)
linux_doc_line_break(os, char_line_count, 6);
os << "</tag>";
desc_on = 2;
- }
- else {
+ } else {
linux_doc_line_break(os, char_line_count, 1);
os << c;
}
- }
- else {
+ } else {
os << sgml_string;
char_line_count += sgml_string.length();
}
enum { MAX_NEST_LEVEL = 25};
-void Buffer::makeDocBookFile(string const & fname, int column)
+void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
{
LyXParagraph * par = paragraph;
+ niceFile = nice; // this will be used by Insetincludes.
+
string top_element= textclasslist.LatexnameOfClass(params.textclass);
// Please use a real stack.
string environment_stack[MAX_NEST_LEVEL];
string c_depth, c_params, tmps;
int depth = 0; // paragraph depth
+ LyXTextClass const & tclass =
+ textclasslist.TextClass(params.textclass);
- tex_code_break_column = column;
+ LaTeXFeatures features(params, tclass.numLayouts());
+ validate(features);
+
+ //if(nice)
+ tex_code_break_column = lyxrc.ascii_linelen;
+ //else
+ //tex_code_break_column = 0;
ofstream ofs(fname.c_str());
if (!ofs) {
texrow.reset();
- ofs << "<!doctype " << top_element
- << " public \"-//OASIS//DTD DocBook V3.1//EN\"";
+ if(!only_body) {
+ string sgml_includedfiles=features.getIncludedFiles();
- if (params.preamble.empty())
- ofs << ">\n\n";
- else
- ofs << "\n [ " << params.preamble << " \n]>\n\n";
+ ofs << "<!doctype " << top_element
+ << " public \"-//OASIS//DTD DocBook V3.1//EN\"";
- ofs << "<!-- DocBook file was created by " << LYX_DOCVERSION
- << "\n See http://www.lyx.org/ for more information -->\n";
+ if (params.preamble.empty() && sgml_includedfiles.empty())
+ ofs << ">\n\n";
+ else
+ ofs << "\n [ " << params.preamble
+ << sgml_includedfiles << " \n]>\n\n";
- if(params.options.empty())
- sgmlOpenTag(ofs, 0, top_element);
- else {
- string top = top_element;
- top += " ";
- top += params.options;
- sgmlOpenTag(ofs, 0, top);
+ if(params.options.empty())
+ sgmlOpenTag(ofs, 0, top_element);
+ else {
+ string top = top_element;
+ top += " ";
+ top += params.options;
+ sgmlOpenTag(ofs, 0, top);
+ }
}
+ ofs << "<!-- DocBook file was created by " << LYX_DOCVERSION
+ << "\n See http://www.lyx.org/ for more information -->\n";
+
while (par) {
int desc_on = 0; // description mode
LyXLayout const & style =
- textclasslist.Style(users->buffer()->params.textclass,
+ textclasslist.Style(params.textclass,
par->layout);
// environment tag closing
if(!command_stack[j].empty())
sgmlCloseTag(ofs, j, command_stack[j]);
command_depth= command_base= cmd_depth;
- }
- else if(cmd_depth <= command_depth) {
+ } else if(cmd_depth <= command_depth) {
for(int j = command_depth;
j >= cmd_depth; --j)
if(!command_stack[j].empty())
sgmlCloseTag(ofs, j, command_stack[j]);
command_depth= cmd_depth;
- }
- else
+ } else
command_depth= cmd_depth;
- }
- else {
+ } else {
command_depth = command_base = cmd_depth;
command_flag = true;
}
item_name= "term";
sgmlOpenTag(ofs, depth + 1 + command_depth,
item_name);
- }
- else {
+ } else {
item_name= "para";
sgmlOpenTag(ofs, depth + 1 + command_depth,
item_name);
break;
}
+#ifndef NEW_INSETS
do {
+#endif
string extra_par;
SimpleDocBookOnePar(ofs, extra_par, par, desc_on,
depth + 1 + command_depth);
par = par->next;
+#ifndef NEW_INSETS
DocBookHandleFootnote(ofs, par,
depth + 1 + command_depth);
}
while(par && par->IsDummy());
-
+#endif
string end_tag;
// write closing SGML tags
switch(style.latextype) {
if(!command_stack[j].empty())
sgmlCloseTag(ofs, j, command_stack[j]);
- ofs << "\n\n";
- sgmlCloseTag(ofs, 0, top_element);
+ if (!only_body) {
+ ofs << "\n\n";
+ sgmlCloseTag(ofs, 0, top_element);
+ }
ofs.close();
// How to check for successful close
int Buffer::runLaTeX()
{
+#ifndef NEW_EXPORT
+
if (!users->text) return 0;
ProhibitInput(users);
AllowInput(users);
return latex.getNumErrors();
+#else
+ return 0;
+#endif
}
users->owner()->getMiniBuffer()->Set(_("Running Literate..."));
// Remove all error insets
- bool a = users->removeAutoInsets();
+ bool removedErrorInsets = users->removeAutoInsets();
// generate the Literate file if necessary
makeLaTeXFile(lit_name, org_path, false);
// if we removed error insets before we ran LaTeX or if we inserted
// error insets after we ran LaTeX this must be run:
- if (a || (res & Literate::ERRORS)){
+ if (removedErrorInsets || (res & Literate::ERRORS)){
users->redraw();
users->fitCursor();
//users->updateScrollbar();
users->owner()->getMiniBuffer()->Set(_("Building Program..."));
// Remove all error insets
- bool a = users->removeAutoInsets();
+ bool removedErrorInsets = users->removeAutoInsets();
// generate the LaTeX file if necessary
- if (!isNwClean() || a) {
+ if (!isNwClean() || removedErrorInsets) {
makeLaTeXFile(lit_name, org_path, false);
markNwDirty();
}
// if we removed error insets before we ran Literate/Build or
// if we inserted error insets after we ran Literate/Build this
// must be run:
- if (a || (res & Literate::ERRORS)){
+ if (removedErrorInsets || (res & Literate::ERRORS)){
users->redraw();
users->fitCursor();
//users->updateScrollbar();
vector<vector<TocItem> > l(4);
LyXParagraph * par = paragraph;
while (par) {
+#ifndef NEW_INSETS
if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
if (textclasslist.Style(params.textclass,
par->GetLayout()).labeltype
}
}
} else if (!par->IsDummy()) {
+#endif
char labeltype = textclasslist.Style(params.textclass,
par->GetLayout()).labeltype;
tmp.str = par->String(this, true);
l[TOC_TOC].push_back(tmp);
}
+#ifndef NEW_INSETS
}
+#endif
par = par->next;
}
return l;
LyXParagraph * par = paragraph;
while (par) {
if (par->bibkey)
- keys.push_back(pair<string,string>(par->bibkey->getContents(),
+ keys.push_back(pair<string, string>(par->bibkey->getContents(),
par->String(this, false)));
par = par->next;
}
bool dispatched = true;
switch (action) {
case LFUN_EXPORT:
+#ifdef NEW_EXPORT
+ Exporter::Export(this, argument, false);
+#else
MenuExport(this, argument);
+#endif
break;
default:
void Buffer::resize()
{
- /// first resize the BufferViews!
- if (users) {
+ /// resize the BufferViews!
+ if (users)
users->resize();
- }
+}
+
+
+void Buffer::resizeInsets(BufferView * bv)
+{
/// then remove all LyXText in text-insets
LyXParagraph * par = paragraph;
for(;par;par = par->next) {
- par->deleteInsetsLyXText(users);
+ par->resizeInsetsLyXText(bv);
}
}
-
void Buffer::ChangeLanguage(Language const * from, Language const * to)
{