*
* \author Lars Gullik Bjønnes
*
- * Full author contact details are available in file CREDITS
+ * Full author contact details are available in file CREDITS.
*/
#include <config.h>
#include "paragraph_funcs.h"
-#include "paragraph_pimpl.h"
+
#include "buffer.h"
-#include "ParagraphParameters.h"
-#include "lyxtextclasslist.h"
+#include "bufferparams.h"
+
#include "debug.h"
+#include "encoding.h"
+#include "errorlist.h"
+#include "factory.h"
#include "gettext.h"
+#include "iterators.h"
#include "language.h"
-#include "encoding.h"
-#include "lyxrc.h"
+#include "latexrunparams.h"
#include "lyxlex.h"
-#include "factory.h"
-#include "Lsstream.h"
-
-#include "support/lstrings.h"
+#include "lyxrc.h"
+#include "paragraph_pimpl.h"
+#include "sgml.h"
+#include "texrow.h"
+#include "vspace.h"
-#include "insets/insetoptarg.h"
-#include "insets/insetcommandparams.h"
#include "insets/insetbibitem.h"
+#include "insets/insethfill.h"
+#include "insets/insetlatexaccent.h"
+#include "insets/insetline.h"
+#include "insets/insetnewline.h"
+#include "insets/insetpagebreak.h"
+#include "insets/insetoptarg.h"
#include "insets/insetspace.h"
#include "insets/insetspecialchar.h"
-#include "insets/insetlatexaccent.h"
#include "insets/insettabular.h"
-#include "insets/insethfill.h"
-#include "insets/insetnewline.h"
-extern string bibitemWidest(Buffer const *);
+#include "support/filetools.h"
+#include "support/lstrings.h"
+#include "support/lyxlib.h"
+#include "support/std_sstream.h"
-using namespace lyx::support;
+#include <vector>
using lyx::pos_type;
-//using lyx::layout_type;
+
+using lyx::support::ascii_lowercase;
+using lyx::support::atoi;
+using lyx::support::bformat;
+using lyx::support::compare_ascii_no_case;
+using lyx::support::compare_no_case;
+using lyx::support::contains;
+using lyx::support::split;
+using lyx::support::subst;
+
+using std::auto_ptr;
using std::endl;
+using std::string;
+using std::vector;
+using std::istringstream;
using std::ostream;
+using std::pair;
+
+extern string bibitemWidest(Buffer const &);
namespace {
if (from.getInset(i)) {
// the inset is not in a paragraph anymore
tmpinset = from.insetlist.release(i);
- tmpinset->parOwner(0);
}
if (!to.insetAllowed(tmpinset->lyxCode()))
tmp->params().align(par->params().align());
tmp->setLabelWidthString(par->params().labelWidthString());
- tmp->params().lineBottom(par->params().lineBottom());
- par->params().lineBottom(false);
- tmp->params().pagebreakBottom(par->params().pagebreakBottom());
- par->params().pagebreakBottom(false);
tmp->params().spaceBottom(par->params().spaceBottom());
par->params().spaceBottom(VSpace(VSpace::NONE));
if (pos)
return;
- tmp->params().lineTop(par->params().lineTop());
- tmp->params().pagebreakTop(par->params().pagebreakTop());
tmp->params().spaceTop(par->params().spaceTop());
par->params().clear();
ParagraphList::iterator the_next = boost::next(par);
// first the DTP-stuff
- par->params().lineBottom(the_next->params().lineBottom());
par->params().spaceBottom(the_next->params().spaceBottom());
- par->params().pagebreakBottom(the_next->params().pagebreakBottom());
pos_type pos_end = the_next->size() - 1;
pos_type pos_insert = par->size();
namespace {
ParagraphList::iterator
-TeXEnvironment(Buffer const * buf,
+TeXEnvironment(Buffer const & buf,
ParagraphList const & paragraphs,
ParagraphList::iterator pit,
ostream & os, TexRow & texrow,
LatexRunParams const & runparams);
ParagraphList::iterator
-TeXOnePar(Buffer const * buf,
+TeXOnePar(Buffer const & buf,
ParagraphList const & paragraphs,
ParagraphList::iterator pit,
ostream & os, TexRow & texrow,
ParagraphList::iterator
-TeXDeeper(Buffer const * buf,
+TeXDeeper(Buffer const & buf,
ParagraphList const & paragraphs,
ParagraphList::iterator pit,
ostream & os, TexRow & texrow,
ParagraphList::iterator
-TeXEnvironment(Buffer const * buf,
+TeXEnvironment(Buffer const & buf,
ParagraphList const & paragraphs,
ParagraphList::iterator pit,
ostream & os, TexRow & texrow,
{
lyxerr[Debug::LATEX] << "TeXEnvironment... " << &*pit << endl;
- BufferParams const & bparams = buf->params;
+ BufferParams const & bparams = buf.params();
LyXLayout_ptr const & style = pit->layout();
ParagraphList::iterator
-TeXOnePar(Buffer const * buf,
+TeXOnePar(Buffer const & buf,
ParagraphList const & paragraphs,
ParagraphList::iterator pit,
ostream & os, TexRow & texrow,
LatexRunParams const & runparams,
string const & everypar)
{
- lyxerr[Debug::LATEX] << "TeXOnePar... " << &*pit << " '" << everypar
-<< "'" << endl;
- BufferParams const & bparams = buf->params;
+ lyxerr[Debug::LATEX] << "TeXOnePar... " << &*pit << " '"
+ << everypar << "'" << endl;
+ BufferParams const & bparams = buf.params();
InsetOld const * in = pit->inInset();
bool further_blank_line = false;
LyXLayout_ptr style;
// well we have to check if we are in an inset with unlimited
- // lenght (all in one row) if that is true then we don't allow
+ // length (all in one row) if that is true then we don't allow
// any special options in the paragraph and also we don't allow
// any environment other then "Standard" to be valid!
- if ((in == 0) || !in->forceDefaultParagraphs(in)) {
+ if (in == 0 || !in->forceDefaultParagraphs(in)) {
style = pit->layout();
if (pit->params().startOfAppendix()) {
}
if (!pit->params().spacing().isDefault()
- && (pit == const_cast<ParagraphList&>(paragraphs).begin() || !boost::prior(pit)->hasSameLayout(*pit))) {
+ && (pit == const_cast<ParagraphList&>(paragraphs).begin()
+ || !boost::prior(pit)->hasSameLayout(*pit)))
+ {
os << pit->params().spacing().writeEnvirBegin() << '\n';
texrow.newline();
}
texrow.newline();
}
- if (pit->params().pagebreakTop()) {
- os << "\\newpage";
- further_blank_line = true;
- }
if (pit->params().spaceTop().kind() != VSpace::NONE) {
os << pit->params().spaceTop().asLatexCommand(bparams);
further_blank_line = true;
}
- if (pit->params().lineTop()) {
- os << "\\lyxline{\\"
- << pit->getFont(bparams, 0, outerFont(pit, paragraphs)).latexSize()
- << '}'
- << "\\vspace{-1\\parskip}";
- further_blank_line = true;
- }
-
if (further_blank_line) {
os << '\n';
texrow.newline();
if (in == 0 || !in->forceDefaultParagraphs(in)) {
further_blank_line = false;
- if (pit->params().lineBottom()) {
- os << "\\lyxline{\\" << font.latexSize() << '}';
- further_blank_line = true;
- }
if (pit->params().spaceBottom().kind() != VSpace::NONE) {
os << pit->params().spaceBottom().asLatexCommand(bparams);
further_blank_line = true;
}
- if (pit->params().pagebreakBottom()) {
- os << "\\newpage";
- further_blank_line = true;
- }
-
if (further_blank_line) {
os << '\n';
texrow.newline();
}
if (!pit->params().spacing().isDefault()
- && (boost::next(pit) == const_cast<ParagraphList&>(paragraphs).end()|| !boost::next(pit)->hasSameLayout(*pit))) {
+ && (boost::next(pit) == const_cast<ParagraphList&>(paragraphs).end()
+ || !boost::next(pit)->hasSameLayout(*pit)))
+ {
os << pit->params().spacing().writeEnvirEnd() << '\n';
texrow.newline();
}
//
// LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end
//
-void latexParagraphs(Buffer const * buf,
+void latexParagraphs(Buffer const & buf,
ParagraphList const & paragraphs,
ostream & os,
TexRow & texrow,
{
bool was_title = false;
bool already_title = false;
- LyXTextClass const & tclass = buf->params.getLyXTextClass();
+ LyXTextClass const & tclass = buf.params().getLyXTextClass();
ParagraphList::iterator par = const_cast<ParagraphList&>(paragraphs).begin();
ParagraphList::iterator endpar = const_cast<ParagraphList&>(paragraphs).end();
// length (all in one row) if that is true then we don't allow
// any special options in the paragraph and also we don't allow
// any environment other then "Standard" to be valid!
- if ((in == 0) || !in->forceDefaultParagraphs(in)) {
+ if (in == 0 || !in->forceDefaultParagraphs(in)) {
LyXLayout_ptr const & layout = par->layout();
if (layout->intitle) {
}
+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, ' '));
+}
+
+}
+
+
+void asciiParagraph(Buffer const & buf,
+ Paragraph const & par,
+ ostream & os,
+ LatexRunParams const & runparams,
+ bool noparbreak)
+{
+ int ltype = 0;
+ Paragraph::depth_type ltype_depth = 0;
+ bool ref_printed = false;
+ Paragraph::depth_type depth = par.params().depth();
+
+ // First write the layout
+ string const & tmp = par.layout()->name();
+ if (compare_no_case(tmp, "itemize") == 0) {
+ ltype = 1;
+ ltype_depth = depth + 1;
+ } else if (compare_ascii_no_case(tmp, "enumerate") == 0) {
+ ltype = 2;
+ ltype_depth = depth + 1;
+ } else if (contains(ascii_lowercase(tmp), "ection")) {
+ ltype = 3;
+ ltype_depth = depth + 1;
+ } else if (contains(ascii_lowercase(tmp), "aragraph")) {
+ ltype = 4;
+ ltype_depth = depth + 1;
+ } else if (compare_ascii_no_case(tmp, "description") == 0) {
+ ltype = 5;
+ ltype_depth = depth + 1;
+ } else if (compare_ascii_no_case(tmp, "abstract") == 0) {
+ ltype = 6;
+ ltype_depth = 0;
+ } else if (compare_ascii_no_case(tmp, "bibliography") == 0) {
+ ltype = 7;
+ ltype_depth = 0;
+ } else {
+ ltype = 0;
+ ltype_depth = 0;
+ }
+
+ /* maybe some vertical spaces */
+
+ /* the labelwidthstring used in lists */
+
+ /* some lines? */
+
+ /* some pagebreaks? */
+
+ /* noindent ? */
+
+ /* what about the alignment */
+
+ // runparams.linelen <= 0 is special and means we don't have paragraph breaks
+
+ string::size_type currlinelen = 0;
+
+ if (!noparbreak) {
+ if (runparams.linelen > 0)
+ os << "\n\n";
+
+ os << 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
+ // the correct language! (20012712 Jug)
+ //--
+ switch (ltype) {
+ case 0: // Standard
+ case 4: // (Sub)Paragraph
+ case 5: // Description
+ break;
+ case 6: // Abstract
+ if (runparams.linelen > 0) {
+ os << _("Abstract") << "\n\n";
+ currlinelen = 0;
+ } else {
+ string const abst = _("Abstract: ");
+ os << abst;
+ currlinelen += abst.length();
+ }
+ break;
+ case 7: // Bibliography
+ if (!ref_printed) {
+ if (runparams.linelen > 0) {
+ os << _("References") << "\n\n";
+ currlinelen = 0;
+ } else {
+ string const refs = _("References: ");
+ os << refs;
+ currlinelen += refs.length();
+ }
+
+ ref_printed = true;
+ }
+ break;
+ default:
+ {
+ string const parlab = par.params().labelString();
+ os << parlab << ' ';
+ currlinelen += parlab.length() + 1;
+ }
+ break;
+
+ }
+ }
+
+ if (!currlinelen) {
+ pair<int, string> p = addDepth(depth, ltype_depth);
+ os << 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 runparams.linelength!) (Jug)
+
+ string word;
+
+ for (pos_type i = 0; i < par.size(); ++i) {
+ char c = par.getUChar(buf.params(), i);
+ switch (c) {
+ case Paragraph::META_INSET:
+ {
+ InsetOld const * inset = par.getInset(i);
+ if (inset) {
+ if (runparams.linelen > 0) {
+ os << word;
+ currlinelen += word.length();
+ word.erase();
+ }
+ if (inset->ascii(buf, os, runparams)) {
+ // to be sure it breaks paragraph
+ currlinelen += runparams.linelen;
+ }
+ }
+ }
+ break;
+
+ default:
+ if (c == ' ') {
+ if (runparams.linelen > 0 &&
+ currlinelen + word.length() > runparams.linelen - 10) {
+ os << "\n";
+ pair<int, string> p = addDepth(depth, ltype_depth);
+ os << p.second;
+ currlinelen = p.first;
+ }
+
+ os << word << ' ';
+ currlinelen += word.length() + 1;
+ word.erase();
+
+ } else {
+ if (c != '\0') {
+ word += c;
+ } else {
+ lyxerr[Debug::INFO] <<
+ "writeAsciiFile: NULL char in structure." << endl;
+ }
+ if ((runparams.linelen > 0) &&
+ (currlinelen + word.length()) > runparams.linelen)
+ {
+ os << "\n";
+
+ pair<int, string> p =
+ addDepth(depth, ltype_depth);
+ os << p.second;
+ currlinelen = p.first;
+ }
+ }
+ break;
+ }
+ }
+ os << word;
+}
+
+
+void linuxdocParagraphs(Buffer const & buf,
+ ParagraphList const & paragraphs,
+ ostream & os,
+ LatexRunParams const & runparams)
+{
+
+ Paragraph::depth_type depth = 0; // paragraph depth
+ string item_name;
+ vector<string> environment_stack(5);
+
+ ParagraphList::iterator pit = const_cast<ParagraphList&>(paragraphs).begin();
+ ParagraphList::iterator pend = const_cast<ParagraphList&>(paragraphs).end();
+ for (; pit != pend; ++pit) {
+ LyXLayout_ptr const & style = pit->layout();
+ // treat <toc> as a special case for compatibility with old code
+ if (pit->isInset(0)) {
+ InsetOld * inset = pit->getInset(0);
+ InsetOld::Code lyx_code = inset->lyxCode();
+ if (lyx_code == InsetOld::TOC_CODE) {
+ string const temp = "toc";
+ sgml::openTag(os, depth, false, temp);
+ continue;
+ }
+ }
+
+ // environment tag closing
+ for (; depth > pit->params().depth(); --depth) {
+ sgml::closeTag(os, depth, false, environment_stack[depth]);
+ environment_stack[depth].erase();
+ }
+
+ // write opening SGML tags
+ switch (style->latextype) {
+ case LATEX_PARAGRAPH:
+ if (depth == pit->params().depth()
+ && !environment_stack[depth].empty()) {
+ sgml::closeTag(os, depth, false, environment_stack[depth]);
+ environment_stack[depth].erase();
+ if (depth)
+ --depth;
+ else
+ os << "</p>";
+ }
+ sgml::openTag(os, depth, false, style->latexname());
+ break;
+
+ case LATEX_COMMAND:
+ if (depth != 0)
+ //error(ErrorItem(_("Error:"), _("Wrong depth for LatexType Command.\n"), pit->id(), 0, pit->size()));
+ ;
+
+ if (!environment_stack[depth].empty()) {
+ sgml::closeTag(os, depth, false, environment_stack[depth]);
+ os << "</p>";
+ }
+
+ environment_stack[depth].erase();
+ sgml::openTag(os, depth, false, style->latexname());
+ break;
+
+ case LATEX_ENVIRONMENT:
+ case LATEX_ITEM_ENVIRONMENT:
+ case LATEX_BIB_ENVIRONMENT:
+ {
+ string const & latexname = style->latexname();
+
+ if (depth == pit->params().depth()
+ && environment_stack[depth] != latexname) {
+ sgml::closeTag(os, depth, false,
+ environment_stack[depth]);
+ environment_stack[depth].erase();
+ }
+ if (depth < pit->params().depth()) {
+ depth = pit->params().depth();
+ environment_stack[depth].erase();
+ }
+ if (environment_stack[depth] != latexname) {
+ if (depth == 0) {
+ sgml::openTag(os, depth, false, "p");
+ }
+ sgml::openTag(os, depth, false, latexname);
+
+ if (environment_stack.size() == depth + 1)
+ environment_stack.push_back("!-- --");
+ environment_stack[depth] = latexname;
+ }
+
+ if (style->latexparam() == "CDATA")
+ os << "<![CDATA[";
+
+ if (style->latextype == LATEX_ENVIRONMENT) break;
+
+ if (style->labeltype == LABEL_MANUAL)
+ item_name = "tag";
+ else
+ item_name = "item";
+
+ sgml::openTag(os, depth + 1, false, item_name);
+ }
+ break;
+
+ default:
+ sgml::openTag(os, depth, false, style->latexname());
+ break;
+ }
+
+ pit->simpleLinuxDocOnePar(buf, os, outerFont(pit, paragraphs),
+ runparams, depth);
+
+ os << "\n";
+ // write closing SGML tags
+ switch (style->latextype) {
+ case LATEX_COMMAND:
+ break;
+ case LATEX_ENVIRONMENT:
+ case LATEX_ITEM_ENVIRONMENT:
+ case LATEX_BIB_ENVIRONMENT:
+ if (style->latexparam() == "CDATA")
+ os << "]]>";
+ break;
+ default:
+ sgml::closeTag(os, depth, false, style->latexname());
+ break;
+ }
+ }
+
+ // Close open tags
+ for (int i = depth; i >= 0; --i)
+ sgml::closeTag(os, depth, false, environment_stack[i]);
+}
+
+
+void docbookParagraphs(Buffer const & buf,
+ ParagraphList const & paragraphs,
+ ostream & os,
+ LatexRunParams const & runparams)
+{
+ vector<string> environment_stack(10);
+ vector<string> environment_inner(10);
+ vector<string> command_stack(10);
+
+ bool command_flag = false;
+ Paragraph::depth_type command_depth = 0;
+ Paragraph::depth_type command_base = 0;
+ Paragraph::depth_type cmd_depth = 0;
+ Paragraph::depth_type depth = 0; // paragraph depth
+
+ string item_name;
+ string command_name;
+
+ ParagraphList::iterator par = const_cast<ParagraphList&>(paragraphs).begin();
+ ParagraphList::iterator pend = const_cast<ParagraphList&>(paragraphs).end();
+
+ for (; par != pend; ++par) {
+ string sgmlparam;
+ string c_depth;
+ string c_params;
+ int desc_on = 0; // description mode
+
+ LyXLayout_ptr const & style = par->layout();
+
+ // environment tag closing
+ for (; depth > par->params().depth(); --depth) {
+ if (!environment_inner[depth].empty())
+ sgml::closeEnvTags(os, false, environment_inner[depth],
+ command_depth + depth);
+ sgml::closeTag(os, depth + command_depth, false, environment_stack[depth]);
+ environment_stack[depth].erase();
+ environment_inner[depth].erase();
+ }
+
+ if (depth == par->params().depth()
+ && environment_stack[depth] != style->latexname()
+ && !environment_stack[depth].empty()) {
+ sgml::closeEnvTags(os, false, environment_inner[depth],
+ command_depth + depth);
+ sgml::closeTag(os, depth + command_depth, false, environment_stack[depth]);
+
+ environment_stack[depth].erase();
+ environment_inner[depth].erase();
+ }
+
+ // Write opening SGML tags.
+ switch (style->latextype) {
+ case LATEX_PARAGRAPH:
+ sgml::openTag(os, depth + command_depth,
+ false, style->latexname());
+ break;
+
+ case LATEX_COMMAND:
+ if (depth != 0)
+ //error(ErrorItem(_("Error"), _("Wrong depth for LatexType Command."), par->id(), 0, par->size()));
+ ;
+
+ command_name = style->latexname();
+
+ sgmlparam = style->latexparam();
+ c_params = split(sgmlparam, c_depth,'|');
+
+ cmd_depth = atoi(c_depth);
+
+ if (command_flag) {
+ if (cmd_depth < command_base) {
+ for (Paragraph::depth_type j = command_depth;
+ j >= command_base; --j) {
+ sgml::closeTag(os, j, false, command_stack[j]);
+ os << endl;
+ }
+ command_depth = command_base = cmd_depth;
+ } else if (cmd_depth <= command_depth) {
+ for (int j = command_depth;
+ j >= int(cmd_depth); --j) {
+ sgml::closeTag(os, j, false, command_stack[j]);
+ os << endl;
+ }
+ command_depth = cmd_depth;
+ } else
+ command_depth = cmd_depth;
+ } else {
+ command_depth = command_base = cmd_depth;
+ command_flag = true;
+ }
+ if (command_stack.size() == command_depth + 1)
+ command_stack.push_back(string());
+ command_stack[command_depth] = command_name;
+
+ // treat label as a special case for
+ // more WYSIWYM handling.
+ // This is a hack while paragraphs can't have
+ // attributes, like id in this case.
+ if (par->isInset(0)) {
+ InsetOld * inset = par->getInset(0);
+ InsetOld::Code lyx_code = inset->lyxCode();
+ if (lyx_code == InsetOld::LABEL_CODE) {
+ command_name += " id=\"";
+ command_name += (static_cast<InsetCommand *>(inset))->getContents();
+ command_name += '"';
+ desc_on = 3;
+ }
+ }
+
+ sgml::openTag(os, depth + command_depth, false, command_name);
+
+ item_name = c_params.empty() ? "title" : c_params;
+ sgml::openTag(os, depth + 1 + command_depth, false, item_name);
+ break;
+
+ case LATEX_ENVIRONMENT:
+ case LATEX_ITEM_ENVIRONMENT:
+ if (depth < par->params().depth()) {
+ depth = par->params().depth();
+ environment_stack[depth].erase();
+ }
+
+ if (environment_stack[depth] != style->latexname()) {
+ if (environment_stack.size() == depth + 1) {
+ environment_stack.push_back("!-- --");
+ environment_inner.push_back("!-- --");
+ }
+ environment_stack[depth] = style->latexname();
+ environment_inner[depth] = "!-- --";
+ sgml::openTag(os, depth + command_depth, false, environment_stack[depth]);
+ } else {
+ sgml::closeEnvTags(os, false, environment_inner[depth],
+ command_depth + depth);
+ }
+
+ if (style->latextype == LATEX_ENVIRONMENT) {
+ if (!style->latexparam().empty()) {
+ if (style->latexparam() == "CDATA")
+ os << "<![CDATA[";
+ else
+ sgml::openTag(os, depth + command_depth, false, style->latexparam());
+ }
+ break;
+ }
+
+ desc_on = (style->labeltype == LABEL_MANUAL);
+
+ environment_inner[depth] = desc_on ? "varlistentry" : "listitem";
+ sgml::openTag(os, depth + 1 + command_depth,
+ false, environment_inner[depth]);
+
+ item_name = desc_on ? "term" : "para";
+ sgml::openTag(os, depth + 1 + command_depth,
+ false, item_name);
+ break;
+ default:
+ sgml::openTag(os, depth + command_depth,
+ false, style->latexname());
+ break;
+ }
+
+ par->simpleDocBookOnePar(buf, os, outerFont(par, paragraphs), desc_on,
+ runparams, depth + 1 + command_depth);
+
+ string end_tag;
+ // write closing SGML tags
+ switch (style->latextype) {
+ case LATEX_COMMAND:
+ end_tag = c_params.empty() ? "title" : c_params;
+ sgml::closeTag(os, depth + command_depth,
+ false, end_tag);
+ break;
+ case LATEX_ENVIRONMENT:
+ if (!style->latexparam().empty()) {
+ if (style->latexparam() == "CDATA")
+ os << "]]>";
+ else
+ sgml::closeTag(os, depth + command_depth, false, style->latexparam());
+ }
+ break;
+ case LATEX_ITEM_ENVIRONMENT:
+ if (desc_on == 1) break;
+ end_tag = "para";
+ sgml::closeTag(os, depth + 1 + command_depth, false, end_tag);
+ break;
+ case LATEX_PARAGRAPH:
+ sgml::closeTag(os, depth + command_depth, false, style->latexname());
+ break;
+ default:
+ sgml::closeTag(os, depth + command_depth, false, style->latexname());
+ break;
+ }
+ }
+
+ // Close open tags
+ for (int d = depth; d >= 0; --d) {
+ if (!environment_stack[depth].empty()) {
+ sgml::closeEnvTags(os, false, environment_inner[depth],
+ command_depth + depth);
+ }
+ }
+
+ for (int j = command_depth; j >= 0 ; --j)
+ if (!command_stack[j].empty()) {
+ sgml::closeTag(os, j, false, command_stack[j]);
+ os << endl;
+ }
+}
+
namespace {
int readParToken(Buffer & buf, Paragraph & par, LyXLex & lex, string const & token)
static LyXFont font;
static Change change;
- BufferParams const & bp = buf.params;
+ BufferParams const & bp = buf.params();
if (token[0] != '\\') {
string::const_iterator cit = token.begin();
<< "Missing \\begin_inset?.\n";
} else if (token == "\\begin_inset") {
InsetOld * inset = readInset(lex, buf);
- par.insertInset(par.size(), inset, font, change);
+ if (inset)
+ par.insertInset(par.size(), inset, font, change);
+ else {
+ lex.eatLine();
+ string line = lex.getString();
+ buf.error(ErrorItem(_("Unknown Inset"), line,
+ buf.paragraphs().back().id(),
+ 0, par.size()));
+ return 1;
+ }
} else if (token == "\\family") {
lex.next();
font.setLyXFamily(lex.getString());
}
}
} else {
- InsetOld * inset = 0;
+ auto_ptr<InsetOld> inset;
if (token == "\\SpecialChar" )
- inset = new InsetSpecialChar;
+ inset.reset(new InsetSpecialChar);
else
- inset = new InsetSpace;
- inset->read(&buf, lex);
- par.insertInset(par.size(), inset, font, change);
+ inset.reset(new InsetSpace);
+ inset->read(buf, lex);
+ par.insertInset(par.size(), inset.release(),
+ font, change);
}
} else if (token == "\\i") {
- InsetOld * inset = new InsetLatexAccent;
- inset->read(&buf, lex);
- par.insertInset(par.size(), inset, font, change);
+ auto_ptr<InsetOld> inset(new InsetLatexAccent);
+ inset->read(buf, lex);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\backslash") {
par.insertChar(par.size(), '\\', font, change);
} else if (token == "\\newline") {
- InsetOld * inset = new InsetNewline;
- inset->read(&buf, lex);
- par.insertInset(par.size(), inset, font, change);
+ auto_ptr<InsetOld> inset(new InsetNewline);
+ inset->read(buf, lex);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\LyXTable") {
- InsetOld * inset = new InsetTabular(buf);
- inset->read(&buf, lex);
- par.insertInset(par.size(), inset, font, change);
+ auto_ptr<InsetOld> inset(new InsetTabular(buf));
+ inset->read(buf, lex);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\bibitem") {
InsetCommandParams p("bibitem", "dummy");
- InsetBibitem * inset = new InsetBibitem(p);
- inset->read(&buf, lex);
- par.insertInset(par.size(), inset, font, change);
+ auto_ptr<InsetBibitem> inset(new InsetBibitem(p));
+ inset->read(buf, lex);
+ par.insertInset(par.size(), inset.release(), font, change);
} else if (token == "\\hfill") {
par.insertInset(par.size(), new InsetHFill, font, change);
+ } else if (token == "\\lyxline") {
+ par.insertInset(par.size(), new InsetLine, font, change);
+ } else if (token == "\\newpage") {
+ par.insertInset(par.size(), new InsetPagebreak, font, change);
} else if (token == "\\change_unchanged") {
// Hack ! Needed for empty paragraphs :/
// FIXME: is it still ??
change = Change(Change::UNCHANGED);
} else if (token == "\\change_inserted") {
lex.nextToken();
- istringstream is(STRCONV(lex.getString()));
+ istringstream is(lex.getString());
int aid;
lyx::time_type ct;
is >> aid >> ct;
change = Change(Change::INSERTED, bp.author_map[aid], ct);
} else if (token == "\\change_deleted") {
lex.nextToken();
- istringstream is(STRCONV(lex.getString()));
+ istringstream is(lex.getString());
int aid;
lyx::time_type ct;
is >> aid >> ct;
token, lex.getString());
buf.error(ErrorItem(_("Unknown token"), s,
- par.id(), 0, par.size()));
+ buf.paragraphs().back().id(),
+ 0, par.size()));
return 1;
}
return 0;
return tmpfont;
}
+
+
+ParagraphList::iterator outerPar(Buffer const & buf, InsetOld const * inset)
+{
+ ParIterator pit = const_cast<Buffer &>(buf).par_iterator_begin();
+ ParIterator end = const_cast<Buffer &>(buf).par_iterator_end();
+ for ( ; pit != end; ++pit) {
+
+ ParagraphList * plist;
+ // the second '=' below is intentional
+ for (int i = 0; (plist = inset->getParagraphs(i)); ++i)
+ if (plist == &pit.plist())
+ return pit.outerPar();
+
+ InsetList::iterator ii = pit->insetlist.begin();
+ InsetList::iterator iend = pit->insetlist.end();
+ for ( ; ii != iend; ++ii)
+ if (ii->inset == inset)
+ return pit.outerPar();
+ }
+ lyxerr << "outerPar: should not happen" << endl;
+ BOOST_ASSERT(false);
+ return const_cast<Buffer &>(buf).paragraphs().end(); // shut up compiler
+}
+
+
+Paragraph const & ownerPar(Buffer const & buf, InsetOld const * inset)
+{
+ ParConstIterator pit = buf.par_iterator_begin();
+ ParConstIterator end = buf.par_iterator_end();
+ for ( ; pit != end; ++pit) {
+ ParagraphList * plist;
+ // the second '=' below is intentional
+ for (int i = 0; (plist = inset->getParagraphs(i)); ++i)
+ if (plist == &pit.plist())
+ return *pit.pit();
+
+ InsetList::const_iterator ii = pit->insetlist.begin();
+ InsetList::const_iterator iend = pit->insetlist.end();
+ for ( ; ii != iend; ++ii)
+ if (ii->inset == inset)
+ return *pit.pit();
+ }
+ lyxerr << "ownerPar: should not happen" << endl;
+ BOOST_ASSERT(false);
+ return buf.paragraphs().front(); // shut up compiler
+}
projects / lyx.git / blobdiff