X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=ca58a7546b283b4183113ddc38c3e20d0f3a7d82;hb=d2b9849fffc03f8278d9d034dbccc59b58a214db;hp=4ab9eac82f7ea6a41eee3d3c70c8df6351242bd9;hpb=27de1486ca34aaad446adb798d71a77d6f6304da;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index 4ab9eac82f..ca58a7546b 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -1,12 +1,12 @@ /* This file is part of -* ====================================================== -* -* LyX, The Document Processor -* -* Copyright (C) 1995 Matthias Ettrich -* Copyright (C) 1995-1998 The LyX Team. -* -*======================================================*/ + * ====================================================== + * + * LyX, The Document Processor + * + * Copyright 1995 Matthias Ettrich + * Copyright 1995-2000 The LyX Team. + * + * ====================================================== */ #include @@ -14,44 +14,46 @@ #pragma implementation "lyxparagraph.h" #endif +#include +using std::fstream; +using std::ios; + #include "lyxparagraph.h" +#include "support/textutils.h" #include "lyxrc.h" #include "layout.h" #include "tex-strings.h" #include "bufferparams.h" -#include "FileInfo.h" -#include "error.h" +#include "support/FileInfo.h" +#include "support/LAssert.h" +#include "debug.h" #include "LaTeXFeatures.h" #include "insets/insetinclude.h" -#include "filetools.h" +#include "insets/insetbib.h" +#include "support/filetools.h" #include "lyx_gui_misc.h" #include "texrow.h" -// $Id: paragraph.C,v 1.1 1999/09/27 18:44:38 larsbj Exp $ - -#if !defined(lint) && !defined(WITH_WARNINGS) -static char vcid[] = "$Id: paragraph.C,v 1.1 1999/09/27 18:44:38 larsbj Exp $"; -#endif /* lint */ -#define INITIAL_SIZE_PAR 10 /*Number of bytes in one paragraph*/ -#define STEP_SIZE_PAR 10 /*Number of bytes added when reallocated*/ - -extern void addNewlineAndDepth(LString & file, int const depth); // Jug 990923 -extern unsigned char GetCurrentTextClass(); // this should be fixed/removed +#ifdef USE_OSTREAM_ONLY +#include "support/lyxmanip.h" +#else +extern void addNewlineAndDepth(string & file, int depth); // Jug 990923 +#endif int tex_code_break_column = 72; // needs non-zero initialization. set later. // this is a bad idea, but how can LyXParagraph find its buffer to get // parameters? (JMarc) -extern BufferView *current_view; -extern LyXRC *lyxrc; +extern BufferView * current_view; +extern LyXRC * lyxrc; // ale970405 -extern LString bibitemWidthest(); +extern string bibitemWidthest(Painter &); -/* this is a minibuffer */ +// this is a minibuffer static char minibuffer_char; static LyXFont minibuffer_font; -static Inset *minibuffer_inset; +static Inset * minibuffer_inset; // Initialization of the counter for the paragraph id's, @@ -61,87 +63,63 @@ unsigned int LyXParagraph::paragraph_id = 0; LyXParagraph::LyXParagraph() { - size = INITIAL_SIZE_PAR; - last = 0; - text = new char[size]; - for (int i=0; i<10; i++) setCounter(i , 0); + text.reserve(500); // is this number too big? + + for (int i = 0; i < 10; ++i) setCounter(i , 0); appendix = false; enumdepth = 0; itemdepth = 0; - next = NULL; - previous = NULL; - fonttable = NULL; - insettable = NULL; + next = 0; + previous = 0; footnoteflag = LyXParagraph::NO_FOOTNOTE; - + footnotekind = LyXParagraph::FOOTNOTE; // should not be needed + align = LYX_ALIGN_BLOCK; /* table stuff -- begin*/ - table = NULL; + table = 0; /* table stuff -- end*/ - id = paragraph_id++; - bibkey = NULL; // ale970302 + id_ = paragraph_id++; + bibkey = 0; // ale970302 Clear(); } -/* this konstruktor inserts the new paragraph in a list */ -LyXParagraph::LyXParagraph(LyXParagraph *par) +// This konstruktor inserts the new paragraph in a list. +LyXParagraph::LyXParagraph(LyXParagraph * par) { - size = INITIAL_SIZE_PAR; - last = 0; - text = new char[size]; - for (int i=0; i<10; i++) setCounter(i, 0); + text.reserve(500); + par->text.resize(par->text.size()); + + for (int i = 0; i < 10; ++i) setCounter(i, 0); appendix = false; enumdepth = 0; itemdepth = 0; + // double linked list begin next = par->next; if (next) next->previous = this; previous = par; previous->next = this; - fonttable = NULL; - insettable = NULL; + // end footnoteflag = LyXParagraph::NO_FOOTNOTE; footnotekind = LyXParagraph::FOOTNOTE; /* table stuff -- begin*/ - table = NULL; + table = 0; /* table stuff -- end*/ - id = paragraph_id++; + id_ = paragraph_id++; - bibkey = NULL; // ale970302 - // ale970302 -// fprintf(stderr, "new bib "); fflush(stderr); -// if (par->bibkey) { -// bibkey = new InsetBibKey(par->bibkey); -// } + bibkey = 0; // ale970302 Clear(); } -/// Used by the spellchecker -bool LyXParagraph::IsLetter(int pos){ - unsigned char c = GetChar(pos); - if (IsLetterChar(c)) - return true; - // '\0' is not a letter, allthough every string contains "" (below) - if( c == '\0') - return false; - // We want to pass the ' and escape chars to ispell - LString extra = lyxrc->isp_esc_chars + '\''; - char ch[2]; - ch[0] = c; - ch[1] = 0; - return extra.contains(ch); -} - -void LyXParagraph::writeFile(FILE *file, BufferParams ¶ms, - char footflag, char dth) +void LyXParagraph::writeFile(ostream & os, BufferParams const & params, + char footflag, char dth) const { LyXFont font1, font2; - Inset *inset; int column = 0; int h = 0; char c = 0; @@ -150,72 +128,72 @@ void LyXParagraph::writeFile(FILE *file, BufferParams ¶ms, || !previous || previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){ - /* The beginning or the end of a footnote environment? */ + // The beginning or the end of a footnote environment? if (footflag != footnoteflag) { footflag = footnoteflag; if (footflag) { - fprintf(file, "\n\\begin_float %s ", - string_footnotekinds[footnotekind]); - } - else { - fprintf(file, "\n\\end_float "); + os << "\n\\begin_float " + << string_footnotekinds[footnotekind] + << " "; + } else { + os << "\n\\end_float "; } } - /* The beginning or end of a deeper (i.e. nested) area? */ + // The beginning or end of a deeper (i.e. nested) area? if (dth != depth) { if (depth > dth) { while (depth > dth) { - fprintf(file, "\n\\begin_deeper "); - dth++; + os << "\n\\begin_deeper "; + ++dth; } - } - else { + } else { while (depth < dth) { - fprintf(file, "\n\\end_deeper "); - dth--; + os << "\n\\end_deeper "; + --dth; } } } - /* First write the layout */ - fprintf(file, "\n\\layout %s\n", - lyxstyle.NameOfLayout(params.textclass,layout).c_str()); + // First write the layout + os << "\n\\layout " + << textclasslist.NameOfLayout(params.textclass, layout) + << "\n"; - /* maybe some vertical spaces */ + // Maybe some vertical spaces. if (added_space_top.kind() != VSpace::NONE) - fprintf(file, "\\added_space_top %s ", - added_space_top.asLyXCommand().c_str()); + os << "\\added_space_top " + << added_space_top.asLyXCommand() << " "; if (added_space_bottom.kind() != VSpace::NONE) - fprintf(file, "\\added_space_bottom %s ", - added_space_bottom.asLyXCommand().c_str()); + os << "\\added_space_bottom " + << added_space_bottom.asLyXCommand() << " "; - /* The labelwidth string used in lists */ + // The labelwidth string used in lists. if (!labelwidthstring.empty()) - fprintf(file, "\\labelwidthstring %s\n", - labelwidthstring.c_str()); + os << "\\labelwidthstring " + << labelwidthstring << '\n'; - /* Lines above or below? */ + // Lines above or below? if (line_top) - fprintf(file, "\\line_top "); + os << "\\line_top "; if (line_bottom) - fprintf(file, "\\line_bottom "); + os << "\\line_bottom "; - /* Pagebreaks above or below? */ + // Pagebreaks above or below? if (pagebreak_top) - fprintf(file, "\\pagebreak_top "); + os << "\\pagebreak_top "; if (pagebreak_bottom) - fprintf(file, "\\pagebreak_bottom "); + os << "\\pagebreak_bottom "; - /* Start of appendix? */ + // Start of appendix? if (start_of_appendix) - fprintf(file, "\\start_of_appendix "); + os << "\\start_of_appendix "; - /* Noindent? */ + // Noindent? if (noindent) - fprintf(file, "\\noindent "); + os << "\\noindent "; - /* Alignment? */ + // Alignment? if (align != LYX_ALIGN_LAYOUT) { switch (align) { case LYX_ALIGN_LEFT: h = 1; break; @@ -223,132 +201,136 @@ void LyXParagraph::writeFile(FILE *file, BufferParams ¶ms, case LYX_ALIGN_CENTER: h = 3; break; default: h = 0; break; } - fprintf(file, "\\align %s ", string_align[h]); + os << "\\align " << string_align[h] << " "; } if (pextra_type != PEXTRA_NONE) { - fprintf(file, "\\pextra_type %d", pextra_type); + os << "\\pextra_type " << pextra_type; if (pextra_type == PEXTRA_MINIPAGE) { - fprintf(file, " \\pextra_alignment %d", - pextra_alignment); + os << " \\pextra_alignment " + << pextra_alignment; if (pextra_hfill) - fprintf(file, " \\pextra_hfill %d", - pextra_hfill); + os << " \\pextra_hfill " + << pextra_hfill; if (pextra_start_minipage) - fprintf(file, " \\pextra_start_minipage %d", - pextra_start_minipage); + os << " \\pextra_start_minipage " + << pextra_start_minipage; } if (!pextra_width.empty()) { - fprintf(file, " \\pextra_width %s", - VSpace(pextra_width).asLyXCommand().c_str()); + os << " \\pextra_width " + << VSpace(pextra_width).asLyXCommand(); } else if (!pextra_widthp.empty()) { - fprintf(file, " \\pextra_widthp %s",pextra_widthp.c_str()); + os << " \\pextra_widthp " + << pextra_widthp; } - fprintf(file,"\n"); + os << '\n'; } - } - else { - /* Dummy layout. This means that a footnote ended */ - fprintf(file, "\n\\end_float "); + } else { + // Dummy layout. This means that a footnote ended. + os << "\n\\end_float "; footflag = LyXParagraph::NO_FOOTNOTE; } - /* It might be a table */ + // It might be a table. if (table){ - fprintf(file, "\\LyXTable\n"); - table->Write(file); + os << "\\LyXTable\n"; + table->Write(os); } // bibitem ale970302 if (bibkey) - bibkey->Write(file); + bibkey->Write(os); font1 = LyXFont(LyXFont::ALL_INHERIT); column = 0; - for (int i = 0; i < last; i++) { - if (!i){ - fprintf(file, "\n"); + for (size_type i = 0; i < size(); ++i) { + if (!i) { + os << "\n"; column = 0; } - + // Write font changes font2 = GetFontSettings(i); if (font2 != font1) { - font2.lyxWriteChanges(font1, file); + font2.lyxWriteChanges(font1, os); column = 0; font1 = font2; } c = GetChar(i); switch (c) { - case LYX_META_INSET: - inset = GetInset(i); + case META_INSET: + { + Inset const * inset = GetInset(i); if (inset) if (inset->DirectWrite()) { // international char, let it write // code directly so it's shorter in // the file - inset->Write(file); + inset->Write(os); } else { - fprintf(file, "\n\\begin_inset "); - inset->Write(file); - fprintf(file, "\n\\end_inset \n"); - fprintf(file, "\n"); + os << "\n\\begin_inset "; + inset->Write(os); + os << "\n\\end_inset \n\n"; column = 0; } - break; - case LYX_META_NEWLINE: - fprintf(file, "\n\\newline \n"); + } + break; + case META_NEWLINE: + os << "\n\\newline \n"; column = 0; break; - case LYX_META_HFILL: - fprintf(file, "\n\\hfill \n"); + case META_HFILL: + os << "\n\\hfill \n"; column = 0; break; - case LYX_META_PROTECTED_SEPARATOR: - fprintf(file, "\n\\protected_separator \n"); +#if 0 + case META_PROTECTED_SEPARATOR: + os << "\n\\protected_separator \n"; column = 0; break; - case '\\': - fprintf(file, "\n\\backslash \n"); +#endif + case '\\': + os << "\n\\backslash \n"; column = 0; break; case '.': - if (i + 1 < last && GetChar(i + 1) == ' ') { - fprintf(file, ".\n"); + if (i + 1 < size() && GetChar(i + 1) == ' ') { + os << ".\n"; column = 0; } else - fprintf(file, "."); + os << "."; break; default: - if ((column > 70 && c==' ') - || column > 79){ - fprintf(file, "\n"); + if ((column > 70 && c == ' ') + || column > 79) { + os << "\n"; column = 0; } // this check is to amend a bug. LyX sometimes // inserts '\0' this could cause problems. if (c != '\0') - fprintf(file, "%c", c); + os << c; else - lyxerr.print("ERROR (LyXParagraph::writeFile):" - " NULL char in structure."); - column++; + lyxerr << "ERROR (LyXParagraph::writeFile):" + " NULL char in structure." << endl; + ++column; break; } } // now write the next paragraph if (next) - next->writeFile(file, params, footflag, dth); + next->writeFile(os, params, footflag, dth); } -void LyXParagraph::validate(LaTeXFeatures &features) +void LyXParagraph::validate(LaTeXFeatures & features) const { // this will be useful later - LyXLayout *layout = lyxstyle.Style(GetCurrentTextClass(), - GetLayout()); + LyXLayout const & layout = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); // check the params. if (line_top || line_bottom) @@ -358,50 +340,48 @@ void LyXParagraph::validate(LaTeXFeatures &features) features.layout[GetLayout()] = true; // then the fonts - FontTable *tmpfonttable = fonttable; - while (tmpfonttable) { - if (tmpfonttable->font.noun() == LyXFont::ON) { - lyxerr.debug(LString("font.noun: ") - + int(tmpfonttable->font.noun()), - Error::LATEX); + for (FontList::const_iterator cit = fontlist.begin(); + cit != fontlist.end(); ++cit) { + if ((*cit).font.noun() == LyXFont::ON) { + lyxerr[Debug::LATEX] << "font.noun: " + << (*cit).font.noun() + << endl; features.noun = true; - lyxerr.debug("Noun enabled. Font: " - +tmpfonttable->font.stateText(), - Error::LATEX); - } - switch (tmpfonttable->font.color()) { - case LyXFont::NONE: - case LyXFont::INHERIT_COLOR: - case LyXFont::IGNORE_COLOR: + lyxerr[Debug::LATEX] << "Noun enabled. Font: " + << (*cit).font.stateText() + << endl; + } + switch ((*cit).font.color()) { + case LColor::none: + case LColor::inherit: + case LColor::ignore: break; default: features.color = true; - lyxerr.debug("Color enabled. Font: " - +tmpfonttable->font.stateText(), - Error::LATEX); + lyxerr[Debug::LATEX] << "Color enabled. Font: " + << (*cit).font.stateText() + << endl; } - tmpfonttable = tmpfonttable->next; } - + // then the insets - InsetTable *tmpinsettable = insettable; - while (tmpinsettable) { - if (tmpinsettable->inset) { - tmpinsettable->inset->Validate(features); - } - tmpinsettable = tmpinsettable->next; + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) { + if ((*cit).inset) + (*cit).inset->Validate(features); } + if (table && table->IsLongTable()) features.longtable = true; if (pextra_type == PEXTRA_INDENT) features.LyXParagraphIndent = true; if (pextra_type == PEXTRA_FLOATFLT) features.floatflt = true; - if (layout->needprotect + if (layout.needprotect && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) features.NeedLyXFootnoteCode = true; - if ((current_view->currentBuffer()->params.paragraph_separation == LYX_PARSEP_INDENT) && - (pextra_type == PEXTRA_MINIPAGE)) + if ((current_view->buffer()->params.paragraph_separation == BufferParams::PARSEP_INDENT) && + (pextra_type == LyXParagraph::PEXTRA_MINIPAGE)) features.NeedLyXMinipageIndent = true; if (table && table->NeedRotating()) features.rotating = true; @@ -410,17 +390,17 @@ void LyXParagraph::validate(LaTeXFeatures &features) } -/* first few functions needed for cut and paste and paragraph breaking */ -void LyXParagraph::CopyIntoMinibuffer(int pos) +// First few functions needed for cut and paste and paragraph breaking. +void LyXParagraph::CopyIntoMinibuffer(LyXParagraph::size_type pos) const { minibuffer_char = GetChar(pos); minibuffer_font = GetFontSettings(pos); minibuffer_inset = 0; - if (minibuffer_char == LYX_META_INSET) { + if (minibuffer_char == LyXParagraph::META_INSET) { if (GetInset(pos)) { minibuffer_inset = GetInset(pos)->Clone(); } else { - minibuffer_inset = NULL; + minibuffer_inset = 0; minibuffer_char = ' '; // This reflects what GetInset() does (ARRae) } @@ -428,47 +408,47 @@ void LyXParagraph::CopyIntoMinibuffer(int pos) } -void LyXParagraph::CutIntoMinibuffer(int pos) +void LyXParagraph::CutIntoMinibuffer(LyXParagraph::size_type pos) { minibuffer_char = GetChar(pos); minibuffer_font = GetFontSettings(pos); minibuffer_inset = 0; - if (minibuffer_char == LYX_META_INSET) { + if (minibuffer_char == LyXParagraph::META_INSET) { if (GetInset(pos)) { minibuffer_inset = GetInset(pos); - /* This is a little hack since I want exactly the inset, - not just a clone. Otherwise the inset would be deleted - when calling Erase(pos) */ - - /* find the entry */ - InsetTable *tmpi = insettable; - while (tmpi && tmpi->pos != pos) { - tmpi=tmpi->next; - } - if (tmpi) { /* This should always be true */ - tmpi->inset = NULL; + // This is a little hack since I want exactly + // the inset, not just a clone. Otherwise + // the inset would be deleted when calling Erase(pos) + // find the entry + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).pos == pos) { + (*it).inset = 0; + break; + } + } } else { - minibuffer_inset = NULL; + minibuffer_inset = 0; minibuffer_char = ' '; // This reflects what GetInset() does (ARRae) } } - /* Erase(pos); now the caller is responsible for that*/ + // Erase(pos); now the caller is responsible for that. } -void LyXParagraph::InsertFromMinibuffer(int pos) +void LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos) { InsertChar(pos, minibuffer_char); SetFont(pos, minibuffer_font); - if (minibuffer_char == LYX_META_INSET) + if (minibuffer_char == LyXParagraph::META_INSET) InsertInset(pos, minibuffer_inset); } -/* end of minibuffer */ +// end of minibuffer @@ -488,22 +468,22 @@ void LyXParagraph::Clear() noindent = false; pextra_type = PEXTRA_NONE; - pextra_width.clean(); - pextra_widthp.clean(); + pextra_width.clear(); + pextra_widthp.clear(); pextra_alignment = MINIPAGE_ALIGN_TOP; pextra_hfill = false; pextra_start_minipage = false; - labelstring.clean(); - labelwidthstring.clean(); + labelstring.clear(); + labelwidthstring.clear(); layout = 0; - bibkey = NULL; + bibkey = 0; start_of_appendix = false; } -/* the destructor removes the new paragraph from the list */ +// the destructor removes the new paragraph from the list LyXParagraph::~LyXParagraph() { if (previous) @@ -511,323 +491,238 @@ LyXParagraph::~LyXParagraph() if (next) next->previous = previous; - if (text) - delete[] text; - - InsetTable *tmpinset; - while (insettable) { - tmpinset = insettable; - insettable = insettable->next; - if (tmpinset->inset) - delete tmpinset->inset; - delete tmpinset; - if (insettable && insettable->next == insettable) { - // somehow this recursion appears occasionally - // but I can't find where. This bandaid - // helps but isn't the best fix. (ARRae) - if (insettable->inset) { - delete insettable->inset; - } - delete insettable; - break; - } - } - - FontTable *tmpfont; - while (fonttable) { - tmpfont = fonttable; - fonttable = fonttable->next; - delete tmpfont; + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + delete (*it).inset; } /* table stuff -- begin*/ - if (table) - delete table; + delete table; /* table stuff -- end*/ // ale970302 - if (bibkey) - delete bibkey; + delete bibkey; } -void LyXParagraph::Erase(int pos) +void LyXParagraph::Erase(LyXParagraph::size_type pos) { - int i; - - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { + // > because last is the next unused position, and you can + // use it if you want + if (pos > size()) { if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote()->Erase(pos - last - 1); + NextAfterFootnote()->Erase(pos - text.size() - 1); else - lyxerr.debug("ERROR (LyXParagraph::Erase): position does not exist."); + lyxerr.debug() << "ERROR (LyXParagraph::Erase): " + "position does not exist." << endl; return; } - if (pos < last) { // last is free for insertation, but should be empty - - /* if it is an inset, delete the inset entry */ - if (text[pos] == LYX_META_INSET) { - /* find the entry */ - InsetTable *tmpi = insettable; - InsetTable *tmpi2 = tmpi; - while (tmpi && tmpi->pos != pos) { - tmpi2=tmpi; - tmpi=tmpi->next; - } - if (tmpi) { // this should always be true - if (tmpi->inset) // delete the inset if it exists - delete tmpi->inset; - if (tmpi == insettable) - insettable = tmpi->next; - else - tmpi2->next = tmpi->next; - delete tmpi; - } - } - - // Shift rest of text - for (i = pos; i < last - 1; i++) { - text[i]=text[i+1]; - } - last--; - - /* erase entries in the tables */ - int found = 0; - FontTable *tmp = fonttable; - FontTable *prev = NULL; - while (tmp && !found) { - if (pos >= tmp->pos && pos <= tmp->pos_end) - found = 1; - else { - prev = tmp; - tmp = tmp->next; + if (pos < size()) { // last is free for insertation, but should be empty + // if it is an inset, delete the inset entry + if (text[pos] == LyXParagraph::META_INSET) { + // find the entry + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).pos == pos) { + delete (*it).inset; + insetlist.erase(it); + break; + } } } - - if (found && tmp->pos == tmp->pos_end) { - /* if it is a multi-character font entry, we just make - * it smaller (see update below), otherwise we should - * delete it */ - if (prev) - prev->next = tmp->next; - else - fonttable = tmp->next; - - delete tmp; + text.erase(text.begin() + pos); + // Erase entries in the tables. + for (FontList::iterator it = fontlist.begin(); + it != fontlist.end(); ++it) { + if (pos >= (*it).pos && pos <= (*it).pos_end) { + if ((*it).pos == (*it).pos_end) { + // If it is a multi-character font + // entry, we just make it smaller + // (see update below), otherwise we + // should delete it. + fontlist.erase(it); + break; + } + } } - - /* update all other entries */ - - tmp = fonttable; - while (tmp) { - if (tmp->pos > pos) - tmp->pos--; - if (tmp->pos_end >= pos) - tmp->pos_end--; - tmp = tmp->next; + // Update all other entries. + for (FontList::iterator it = fontlist.begin(); + it != fontlist.end(); ++it) { + if ((*it).pos > pos) + (*it).pos--; + if ((*it).pos_end >= pos) + (*it).pos_end--; } - - /* update the inset table */ - InsetTable *tmpi = insettable; - while (tmpi) { - if (tmpi->pos > pos) - tmpi->pos--; - tmpi=tmpi->next; + + // Update the inset table. + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).pos > pos) + (*it).pos--; } - } else { - lyxerr.print("ERROR (LyXParagraph::Erase): can't erase non-existant char."); + lyxerr << "ERROR (LyXParagraph::Erase): " + "can't erase non-existant char." << endl; } } -/* pos is needed to specify the paragraph correctly. Remember the -* closed footnotes */ -void LyXParagraph::Enlarge(int pos, int number) +void LyXParagraph::InsertChar(LyXParagraph::size_type pos, char c) { - int i; - - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote()->Enlarge(pos - last - 1, number); + // > because last is the next unused position, and you can + // use it if you want + if (pos > size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + NextAfterFootnote()->InsertChar(pos - text.size() - 1, + c); else - lyxerr.print("ERROR (LyXParagraph::Enlarge): position does not exist."); + lyxerr.debug() << "ERROR (LyXParagraph::InsertChar): " + "position does not exist." << endl; return; } - - if (size - last < number) { - size += number - size + last + STEP_SIZE_PAR; - char *tmp = new char[size]; - for (i = 0; i < last; i++) - tmp[i] = text[i]; - delete[] text; - text = tmp; + text.insert(text.begin() + pos, c); + // Update the font table. + for (FontList::iterator it = fontlist.begin(); + it != fontlist.end(); ++it) { + if ((*it).pos >= pos) + (*it).pos++; + if ((*it).pos_end >= pos) + (*it).pos_end++; } -} - - -/* make the allocated memory fit to the needed size */ -/* used to make a paragraph smaller */ -void LyXParagraph::FitSize() -{ - int i; - - if (size - last > STEP_SIZE_PAR) { - size = last + STEP_SIZE_PAR; - char *tmp = new char[size]; - for (i = 0; i < last; i++) - tmp[i] = text[i]; - delete[] text; - text = tmp; + + // Update the inset table. + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).pos >= pos) + (*it).pos++; } } -void LyXParagraph::InsertChar(int pos, char c) +void LyXParagraph::InsertInset(LyXParagraph::size_type pos, + Inset * inset) { - register int i; - - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote()->InsertChar(pos - last - 1, c); + // > because last is the next unused position, and you can + // use it if you want + if (pos > size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + NextAfterFootnote() + ->InsertInset(pos - text.size() - 1, inset); else - lyxerr.debug("ERROR (LyXParagraph::InsertChar): " - "position does not exist."); + lyxerr << "ERROR (LyXParagraph::InsertInset): " + "position does not exist: " << pos << endl; return; } - - // Are we full? If so, enlarge. - if (last == size) { - size += STEP_SIZE_PAR; - char *tmp = new char[size]; - for (i = 0; i < last; i++) - tmp[i] = text[i]; - delete[] text; - text = tmp; - } - - // Shift rest of character - for (i = last; i>pos; i--) { - text[i]=text[i-1]; + if (text[pos] != LyXParagraph::META_INSET) { + lyxerr << "ERROR (LyXParagraph::InsertInset): " + "there is no LyXParagraph::META_INSET" << endl; + return; } - text[pos]=c; - last++; - - /* update the font table */ - FontTable *tmp = fonttable; - while (tmp) { - if (tmp->pos >= pos) - tmp->pos++; - if (tmp->pos_end >= pos) - tmp->pos_end++; - tmp = tmp->next; - } - - /* update the inset table */ - InsetTable *tmpi = insettable; - while (tmpi) { - if (tmpi->pos >= pos) - tmpi->pos++; - tmpi=tmpi->next; + if (inset) { + // Add a new entry in the inset table. + InsetList::iterator it = + insetlist.insert(insetlist.begin(), InsetTable()); + (*it).inset = inset; + (*it).pos = pos; } } -void LyXParagraph::InsertInset(int pos, Inset *inset) +Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) { - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote()->InsertInset(pos - last - 1, inset); - else - lyxerr.print("ERROR (LyXParagraph::InsertInset): " - "position does not exist: " + pos); - return; - } - - if (text[pos]!=LYX_META_INSET) { - lyxerr.print("ERROR (LyXParagraph::InsertInset): " - "there is no LYX_META_INSET"); - return; + if (pos >= size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + return NextAfterFootnote() + ->GetInset(pos - text.size() - 1); + else { + lyxerr << "ERROR (LyXParagraph::GetInset): " + "position does not exist: " + << pos << endl; + } + return 0; } - - if (inset) { - /* add a new entry in the inset table */ - InsetTable *tmpi = new InsetTable; - tmpi->pos = pos; - tmpi->inset = inset; - tmpi->next = insettable; - insettable = tmpi; + // Find the inset. + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).pos == pos) { + return (*it).inset; + } } + lyxerr << "ERROR (LyXParagraph::GetInset): " + "Inset does not exist: " << pos << endl; + text[pos] = ' '; // WHY!!! does this set the pos to ' '???? + // Did this commenting out introduce a bug? So far I have not + // see any, please enlighten me. (Lgb) + // My guess is that since the inset does not exist, we might + // as well replace it with a space to prevent craches. (Asger) + return 0; } -Inset* LyXParagraph::GetInset(int pos) +Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const { - if (pos >= last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote()->GetInset(pos - last - 1); + if (pos >= size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + return NextAfterFootnote() + ->GetInset(pos - text.size() - 1); else { - lyxerr.print(LString("ERROR (LyXParagraph::GetInset): position does not exist: ") + pos); + lyxerr << "ERROR (LyXParagraph::GetInset): " + "position does not exist: " + << pos << endl; } - return NULL; + return 0; } - - /* find the inset */ - InsetTable *tmpi = insettable; - - while (tmpi && tmpi->pos != pos) - tmpi = tmpi->next; - - if (tmpi) - return tmpi->inset; - else { - lyxerr.print(LString("ERROR (LyXParagraph::GetInset): " - "Inset does not exist: ") + pos); - text[pos] = ' '; /// WHY!!! does this set the pos to ' '???? - // Did this commenting out introduce a bug? So far I have not - // seen any, please enlighten me. (Lgb) - // My guess is that since the inset does not exist, we might - // as well replace it with a space to prevent crashes. (Asger) - return NULL; + // Find the inset. + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) { + if ((*cit).pos == pos) { + return (*cit).inset; + } } + lyxerr << "ERROR (LyXParagraph::GetInset): " + "Inset does not exist: " << pos << endl; + //text[pos] = ' '; // WHY!!! does this set the pos to ' '???? + // Did this commenting out introduce a bug? So far I have not + // see any, please enlighten me. (Lgb) + // My guess is that since the inset does not exist, we might + // as well replace it with a space to prevent craches. (Asger) + return 0; } // Gets uninstantiated font setting at position. // Optimized after profiling. (Asger) -LyXFont LyXParagraph::GetFontSettings(int pos) +LyXFont LyXParagraph::GetFontSettings(LyXParagraph::size_type pos) const { - if (pos < last) { - FontTable *tmp = fonttable; - while (tmp) { - if (pos >= tmp->pos && pos <= tmp->pos_end) - return tmp->font; - tmp = tmp->next; + if (pos < size()) { + for (FontList::const_iterator cit = fontlist.begin(); + cit != fontlist.end(); ++cit) { + if (pos >= (*cit).pos && pos <= (*cit).pos_end) + return (*cit).font; } } - - /* > because last is the next unused position, and you can - * use it if you want */ - else if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote()->GetFontSettings(pos - last - 1); + // > because last is the next unused position, and you can + // use it if you want + else if (pos > size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + return NextAfterFootnote() + ->GetFontSettings(pos - text.size() - 1); else { // Why is it an error to ask for the font of a // position that does not exist? Would it be - // enough for this to be anable on debug? + // enough for this to be enabled on debug? // We want strict error checking, but it's ok to only // have it when debugging. (Asger) - lyxerr.print( - LString("ERROR (LyXParagraph::GetFontSettings): " - "position does not exist. ") + pos); + lyxerr << "ERROR (LyXParagraph::GetFontSettings): " + "position does not exist. " + << pos << " (" << static_cast(pos) + << ")" << endl; } } else if (pos) { return GetFontSettings(pos - 1); @@ -843,172 +738,185 @@ LyXFont LyXParagraph::GetFontSettings(int pos) // the true picture of the buffer. (Asger) // If position is -1, we get the layout font of the paragraph. // If position is -2, we get the font of the manual label of the paragraph. -LyXFont LyXParagraph::getFont(int pos) +LyXFont LyXParagraph::getFont(LyXParagraph::size_type pos) const { LyXFont tmpfont; - LyXLayout *layout = lyxstyle.Style(GetCurrentTextClass(), - GetLayout()); - - int main_body=0; - if (layout->labeltype == LABEL_MANUAL) + LyXLayout const & layout = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + LyXParagraph::size_type main_body = 0; + if (layout.labeltype == LABEL_MANUAL) main_body = BeginningOfMainBody(); if (pos >= 0){ LyXFont layoutfont; if (pos < main_body) - layoutfont = layout->labelfont; + layoutfont = layout.labelfont; else - layoutfont = layout->font; + layoutfont = layout.font; tmpfont = GetFontSettings(pos); tmpfont.realize(layoutfont); } else { // process layoutfont for pos == -1 and labelfont for pos < -1 if (pos == -1) - tmpfont = layout->font; + tmpfont = layout.font; else - tmpfont = layout->labelfont; + tmpfont = layout.labelfont; + if (getParDirection() == LYX_DIR_RIGHT_TO_LEFT) + tmpfont.setDirection(LyXFont::RTL_DIR); } // check for environment font information char par_depth = GetDepth(); - LyXParagraph * par = this; + LyXParagraph const * par = this; while (par && par_depth && !tmpfont.resolved()) { par = par->DepthHook(par_depth - 1); if (par) { - tmpfont.realize(lyxstyle. - Style(GetCurrentTextClass(), - par->GetLayout())->font); + tmpfont.realize(textclasslist. + Style(current_view->buffer()->params.textclass, + par->GetLayout()).font); par_depth = par->GetDepth(); } } - tmpfont.realize(lyxstyle.TextClass(GetCurrentTextClass())->defaultfont); + tmpfont.realize(textclasslist + .TextClass(current_view->buffer()->params.textclass) + .defaultfont()); return tmpfont; } /// Returns the height of the highest font in range -LyXFont::FONT_SIZE LyXParagraph::HighestFontInRange(int startpos, int endpos) const +LyXFont::FONT_SIZE +LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos, + LyXParagraph::size_type endpos) const { LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY; - - FontTable *tmp = fonttable; - while (tmp) { - if (startpos <= tmp->pos_end && endpos >= tmp->pos) { - LyXFont::FONT_SIZE size = tmp->font.size(); - if (size > maxsize && size<=LyXFont::SIZE_HUGER) + for (FontList::const_iterator cit = fontlist.begin(); + cit != fontlist.end(); ++cit) { + if (startpos <= (*cit).pos_end && endpos >= (*cit).pos) { + LyXFont::FONT_SIZE size = (*cit).font.size(); + if (size > maxsize && size <= LyXFont::SIZE_HUGER) maxsize = size; } - tmp = tmp->next; } return maxsize; } -char LyXParagraph::GetChar(int pos) +char LyXParagraph::GetChar(LyXParagraph::size_type pos) { -#ifdef DEVEL_VERSION - /* a workaround to 'fix' some bugs in text-class */ - if (pos < 0) { - // This function is important. It should not work around bugs. - // Let's find the bugs instead and fix them. (Asger) - lyxerr.print(LString("FATAL ERROR (LyXParagraph::GetChar):" - " bad position ") + pos); - abort(); - } -#endif + Assert(pos >= 0); - if (pos < last) { + if (pos < size()) { return text[pos]; } - - /* > because last is the next unused position, and you can - * use it if you want */ - else if (pos > last) { + // > because last is the next unused position, and you can + // use it if you want + else if (pos > size()) { if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) - return NextAfterFootnote()->GetChar(pos - last - 1); - else - lyxerr.print("ERROR (LyXParagraph::GetChar): " - "position does not exist."); + return NextAfterFootnote() + ->GetChar(pos - text.size() - 1); + else { + lyxerr << "ERROR (LyXParagraph::GetChar): " + "position does not exist." + << pos << " (" << static_cast(pos) + << ")\n"; + // Assert(false); // This triggers sometimes... + // Why? + } return '\0'; - } else { // pos==last - /* we should have a footnote environment */ + } else { + // We should have a footnote environment. if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) { -// Notice that LyX does request the last char from time to time. (Asger) -// lyxerr.print("ERROR (LyXParagraph::GetChar): " -// "expected footnote."); + // Notice that LyX does request the + // last char from time to time. (Asger) + //lyxerr << "ERROR (LyXParagraph::GetChar): " + // "expected footnote." << endl; return '\0'; } switch (next->footnotekind) { case LyXParagraph::FOOTNOTE: - return LYX_META_FOOTNOTE; + return LyXParagraph::META_FOOTNOTE; case LyXParagraph::MARGIN: - return LYX_META_MARGIN; + return LyXParagraph::META_MARGIN; case LyXParagraph::FIG: case LyXParagraph::WIDE_FIG: - return LYX_META_FIG; + return LyXParagraph::META_FIG; case LyXParagraph::TAB: case LyXParagraph::WIDE_TAB: - return LYX_META_TAB; + return LyXParagraph::META_TAB; case LyXParagraph::ALGORITHM: - return LYX_META_ALGORITHM; - } -// if (next->footnotekind == LyXParagraph::FOOTNOTE) -// return LYX_META_FOOTNOTE; -// if (next->footnotekind == LyXParagraph::MARGIN) -// return LYX_META_MARGIN; -// if (next->footnotekind == LyXParagraph::FIG) -// return LYX_META_FIG; -// if (next->footnotekind == LyXParagraph::TAB) -// return LYX_META_TAB; -// if (next->footnotekind == LyXParagraph::ALGORITHM) -// return LYX_META_ALGORITHM; -// lyxerr.print("ERROR (LyXParagraph::GetChar): " -// "unknown footnote kind."); -// return 'F'; /* this should not happen! */ - // This _can_ not happen, due to the type of next->footnotekind - // being LyXParagraph::footnot_kind + return LyXParagraph::META_ALGORITHM; + } return '\0'; // to shut up gcc } } -LString LyXParagraph::GetWord(int & lastpos) - - - //Added 98/9/21 by REH - // return an LString of the current word, and the end of the word - // in lastpos. +char LyXParagraph::GetChar(LyXParagraph::size_type pos) const +{ + Assert(pos >= 0); - // the current word is defined as starting at the first character from - // the immediate left of lastpospos which meets the definition of IsLetter(), - // continuing to the last character to the right of this meeting - // IsLetter. + if (pos < size()) { + return text[pos]; + } + // > because last is the next unused position, and you can + // use it if you want + else if (pos > size()) { + if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) + return NextAfterFootnote() + ->GetChar(pos - text.size() - 1); + else { + lyxerr << "ERROR (LyXParagraph::GetChar const): " + "position does not exist." + << pos << " (" << static_cast(pos) + << ")\n"; + Assert(false); + } + return '\0'; + } else { + // We should have a footnote environment. + if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) { + // Notice that LyX does request the + // last char from time to time. (Asger) + //lyxerr << "ERROR (LyXParagraph::GetChar): " + // "expected footnote." << endl; + return '\0'; + } + switch (next->footnotekind) { + case LyXParagraph::FOOTNOTE: + return LyXParagraph::META_FOOTNOTE; + case LyXParagraph::MARGIN: + return LyXParagraph::META_MARGIN; + case LyXParagraph::FIG: + case LyXParagraph::WIDE_FIG: + return LyXParagraph::META_FIG; + case LyXParagraph::TAB: + case LyXParagraph::WIDE_TAB: + return LyXParagraph::META_TAB; + case LyXParagraph::ALGORITHM: + return LyXParagraph::META_ALGORITHM; + } + return '\0'; // to shut up gcc + } +} - // i just left this in from GetChar() +// return an string of the current word, and the end of the word in lastpos. +string LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const { -#ifdef DEVEL_VERSION - /* a workaround to 'fix' some bugs in text-class */ - if (lastpos < 0) { - // This function is important. It should not work around bugs. - // Let's find the bugs instead and fix them. (Asger) - lyxerr.print(LString("FATAL ERROR (LyXParagraph::GetWord):" - " bad position ") + lastpos); - abort(); - } -#endif + Assert(lastpos>=0); - LString theword; + // the current word is defined as starting at the first character + // from the immediate left of lastpospos which meets the definition + // of IsLetter(), continuing to the last character to the right + // of this meeting IsLetter. - // grab a word - - - //i think the devcode aborts before this, but why not be - // versatile? - if (lastpos < 0) lastpos=0; + string theword; - + // grab a word + // move back until we have a letter //there's no real reason to have firstpos & lastpos as @@ -1018,17 +926,17 @@ LString LyXParagraph::GetWord(int & lastpos) //since someone might have typed a punctuation first int firstpos = lastpos; - while ((firstpos >=0) && !IsLetter(firstpos)) - firstpos--; + while ((firstpos >= 0) && !IsLetter(firstpos)) + --firstpos; // now find the beginning by looking for a nonletter - while ((firstpos>=0) && IsLetter(firstpos)) - firstpos--; + while ((firstpos>= 0) && IsLetter(firstpos)) + --firstpos; // the above is now pointing to the preceeding non-letter - firstpos++; - lastpos=firstpos; + ++firstpos; + lastpos = firstpos; // so copy characters into theword until we get a nonletter // note that this can easily exceed lastpos, wich means @@ -1037,49 +945,53 @@ LString LyXParagraph::GetWord(int & lastpos) while (IsLetter(lastpos)) theword += GetChar(lastpos++); - return theword; + return theword; } - -int LyXParagraph::Last() + +LyXParagraph::size_type LyXParagraph::Last() const { if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return last + NextAfterFootnote()->Last() + 1; /* the 1 is the symbol - * for the footnote */ + return text.size() + NextAfterFootnote()->Last() + 1; + // the 1 is the symbol + // for the footnote else - return last; + return text.size(); } -LyXParagraph *LyXParagraph::ParFromPos(int pos) +LyXParagraph * LyXParagraph::ParFromPos(LyXParagraph::size_type pos) { - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote()->ParFromPos(pos - last - 1); + // > because last is the next unused position, and you can + // use it if you want + if (pos > size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + return NextAfterFootnote() + ->ParFromPos(pos - text.size() - 1); else - lyxerr.print("ERROR (LyXParagraph::ParFromPos): " - "position does not exist."); + lyxerr << "ERROR (LyXParagraph::ParFromPos): " + "position does not exist." << endl; return this; - } - else + } else return this; } -int LyXParagraph::PositionInParFromPos(int pos) +int LyXParagraph::PositionInParFromPos(LyXParagraph::size_type pos) const { - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote()->PositionInParFromPos(pos - last - 1); + // > because last is the next unused position, and you can + // use it if you want + if (pos > size()) { + if (next + && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + return NextAfterFootnote() + ->PositionInParFromPos(pos - text.size() - 1); else - lyxerr.print( + lyxerr << "ERROR (LyXParagraph::PositionInParFromPos): " - "position does not exist."); + "position does not exist." << endl; return pos; } else @@ -1087,209 +999,210 @@ int LyXParagraph::PositionInParFromPos(int pos) } -void LyXParagraph::SetFont(int pos, LyXFont const & font) +void LyXParagraph::SetFont(LyXParagraph::size_type pos, + LyXFont const & font) { - /* > because last is the next unused position, and you can - * use it if you want */ - if (pos > last) { - if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - NextAfterFootnote()->SetFont(pos - last - 1, font); + // > because last is the next unused position, and you can + // use it if you want + if (pos > size()) { + if (next && + next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { + NextAfterFootnote()->SetFont(pos - text.size() - 1, + font); } else { - lyxerr.print("ERROR (LyXParagraph::SetFont): " - "position does not exist."); + lyxerr << "ERROR (LyXParagraph::SetFont): " + "position does not exist." << endl; } return; } - LyXFont patternfont(LyXFont::ALL_INHERIT); -// First, reduce font against layout/label font -// Update: The SetCharFont() routine in text2.C already reduces font, so -// we don't need to do that here. (Asger) -// No need to simplify this because it will disappear in a new kernel. (Asger) - + // First, reduce font against layout/label font + // Update: The SetCharFont() routine in text2.C already + // reduces font, so we don't need to do that here. (Asger) + // No need to simplify this because it will disappear + // in a new kernel. (Asger) // Next search font table - FontTable *tmp2; - - bool found = false; - FontTable *tmp = fonttable; - while (tmp && !found) { - if (pos >= tmp->pos && pos <= tmp->pos_end) - found = true; - else - tmp = tmp->next; + FontList::iterator tmp = fontlist.begin(); + for (; tmp != fontlist.end(); ++tmp) { + if (pos >= (*tmp).pos && pos <= (*tmp).pos_end) { + break; + } } - - if (!found) { - /* if we did not find a font entry, but if the font at hand - * is the same as default, we just forget it */ - if (font == patternfont) - return; - - /* ok, we did not find a font entry. But maybe there is exactly - * the needed font entry one position left */ - found = false; - tmp2 = fonttable; - while (tmp2 && !found) { - if (pos - 1 >= tmp2->pos && pos - 1 <= tmp2->pos_end) - found = true; - else - tmp2 = tmp2->next; + if (tmp == fontlist.end()) { // !found + // if we did not find a font entry, but if the font at hand + // is the same as default, we just forget it + if (font == patternfont) return; + + // ok, we did not find a font entry. But maybe there is exactly + // the needed font ientry one position left + FontList::iterator tmp2 = fontlist.begin(); + for (; tmp2 != fontlist.end(); ++tmp2) { + if (pos - 1 >= (*tmp2).pos + && pos - 1 <= (*tmp2).pos_end) + break; } - if (found) { - /* ok there is one. maybe it is exactly the needed font */ - if (tmp2->font == font) { - /* put the position under the font */ - tmp2->pos_end++; + if (tmp2 != fontlist.end()) { + // ok there is one, maybe it is exactly + // the needed font + if ((*tmp2).font == font) { + // put the position under the font + (*tmp2).pos_end++; return; } } - /* Add a new entry in the - * fonttable for the position */ - tmp = new FontTable; - tmp->pos = pos; - tmp->pos_end = pos; - tmp->font = patternfont; - tmp->next = fonttable; - fonttable = tmp; - } - else { - /* we found a font entry. maybe we have to split it and create - * a new one */ - - if (tmp->pos != tmp->pos_end) { /* more than one character */ - - if (pos == tmp->pos) { - /* maybe we could enlarge the left fonttable */ - - found = false; - tmp2 = fonttable; - while (tmp2 && !found) { - if (pos - 1 >= tmp2->pos && pos - 1 <= tmp2->pos_end) - found = true; - else - tmp2 = tmp2->next; - } - - /* Is there is one, and is it exactly the needed font? */ - if (found && tmp2->font == font) { - /* put the position under the font */ - tmp2->pos_end++; - tmp->pos++; - return; - } + // Add a new entry in the + // fontlist for the position + FontTable ft; + ft.pos = pos; + ft.pos_end = pos; + ft.font = font; // or patternfont + // It seems that using font instead of patternfont here + // fixes all the problems. This also surfaces a "bug" in + // the old code. + fontlist.insert(fontlist.begin(), ft); + } else if ((*tmp).pos != (*tmp).pos_end) { // we found a font entry. maybe we have to split it and create a new one. + +// more than one character + if (pos == (*tmp).pos) { + // maybe we should enlarge the left fonttable + FontList::iterator tmp2 = fontlist.begin(); + for (; tmp2 != fontlist.end(); ++tmp2) { + if (pos - 1 >= (*tmp2).pos + && pos - 1 <= (*tmp2).pos_end) + break; + } + // Is there is one, and is it exactly + // the needed font? + if (tmp2 != fontlist.end() && + (*tmp2).font == font) { + // Put the position under the font + (*tmp2).pos_end++; + (*tmp).pos++; + return; + } - /* Add a new entry in the - * fonttable for the position */ - tmp2 = new FontTable; - tmp2->pos = pos + 1; - tmp2->pos_end = tmp->pos_end; - tmp2->font = tmp->font; - tmp->pos_end = pos; - tmp2->next = fonttable; - fonttable = tmp2; - } - else if (pos == tmp->pos_end) { - /* Add a new entry in the - * fonttable for the position */ - tmp2 = new FontTable; - tmp2->pos = tmp->pos; - tmp2->pos_end = tmp->pos_end - 1; - tmp2->font = tmp->font; - tmp->pos = tmp->pos_end; - tmp2->next = fonttable; - fonttable = tmp2; - } - else { - /* Add a new entry in the - * fonttable for the position */ - tmp2 = new FontTable; - tmp2->pos = tmp->pos; - tmp2->pos_end = pos - 1; - tmp2->font = tmp->font; - tmp2->next = fonttable; - fonttable = tmp2; - - tmp2 = new FontTable; - tmp2->pos = pos + 1; - tmp2->pos_end = tmp->pos_end; - tmp2->font = tmp->font; - tmp2->next = fonttable; - fonttable = tmp2; - - tmp->pos = pos; - tmp->pos_end = pos; - } - } - } - - tmp->font = font; + // Add a new entry in the + // fontlist for the position + FontTable ft; + ft.pos = pos + 1; + ft.pos_end = (*tmp).pos_end; + ft.font = (*tmp).font; + (*tmp).pos_end = pos; + (*tmp).font = font; + fontlist.insert(fontlist.begin(), ft); + } else if (pos == (*tmp).pos_end) { + // Add a new entry in the + // fontlist for the position + FontTable ft; + ft.pos = (*tmp).pos; + ft.pos_end = (*tmp).pos_end - 1; + ft.font = (*tmp).font; + (*tmp).pos = (*tmp).pos_end; + (*tmp).font = font; + fontlist.insert(fontlist.begin(), ft); + } else { + // Add a new entry in the + // fontlist for the position + FontTable ft; + ft.pos = (*tmp).pos; + ft.pos_end = pos - 1; + ft.font = (*tmp).font; + + FontTable ft2; + ft2.pos = pos + 1; + ft2.pos_end = (*tmp).pos_end; + ft2.font = (*tmp).font; + + (*tmp).pos = pos; + (*tmp).pos_end = pos; + (*tmp).font = font; + + fontlist.insert(fontlist.begin(), ft); + fontlist.insert(fontlist.begin(), ft2); + } + } else { + (*tmp).font = font; + } } -/* this function is able to hide closed footnotes */ -LyXParagraph *LyXParagraph::Next() +// This function is able to hide closed footnotes. +LyXParagraph * LyXParagraph::Next() { - LyXParagraph *tmp; if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - tmp = next; - while (tmp && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + LyXParagraph * tmp = next; + while (tmp + && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) tmp = tmp->next; if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp->Next(); /* there can be more than one footnote - * in a logical paragraph */ + return tmp->Next(); /* there can be more than one + footnote in a logical + paragraph */ else - return next; /* this should never happen! */ - } - else + return next; // This should never happen! + } else return next; } -LyXParagraph *LyXParagraph::NextAfterFootnote() +LyXParagraph * LyXParagraph::NextAfterFootnote() { - LyXParagraph *tmp; if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmp = next; + LyXParagraph * tmp = next; while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) tmp = tmp->next; if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp; /* there can be more than one footnote - * in a logical paragraph */ + return tmp; /* there can be more than one footnote + in a logical paragraph */ else - return next; /* this should never happen! */ - } - else + return next; // This should never happen! + } else + return next; +} + + +LyXParagraph const * LyXParagraph::NextAfterFootnote() const +{ + if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) { + LyXParagraph * tmp = next; + while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) + tmp = tmp->next; + if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) + return tmp; /* there can be more than one footnote + in a logical paragraph */ + else + return next; // This should never happen! + } else return next; } -LyXParagraph *LyXParagraph::PreviousBeforeFootnote() +LyXParagraph * LyXParagraph::PreviousBeforeFootnote() { - LyXParagraph *tmp; + LyXParagraph * tmp; if (previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE) { tmp = next; while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) tmp = tmp->previous; if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp; /* there can be more than one footnote - * in a logical paragraph */ + return tmp; /* there can be more than one footnote + in a logical paragraph */ else - return previous; /* this should never happen! */ - } - else + return previous; // This should never happen! + } else return previous; } -LyXParagraph *LyXParagraph::LastPhysicalPar() +LyXParagraph * LyXParagraph::LastPhysicalPar() { - LyXParagraph *tmp; if (footnoteflag != LyXParagraph::NO_FOOTNOTE) return this; - tmp = this; - while (tmp->next && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE) + LyXParagraph * tmp = this; + while (tmp->next + && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE) tmp = tmp->NextAfterFootnote(); return tmp; @@ -1297,62 +1210,105 @@ LyXParagraph *LyXParagraph::LastPhysicalPar() } -LyXParagraph *LyXParagraph::FirstPhysicalPar() +LyXParagraph * LyXParagraph::FirstPhysicalPar() { if (!IsDummy()) return this; - LyXParagraph *tmppar = this; + LyXParagraph * tmppar = this; - while (tmppar && (tmppar->IsDummy() - || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE)) + while (tmppar && + (tmppar->IsDummy() + || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE)) tmppar = tmppar->previous; - if (!tmppar) - return this; /* this should never happen! */ - else + if (!tmppar) { + return this; + } else + return tmppar; +} + + +LyXParagraph const * LyXParagraph::FirstPhysicalPar() const +{ + if (!IsDummy()) + return this; + LyXParagraph const * tmppar = this; + + while (tmppar && + (tmppar->IsDummy() + || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE)) + tmppar = tmppar->previous; + + if (!tmppar) { + return this; + } else return tmppar; } -/* this function is able to hide closed footnotes */ -LyXParagraph *LyXParagraph::Previous() +// This function is able to hide closed footnotes. +LyXParagraph * LyXParagraph::Previous() { - LyXParagraph *tmp = previous; + LyXParagraph * tmp = previous; if (!tmp) return tmp; - if (tmp->previous && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { + if (tmp->previous + && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { tmp = tmp->previous; - while (tmp && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + while (tmp + && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) tmp = tmp->previous; if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) return tmp->next->Previous(); else return previous; - } - else + } else return previous; } - -void LyXParagraph::BreakParagraph(int pos, int flag) -{ - int i, pos_end, pos_first; - /* create a new paragraph */ - LyXParagraph *par = ParFromPos(pos); - LyXParagraph *firstpar = FirstPhysicalPar(); +// This function is able to hide closed footnotes. +LyXParagraph const * LyXParagraph::Previous() const +{ + LyXParagraph * tmp = previous; + if (!tmp) + return tmp; - LyXParagraph *tmp = new LyXParagraph(par); + if (tmp->previous + && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { + tmp = tmp->previous; + while (tmp + && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + tmp = tmp->previous; + if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) + return tmp->next->Previous(); + + else + return previous; + } else + return previous; +} + + +void LyXParagraph::BreakParagraph(LyXParagraph::size_type pos, + int flag) +{ + size_type i, pos_end, pos_first; + // create a new paragraph + LyXParagraph * par = ParFromPos(pos); + LyXParagraph * firstpar = FirstPhysicalPar(); + LyXParagraph * tmp = new LyXParagraph(par); + tmp->footnoteflag = footnoteflag; tmp->footnotekind = footnotekind; - /* this is an idea for a more userfriendly layout handling, I will - * see what the users say */ + // this is an idea for a more userfriendly layout handling, I will + // see what the users say - /* layout stays the same with latex-environments */ + // layout stays the same with latex-environments if (flag) { tmp->SetOnlyLayout(firstpar->layout); tmp->SetLabelWidthString(firstpar->labelwidthstring); @@ -1373,40 +1329,36 @@ void LyXParagraph::BreakParagraph(int pos, int flag) tmp->depth = firstpar->depth; tmp->noindent = firstpar->noindent; - /* copy everything behind the break-position to the new paragraph */ + // copy everything behind the break-position + // to the new paragraph pos_first = 0; while (ParFromPos(pos_first) != par) - pos_first++; - - pos_end = pos_first + par->last - 1; - - /* make sure there is enough memory for the now larger - paragraph. This is not neccessary, because - InsertFromMinibuffer will enlarge the memory (it uses - InsertChar of course). But doing it by hand - is MUCH faster! (only one time, not thousend times!!) */ + ++pos_first; - tmp->Enlarge(0, pos_end - pos); + pos_end = pos_first + par->text.size() - 1; + // The constructor has already reserved 500 elements + //if (pos_end > pos) + // tmp->text.reserve(pos_end - pos); - for (i = pos; i <= pos_end; i++) { + for (i = pos; i <= pos_end; ++i) { par->CutIntoMinibuffer(i - pos_first); tmp->InsertFromMinibuffer(i - pos); } - - for (i = pos_end; i >= pos; i--) + tmp->text.resize(tmp->text.size()); + for (i = pos_end; i >= pos; --i) par->Erase(i - pos_first); - /* free memory of the now shorter paragraph*/ - par->FitSize(); + + par->text.resize(par->text.size()); } - /* just an idea of me */ + // just an idea of me if (!pos) { tmp->line_top = firstpar->line_top; tmp->pagebreak_top = firstpar->pagebreak_top; tmp->added_space_top = firstpar->added_space_top; tmp->bibkey = firstpar->bibkey; firstpar->Clear(); - /* layout stays the same with latex-environments */ + // layout stays the same with latex-environments if (flag) { firstpar->SetOnlyLayout(tmp->layout); firstpar->SetLabelWidthString(tmp->labelwidthstring); @@ -1416,7 +1368,7 @@ void LyXParagraph::BreakParagraph(int pos, int flag) } -void LyXParagraph::MakeSameLayout(LyXParagraph *par) +void LyXParagraph::MakeSameLayout(LyXParagraph const * par) { par = par->FirstPhysicalPar(); footnoteflag = par->footnoteflag; @@ -1446,65 +1398,57 @@ void LyXParagraph::MakeSameLayout(LyXParagraph *par) } -LyXParagraph *LyXParagraph::FirstSelfrowPar() +LyXParagraph * LyXParagraph::FirstSelfrowPar() { - LyXParagraph *tmppar; - - tmppar = this; + LyXParagraph * tmppar = this; while (tmppar && ( - (tmppar->IsDummy() && tmppar->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) + (tmppar->IsDummy() + && tmppar->previous->footnoteflag == + LyXParagraph::CLOSED_FOOTNOTE) || tmppar->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)) tmppar = tmppar->previous; if (!tmppar) - return this; /* this should never happen! */ + return this; // This should never happen! else return tmppar; } -LyXParagraph *LyXParagraph::Clone() +LyXParagraph * LyXParagraph::Clone() const { - int i; - - /* create a new paragraph */ - LyXParagraph *result = new LyXParagraph(); + // create a new paragraph + LyXParagraph * result = new LyXParagraph; result->MakeSameLayout(this); - /* this is because of the dummy layout of the paragraphs that - follow footnotes */ + // this is because of the dummy layout of the paragraphs that + // follow footnotes result->layout = layout; /* table stuff -- begin*/ if (table) result->table = table->Clone(); else - result->table = NULL; + result->table = 0; /* table stuff -- end*/ // ale970302 result->bibkey = (bibkey) ? new InsetBibKey(bibkey): 0; - /* copy everything behind the break-position to the new paragraph */ - - /* make shure there is enough memory for the now larger paragraph. - * This is not neccessary, because InsertFromMinibuffer will enlarge - * the memory (it uses InsertChar of course). But doing it by hand - * is MUCH faster! (only one time, not thousend times!!) */ - - result->Enlarge(0, last+2); + // copy everything behind the break-position to the new paragraph - for (i = 0; i < last; i++) { + for (size_type i = 0; i < size(); ++i) { CopyIntoMinibuffer(i); result->InsertFromMinibuffer(i); } + result->text.resize(result->text.size()); return result; } -bool LyXParagraph::HasSameLayout(LyXParagraph* par) +bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const { par = par->FirstPhysicalPar(); @@ -1538,86 +1482,77 @@ bool LyXParagraph::HasSameLayout(LyXParagraph* par) } -void LyXParagraph::BreakParagraphConservative(int pos) +void LyXParagraph::BreakParagraphConservative(LyXParagraph::size_type pos) { - int i, pos_end, pos_first; - - /* create a new paragraph */ - LyXParagraph *par = ParFromPos(pos); + // create a new paragraph + LyXParagraph * par = ParFromPos(pos); - LyXParagraph *tmp = new LyXParagraph(par); + LyXParagraph * tmp = new LyXParagraph(par); tmp->MakeSameLayout(par); - - if (Last() > pos) { - /* copy everything behind the break-position to the new - paragraph */ - pos_first = 0; + + // When can pos < Last()? + // I guess pos == Last() is possible. + if (Last() > pos) { + // copy everything behind the break-position to the new + // paragraph + size_type pos_first = 0; while (ParFromPos(pos_first) != par) - pos_first++; - - pos_end = pos_first + par->last - 1; - - /* make shure there is enough memory for the now larger - paragraph. This is not neccessary, because - InsertFromMinibuffer will enlarge the memory (it uses - InsertChar of course). But doing it by hand - is MUCH faster! (only one time, not thousend times!!) */ - - tmp->Enlarge(0, pos_end - pos); - - for (i = pos; i <= pos_end; i++) { - + ++pos_first; + size_type pos_end = pos_first + par->text.size() - 1; + // make sure there is enough memory for the now larger + // paragraph. This is not neccessary, because + // InsertFromMinibuffer will enlarge the memory (it uses + // InsertChar of course). But doing it by hand + // is MUCH faster! (only one time, not thousend times!!) + // Not needed since the constructor aleady have + // reserved 500 elements in text. + //if (pos_end > pos) + // tmp->text.reserve(pos_end - pos); + + for (size_type i = pos; i <= pos_end; ++i) { par->CutIntoMinibuffer(i - pos_first); tmp->InsertFromMinibuffer(i - pos); } - for (i = pos_end; i >= pos; i--) + tmp->text.resize(tmp->text.size()); + for (size_type i = pos_end; i >= pos; --i) par->Erase(i - pos_first); - /* free memory of the now shorter paragraph*/ - par->FitSize(); + par->text.resize(par->text.size()); } } -/* be carefull, this does not make any check at all */ +// Be carefull, this does not make any check at all. void LyXParagraph::PasteParagraph() { - int i, pos_end, pos_insert; - LyXParagraph *the_next; - - /* copy the next paragraph to this one */ - the_next = Next(); + // copy the next paragraph to this one + LyXParagraph * the_next = Next(); - LyXParagraph *firstpar = FirstPhysicalPar(); + LyXParagraph * firstpar = FirstPhysicalPar(); - /* first the DTP-stuff */ + // first the DTP-stuff firstpar->line_bottom = the_next->line_bottom; firstpar->added_space_bottom = the_next->added_space_bottom; firstpar->pagebreak_bottom = the_next->pagebreak_bottom; - - pos_end = the_next->last - 1; - pos_insert = Last(); - - /* enlarge the paragraph. This is faster than enlarge it - * every 10th insertion. */ - if (pos_end >= 0) - Enlarge(pos_insert, pos_end); - - /* ok, now copy the paragraph */ - for (i = 0; i <= pos_end; i++) { + + size_type pos_end = the_next->text.size() - 1; + size_type pos_insert = Last(); + + // ok, now copy the paragraph + for (size_type i = 0; i <= pos_end; ++i) { the_next->CutIntoMinibuffer(i); InsertFromMinibuffer(pos_insert + i); } - /* delete the next paragraph */ + // delete the next paragraph delete the_next; } -void LyXParagraph::OpenFootnote(int pos) +void LyXParagraph::OpenFootnote(LyXParagraph::size_type pos) { - LyXParagraph *par = ParFromPos(pos); + LyXParagraph * par = ParFromPos(pos); par = par->next; while (par && par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { par->footnoteflag = LyXParagraph::OPEN_FOOTNOTE; @@ -1626,9 +1561,9 @@ void LyXParagraph::OpenFootnote(int pos) } -void LyXParagraph::CloseFootnote(int pos) +void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos) { - LyXParagraph *par = ParFromPos(pos); + LyXParagraph * par = ParFromPos(pos); par = par->next; while (par && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { par->footnoteflag = LyXParagraph::CLOSED_FOOTNOTE; @@ -1637,38 +1572,38 @@ void LyXParagraph::CloseFootnote(int pos) } -int LyXParagraph::GetLayout() +LyXTextClass::size_type LyXParagraph::GetLayout() const { return FirstPhysicalPar()->layout; } -char LyXParagraph::GetDepth() +char LyXParagraph::GetDepth() const { return FirstPhysicalPar()->depth; } -char LyXParagraph::GetAlign() +char LyXParagraph::GetAlign() const { return FirstPhysicalPar()->align; } -LString LyXParagraph::GetLabelString() +string LyXParagraph::GetLabestring() const { return FirstPhysicalPar()->labelstring; } -int LyXParagraph::GetFirstCounter(int i) +int LyXParagraph::GetFirstCounter(int i) const { - return FirstPhysicalPar()->counter[i]; + return FirstPhysicalPar()->counter_[i]; } -/* the next two functions are for the manual labels */ -LString LyXParagraph::GetLabelWidthString() +// the next two functions are for the manual labels +string LyXParagraph::GetLabelWidthString() const { if (!FirstPhysicalPar()->labelwidthstring.empty()) return FirstPhysicalPar()->labelwidthstring; @@ -1677,20 +1612,19 @@ LString LyXParagraph::GetLabelWidthString() } -void LyXParagraph::SetLabelWidthString(LString const & s) +void LyXParagraph::SetLabelWidthString(string const & s) { - LyXParagraph *par = FirstPhysicalPar(); + LyXParagraph * par = FirstPhysicalPar(); par->labelwidthstring = s; } -void LyXParagraph::SetOnlyLayout(char new_layout) +void LyXParagraph::SetOnlyLayout(LyXTextClass::size_type new_layout) { - LyXParagraph - *par = FirstPhysicalPar(), - *ppar = NULL, - *npar = NULL; + LyXParagraph * par = FirstPhysicalPar(); + LyXParagraph * ppar = 0; + LyXParagraph * npar = 0; par->layout = new_layout; /* table stuff -- begin*/ @@ -1713,35 +1647,34 @@ void LyXParagraph::SetOnlyLayout(char new_layout) npar = npar->Next()->NextAfterFootnote(); } if (ppar && (ppar->pextra_type != PEXTRA_NONE)) { - LString + string p1 = ppar->pextra_width, p2 = ppar->pextra_widthp; ppar->SetPExtraType(ppar->pextra_type, - p1.c_str(),p2.c_str()); + p1.c_str(), p2.c_str()); } if ((par->pextra_type == PEXTRA_NONE) && npar && (npar->pextra_type != PEXTRA_NONE)) { - LString + string p1 = npar->pextra_width, p2 = npar->pextra_widthp; npar->SetPExtraType(npar->pextra_type, - p1.c_str(),p2.c_str()); + p1.c_str(), p2.c_str()); } } } -void LyXParagraph::SetLayout(char new_layout) +void LyXParagraph::SetLayout(LyXTextClass::size_type new_layout) { LyXParagraph - *par = FirstPhysicalPar(), - *ppar = NULL, - *npar = NULL; + * par = FirstPhysicalPar(), + * ppar = 0, + * npar = 0; par->layout = new_layout; - par->labelwidthstring.clean(); + par->labelwidthstring.clear(); par->align = LYX_ALIGN_LAYOUT; - //par->depth = 0; par->added_space_top = VSpace(VSpace::NONE); par->added_space_bottom = VSpace(VSpace::NONE); /* table stuff -- begin*/ @@ -1764,77 +1697,94 @@ void LyXParagraph::SetLayout(char new_layout) npar = npar->Next()->NextAfterFootnote(); } if (ppar && (ppar->pextra_type != PEXTRA_NONE)) { - LString + string p1 = ppar->pextra_width, p2 = ppar->pextra_widthp; ppar->SetPExtraType(ppar->pextra_type, - p1.c_str(),p2.c_str()); + p1.c_str(), p2.c_str()); } if ((par->pextra_type == PEXTRA_NONE) && npar && (npar->pextra_type != PEXTRA_NONE)) { - LString + string p1 = npar->pextra_width, p2 = npar->pextra_widthp; npar->SetPExtraType(npar->pextra_type, - p1.c_str(),p2.c_str()); + p1.c_str(), p2.c_str()); } } } -/* if the layout of a paragraph contains a manual label, the beginning of the -* main body is the beginning of the second word. This is what the par- -* function returns. If the layout does not contain a label, the main -* body always starts with position 0. This differentiation is necessary, -* because there cannot be a newline or a blank <= the beginning of the -* main body in TeX. */ +// if the layout of a paragraph contains a manual label, the beginning of the +// main body is the beginning of the second word. This is what the par- +// function returns. If the layout does not contain a label, the main +// body always starts with position 0. This differentiation is necessary, +// because there cannot be a newline or a blank <= the beginning of the +// main body in TeX. -int LyXParagraph::BeginningOfMainBody() +int LyXParagraph::BeginningOfMainBody() const { if (FirstPhysicalPar() != this) return -1; - int i = 0; - -// while (i < last && !(i > 1 && GetChar(i-1)==' ') -// && GetChar(i)!=LYX_META_NEWLINE) -// i++; -// Unroll the first two cycles of this loop -// and remember the previous character to remove unnecessary GetChar() calls - - if (i < last - && GetChar(i) != LYX_META_NEWLINE) { + // Unroll the first two cycles of the loop + // and remember the previous character to + // remove unnecessary GetChar() calls + size_type i = 0; + if (i < size() + && GetChar(i) != LyXParagraph::META_NEWLINE + ) { ++i; - char previous_char, temp; - if (i < last - && (previous_char = GetChar(i)) != LYX_META_NEWLINE) { - // Yes, this ^ is supposed to be "=" not "==" + char previous_char = 0, temp = 0; + if (i < size() + && (previous_char = GetChar(i)) != LyXParagraph::META_NEWLINE) { + // Yes, this ^ is supposed to be "= " not "==" ++i; - while (i < last + while (i < size() && previous_char != ' ' - && (temp = GetChar(i)) != LYX_META_NEWLINE) { + && (temp = GetChar(i)) != LyXParagraph::META_NEWLINE) { ++i; previous_char = temp; } } } - if (i==0 && i == last && - !(footnoteflag==LyXParagraph::NO_FOOTNOTE - && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) - ) - i++; /* the cursor should not jump + if (i == 0 && i == size() && + !(footnoteflag == LyXParagraph::NO_FOOTNOTE + && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)) + ++i; /* the cursor should not jump * to the main body if there * is nothing in! */ return i; } -LyXParagraph* LyXParagraph::DepthHook(int deth) +LyXParagraph * LyXParagraph::DepthHook(int deth) +{ + LyXParagraph * newpar = this; + if (deth < 0) + return 0; + + do { + newpar = newpar->FirstPhysicalPar()->Previous(); + } while (newpar && newpar->GetDepth() > deth + && newpar->footnoteflag == footnoteflag); + + if (!newpar) { + if (Previous() || GetDepth()) + lyxerr << "ERROR (LyXParagraph::DepthHook): " + "no hook." << endl; + newpar = this; + } + return newpar->FirstPhysicalPar(); +} + + +LyXParagraph const * LyXParagraph::DepthHook(int deth) const { - LyXParagraph *newpar = this; + LyXParagraph const * newpar = this; if (deth < 0) - return NULL; + return 0; do { newpar = newpar->FirstPhysicalPar()->Previous(); @@ -1843,8 +1793,8 @@ LyXParagraph* LyXParagraph::DepthHook(int deth) if (!newpar) { if (Previous() || GetDepth()) - lyxerr.print("ERROR (LyXParagraph::DepthHook): " - "no hook."); + lyxerr << "ERROR (LyXParagraph::DepthHook): " + "no hook." << endl; newpar = this; } return newpar->FirstPhysicalPar(); @@ -1853,112 +1803,276 @@ LyXParagraph* LyXParagraph::DepthHook(int deth) int LyXParagraph::AutoDeleteInsets() { - InsetTable *tmpi = insettable; - InsetTable *tmpi2 = tmpi; - int i=0; - while (tmpi) { - tmpi2 = tmpi; - tmpi = tmpi->next; - if (tmpi2->inset) - if (tmpi2->inset->AutoDelete()) { - i++; - Erase(tmpi2->pos); - } else {} - else - lyxerr.print( - "ERROR (LyXParagraph::AutoDeleteInsets): " - "cannot auto-delete insets"); + vector tmpvec; + int i = 0; + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).inset && (*it).inset->AutoDelete()) { + tmpvec.push_back((*it).pos); + ++i; + } + } + for (vector::const_iterator cit = tmpvec.begin(); + cit != tmpvec.end(); ++cit) { + Erase((*cit)); } return i; } -Inset* LyXParagraph::ReturnNextInsetPointer(int &pos) +Inset * LyXParagraph::ReturnNextInsetPointer(LyXParagraph::size_type & pos) { - InsetTable *tmpi = insettable; - InsetTable *tmpi2 = NULL; - while (tmpi){ - if (tmpi->pos >= pos) { - if (!tmpi2 || tmpi->pos < tmpi2->pos) - tmpi2 = tmpi; + InsetList::iterator it2 = insetlist.end(); + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + if ((*it).pos >= pos) { + if (it2 == insetlist.end() || (*it).pos < (*it2).pos) + it2 = it; } - tmpi=tmpi->next; } - if (tmpi2){ - pos = tmpi2->pos; - return tmpi2->inset; + if (it2 != insetlist.end()) { + pos = (*it2).pos; + return (*it2).inset; } - else - return NULL; + return 0; } -/* returns -1 if inset not found */ -int LyXParagraph::GetPositionOfInset(Inset* inset) +// returns -1 if inset not found +int LyXParagraph::GetPositionOfInset(Inset * inset) const { - /* find the entry */ - InsetTable *tmpi = insettable; - while (tmpi && tmpi->inset != inset) { - tmpi=tmpi->next; - } - if (tmpi && tmpi->inset) - return tmpi->pos; - else{ - /* think about footnotes */ - if (footnoteflag == LyXParagraph::NO_FOOTNOTE - && next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - int further = - NextAfterFootnote()->GetPositionOfInset(inset); - if (further != -1) - return last + 1 + further; + // Find the entry. + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) { + if ((*cit).inset == inset) { + return (*cit).pos; } - return -1; } + // Think about footnotes. + if (footnoteflag == LyXParagraph::NO_FOOTNOTE + && next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { + int further = + NextAfterFootnote()->GetPositionOfInset(inset); + if (further != -1) + return text.size() + 1 + further; + } + return -1; } -void LyXParagraph::readSimpleWholeFile(FILE *myfile) +void LyXParagraph::readSimpleWholeFile(istream & is) { - char c; + is.seekg(0); + char c = 0; + while(!is.eof()) { + is.get(c); + InsertChar(text.size(), c); + }; +} - FileInfo fileInfo(fileno(myfile)); - long file_size = fileInfo.getSize(); - /* it is horrible, I know, but faster. - * I should not use InsertString for that :-( */ - - /* I will write a better insertion in the future */ - Enlarge(0, file_size + 10); - - rewind(myfile); - - if (!feof(myfile)) { - do { - c = fgetc(myfile); - InsertChar(last,c); - } while (!feof(myfile)); + +#ifdef USE_OSTREAM_ONLY +LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, + ostream & foot, TexRow & foot_texrow, + int & foot_count) +{ + lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; + LyXParagraph * par = next; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + layout); + + bool further_blank_line = false; + if (IsDummy()) + lyxerr << "ERROR (LyXParagraph::TeXOnePar) is dummy." << endl; + + if (start_of_appendix) { + os << "\\appendix\n"; + texrow.newline(); + } + + if (tex_code_break_column && style.isCommand()){ + os << '\n'; + texrow.newline(); + } + + if (pagebreak_top) { + os << "\\newpage"; + further_blank_line = true; + } + if (added_space_top.kind() != VSpace::NONE) { + os << added_space_top.asLatexCommand(current_view->buffer()->params); + further_blank_line = true; + } + if (line_top) { + os << "\\lyxline{\\" << getFont(0).latexSize() << '}' + << "\\vspace{-1\\parskip}"; + further_blank_line = true; + } + + if (further_blank_line){ + os << '\n'; + texrow.newline(); + } + + LyXDirection direction = getParDirection(); + LyXDirection global_direction = + current_view->buffer()->params.getDocumentDirection(); + if (direction != global_direction) { + if (direction == LYX_DIR_LEFT_TO_RIGHT) + os << "\\unsethebrew\n"; + else + os << "\\sethebrew\n"; + texrow.newline(); + } + + + switch (style.latextype) { + case LATEX_COMMAND: + os << '\\' + << style.latexname() + << style.latexparam(); + break; + case LATEX_ITEM_ENVIRONMENT: + if (bibkey) { + bibkey->Latex(os, false); + } else + os << "\\item "; + break; + case LATEX_LIST_ENVIRONMENT: + os << "\\item "; + break; + default: + break; + } + + bool need_par = SimpleTeXOnePar(os, texrow); + + // Spit out footnotes + while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE + && par->footnoteflag != footnoteflag) { + par = par->TeXFootnote(os, texrow, + foot, foot_texrow, foot_count, + direction); + par->SimpleTeXOnePar(os, texrow); + par = par->next; + } + + // Make sure that \\par is done with the font of the last + // character if this has another size as the default. + // This is necessary because LaTeX (and LyX on the screen) + // calculates the space between the baselines according + // to this font. (Matthias) + LyXFont font = getFont(Last() - 1); + if (need_par) { + if (style.resfont.size() != font.size()) { + os << '\\' + << font.latexSize() + << ' '; + } + os << "\\par}"; + } else if (textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()).isCommand()){ + if (style.resfont.size() != font.size()) { + os << '\\' + << font.latexSize() + << ' '; + } + os << '}'; + } else if (style.resfont.size() != font.size()){ + os << "{\\" << font.latexSize() << " \\par}"; + } + + if (direction != global_direction) + if (direction == LYX_DIR_LEFT_TO_RIGHT) + os << "\\sethebrew"; + else + os << "\\unsethebrew"; + + switch (style.latextype) { + case LATEX_ITEM_ENVIRONMENT: + case LATEX_LIST_ENVIRONMENT: + if (par && (depth < par->depth)) { + os << '\n'; + texrow.newline(); + } + break; + case LATEX_ENVIRONMENT: + // if its the last paragraph of the current environment + // skip it otherwise fall through + if (par + && (par->layout != layout + || par->depth != depth + || par->pextra_type != pextra_type)) + break; + default: + if (!(footnoteflag != LyXParagraph::NO_FOOTNOTE + && footnotekind != LyXParagraph::FOOTNOTE + && footnotekind != LyXParagraph::MARGIN + && (table + || (par + && par->table)))) { + // don't insert this if we would be adding it + // before or after a table in a float. This + // little trick is needed in order to allow + // use of tables in \subfigures or \subtables. + os << '\n'; + texrow.newline(); + } + } + + further_blank_line = false; + if (line_bottom) { + os << "\\lyxline{\\" << getFont(Last() - 1).latexSize() << '}'; + further_blank_line = true; + } + + if (added_space_bottom.kind() != VSpace::NONE) { + os << added_space_bottom.asLatexCommand(current_view->buffer()->params); + further_blank_line = true; + } + + if (pagebreak_bottom) { + os << "\\newpage"; + further_blank_line = true; + } + + if (further_blank_line){ + os << '\n'; + texrow.newline(); } -} + if (!(footnoteflag != LyXParagraph::NO_FOOTNOTE && par && + par->footnoteflag == LyXParagraph::NO_FOOTNOTE)) { + os << '\n'; + texrow.newline(); + } -LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, - LString &foot, TexRow &foot_texrow, - int &foot_count) + lyxerr[Debug::LATEX] << "TeXOnePar...done " << par << endl; + return par; +} +#else +LyXParagraph * LyXParagraph::TeXOnePar(string & file, TexRow & texrow, + string & foot, TexRow & foot_texrow, + int & foot_count) { - lyxerr.debug(LString("TeXOnePar... ") + (long)this, Error::LATEX); - LyXParagraph *par = next; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), layout); + lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; + LyXParagraph * par = next; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + layout); bool further_blank_line = false; if (IsDummy()) - lyxerr.print("ERROR (LyXParagraph::TeXOnePar) is dummy."); + lyxerr << "ERROR (LyXParagraph::TeXOnePar) is dummy." << endl; if (start_of_appendix) { file += "\\appendix\n"; texrow.newline(); } - if (tex_code_break_column && style->isCommand()){ + if (tex_code_break_column && style.isCommand()){ file += '\n'; texrow.newline(); } @@ -1968,7 +2082,7 @@ LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, further_blank_line = true; } if (added_space_top.kind() != VSpace::NONE) { - file += added_space_top.asLatexCommand(); + file += added_space_top.asLatexCommand(current_view->buffer()->params); further_blank_line = true; } @@ -1983,16 +2097,43 @@ LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, texrow.newline(); } - switch (style->latextype) { + LyXDirection direction = getParDirection(); + LyXDirection global_direction = + current_view->buffer()->params.getDocumentDirection(); + if (direction != global_direction) { + if (direction == LYX_DIR_LEFT_TO_RIGHT) + file += "\\unsethebrew\n"; + else + file += "\\sethebrew\n"; + texrow.newline(); + } + + + switch (style.latextype) { case LATEX_COMMAND: file += '\\'; - file += style->latexname; - file += style->latexparam; + file += style.latexname(); + file += style.latexparam(); break; case LATEX_ITEM_ENVIRONMENT: - if (bibkey) + if (bibkey) { +#ifdef USE_OSTREAM_ONLY +#ifdef HAVE_SSTREAM + ostringstream ost; + bibkey->Latex(ost, false); + file += ost.str().c_str(); +#else + ostrstream ost; + bibkey->Latex(ost, false); + ost << '\0'; + char * tmp = ost.str(); + file += tmp; + delete [] tmp; +#endif +#else bibkey->Latex(file, false); - else +#endif + } else file += "\\item "; break; case LATEX_LIST_ENVIRONMENT: @@ -2008,7 +2149,8 @@ LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE && par->footnoteflag != footnoteflag) { par = par->TeXFootnote(file, texrow, - foot, foot_texrow, foot_count); + foot, foot_texrow, foot_count, + direction); par->SimpleTeXOnePar(file, texrow); par = par->next; } @@ -2020,25 +2162,31 @@ LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, // to this font. (Matthias) LyXFont font = getFont(Last()-1); if (need_par) { - if (style->resfont.size() != font.size()) { + if (style.resfont.size() != font.size()) { file += '\\'; file += font.latexSize(); file += ' '; } file += "\\par}"; - } else if (lyxstyle.Style(GetCurrentTextClass(), - GetLayout())->isCommand()){ - if (style->resfont.size() != font.size()) { + } else if (textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()).isCommand()){ + if (style.resfont.size() != font.size()) { file += '\\'; file += font.latexSize(); file += ' '; } file += '}'; - } else if (style->resfont.size() != font.size()){ + } else if (style.resfont.size() != font.size()){ file += "{\\" + font.latexSize() + " \\par}"; } + + if (direction != global_direction) + if (direction == LYX_DIR_LEFT_TO_RIGHT) + file += "\\sethebrew"; + else + file += "\\unsethebrew"; - switch (style->latextype) { + switch (style.latextype) { case LATEX_ITEM_ENVIRONMENT: case LATEX_LIST_ENVIRONMENT: if (par && (depth < par->depth)) { @@ -2077,7 +2225,7 @@ LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, } if (added_space_bottom.kind() != VSpace::NONE) { - file += added_space_bottom.asLatexCommand(); + file += added_space_bottom.asLatexCommand(current_view->buffer()->params); further_blank_line = true; } @@ -2092,132 +2240,135 @@ LyXParagraph* LyXParagraph::TeXOnePar(LString &file, TexRow &texrow, } if (!(footnoteflag != LyXParagraph::NO_FOOTNOTE && par && - par->footnoteflag == LyXParagraph::NO_FOOTNOTE) // && -// (pextra_type != PEXTRA_MINIPAGE || -/* (par && !par->pextra_type == PEXTRA_MINIPAGE)) */ ) { + par->footnoteflag == LyXParagraph::NO_FOOTNOTE)) { file += '\n'; texrow.newline(); } - lyxerr.debug(LString("TeXOnePar...done ") + (long)par, Error::LATEX); + lyxerr[Debug::LATEX] << "TeXOnePar...done " << par << endl; return par; } +#endif // This one spits out the text of the paragraph -bool LyXParagraph::SimpleTeXOnePar(LString &file, TexRow &texrow) +#ifdef USE_OSTREAM_ONLY +bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) { - lyxerr.debug(LString("SimpleTeXOnePar... ") + (long)this, - Error::LATEX); + lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; if (table) - return SimpleTeXOneTablePar(file, texrow); + return SimpleTeXOneTablePar(os, texrow); - char c; - int main_body; - int column; - bool return_value = false; - //bool underbar = false; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout()); - LyXFont basefont; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + LyXFont basefont, last_font; - /* maybe we have to create a optional argument */ - if (style->labeltype != LABEL_MANUAL) + // Maybe we have to create a optional argument. + size_type main_body; + if (style.labeltype != LABEL_MANUAL) main_body = 0; else main_body = BeginningOfMainBody(); if (main_body > 0) { - file += '['; + os << '['; basefont = getFont(-2); // Get label font } else { basefont = getFont(-1); // Get layout font } - column = 0; + int column = 0; if (main_body >= 0 - && !last + && !text.size() && !IsDummy()) { - if (style->isCommand()) { - file += '{'; - column++; + if (style.isCommand()) { + os << '{'; + ++column; } else if (align != LYX_ALIGN_LAYOUT) { - file += '{'; - column++; + os << '{'; + ++column; return_value = true; } } // Which font is currently active? - LyXFont running_font = basefont; + LyXFont running_font(basefont); // Do we have an open font change? bool open_font = false; texrow.start(this, 0); - - for (int i = 0; i < last; i++) { - column++; + + for (size_type i = 0; i < size(); ++i) { + ++column; // First char in paragraph or after label? if (i == main_body && !IsDummy()) { if (main_body > 0) { if (open_font) { - column += running_font.latexWriteEndChanges(file, basefont); + column += running_font.latexWriteEndChanges(os, basefont, basefont); open_font = false; } basefont = getFont(-1); // Now use the layout font running_font = basefont; - file += ']'; - column++; + os << ']'; + ++column; } - if (style->isCommand()) { - file += '{'; - column++; + if (style.isCommand()) { + os << '{'; + ++column; } else if (align != LYX_ALIGN_LAYOUT) { - file += "{\\par"; + os << "{\\par"; column += 4; return_value = true; } if (noindent) { - file += "\\noindent "; + os << "\\noindent "; column += 10; } switch (align) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: break; case LYX_ALIGN_LEFT: - file += "\\raggedright "; - column+=13; + os << "\\raggedright "; + column+= 13; break; case LYX_ALIGN_RIGHT: - file += "\\raggedleft "; - column+=12; + os << "\\raggedleft "; + column+= 12; break; case LYX_ALIGN_CENTER: - file += "\\centering "; - column+=11; + os << "\\centering "; + column+= 11; break; } } - c = GetChar(i); + int c = GetChar(i); // Fully instantiated font LyXFont font = getFont(i); + last_font = running_font; // Spaces at end of font change are simulated to be // outside font change, i.e. we write "\textXX{text} " - // rather than "\textXX{text }". (Asger) - if (open_font && c == ' ' && i <= last-2 + // rather than "\textXX{text }". (Asger) + if (open_font && c == ' ' && i <= size() - 2 && !getFont(i+1).equalExceptLatex(running_font) && !getFont(i+1).equalExceptLatex(font)) { - font = getFont(i+1); + font = getFont(i + 1); } - // We end font definition before blanks if (!font.equalExceptLatex(running_font) && open_font) { - column += running_font.latexWriteEndChanges(file, basefont); + column += running_font.latexWriteEndChanges(os, + basefont, + (i == main_body-1) ? basefont : font); running_font = basefont; open_font = false; } @@ -2226,42 +2377,44 @@ bool LyXParagraph::SimpleTeXOnePar(LString &file, TexRow &texrow) if (c == ' '){ // Do not print the separation of the optional argument if (i != main_body - 1) { - SimpleTeXBlanks(file, texrow, i, column, font, style); + SimpleTeXBlanks(os, texrow, i, + column, font, style); } } // Do we need to change font? if (!font.equalExceptLatex(running_font) && i != main_body-1) { - column += font.latexWriteStartChanges(file, basefont); + column += font.latexWriteStartChanges(os, basefont, + last_font); running_font = font; open_font = true; } - if (c == LYX_META_NEWLINE) { + if (c == LyXParagraph::META_NEWLINE) { // newlines are handled differently here than // the default in SimpleTeXSpecialChars(). - if (!style->newline_allowed + if (!style.newline_allowed || font.latex() == LyXFont::ON) { - file += '\n'; + os << '\n'; } else { if (open_font) { - column += running_font.latexWriteEndChanges(file, basefont); + column += running_font.latexWriteEndChanges(os, basefont, basefont); open_font = false; } basefont = getFont(-1); running_font = basefont; if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - file += "~"; + os << "~"; } - file += "\\\\\n"; + os << "\\\\\n"; } texrow.newline(); - texrow.start(this, i+1); + texrow.start(this, i + 1); column = 0; } else { - SimpleTeXSpecialChars(file, texrow, + SimpleTeXSpecialChars(os, texrow, font, running_font, basefont, open_font, style, i, column, c); } @@ -2269,150 +2422,506 @@ bool LyXParagraph::SimpleTeXOnePar(LString &file, TexRow &texrow) // If we have an open font definition, we have to close it if (open_font) { - running_font.latexWriteEndChanges(file, basefont); + running_font.latexWriteEndChanges(os, basefont, basefont); } - /* needed if there is an optional argument but no contents */ - if (main_body > 0 && main_body == last) { - file += "]~"; + // Needed if there is an optional argument but no contents. + if (main_body > 0 && main_body == size()) { + os << "]~"; return_value = false; } - lyxerr.debug(LString("SimpleTeXOnePar...done ") + (long)this, - Error::LATEX); + lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; return return_value; } +#else +bool LyXParagraph::SimpleTeXOnePar(string & file, TexRow & texrow) +{ + lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; + if (table) + return SimpleTeXOneTablePar(file, texrow); -// This one spits out the text of a table paragraph -bool LyXParagraph::SimpleTeXOneTablePar(LString &file, TexRow &texrow) -{ - lyxerr.debug(LString("SimpleTeXOneTablePar... ")+ - (long)this, Error::LATEX); - char c; - int column, tmp; - bool return_value = false; - int current_cell_number = -1; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout()); - LyXFont basefont; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + LyXFont basefont, last_font; - basefont = getFont(-1); // Get layout font - // Which font is currently active? - LyXFont running_font = basefont; - // Do we have an open font change? - bool open_font = false; - - column = 0; - if (!IsDummy()) { // it is dummy if it is in a float!!! - if (style->isCommand()) { + // Maybe we have to create a optional argument. + size_type main_body; + if (style.labeltype != LABEL_MANUAL) + main_body = 0; + else + main_body = BeginningOfMainBody(); + + if (main_body > 0) { + file += '['; + basefont = getFont(-2); // Get label font + } else { + basefont = getFont(-1); // Get layout font + } + + int column = 0; + + if (main_body >= 0 + && !text.size() + && !IsDummy()) { + if (style.isCommand()) { file += '{'; - column++; + ++column; } else if (align != LYX_ALIGN_LAYOUT) { file += '{'; - column++; + ++column; return_value = true; } - if (noindent) { - file += "\\noindent "; - column += 10; - } - switch (align) { - case LYX_ALIGN_LEFT: - file += "\\raggedright "; - column+=13; - break; - case LYX_ALIGN_RIGHT: - file += "\\raggedleft "; - column+=12; - break; - case LYX_ALIGN_CENTER: - file += "\\centering "; - column+=11; - break; - } } - current_cell_number = -1; - tmp = table->TexEndOfCell(file,current_cell_number); - for (;tmp>0;tmp--) - texrow.newline(); - - texrow.start(this, 0); - - for (int i = 0; i < last; i++) { - c = GetChar(i); - if (table->IsContRow(current_cell_number+1)) { - if (c == LYX_META_NEWLINE) - current_cell_number++; - continue; - } - column++; - - // Fully instantiated font - LyXFont font = getFont(i); + + // Which font is currently active? + LyXFont running_font = basefont; + // Do we have an open font change? + bool open_font = false; - // Spaces at end of font change are simulated to be outside font change. - // i.e. we write "\textXX{text} " rather than "\textXX{text }". (Asger) - if (open_font && c == ' ' && i <= last-2 - && getFont(i+1) != running_font && getFont(i+1) != font) { - font = getFont(i+1); - } + texrow.start(this, 0); - // We end font definition before blanks - if (font != running_font && open_font) { - column += running_font.latexWriteEndChanges(file, basefont); - running_font = basefont; - open_font = false; - } + for (size_type i = 0; i < size(); ++i) { + ++column; + // First char in paragraph or after label? + if (i == main_body && !IsDummy()) { + if (main_body > 0) { + if (open_font) { + column += running_font.latexWriteEndChanges(file, basefont, basefont); + open_font = false; + } + basefont = getFont(-1); // Now use the layout font + running_font = basefont; + file += ']'; + ++column; + } + if (style.isCommand()) { + file += '{'; + ++column; + } else if (align != LYX_ALIGN_LAYOUT) { + file += "{\\par"; + column += 4; + return_value = true; + } + + if (noindent) { + file += "\\noindent "; + column += 10; + } + switch (align) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: break; + case LYX_ALIGN_LEFT: + file += "\\raggedright "; + column+= 13; + break; + case LYX_ALIGN_RIGHT: + file += "\\raggedleft "; + column+= 12; + break; + case LYX_ALIGN_CENTER: + file += "\\centering "; + column+= 11; + break; + } + } + + int c = GetChar(i); + + // Fully instantiated font + LyXFont font = getFont(i); + last_font = running_font; + + // Spaces at end of font change are simulated to be + // outside font change, i.e. we write "\textXX{text} " + // rather than "\textXX{text }". (Asger) + if (open_font && c == ' ' && i <= size() - 2 + && !getFont(i+1).equalExceptLatex(running_font) + && !getFont(i+1).equalExceptLatex(font)) { + font = getFont(i + 1); + } + // We end font definition before blanks + if (!font.equalExceptLatex(running_font) && open_font) { + column += running_font.latexWriteEndChanges(file, + basefont, + (i == main_body-1) ? basefont : font); + running_font = basefont; + open_font = false; + } + + // Blanks are printed before start of fontswitch + if (c == ' '){ + // Do not print the separation of the optional argument + if (i != main_body - 1) { + SimpleTeXBlanks(file, texrow, i, + column, font, style); + } + } + + // Do we need to change font? + if (!font.equalExceptLatex(running_font) + && i != main_body-1) { + column += font.latexWriteStartChanges(file, basefont, last_font); + running_font = font; + open_font = true; + } + + if (c == LyXParagraph::META_NEWLINE) { + // newlines are handled differently here than + // the default in SimpleTeXSpecialChars(). + if (!style.newline_allowed + || font.latex() == LyXFont::ON) { + file += '\n'; + } else { + if (open_font) { + column += running_font.latexWriteEndChanges(file, basefont, basefont); + open_font = false; + } + basefont = getFont(-1); + running_font = basefont; + if (font.family() == + LyXFont::TYPEWRITER_FAMILY) { + file += "~"; + } + file += "\\\\\n"; + } + texrow.newline(); + texrow.start(this, i + 1); + column = 0; + } else { + SimpleTeXSpecialChars(file, texrow, + font, running_font, basefont, + open_font, style, i, column, c); + } + } + + // If we have an open font definition, we have to close it + if (open_font) { + running_font.latexWriteEndChanges(file, basefont, basefont); + } + + // Needed if there is an optional argument but no contents. + if (main_body > 0 && main_body == size()) { + file += "]~"; + return_value = false; + } + + lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; + return return_value; +} +#endif + + +#ifdef USE_OSTREAM_ONLY +// This one spits out the text of a table paragraph +bool LyXParagraph::SimpleTeXOneTablePar(ostream & os, TexRow & texrow) +{ + lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar... " << this << endl; + + bool return_value = false; + + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + + int column = 0; + if (!IsDummy()) { // it is dummy if it is in a float!!! + if (style.isCommand()) { + os << '{'; + ++column; + } else if (align != LYX_ALIGN_LAYOUT) { + os << '{'; + ++column; + return_value = true; + } + if (noindent) { + os << "\\noindent "; + column += 10; + } + switch (align) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: break; + case LYX_ALIGN_LEFT: + os << "\\raggedright "; + column+= 13; + break; + case LYX_ALIGN_RIGHT: + os << "\\raggedleft "; + column+= 12; + break; + case LYX_ALIGN_CENTER: + os << "\\centering "; + column+= 11; + break; + } + } + + LyXFont basefont = getFont(-1); // Get layout font + // Which font is currently active? + LyXFont running_font = basefont; + LyXFont last_font; + // Do we have an open font change? + bool open_font = false; + int current_cell_number = -1; + int tmp = table->TexEndOfCell(os, current_cell_number); + for (; tmp > 0 ; --tmp) + texrow.newline(); + + texrow.start(this, 0); + + for (size_type i = 0; i < size(); ++i) { + char c = GetChar(i); + if (table->IsContRow(current_cell_number + 1)) { + if (c == LyXParagraph::META_NEWLINE) + ++current_cell_number; + continue; + } + ++column; + + // Fully instantiated font + LyXFont font = getFont(i); + last_font = running_font; + + // Spaces at end of font change are simulated to be + // outside font change. + // i.e. we write "\textXX{text} " rather than + // "\textXX{text }". (Asger) + if (open_font && c == ' ' && i <= size() - 2 + && getFont(i + 1) != running_font + && getFont(i + 1) != font) { + font = getFont(i + 1); + } + + // We end font definition before blanks + if (font != running_font && open_font) { + column += running_font.latexWriteEndChanges(os, + basefont, + font); + running_font = basefont; + open_font = false; + } + // Blanks are printed before start of fontswitch + if (c == ' '){ + SimpleTeXBlanks(os, texrow, i, column, font, style); + } + // Do we need to change font? + if (font != running_font) { + column += font.latexWriteStartChanges(os, basefont, + last_font); + running_font = font; + open_font = true; + } + // Do we need to turn on LaTeX mode? + if (font.latex() != running_font.latex()) { + if (font.latex() == LyXFont::ON + && style.needprotect) { + os << "\\protect "; + column += 9; + } + } + if (c == LyXParagraph::META_NEWLINE) { + // special case for inside a table + // different from default case in + // SimpleTeXSpecialChars() + if (open_font) { + column += running_font + .latexWriteEndChanges(os, basefont, + basefont); + open_font = false; + } + basefont = getFont(-1); + running_font = basefont; + ++current_cell_number; + if (table->CellHasContRow(current_cell_number) >= 0) { + TeXContTableRows(os, i + 1, + current_cell_number, + column, texrow); + } + // if this cell follow only ContRows till end don't + // put the EndOfCell because it is put after the + // for(...) + if (table->ShouldBeVeryLastCell(current_cell_number)) { + --current_cell_number; + break; + } + int tmp = table->TexEndOfCell(os, + current_cell_number); + if (tmp > 0) { + column = 0; + } else if (tmp < 0) { + tmp = -tmp; + } + for (; tmp--;) { + texrow.newline(); + } + texrow.start(this, i + 1); + } else { + SimpleTeXSpecialChars(os, texrow, + font, running_font, basefont, + open_font, style, i, column, c); + } + } + + // If we have an open font definition, we have to close it + if (open_font) { + running_font.latexWriteEndChanges(os, basefont, basefont); + } + ++current_cell_number; + tmp = table->TexEndOfCell(os, current_cell_number); + for (; tmp > 0; --tmp) + texrow.newline(); + lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar...done " << this << endl; + return return_value; +} +#else +// This one spits out the text of a table paragraph +bool LyXParagraph::SimpleTeXOneTablePar(string & file, TexRow & texrow) +{ + lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar... " << this << endl; + + bool return_value = false; + + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + + int column = 0; + if (!IsDummy()) { // it is dummy if it is in a float!!! + if (style.isCommand()) { + file += '{'; + ++column; + } else if (align != LYX_ALIGN_LAYOUT) { + file += '{'; + ++column; + return_value = true; + } + if (noindent) { + file += "\\noindent "; + column += 10; + } + switch (align) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: break; + case LYX_ALIGN_LEFT: + file += "\\raggedright "; + column+= 13; + break; + case LYX_ALIGN_RIGHT: + file += "\\raggedleft "; + column+= 12; + break; + case LYX_ALIGN_CENTER: + file += "\\centering "; + column+= 11; + break; + } + } + + LyXFont basefont = getFont(-1); // Get layout font + // Which font is currently active? + LyXFont running_font = basefont; + LyXFont last_font; + // Do we have an open font change? + bool open_font = false; + int current_cell_number = -1; + int tmp = table->TexEndOfCell(file, current_cell_number); + for (; tmp > 0 ; --tmp) + texrow.newline(); + + texrow.start(this, 0); + + for (size_type i = 0; i < size(); ++i) { + char c = GetChar(i); + if (table->IsContRow(current_cell_number + 1)) { + if (c == LyXParagraph::META_NEWLINE) + ++current_cell_number; + continue; + } + ++column; + + // Fully instantiated font + LyXFont font = getFont(i); + last_font = running_font; + + // Spaces at end of font change are simulated to be + // outside font change. + // i.e. we write "\textXX{text} " rather than + // "\textXX{text }". (Asger) + if (open_font && c == ' ' && i <= size() - 2 + && getFont(i+1) != running_font && getFont(i+1) != font) { + font = getFont(i+1); + } + + // We end font definition before blanks + if (font != running_font && open_font) { + column += running_font.latexWriteEndChanges(file, + basefont, font); + running_font = basefont; + open_font = false; + } // Blanks are printed before start of fontswitch if (c == ' '){ SimpleTeXBlanks(file, texrow, i, column, font, style); } // Do we need to change font? if (font != running_font) { - column += font.latexWriteStartChanges(file, basefont); + column += font.latexWriteStartChanges(file, basefont, last_font); running_font = font; open_font = true; } // Do we need to turn on LaTeX mode? if (font.latex() != running_font.latex()) { if (font.latex() == LyXFont::ON - && style->needprotect) { + && style.needprotect) { file += "\\protect "; column += 9; } } - if (c == LYX_META_NEWLINE) { + if (c == LyXParagraph::META_NEWLINE) { // special case for inside a table - // different from default case in SimpleTeXSpecialChars() + // different from default case in + // SimpleTeXSpecialChars() if (open_font) { - column += running_font.latexWriteEndChanges(file, basefont); + column += running_font + .latexWriteEndChanges(file, basefont, basefont); open_font = false; } basefont = getFont(-1); running_font = basefont; - current_cell_number++; + ++current_cell_number; if (table->CellHasContRow(current_cell_number) >= 0) { - TeXContTableRows(file, i+1, current_cell_number, column, texrow); + TeXContTableRows(file, i + 1, + current_cell_number, + column, texrow); } // if this cell follow only ContRows till end don't // put the EndOfCell because it is put after the // for(...) if (table->ShouldBeVeryLastCell(current_cell_number)) { - current_cell_number--; - break; + --current_cell_number; + break; } - int tmp = table->TexEndOfCell(file, current_cell_number); - if (tmp>0) { + int tmp = table->TexEndOfCell(file, + current_cell_number); + if (tmp > 0) { column = 0; } else if (tmp < 0) { tmp = -tmp; } - for (;tmp--;) { + for (; tmp--;) { texrow.newline(); } - texrow.start(this, i+1); + texrow.start(this, i + 1); } else { SimpleTeXSpecialChars(file, texrow, font, running_font, basefont, @@ -2422,127 +2931,251 @@ bool LyXParagraph::SimpleTeXOneTablePar(LString &file, TexRow &texrow) // If we have an open font definition, we have to close it if (open_font) { - running_font.latexWriteEndChanges(file, basefont); + running_font.latexWriteEndChanges(file, basefont, basefont); } - current_cell_number++; + ++current_cell_number; tmp = table->TexEndOfCell(file, current_cell_number); - for (;tmp>0;tmp--) + for (; tmp > 0; --tmp) texrow.newline(); - lyxerr.debug(LString("SimpleTeXOneTablePar...done ")+(long)this, Error::LATEX); + lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar...done " << this << endl; return return_value; } +#endif +#ifdef USE_OSTREAM_ONLY // This one spits out the text off ContRows in tables -bool LyXParagraph::TeXContTableRows(LString &file, int i, +bool LyXParagraph::TeXContTableRows(ostream & os, + LyXParagraph::size_type i, int current_cell_number, - int &column, TexRow &texrow) + int & column, TexRow & texrow) { - lyxerr.debug(LString("TeXContTableRows... ") + - (long)this, Error::LATEX); + lyxerr[Debug::LATEX] << "TeXContTableRows... " << this << endl; if (!table) return false; char c; - int cell; - int lastpos; bool return_value = false; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout()); - LyXFont basefont; - - basefont = getFont(-1); // Get layout font + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + LyXFont basefont = getFont(-1); // Get layout font + LyXFont last_font; // Which font is currently active? LyXFont running_font = basefont; // Do we have an open font change? bool open_font = false; - lastpos = i; - cell = table->CellHasContRow(current_cell_number); - current_cell_number++; + size_type lastpos = i; + int cell = table->CellHasContRow(current_cell_number); + ++current_cell_number; while(cell >= 0) { // first find the right position i = lastpos; - for (; (iLinebreaks(table->FirstVirtualCell(cell))) { - file += " \\\\\n"; + os << " \\\\\n"; texrow.newline(); column = 0; - } else if ((c != ' ') && (c != LYX_META_NEWLINE)) { - file += ' '; + } else if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) { + os << ' '; } - for (; (i < last) && ((c=GetChar(i)) != LYX_META_NEWLINE); i++) { - column++; + + for (; i < size() + && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; + ++i) { + ++column; // Fully instantiated font LyXFont font = getFont(i); + last_font = running_font; + + // Spaces at end of font change are simulated to + // be outside font change. i.e. we write + // "\textXX{text} " rather than "\textXX{text }". + // (Asger) + if (open_font && c == ' ' && i <= size() - 2 + && getFont(i + 1) != running_font + && getFont(i + 1) != font) { + font = getFont(i + 1); + } - // Spaces at end of font change are simulated to be outside font change. - // i.e. we write "\textXX{text} " rather than "\textXX{text }". (Asger) - if (open_font && c == ' ' && i <= last-2 - && getFont(i+1) != running_font && getFont(i+1) != font) { - font = getFont(i+1); + // We end font definition before blanks + if (font != running_font && open_font) { + column += running_font.latexWriteEndChanges(os, basefont, font); + running_font = basefont; + open_font = false; + } + // Blanks are printed before start of fontswitch + if (c == ' '){ + SimpleTeXBlanks(os, texrow, i, + column, font, style); + } + // Do we need to change font? + if (font != running_font) { + column += + font.latexWriteStartChanges(os, + basefont, + last_font); + running_font = font; + open_font = true; + } + // Do we need to turn on LaTeX mode? + if (font.latex() != running_font.latex()) { + if (font.latex() == LyXFont::ON + && style.needprotect) { + os << "\\protect "; + column += 9; + } + } + SimpleTeXSpecialChars(os, texrow, font, + running_font, basefont, + open_font, style, i, column, c); + } + // If we have an open font definition, we have to close it + if (open_font) { + running_font.latexWriteEndChanges(os, basefont, + basefont); + open_font = false; + } + basefont = getFont(-1); + running_font = basefont; + cell = table->CellHasContRow(current_cell_number); + } + lyxerr[Debug::LATEX] << "TeXContTableRows...done " << this << endl; + return return_value; +} +#else +// This one spits out the text off ContRows in tables +bool LyXParagraph::TeXContTableRows(string & file, + LyXParagraph::size_type i, + int current_cell_number, + int & column, TexRow & texrow) +{ + lyxerr[Debug::LATEX] << "TeXContTableRows... " << this << endl; + if (!table) + return false; + + char c; + + bool return_value = false; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + LyXFont basefont = getFont(-1); // Get layout font + LyXFont last_font; + // Which font is currently active? + LyXFont running_font = basefont; + // Do we have an open font change? + bool open_font = false; + + size_type lastpos = i; + int cell = table->CellHasContRow(current_cell_number); + ++current_cell_number; + while(cell >= 0) { + // first find the right position + i = lastpos; + for (; (i < size()) && (current_cell_numberLinebreaks(table->FirstVirtualCell(cell))) { + file += " \\\\\n"; + texrow.newline(); + column = 0; + } else if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) { + file += ' '; + } + + for (; i < size() + && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; + ++i) { + ++column; + + // Fully instantiated font + LyXFont font = getFont(i); + last_font = running_font; + + // Spaces at end of font change are simulated to + // be outside font change. i.e. we write + // "\textXX{text} " rather than "\textXX{text }". + // (Asger) + if (open_font && c == ' ' && i <= size() - 2 + && getFont(i + 1) != running_font + && getFont(i + 1) != font) { + font = getFont(i + 1); } // We end font definition before blanks if (font != running_font && open_font) { - column += running_font.latexWriteEndChanges(file, basefont); + column += running_font.latexWriteEndChanges(file, basefont, font); running_font = basefont; open_font = false; } // Blanks are printed before start of fontswitch if (c == ' '){ - SimpleTeXBlanks(file, texrow, i, column, font, style); + SimpleTeXBlanks(file, texrow, i, + column, font, style); } // Do we need to change font? if (font != running_font) { - column += font.latexWriteStartChanges(file, basefont); + column += + font.latexWriteStartChanges(file, + basefont, last_font); running_font = font; open_font = true; } // Do we need to turn on LaTeX mode? if (font.latex() != running_font.latex()) { if (font.latex() == LyXFont::ON - && style->needprotect) + && style.needprotect) { file += "\\protect "; column += 9; } } - SimpleTeXSpecialChars(file, texrow, font, running_font, basefont, + SimpleTeXSpecialChars(file, texrow, font, + running_font, basefont, open_font, style, i, column, c); } // If we have an open font definition, we have to close it if (open_font) { - running_font.latexWriteEndChanges(file, basefont); + running_font.latexWriteEndChanges(file, basefont, basefont); open_font = false; } basefont = getFont(-1); running_font = basefont; cell = table->CellHasContRow(current_cell_number); } - lyxerr.debug(LString("TeXContTableRows...done ")+(long)this, Error::LATEX); + lyxerr[Debug::LATEX] << "TeXContTableRows...done " << this << endl; return return_value; } +#endif -bool LyXParagraph::linuxDocConvertChar(char c, LString &sgml_string) +bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) { bool retval = false; switch (c) { - case LYX_META_HFILL: - sgml_string.clean(); + case LyXParagraph::META_HFILL: + sgml_string.clear(); break; - case LYX_META_PROTECTED_SEPARATOR: +#if 0 + case LyXParagraph::META_PROTECTED_SEPARATOR: sgml_string = ' '; break; - case LYX_META_NEWLINE: +#endif + case LyXParagraph::META_NEWLINE: sgml_string = '\n'; break; case '&': @@ -2579,7 +3212,7 @@ bool LyXParagraph::linuxDocConvertChar(char c, LString &sgml_string) sgml_string = "˜"; break; case '"': - sgml_string = "&dquot;"; + sgml_string = """; break; case '\\': sgml_string = "\"; @@ -2588,8 +3221,8 @@ bool LyXParagraph::linuxDocConvertChar(char c, LString &sgml_string) retval = true; sgml_string = ' '; break; - case '\0': /* Ignore :-) */ - sgml_string.clean(); + case '\0': // Ignore :-) + sgml_string.clear(); break; default: sgml_string = c; @@ -2598,77 +3231,250 @@ bool LyXParagraph::linuxDocConvertChar(char c, LString &sgml_string) return retval; } -void LyXParagraph::SimpleDocBookOneTablePar(LString &file, LString &extra, + +#ifdef USE_OSTREAM_ONLY +void LyXParagraph::SimpleDocBookOneTablePar(ostream & os, string & extra, int & desc_on, int depth) { - if (!table) - return; - lyxerr.debug(LString("SimpleDocbookOneTablePar... ") + - (long)this, Error::LATEX); - int column, tmp; - bool return_value = false; + if (!table) return; + lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar... " << this << endl; + int column = 0; + LyXFont font1, font2; + char c; + Inset * inset; + size_type main_body; + bool emph_flag = false; + + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + + if (style.labeltype != LABEL_MANUAL) + main_body = 0; + else + main_body = BeginningOfMainBody(); + + // Gets paragraph main font. + if (main_body > 0) + font1 = style.labelfont; + else + font1 = style.font; + + int char_line_count = depth; + os << newlineAndDepth(depth); + if (footnoteflag == LyXParagraph::NO_FOOTNOTE) { + os << "" + << newlineAndDepth(++depth); + } int current_cell_number = -1; - LyXFont font1,font2; + int tmp = table->DocBookEndOfCell(os, current_cell_number, depth); + + // Parsing main loop. + for (size_type i = 0; i < size(); ++i) { + c = GetChar(i); + if (table->IsContRow(current_cell_number+1)) { + if (c == LyXParagraph::META_NEWLINE) + ++current_cell_number; + continue; + } + ++column; + + // Fully instantiated font + font2 = getFont(i); + + // Handle tag. + if (font1.emph() != font2.emph() && i) { + if (font2.emph() == LyXFont::ON) { + os << ""; + emph_flag= true; + } else if (emph_flag) { + os << ""; + emph_flag= false; + } + } + if (c == LyXParagraph::META_NEWLINE) { + // We have only to control for emphasis open here! + if (emph_flag) { + os << ""; + emph_flag= false; + } + font1 = font2 = getFont(-1); + ++current_cell_number; + if (table->CellHasContRow(current_cell_number) >= 0) { + DocBookContTableRows(os, extra, desc_on, i + 1, + current_cell_number, + column); + } + // if this cell follow only ContRows till end don't + // put the EndOfCell because it is put after the + // for(...) + if (table->ShouldBeVeryLastCell(current_cell_number)) { + --current_cell_number; + break; + } + tmp = table->DocBookEndOfCell(os, + current_cell_number, + depth); + + if (tmp > 0) + column = 0; + } else if (c == LyXParagraph::META_INSET) { + inset = GetInset(i); +#ifdef HAVE_SSTREAM + ostringstream ost; + inset->DocBook(ost); + string tmp_out = ost.str().c_str(); +#else + ostrstream ost; + inset->DocBook(ost); + ost << '\0'; + char * ctmp = ost.str(); + string tmp_out(ctmp); + delete [] ctmp; +#endif + // + // This code needs some explanation: + // Two insets are treated specially + // label if it is the first element in a + // command paragraph + // desc_on == 3 + // graphics inside tables or figure floats + // can't go on + // title (the equivalente in latex for this + // case is caption + // and title should come first + // desc_on == 4 + // + if(desc_on != 3 || i != 0) { + if(tmp_out[0] == '@') { + if(desc_on == 4) + extra += frontStrip(tmp_out, + '@'); + else + os << frontStrip(tmp_out, + '@'); + } else + os << tmp_out; + } + } else if (font2.latex() == LyXFont::ON) { + // "TeX"-Mode on == > SGML-Mode on. + if (c != '\0') + os << c; + ++char_line_count; + } else { + string sgml_string; + if (linuxDocConvertChar(c, sgml_string) + && !style.free_spacing) { + // in freespacing mode, spaces are + // non-breaking characters + // char is ' ' + if (desc_on == 1) { + ++char_line_count; + os << '\n' + << ""; + desc_on = 2; + } else { + os << c; + } + } else { + os << sgml_string; + } + } + font1 = font2; + } + + // Needed if there is an optional argument but no contents. + if (main_body > 0 && main_body == size()) { + font1 = style.font; + } + + if (emph_flag) { + os << ""; + } + + ++current_cell_number; + tmp = table->DocBookEndOfCell(os, current_cell_number, depth); + // Resets description flag correctly. + switch(desc_on){ + case 1: + // not closed... + os << ""; + break; + } + if (footnoteflag == LyXParagraph::NO_FOOTNOTE) + os << ""; + os << '\n'; + lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar...done " + << this << endl; +} +#else +void LyXParagraph::SimpleDocBookOneTablePar(string & file, string & extra, + int & desc_on, int depth) +{ + if (!table) return; + lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar... " << this << endl; + int column = 0; + LyXFont font1, font2; char c; - Inset *inset; - int main_body, j; - LString emph="emphasis"; - bool emph_flag=false; - int char_line_count=0; + Inset * inset; + size_type main_body; + bool emph_flag = false; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout()); + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); - if (style->labeltype != LABEL_MANUAL) + if (style.labeltype != LABEL_MANUAL) main_body = 0; else main_body = BeginningOfMainBody(); - /* gets paragraph main font */ + // Gets paragraph main font. if (main_body > 0) - font1 = style->labelfont; + font1 = style.labelfont; else - font1 = style->font; + font1 = style.font; - char_line_count = depth; + int char_line_count = depth; addNewlineAndDepth(file, depth); if (footnoteflag == LyXParagraph::NO_FOOTNOTE) { file += ""; addNewlineAndDepth(file, ++depth); } - current_cell_number = -1; - tmp = table->DocBookEndOfCell(file,current_cell_number, depth); + int current_cell_number = -1; + int tmp = table->DocBookEndOfCell(file, current_cell_number, depth); - /* parsing main loop */ - for (int i = 0; i < last; i++) { + // Parsing main loop. + for (size_type i = 0; i < size(); ++i) { c = GetChar(i); if (table->IsContRow(current_cell_number+1)) { - if (c == LYX_META_NEWLINE) - current_cell_number++; + if (c == LyXParagraph::META_NEWLINE) + ++current_cell_number; continue; } - column++; + ++column; // Fully instantiated font font2 = getFont(i); - /* handle tag */ + // Handle tag. if (font1.emph() != font2.emph() && i) { if (font2.emph() == LyXFont::ON) { file += ""; - emph_flag=true; + emph_flag= true; } else if (emph_flag) { file += ""; - emph_flag=false; + emph_flag= false; } } - if (c == LYX_META_NEWLINE) { - // we have only to control for emphasis open here! + if (c == LyXParagraph::META_NEWLINE) { + // We have only to control for emphasis open here! if (emph_flag) { file += ""; - emph_flag=false; + emph_flag= false; } font1 = font2 = getFont(-1); - current_cell_number++; + ++current_cell_number; if (table->CellHasContRow(current_cell_number) >= 0) { DocBookContTableRows(file, extra, desc_on, i+1, current_cell_number, @@ -2678,51 +3484,72 @@ void LyXParagraph::SimpleDocBookOneTablePar(LString &file, LString &extra, // put the EndOfCell because it is put after the // for(...) if (table->ShouldBeVeryLastCell(current_cell_number)) { - current_cell_number--; + --current_cell_number; break; } - tmp=table->DocBookEndOfCell(file, current_cell_number, - depth); + tmp = table->DocBookEndOfCell(file, + current_cell_number, + depth); if (tmp > 0) column = 0; - } else if (c == LYX_META_INSET) { + } else if (c == LyXParagraph::META_INSET) { inset = GetInset(i); - LString tmp_out; +#ifdef USE_OSTREAM_ONLY +#ifdef HAVE_SSTREAM + ostringstream ost; + inset->DocBook(ost); + string tmp_out = ost.str().c_str(); +#else + ostrstream ost; + inset->DocBook(ost); + ost << '\0'; + char * ctmp = ost.str(); + string tmp_out(ctmp); + delete [] ctmp; +#endif +#else + string tmp_out; inset->DocBook(tmp_out); +#endif // // This code needs some explanation: // Two insets are treated specially - // label if it is the first element in a command paragraph - // desc_on==3 - // graphics inside tables or figure floats can't go on - // title (the equivalente in latex for this case is caption + // label if it is the first element in a + // command paragraph + // desc_on == 3 + // graphics inside tables or figure floats + // can't go on + // title (the equivalente in latex for this + // case is caption // and title should come first - // desc_on==4 + // desc_on == 4 // - if(desc_on!=3 || i!=0) { - if(tmp_out[0]=='@') { - if(desc_on==4) - extra += tmp_out.frontStrip('@'); + if(desc_on != 3 || i != 0) { + if(tmp_out[0] == '@') { + if(desc_on == 4) + extra += frontStrip(tmp_out, + '@'); else - file += tmp_out.frontStrip('@'); + file += frontStrip(tmp_out, + '@'); } else file += tmp_out; } } else if (font2.latex() == LyXFont::ON) { - // "TeX"-Mode on ==> SGML-Mode on. - if (c!='\0') + // "TeX"-Mode on == > SGML-Mode on. + if (c != '\0') file += c; - char_line_count++; + ++char_line_count; } else { - LString sgml_string; + string sgml_string; if (linuxDocConvertChar(c, sgml_string) - && !style->free_spacing) { + && !style.free_spacing) { // in freespacing mode, spaces are // non-breaking characters // char is ' ' if (desc_on == 1) { - char_line_count++; + ++char_line_count; file += '\n'; file += ""; desc_on = 2; @@ -2736,137 +3563,309 @@ void LyXParagraph::SimpleDocBookOneTablePar(LString &file, LString &extra, font1 = font2; } - /* needed if there is an optional argument but no contents */ - if (main_body > 0 && main_body == last) { - font1 = style->font; + // Needed if there is an optional argument but no contents. + if (main_body > 0 && main_body == size()) { + font1 = style.font; } - + if (emph_flag) { file += ""; } - current_cell_number++; + ++current_cell_number; tmp = table->DocBookEndOfCell(file, current_cell_number, depth); - /* resets description flag correctly */ + // Resets description flag correctly. switch(desc_on){ case 1: - /* not closed... */ + // not closed... file += ""; break; } if (footnoteflag == LyXParagraph::NO_FOOTNOTE) file += ""; file += '\n'; - lyxerr.debug(LString("SimpleDocbookOneTablePar...done ") + - (long)this, Error::LATEX); + lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar...done " + << this << endl; } +#endif + -void LyXParagraph::DocBookContTableRows(LString &file, LString &extra, - int & desc_on, int i, +#ifdef USE_OSTREAM_ONLY +void LyXParagraph::DocBookContTableRows(ostream & os, string & extra, + int & desc_on, + LyXParagraph::size_type i, int current_cell_number, int &column) + { - if (!table) - return; + if (!table) return; - lyxerr.debug(LString("DocBookContTableRows... ") + - (long)this, Error::LATEX); - int tmp, cell, lastpos; - LyXFont font1,font2; + lyxerr[Debug::LATEX] << "DocBookContTableRows... " << this << endl; + + LyXFont font2; char c; - Inset *inset; - int main_body, j; - LString emph="emphasis"; - bool emph_flag=false; - int char_line_count=0; + Inset * inset; + //string emph = "emphasis"; + bool emph_flag = false; + int char_line_count = 0; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout()); + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); - if (style->labeltype != LABEL_MANUAL) + size_type main_body; + if (style.labeltype != LABEL_MANUAL) main_body = 0; else main_body = BeginningOfMainBody(); - /* gets paragraph main font */ + // Gets paragraph main font. + LyXFont font1; if (main_body > 0) - font1 = style->labelfont; + font1 = style.labelfont; else - font1 = style->font; + font1 = style.font; - lastpos = i; - cell = table->CellHasContRow(current_cell_number); - current_cell_number++; + size_type lastpos = i; + int cell = table->CellHasContRow(current_cell_number); + ++current_cell_number; while(cell >= 0) { // first find the right position i = lastpos; - for (; (iLinebreaks(table->FirstVirtualCell(cell))) { // file += " \\\\\n"; // column = 0; // } else - if ((c != ' ') && (c != LYX_META_NEWLINE)) { + if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) { + os << ' '; + } + + for (; i < size() + && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; + ++i) { + ++column; + + // Fully instantiated font + font2 = getFont(i); + + // Handle tag. + if (font1.emph() != font2.emph() && i) { + if (font2.emph() == LyXFont::ON) { + os << ""; + emph_flag= true; + } else if (emph_flag) { + os << ""; + emph_flag= false; + } + } + if (c == LyXParagraph::META_INSET) { + inset = GetInset(i); +#ifdef HAVE_SSTREAM + ostringstream ost; + inset->DocBook(ost); + string tmp_out = ost.str().c_str(); +#else + ostrstream ost; + inset->DocBook(ost); + ost << '\0'; + char * ctmp = ost.str(); + string tmp_out(ctmp); + delete [] ctmp; +#endif + // + // This code needs some explanation: + // Two insets are treated specially + // label if it is the first element in a + // command paragraph + // desc_on == 3 + // graphics inside tables or figure floats + // can't go on title (the equivalente in + // latex for this case is caption and title + // should come first + // desc_on == 4 + // + if(desc_on != 3 || i != 0) { + if(tmp_out[0] == '@') { + if(desc_on == 4) + extra += frontStrip(tmp_out, '@'); + else + os << frontStrip(tmp_out, '@'); + } else + os << tmp_out; + } + } else if (font2.latex() == LyXFont::ON) { + // "TeX"-Mode on == > SGML-Mode on. + if (c!= '\0') + os << c; + ++char_line_count; + } else { + string sgml_string; + if (linuxDocConvertChar(c, sgml_string) + && !style.free_spacing) { + // in freespacing mode, spaces are + // non-breaking characters + // char is ' ' + if (desc_on == 1) { + ++char_line_count; + os << '\n' + << ""; + desc_on = 2; + } else { + os << c; + } + } else { + os << sgml_string; + } + } + } + // we have only to control for emphasis open here! + if (emph_flag) { + os << ""; + emph_flag= false; + } + font1 = font2 = getFont(-1); + cell = table->CellHasContRow(current_cell_number); + } + lyxerr[Debug::LATEX] << "DocBookContTableRows...done " << this << endl; +} +#else +void LyXParagraph::DocBookContTableRows(string & file, string & extra, + int & desc_on, + LyXParagraph::size_type i, + int current_cell_number, int &column) + +{ + if (!table) return; + + lyxerr[Debug::LATEX] << "DocBookContTableRows... " << this << endl; + + LyXFont font2; + char c; + Inset * inset; + //string emph = "emphasis"; + bool emph_flag= false; + int char_line_count= 0; + + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + GetLayout()); + + size_type main_body; + if (style.labeltype != LABEL_MANUAL) + main_body = 0; + else + main_body = BeginningOfMainBody(); + + // Gets paragraph main font. + LyXFont font1; + if (main_body > 0) + font1 = style.labelfont; + else + font1 = style.font; + + size_type lastpos = i; + int cell = table->CellHasContRow(current_cell_number); + ++current_cell_number; + while(cell >= 0) { + // first find the right position + i = lastpos; + for (; i < size() && current_cell_number < cell; ++i) { + c = GetChar(i); + if (c == LyXParagraph::META_NEWLINE) + ++current_cell_number; + } + lastpos = i; + c = GetChar(i); + // I don't know how to handle this so I comment it + // for the moment (Jug) +// if (table->Linebreaks(table->FirstVirtualCell(cell))) { +// file += " \\\\\n"; +// column = 0; +// } else + if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) { file += ' '; } - for (; (i < last) && ((c=GetChar(i)) != LYX_META_NEWLINE); i++) { - column++; + + for (; i < size() + && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; + ++i) { + ++column; // Fully instantiated font font2 = getFont(i); - /* handle tag */ + // Handle tag. if (font1.emph() != font2.emph() && i) { if (font2.emph() == LyXFont::ON) { file += ""; - emph_flag=true; + emph_flag= true; } else if (emph_flag) { file += ""; - emph_flag=false; + emph_flag= false; } } - if (c == LYX_META_INSET) { + if (c == LyXParagraph::META_INSET) { inset = GetInset(i); - LString tmp_out; +#ifdef USE_OSTREAM_ONLY +#ifdef HAVE_SSTREAM + ostringstream ost; + inset->DocBook(ost); + string tmp_out = ost.str().c_str(); +#else + ostrstream ost; + inset->DocBook(ost); + ost << '\0'; + char * ctmp = ost.str(); + string tmp_out(ctmp); + delete [] ctmp; +#endif +#else + string tmp_out; inset->DocBook(tmp_out); +#endif // // This code needs some explanation: // Two insets are treated specially - // label if it is the first element in a command paragraph - // desc_on==3 - // graphics inside tables or figure floats can't go on - // title (the equivalente in latex for this case is caption - // and title should come first - // desc_on==4 + // label if it is the first element in a + // command paragraph + // desc_on == 3 + // graphics inside tables or figure floats + // can't go on title (the equivalente in + // latex for this case is caption and title + // should come first + // desc_on == 4 // - if(desc_on!=3 || i!=0) { - if(tmp_out[0]=='@') { - if(desc_on==4) - extra += tmp_out.frontStrip('@'); + if(desc_on != 3 || i != 0) { + if(tmp_out[0] == '@') { + if(desc_on == 4) + extra += frontStrip(tmp_out, '@'); else - file += tmp_out.frontStrip('@'); + file += frontStrip(tmp_out, '@'); } else file += tmp_out; } } else if (font2.latex() == LyXFont::ON) { - // "TeX"-Mode on ==> SGML-Mode on. - if (c!='\0') + // "TeX"-Mode on == > SGML-Mode on. + if (c!= '\0') file += c; - char_line_count++; + ++char_line_count; } else { - LString sgml_string; + string sgml_string; if (linuxDocConvertChar(c, sgml_string) - && !style->free_spacing) { - // in freespacing mode, spaces are - // non-breaking characters - // char is ' ' + && !style.free_spacing) { + // in freespacing mode, spaces are + // non-breaking characters + // char is ' ' if (desc_on == 1) { - char_line_count++; + ++char_line_count; file += '\n'; file += ""; desc_on = 2; @@ -2878,100 +3877,432 @@ void LyXParagraph::DocBookContTableRows(LString &file, LString &extra, } } } - // we have only to control for emphasis open here! - if (emph_flag) { - file += ""; - emph_flag=false; - } - font1 = font2 = getFont(-1); - cell = table->CellHasContRow(current_cell_number); - } - lyxerr.debug(LString("DocBookContTableRows...done ") + - (long)this, Error::LATEX); -} - - -// -void LyXParagraph::SimpleTeXBlanks(LString &file, TexRow &texrow, - int const i, int &column, LyXFont const &font, - LyXLayout const * const style) -{ - if (column > tex_code_break_column - && i - && GetChar(i-1) != ' ' - && (i < last-1) - // In LaTeX mode, we don't want to - // break lines since some commands - // do not like this - && ! (font.latex() == LyXFont::ON) - // same in FreeSpacing mode - && !style->free_spacing - // In typewriter mode, we want to avoid - // ! . ? : at the end of a line - && !(font.family() == LyXFont::TYPEWRITER_FAMILY - && (GetChar(i-1) == '.' - || GetChar(i-1) == '?' - || GetChar(i-1) == ':' - || GetChar(i-1) == '!'))) { - if (tex_code_break_column == 0) { - // in batchmode we need LaTeX to still - // see it as a space not as an extra '\n' - file += " %\n"; - } else { - file += '\n'; - } - texrow.newline(); - texrow.start(this, i+1); - column = 0; - } else if (font.latex() == LyXFont::OFF) { - if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - file += '~'; - } else { - file += ' '; - } + // we have only to control for emphasis open here! + if (emph_flag) { + file += ""; + emph_flag= false; + } + font1 = font2 = getFont(-1); + cell = table->CellHasContRow(current_cell_number); + } + lyxerr[Debug::LATEX] << "DocBookContTableRows...done " << this << endl; +} +#endif + + +#ifdef USE_OSTREAM_ONLY +void LyXParagraph::SimpleTeXBlanks(ostream & os, TexRow & texrow, + LyXParagraph::size_type const i, + int & column, LyXFont const & font, + LyXLayout const & style) +{ + if (column > tex_code_break_column + && i + && GetChar(i - 1) != ' ' + && (i < size() - 1) + // In LaTeX mode, we don't want to + // break lines since some commands + // do not like this + && ! (font.latex() == LyXFont::ON) + // same in FreeSpacing mode + && !style.free_spacing + // In typewriter mode, we want to avoid + // ! . ? : at the end of a line + && !(font.family() == LyXFont::TYPEWRITER_FAMILY + && (GetChar(i-1) == '.' + || GetChar(i-1) == '?' + || GetChar(i-1) == ':' + || GetChar(i-1) == '!'))) { + if (tex_code_break_column == 0) { + // in batchmode we need LaTeX to still + // see it as a space not as an extra '\n' + os << " %\n"; + } else { + os << '\n'; + } + texrow.newline(); + texrow.start(this, i + 1); + column = 0; + } else if (font.latex() == LyXFont::OFF) { + if (style.free_spacing) { + os << '~'; + } else { + os << ' '; + } + } +} +#else +void LyXParagraph::SimpleTeXBlanks(string & file, TexRow & texrow, + LyXParagraph::size_type const i, + int & column, LyXFont const & font, + LyXLayout const & style) +{ + if (column > tex_code_break_column + && i + && GetChar(i - 1) != ' ' + && (i < size() - 1) + // In LaTeX mode, we don't want to + // break lines since some commands + // do not like this + && ! (font.latex() == LyXFont::ON) + // same in FreeSpacing mode + && !style.free_spacing + // In typewriter mode, we want to avoid + // ! . ? : at the end of a line + && !(font.family() == LyXFont::TYPEWRITER_FAMILY + && (GetChar(i-1) == '.' + || GetChar(i-1) == '?' + || GetChar(i-1) == ':' + || GetChar(i-1) == '!'))) { + if (tex_code_break_column == 0) { + // in batchmode we need LaTeX to still + // see it as a space not as an extra '\n' + file += " %\n"; + } else { + file += '\n'; + } + texrow.newline(); + texrow.start(this, i+1); + column = 0; + } else if (font.latex() == LyXFont::OFF) { + if (style.free_spacing) { + file += '~'; + } else { + file += ' '; + } + } +} +#endif + + +#ifdef USE_OSTREAM_ONLY +void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, + LyXFont & font, + LyXFont & running_font, + LyXFont & basefont, + bool & open_font, + LyXLayout const & style, + LyXParagraph::size_type & i, + int & column, char const c) +{ + // Two major modes: LaTeX or plain + // Handle here those cases common to both modes + // and then split to handle the two modes separately. + switch (c) { + case LyXParagraph::META_INSET: { + Inset * inset = GetInset(i); + if (inset) { + bool close = false; + int len = os.tellp(); + if ((inset->LyxCode() == Inset::GRAPHICS_CODE + || inset->LyxCode() == Inset::MATH_CODE + || inset->LyxCode() == Inset::URL_CODE) + && running_font.getFontDirection() + == LYX_DIR_RIGHT_TO_LEFT) { + os << "\\L{"; + close = true; + } + + int tmp = inset->Latex(os, style.isCommand()); + + if (close) + os << "}"; + + if (tmp) { + column = 0; + } else { + column += os.tellp() - len; + } + for (; tmp--;) { + texrow.newline(); + } + } + } + break; + + case LyXParagraph::META_NEWLINE: + if (open_font) { + column += running_font.latexWriteEndChanges(os, + basefont, + basefont); + open_font = false; + } + basefont = getFont(-1); + running_font = basefont; + break; + + case LyXParagraph::META_HFILL: + os << "\\hfill{}"; + column += 7; + break; + + default: + // And now for the special cases within each mode + // Are we in LaTeX mode? + if (font.latex() == LyXFont::ON) { + // at present we only have one option + // but I'll leave it as a switch statement + // so its simpler to extend. (ARRae) + switch (c) { +#if 0 + case LyXParagraph::META_PROTECTED_SEPARATOR: + os << ' '; + break; +#endif + default: + // make sure that we will not print + // error generating chars to the tex + // file. This test would not be needed + // if it were done in the buffer + // itself. + if (c != '\0') { + os << c; + } + break; + } + } else { + // Plain mode (i.e. not LaTeX) + switch (c) { +#if 0 + case LyXParagraph::META_PROTECTED_SEPARATOR: + os << '~'; + break; +#endif + case '\\': + os << "\\textbackslash{}"; + column += 15; + break; + + case '°': case '±': case '²': case '³': + case '×': case '÷': case '¹': case 'ª': + case 'º': case '¬': case 'µ': + if (current_view->buffer()->params.inputenc == "latin1") { + os << "\\ensuremath{" + << c + << '}'; + column += 13; + } else { + os << c; + } + break; + + case '|': case '<': case '>': + // In T1 encoding, these characters exist + if (lyxrc->fontenc == "T1") { + os << c; + //... but we should avoid ligatures + if ((c == '>' || c == '<') + && i <= size() - 2 + && GetChar(i + 1) == c){ + os << "\\textcompwordmark{}"; + column += 19; + } + break; + } + // Typewriter font also has them + if (font.family() == LyXFont::TYPEWRITER_FAMILY) { + os << c; + break; + } + // Otherwise, we use what LaTeX + // provides us. + switch(c) { + case '<': + os << "\\textless{}"; + column += 10; + break; + case '>': + os << "\\textgreater{}"; + column += 13; + break; + case '|': + os << "\\textbar{}"; + column += 9; + break; + } + break; + + case '-': // "--" in Typewriter mode -> "-{}-" + if (i <= size() - 2 + && GetChar(i + 1) == '-' + && font.family() == LyXFont::TYPEWRITER_FAMILY) { + os << "-{}"; + column += 2; + } else { + os << '-'; + } + break; + + case '\"': + os << "\\char`\\\"{}"; + column += 9; + break; + + case '£': + if (current_view->buffer()->params.inputenc == "default") { + os << "\\pounds{}"; + column += 8; + } else { + os << c; + } + break; + + case '$': case '&': + case '%': case '#': case '{': + case '}': case '_': + os << '\\' << c; + column += 1; + break; + + case '~': + os << "\\textasciitilde{}"; + column += 16; + break; + + case '^': + os << "\\textasciicircum{}"; + column += 17; + break; + + case '*': case '[': case ']': + // avoid being mistaken for optional arguments + os << '{' << c << '}'; + column += 2; + break; + + case ' ': + // Blanks are printed before font switching. + // Sure? I am not! (try nice-latex) + // I am sure it's correct. LyX might be smarter + // in the future, but for now, nothing wrong is + // written. (Asger) + break; + + default: + /* idea for labels --- begin*/ + // Check for "LyX" + if (c == 'L' + && i <= size() - 3 + && font.family() != LyXFont::TYPEWRITER_FAMILY + && GetChar(i + 1) == 'y' + && GetChar(i + 2) == 'X') { + os << "\\LyX{}"; + i += 2; + column += 5; + } + // Check for "TeX" + else if (c == 'T' + && i <= size() - 3 + && font.family() != LyXFont::TYPEWRITER_FAMILY + && GetChar(i + 1) == 'e' + && GetChar(i + 2) == 'X') { + os << "\\TeX{}"; + i += 2; + column += 5; + } + // Check for "LaTeX2e" + else if (c == 'L' + && i <= size() - 7 + && font.family() != LyXFont::TYPEWRITER_FAMILY + && GetChar(i + 1) == 'a' + && GetChar(i + 2) == 'T' + && GetChar(i + 3) == 'e' + && GetChar(i + 4) == 'X' + && GetChar(i + 5) == '2' + && GetChar(i + 6) == 'e') { + os << "\\LaTeXe{}"; + i += 6; + column += 8; + } + // Check for "LaTeX" + else if (c == 'L' + && i <= size() - 5 + && font.family() != LyXFont::TYPEWRITER_FAMILY + && GetChar(i + 1) == 'a' + && GetChar(i + 2) == 'T' + && GetChar(i + 3) == 'e' + && GetChar(i + 4) == 'X') { + os << "\\LaTeX{}"; + i += 4; + column += 7; + /* idea for labels --- end*/ + } else if (c != '\0') { + os << c; + } + break; + } + } } } - - -// -void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, - LyXFont &font, LyXFont &running_font, LyXFont &basefont, - bool &open_font, LyXLayout const * const style, - int &i, int &column, char const c) +#else +void LyXParagraph::SimpleTeXSpecialChars(string & file, TexRow & texrow, + LyXFont & font, + LyXFont & running_font, + LyXFont & basefont, + bool & open_font, + LyXLayout const & style, + LyXParagraph::size_type & i, + int & column, char const c) { - Inset* inset; - // Two major modes: LaTeX or plain // Handle here those cases common to both modes // and then split to handle the two modes separately. switch (c) { - case LYX_META_INSET: - inset = GetInset(i); + case LyXParagraph::META_INSET: { + Inset * inset = GetInset(i); if (inset) { + bool close = false; int len = file.length(); - int tmp = inset->Latex(file, style->isCommand()); + if ((inset->LyxCode() == Inset::GRAPHICS_CODE + || inset->LyxCode() == Inset::MATH_CODE + || inset->LyxCode() == Inset::URL_CODE) + && running_font.getFontDirection() + == LYX_DIR_RIGHT_TO_LEFT) { + file += "\\L{"; + close = true; + } +#ifdef USE_OSTREAM_ONLY +#ifdef HAVE_SSTREAM + ostringstream ost; + int tmp = inset->Latex(ost, style.isCommand()); + file += ost.str().c_str(); +#else + ostrstream ost; + int tmp = inset->Latex(ost, style.isCommand()); + ost << '\0'; + char * chtmp = ost.str(); + file += chtmp; + delete [] chtmp; +#endif +#else + int tmp = inset->Latex(file, style.isCommand()); +#endif + if (close) + file += "}"; if (tmp) { column = 0; } else { column += file.length() - len; } - for (;tmp--;) { + for (; tmp--;) { texrow.newline(); } } - break; + } + break; - case LYX_META_NEWLINE: + case LyXParagraph::META_NEWLINE: if (open_font) { - column += running_font.latexWriteEndChanges(file, basefont); + column += running_font.latexWriteEndChanges(file, + basefont, basefont); open_font = false; } basefont = getFont(-1); running_font = basefont; break; - case LYX_META_HFILL: + case LyXParagraph::META_HFILL: file += "\\hfill{}"; column += 7; break; @@ -2984,10 +4315,11 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, // but I'll leave it as a switch statement // so its simpler to extend. (ARRae) switch (c) { - case LYX_META_PROTECTED_SEPARATOR: +#if 0 + case LyXParagraph::META_PROTECTED_SEPARATOR: file += ' '; break; - +#endif default: // make sure that we will not print // error generating chars to the tex @@ -3002,10 +4334,11 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, } else { // Plain mode (i.e. not LaTeX) switch (c) { - case LYX_META_PROTECTED_SEPARATOR: +#if 0 + case LyXParagraph::META_PROTECTED_SEPARATOR: file += '~'; break; - +#endif case '\\': file += "\\textbackslash{}"; column += 15; @@ -3014,7 +4347,7 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, case '°': case '±': case '²': case '³': case '×': case '÷': case '¹': case 'ª': case 'º': case '¬': case 'µ': - if (current_view->currentBuffer()->params.inputenc == "latin1") { + if (current_view->buffer()->params.inputenc == "latin1") { file += "\\ensuremath{"; file += c; file += '}'; @@ -3030,7 +4363,7 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, file += c; //... but we should avoid ligatures if ((c == '>' || c == '<') - && i <= last-2 + && i <= size() - 2 && GetChar(i+1) == c){ file += "\\textcompwordmark{}"; column += 19; @@ -3061,8 +4394,8 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, break; case '-': // "--" in Typewriter mode -> "-{}-" - if (i <= last-2 - && GetChar(i+1) == '-' + if (i <= size() - 2 + && GetChar(i + 1) == '-' && font.family() == LyXFont::TYPEWRITER_FAMILY) { file += "-{}"; column += 2; @@ -3077,7 +4410,7 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, break; case '£': - if (current_view->currentBuffer()->params.inputenc == "default") { + if (current_view->buffer()->params.inputenc == "default") { file += "\\pounds{}"; column += 8; } else { @@ -3093,11 +4426,14 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, column += 1; break; - case '^': case '~': - file += '\\'; - file += c; - file += "{}"; - column += 3; + case '~': + file += "\\textasciitilde{}"; + column += 16; + break; + + case '^': + file += "\\textasciicircum{}"; + column += 17; break; case '*': case '[': case ']': @@ -3109,7 +4445,7 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, break; case ' ': - /* blanks are printed before font switching */ + // Blanks are printed before font switching. // Sure? I am not! (try nice-latex) // I am sure it's correct. LyX might be smarter // in the future, but for now, nothing wrong is @@ -3118,48 +4454,48 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, default: /* idea for labels --- begin*/ - /* check for LyX */ + // Check for "LyX" if (c == 'L' - && i <= last-3 + && i <= size() - 3 && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i+1) == 'y' - && GetChar(i+2) == 'X') { + && GetChar(i + 1) == 'y' + && GetChar(i + 2) == 'X') { file += "\\LyX{}"; i += 2; column += 5; } - /* check for TeX */ + // Check for "TeX" else if (c == 'T' - && i <= last-3 + && i <= size() - 3 && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i+1) == 'e' - && GetChar(i+2) == 'X') { + && GetChar(i + 1) == 'e' + && GetChar(i + 2) == 'X') { file += "\\TeX{}"; i += 2; column += 5; } - /* check for LaTeX2e */ + // Check for "LaTeX2e" else if (c == 'L' - && i <= last-7 + && i <= size() - 7 && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i+1) == 'a' - && GetChar(i+2) == 'T' - && GetChar(i+3) == 'e' - && GetChar(i+4) == 'X' - && GetChar(i+5) == '2' - && GetChar(i+6) == 'e') { + && GetChar(i + 1) == 'a' + && GetChar(i + 2) == 'T' + && GetChar(i + 3) == 'e' + && GetChar(i + 4) == 'X' + && GetChar(i + 5) == '2' + && GetChar(i + 6) == 'e') { file += "\\LaTeXe{}"; i += 6; column += 8; } - /* check for LaTeX */ + // Check for "LaTeX" else if (c == 'L' - && i <= last-5 + && i <= size() - 5 && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i+1) == 'a' - && GetChar(i+2) == 'T' - && GetChar(i+3) == 'e' - && GetChar(i+4) == 'X') { + && GetChar(i + 1) == 'a' + && GetChar(i + 2) == 'T' + && GetChar(i + 3) == 'e' + && GetChar(i + 4) == 'X') { file += "\\LaTeX{}"; i += 4; column += 7; @@ -3172,44 +4508,41 @@ void LyXParagraph::SimpleTeXSpecialChars(LString &file, TexRow &texrow, } } } +#endif -bool LyXParagraph::RoffContTableRows(FILE *fp, int i, int actcell) +#if 0 +bool LyXParagraph::RoffContTableRows(ostream & os, + LyXParagraph::size_type i, + int actcell) { if (!table) return false; - LyXFont - font1 = LyXFont(LyXFont::ALL_INHERIT), - font2; - Inset - *inset; - int - lastpos, cell; - char - c; - LString - fname2; - FILE - *fp2; - - fname2 = TmpFileName(LString(),"RAT2"); - lastpos = i; - cell = table->CellHasContRow(actcell); - actcell++; + LyXFont font1(LyXFont::ALL_INHERIT); + LyXFont font2; + Inset * inset; + char c; + + string fname2 = TmpFileName(string(), "RAT2"); + int lastpos = i; + int cell = table->CellHasContRow(actcell); + ++actcell; while(cell >= 0) { // first find the right position i = lastpos; - for (; (iLatex(ss, -1); + ss.seekp(0); + ss.get(c); + while (!ss) { + if (c == '\\') + os << "\\\\"; + else + os << c; + ss.get(c); + } +#else + strstream ss; + inset->Latex(ss, -1); + ss.seekp(0); + ss.get(c); + while (!ss) { + if (c == '\\') + os << "\\\\"; + else + os << c; + ss.get(c); + } + delete [] ss.str(); +#endif +#else + fstream fs(fname2.c_str(), + ios::in|ios::out); + if (!fs) { + WriteAlert(_("LYX_ERROR:"), + _("Cannot open temporary file:"), + fname2); return false; } - inset->Latex(fp2,-1); - rewind(fp2); - c = fgetc(fp2); - while(!feof(fp2)) { + inset->Latex(fs, -1); + fs.seekp(0); + fs.get(c); + while (!fs) { if (c == '\\') - fprintf(fp,"\\\\"); + os << "\\\\"; else - fputc(c,fp); - c = fgetc(fp2); + os << c; + fs.get(c); } - fclose(fp2); + fs.close(); +#endif } break; - case LYX_META_NEWLINE: + case LyXParagraph::META_NEWLINE: break; - case LYX_META_HFILL: + case LyXParagraph::META_HFILL: break; - case LYX_META_PROTECTED_SEPARATOR: +#if 0 + case LyXParagraph::META_PROTECTED_SEPARATOR: break; +#endif case '\\': - fprintf(fp, "\\\\"); + os << "\\\\"; break; default: if (c != '\0') - fprintf(fp, "%c", c); + os << c; else - lyxerr.debug("RoffAsciiTable: NULL char in structure."); + lyxerr.debug() << "RoffAsciiTable: " + "NULL char in structure." + << endl; break; } } @@ -3257,19 +4627,49 @@ bool LyXParagraph::RoffContTableRows(FILE *fp, int i, int actcell) } return true; } +#endif + + +#ifdef USE_OSTREAM_ONLY +LyXParagraph * LyXParagraph::TeXDeeper(ostream & os, TexRow & texrow, + ostream & foot, TexRow & foot_texrow, + int & foot_count) +{ + lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; + LyXParagraph * par = this; + + while (par && par->depth == depth) { + if (par->IsDummy()) + lyxerr << "ERROR (LyXParagraph::TeXDeeper)" << endl; + if (textclasslist.Style(current_view->buffer()->params.textclass, + par->layout).isEnvironment() + || par->pextra_type != PEXTRA_NONE) { + par = par->TeXEnvironment(os, texrow, + foot, foot_texrow, + foot_count); + } else { + par = par->TeXOnePar(os, texrow, + foot, foot_texrow, + foot_count); + } + } + lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; -LyXParagraph * LyXParagraph::TeXDeeper(LString &file, TexRow &texrow, - LString &foot, TexRow &foot_texrow, - int &foot_count) + return par; +} +#else +LyXParagraph * LyXParagraph::TeXDeeper(string & file, TexRow & texrow, + string & foot, TexRow & foot_texrow, + int & foot_count) { - lyxerr.debug(LString("TeXDeeper... ") + (long)this, Error::LATEX); - LyXParagraph *par = this; + lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; + LyXParagraph * par = this; while (par && par->depth == depth) { if (par->IsDummy()) - lyxerr.print("ERROR (LyXParagraph::TeXDeeper)"); - if (lyxstyle.Style(GetCurrentTextClass(), - par->layout)->isEnvironment() + lyxerr << "ERROR (LyXParagraph::TeXDeeper)" << endl; + if (textclasslist.Style(current_view->buffer()->params.textclass, + par->layout).isEnvironment() || par->pextra_type != PEXTRA_NONE) { par = par->TeXEnvironment(file, texrow, @@ -3281,33 +4681,314 @@ LyXParagraph * LyXParagraph::TeXDeeper(LString &file, TexRow &texrow, foot_count); } } - lyxerr.debug(LString("TeXDeeper...done ") + (long)par, Error::LATEX); - - return par; + lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; + + return par; +} +#endif + + +#ifdef USE_OSTREAM_ONLY +LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, + ostream & foot, + TexRow & foot_texrow, + int & foot_count) +{ + bool eindent_open = false; + bool foot_this_level = false; + // flags when footnotetext should be appended to file. + static bool minipage_open = false; + static int minipage_open_depth = 0; + char par_sep = current_view->buffer()->params.paragraph_separation; + + lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; + if (IsDummy()) + lyxerr << "ERROR (LyXParagraph::TeXEnvironment)" << endl; + + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + layout); + + if (pextra_type == PEXTRA_INDENT) { + if (!pextra_width.empty()) { + os << "\\begin{LyXParagraphIndent}{" + << pextra_width << "}\n"; + } else { + //float ib = atof(pextra_widthp.c_str())/100; + // string can't handle floats at present (971109) + // so I'll do a conversion by hand knowing that + // the limits are 0.0 to 1.0. ARRae. + os << "\\begin{LyXParagraphIndent}{"; + switch (pextra_widthp.length()) { + case 3: + os << "1.00"; + break; + case 2: + os << "0." + << pextra_widthp; + break; + case 1: + os << "0.0" + << pextra_widthp; + } + os << "\\columnwidth}\n"; + } + texrow.newline(); + eindent_open = true; + } + if ((pextra_type == PEXTRA_MINIPAGE) && !minipage_open) { + if (pextra_hfill && Previous() && + (Previous()->pextra_type == PEXTRA_MINIPAGE)) { + os << "\\hfill{}\n"; + texrow.newline(); + } + if (par_sep == BufferParams::PARSEP_INDENT) { + os << "{\\setlength\\parindent{0pt}\n"; + texrow.newline(); + } + os << "\\begin{minipage}"; + switch(pextra_alignment) { + case MINIPAGE_ALIGN_TOP: + os << "[t]"; + break; + case MINIPAGE_ALIGN_MIDDLE: + os << "[m]"; + break; + case MINIPAGE_ALIGN_BOTTOM: + os << "[b]"; + break; + } + if (!pextra_width.empty()) { + os << '{' << pextra_width << "}\n"; + } else { + //float ib = atof(par->pextra_width.c_str())/100; + // string can't handle floats at present + // so I'll do a conversion by hand knowing that + // the limits are 0.0 to 1.0. ARRae. + os << '{'; + switch (pextra_widthp.length()) { + case 3: + os << "1.00"; + break; + case 2: + os << "0." + << pextra_widthp; + break; + case 1: + os << "0.0" + << pextra_widthp; + } + os << "\\columnwidth}\n"; + } + texrow.newline(); + if (par_sep == BufferParams::PARSEP_INDENT) { + os << "\\setlength\\parindent{\\LyXMinipageIndent}\n"; + texrow.newline(); + } + minipage_open = true; + minipage_open_depth = depth; + } + +#ifdef WITH_WARNINGS +#warning Define FANCY_FOOTNOTE_CODE to re-enable Allan footnote code + //I disabled it because it breaks when lists span on several + //pages (JMarc) +#endif + if (style.isEnvironment()){ + if (style.latextype == LATEX_LIST_ENVIRONMENT) { +#ifdef FANCY_FOOTNOTE_CODE + if (foot_count < 0) { + // flag that footnote[mark][text] should be + // used for any footnotes from now on + foot_count = 0; + foot_this_level = true; + } +#endif + os << "\\begin{" << style.latexname() << "}{" + << labelwidthstring << "}\n"; + } else if (style.labeltype == LABEL_BIBLIO) { + // ale970405 + os << "\\begin{" << style.latexname() << "}{" + << bibitemWidthest(current_view->painter()) + << "}\n"; + } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { +#ifdef FANCY_FOOTNOTE_CODE + if (foot_count < 0) { + // flag that footnote[mark][text] should be + // used for any footnotes from now on + foot_count = 0; + foot_this_level = true; + } +#endif + os << "\\begin{" << style.latexname() << '}' + << style.latexparam() << '\n'; + } else + os << "\\begin{" << style.latexname() << '}' + << style.latexparam() << '\n'; + texrow.newline(); + } + LyXParagraph * par = this; + do { + par = par->TeXOnePar(os, texrow, + foot, foot_texrow, foot_count); + + if (minipage_open && par && !style.isEnvironment() && + (par->pextra_type == PEXTRA_MINIPAGE) && + par->pextra_start_minipage) { + os << "\\end{minipage}\n"; + texrow.newline(); + if (par_sep == BufferParams::PARSEP_INDENT) { + os << "}\n"; + texrow.newline(); + } + minipage_open = false; + } + if (par && par->depth > depth) { + if (textclasslist.Style(current_view->buffer()->params.textclass, + par->layout).isParagraph() + && !par->table + // Thinko! + // How to handle this? (Lgb) + //&& !suffixIs(os, "\n\n") + ) { + // There should be at least one '\n' already + // but we need there to be two for Standard + // paragraphs that are depth-increment'ed to be + // output correctly. However, tables can + // also be paragraphs so don't adjust them. + // ARRae + // Thinkee: + // Will it ever harm to have one '\n' too + // many? i.e. that we sometimes will have + // three in a row. (Lgb) + os << '\n'; + texrow.newline(); + } + par = par->TeXDeeper(os, texrow, + foot, foot_texrow, foot_count); + } + if (par && par->layout == layout && par->depth == depth && + (par->pextra_type == PEXTRA_MINIPAGE) && !minipage_open) { + if (par->pextra_hfill && par->Previous() && + (par->Previous()->pextra_type == PEXTRA_MINIPAGE)){ + os << "\\hfill{}\n"; + texrow.newline(); + } + if (par_sep == BufferParams::PARSEP_INDENT) { + os << "{\\setlength\\parindent{0pt}\n"; + texrow.newline(); + } + os << "\\begin{minipage}"; + switch(par->pextra_alignment) { + case MINIPAGE_ALIGN_TOP: + os << "[t]"; + break; + case MINIPAGE_ALIGN_MIDDLE: + os << "[m]"; + break; + case MINIPAGE_ALIGN_BOTTOM: + os << "[b]"; + break; + } + if (!par->pextra_width.empty()) { + os << '{' << par->pextra_width << "}\n"; + } else { + //float ib = atof(par->pextra_widthp.c_str())/100; + // string can't handle floats at present + // so I'll do a conversion by hand knowing that + // the limits are 0.0 to 1.0. ARRae. + os << '{'; + switch (par->pextra_widthp.length()) { + case 3: + os << "1.00"; + break; + case 2: + os << "0." << par->pextra_widthp; + break; + case 1: + os << "0.0" << par->pextra_widthp; + } + os << "\\columnwidth}\n"; + } + texrow.newline(); + if (par_sep == BufferParams::PARSEP_INDENT) { + os << "\\setlength\\parindent{\\LyXMinipageIndent}\n"; + texrow.newline(); + } + minipage_open = true; + minipage_open_depth = par->depth; + } + } while (par + && par->layout == layout + && par->depth == depth + && par->pextra_type == pextra_type); + + if (style.isEnvironment()) { + os << "\\end{" << style.latexname() << '}'; + // maybe this should go after the minipage closes? + if (foot_this_level) { + if (foot_count >= 1) { + if (foot_count > 1) { + os << "\\addtocounter{footnote}{-" + << foot_count - 1 + << '}'; + } + os << foot; + texrow += foot_texrow; + foot.clear(); + foot_texrow.reset(); + foot_count = 0; + } + } + } + if (minipage_open && (minipage_open_depth == depth) && + (!par || par->pextra_start_minipage || + par->pextra_type != PEXTRA_MINIPAGE)) { + os << "\\end{minipage}\n"; + texrow.newline(); + if (par_sep == BufferParams::PARSEP_INDENT) { + os << "}\n"; + texrow.newline(); + } + if (par && par->pextra_type != PEXTRA_MINIPAGE) { + os << "\\medskip\n\n"; + texrow.newline(); + texrow.newline(); + } + minipage_open = false; + } + if (eindent_open) { + os << "\\end{LyXParagraphIndent}\n"; + texrow.newline(); + } + if (!(par && (par->pextra_type == PEXTRA_MINIPAGE) + && par->pextra_hfill)) { + os << '\n'; + texrow.newline(); + } + lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; + return par; // ale970302 } - - -LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, - LString &foot, TexRow &foot_texrow, - int &foot_count) +#else +LyXParagraph * LyXParagraph::TeXEnvironment(string & file, TexRow & texrow, + string & foot, + TexRow & foot_texrow, + int & foot_count) { - bool - eindent_open = false; - bool - foot_this_level = false; - // flags when footnotetext should be appended to file. - static bool - minipage_open = false; - static int - minipage_open_depth = 0; - char - par_sep = current_view->currentBuffer()->params.paragraph_separation; + bool eindent_open = false; + bool foot_this_level = false; + // flags when footnotetext should be appended to file. + static bool minipage_open = false; + static int minipage_open_depth = 0; + char par_sep = current_view->buffer()->params.paragraph_separation; - lyxerr.debug(LString("TeXEnvironment... ") + long(this), Error::LATEX); + lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; if (IsDummy()) - lyxerr.print("ERROR (LyXParagraph::TeXEnvironment)"); + lyxerr << "ERROR (LyXParagraph::TeXEnvironment)" << endl; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), layout); + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + layout); if (pextra_type == PEXTRA_INDENT) { if (!pextra_width.empty()) { @@ -3315,7 +4996,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, + pextra_width + "}\n"; } else { //float ib = atof(pextra_widthp.c_str())/100; - // LString can't handle floats at present (971109) + // string can't handle floats at present (971109) // so I'll do a conversion by hand knowing that // the limits are 0.0 to 1.0. ARRae. file += "\\begin{LyXParagraphIndent}{"; @@ -3342,7 +5023,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += "\\hfill{}\n"; texrow.newline(); } - if (par_sep == LYX_PARSEP_INDENT) { + if (par_sep == BufferParams::PARSEP_INDENT) { file += "{\\setlength\\parindent{0pt}\n"; texrow.newline(); } @@ -3363,7 +5044,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += pextra_width + "}\n"; } else { //float ib = atof(par->pextra_width.c_str())/100; - // LString can't handle floats at present + // string can't handle floats at present // so I'll do a conversion by hand knowing that // the limits are 0.0 to 1.0. ARRae. file += '{'; @@ -3382,7 +5063,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += "\\columnwidth}\n"; } texrow.newline(); - if (par_sep == LYX_PARSEP_INDENT) { + if (par_sep == BufferParams::PARSEP_INDENT) { file += "\\setlength\\parindent{\\LyXMinipageIndent}\n"; texrow.newline(); } @@ -3395,8 +5076,8 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, //I disabled it because it breaks when lists span on several //pages (JMarc) #endif - if (style->isEnvironment()){ - if (style->latextype == LATEX_LIST_ENVIRONMENT) { + if (style.isEnvironment()){ + if (style.latextype == LATEX_LIST_ENVIRONMENT) { #ifdef FANCY_FOOTNOTE_CODE if (foot_count < 0) { // flag that footnote[mark][text] should be @@ -3405,13 +5086,14 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, foot_this_level = true; } #endif - file += "\\begin{" + style->latexname + "}{" + file += "\\begin{" + style.latexname() + "}{" + labelwidthstring + "}\n"; - } else if (style->labeltype == LABEL_BIBLIO) { + } else if (style.labeltype == LABEL_BIBLIO) { // ale970405 - file += "\\begin{" + style->latexname + "}{" - + bibitemWidthest() + "}\n"; - } else if (style->latextype == LATEX_ITEM_ENVIRONMENT) { + file += "\\begin{" + style.latexname() + "}{" + + bibitemWidthest(current_view->painter()) + + "}\n"; + } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { #ifdef FANCY_FOOTNOTE_CODE if (foot_count < 0) { // flag that footnote[mark][text] should be @@ -3420,47 +5102,40 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, foot_this_level = true; } #endif - file += "\\begin{" + style->latexname + '}' - + style->latexparam + '\n'; + file += "\\begin{" + style.latexname() + '}' + + style.latexparam() + '\n'; } else - file += "\\begin{" + style->latexname + '}' - + style->latexparam + '\n'; + file += "\\begin{" + style.latexname() + '}' + + style.latexparam() + '\n'; texrow.newline(); } - LyXParagraph *par = this; + LyXParagraph * par = this; do { par = par->TeXOnePar(file, texrow, foot, foot_texrow, foot_count); -#if 0 - if (eindent_open && par && par->pextra_type != PEXTRA_INDENT) { - file += "\\end{LyXParagraphIndent}\n"; - texrow.newline(); - eindent_open = false; - if (!style->isEnvironment()) - break; - } -#endif - if (minipage_open && par && !style->isEnvironment() && + + if (minipage_open && par && !style.isEnvironment() && (par->pextra_type == PEXTRA_MINIPAGE) && par->pextra_start_minipage) { - file += "\\end{minipage}\n"; - texrow.newline(); - if (par_sep == LYX_PARSEP_INDENT) { - file += "}\n"; + file += "\\end{minipage}\n"; texrow.newline(); - } - minipage_open = false; + if (par_sep == BufferParams::PARSEP_INDENT) { + file += "}\n"; + texrow.newline(); + } + minipage_open = false; } if (par && par->depth > depth) { - if (lyxstyle.Style(GetCurrentTextClass(), - par->layout)->isParagraph() + if (textclasslist.Style(current_view->buffer()->params.textclass, + par->layout).isParagraph() && !par->table - && !file.suffixIs("\n\n")) { - // There should be at least one '\n' already - // but we need there to be two for Standard - // paragraphs that are depth-increment'ed to be - // output correctly. However, tables can also be - // paragraphs so don't adjust them. ARRae + && !suffixIs(file, "\n\n")) { + // There should be at least one '\n' already + // but we need there to be two for Standard + // paragraphs that are depth-increment'ed to be + // output correctly. However, tables can + // also be paragraphs so don't adjust them. + // ARRae file += '\n'; texrow.newline(); } @@ -3474,9 +5149,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += "\\hfill{}\n"; texrow.newline(); } -// else -// file += '\n'; - if (par_sep == LYX_PARSEP_INDENT) { + if (par_sep == BufferParams::PARSEP_INDENT) { file += "{\\setlength\\parindent{0pt}\n"; texrow.newline(); } @@ -3498,7 +5171,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += "}\n"; } else { //float ib = atof(par->pextra_widthp.c_str())/100; - // LString can't handle floats at present + // string can't handle floats at present // so I'll do a conversion by hand knowing that // the limits are 0.0 to 1.0. ARRae. file += '{'; @@ -3517,7 +5190,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += "\\columnwidth}\n"; } texrow.newline(); - if (par_sep == LYX_PARSEP_INDENT) { + if (par_sep == BufferParams::PARSEP_INDENT) { file += "\\setlength\\parindent{\\LyXMinipageIndent}\n"; texrow.newline(); } @@ -3529,19 +5202,19 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, && par->depth == depth && par->pextra_type == pextra_type); - if (style->isEnvironment()) { - file += "\\end{" + style->latexname + '}'; + if (style.isEnvironment()) { + file += "\\end{" + style.latexname() + '}'; // maybe this should go after the minipage closes? if (foot_this_level) { if (foot_count >= 1) { if (foot_count > 1) { file += "\\addtocounter{footnote}{-"; - file += foot_count - 1; + file += tostr(foot_count - 1); file += '}'; } file += foot; texrow += foot_texrow; - foot.clean(); + foot.clear(); foot_texrow.reset(); foot_count = 0; } @@ -3552,7 +5225,7 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, par->pextra_type != PEXTRA_MINIPAGE)) { file += "\\end{minipage}\n"; texrow.newline(); - if (par_sep == LYX_PARSEP_INDENT) { + if (par_sep == BufferParams::PARSEP_INDENT) { file += "}\n"; texrow.newline(); } @@ -3567,42 +5240,307 @@ LyXParagraph* LyXParagraph::TeXEnvironment(LString &file, TexRow &texrow, file += "\\end{LyXParagraphIndent}\n"; texrow.newline(); } -// if (tex_code_break_column){ - if (!(par && (par->pextra_type==PEXTRA_MINIPAGE) + if (!(par && (par->pextra_type == PEXTRA_MINIPAGE) && par->pextra_hfill)) { file += '\n'; texrow.newline(); } - lyxerr.debug(LString("TeXEnvironment...done ") - + (long)par, Error::LATEX); + lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; return par; // ale970302 } +#endif + + +#ifdef USE_OSTREAM_ONLY +LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, + ostream & foot, TexRow & foot_texrow, + int & foot_count, + LyXDirection par_direction) +{ + lyxerr[Debug::LATEX] << "TeXFootnote... " << this << endl; + if (footnoteflag == LyXParagraph::NO_FOOTNOTE) + lyxerr << "ERROR (LyXParagraph::TeXFootnote): " + "No footnote!" << endl; + + LyXParagraph * par = this; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + previous->GetLayout()); + + if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){ + lyxerr << "ERROR (LyXParagraph::TeXFootnote): " + "Float other than footnote in command" + " with moving argument is illegal" << endl; + } + + if (footnotekind != LyXParagraph::FOOTNOTE + && footnotekind != LyXParagraph::MARGIN + && os.tellp() + // Thinko + // How to solve this? + //&& !suffixIs(file, '\n') + ) { + // we need to ensure that real floats like tables and figures + // have their \begin{} on a new line otherwise we can get + // incorrect results when using the endfloat.sty package + // especially if two floats follow one another. ARRae 981022 + // NOTE: if the file is length 0 it must have just been + // written out so we assume it ended with a '\n' + // Thinkee: + // As far as I can see there is never any harm in writing + // a '\n' too much. Please tell me if I am wrong. (Lgb) + os << '\n'; + texrow.newline(); + } + + BufferParams * params = ¤t_view->buffer()->params; + bool footer_in_body = true; + switch (footnotekind) { + case LyXParagraph::FOOTNOTE: + if (style.intitle) { + os << "\\thanks{\n"; + footer_in_body = false; + } else { + if (foot_count == -1) { + // we're at depth 0 so we can use: + os << "\\footnote{%\n"; + footer_in_body = false; + } else { + os << "\\footnotemark{}%\n"; + if (foot_count) { + // we only need this when there are + // multiple footnotes + os << "\\stepcounter{footnote}"; + } + os << "\\footnotetext{%\n"; + foot_texrow.start(this, 0); + foot_texrow.newline(); + ++foot_count; + } + } + break; + case LyXParagraph::MARGIN: + os << "\\marginpar{\n"; + break; + case LyXParagraph::FIG: + if (pextra_type == PEXTRA_FLOATFLT + && (!pextra_width.empty() + || !pextra_widthp.empty())) { + if (!pextra_width.empty()) + os << "\\begin{floatingfigure}{" + << pextra_width << "}\n"; + else + os << "\\begin{floatingfigure}{" + << atoi(pextra_widthp.c_str())/100.0 + << "\\textwidth}\n"; + } else { + os << "\\begin{figure}"; + if (!params->float_placement.empty()) { + os << '[' << params->float_placement << "]\n"; + } else { + os << '\n'; + } + } + break; + case LyXParagraph::TAB: + os << "\\begin{table}"; + if (!params->float_placement.empty()) { + os << '[' << params->float_placement << "]\n"; + } else { + os << '\n'; + } + break; + case LyXParagraph::WIDE_FIG: + os << "\\begin{figure*}"; + if (!params->float_placement.empty()) { + os << '[' << params->float_placement << "]\n"; + } else { + os << '\n'; + } + break; + case LyXParagraph::WIDE_TAB: + os << "\\begin{table*}"; + if (!params->float_placement.empty()) { + os << '[' << params->float_placement << "]\n"; + } else { + os << '\n'; + } + break; + case LyXParagraph::ALGORITHM: + os << "\\begin{algorithm}\n"; + break; + } + texrow.newline(); + + + LyXDirection direction = getParDirection(); + if (direction != par_direction) { + if (direction == LYX_DIR_LEFT_TO_RIGHT) + os << "\\unsethebrew\n"; + else + os << "\\sethebrew\n"; + texrow.newline(); + } + + if (footnotekind != LyXParagraph::FOOTNOTE + || !footer_in_body) { + // Process text for all floats except footnotes in body + do { + LyXLayout const & style = + textclasslist + .Style(current_view->buffer()->params + .textclass, + par->layout); + if (par->IsDummy()) + lyxerr << "ERROR (LyXParagraph::TeXFootnote)" + << endl; + if (style.isEnvironment() + || par->pextra_type == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */ + // Allows the use of minipages within float + // environments. Shouldn't be circular because + // we don't support footnotes inside + // floats (yet). ARRae + par = par->TeXEnvironment(os, texrow, + foot, foot_texrow, + foot_count); + } else { + par = par->TeXOnePar(os, texrow, + foot, foot_texrow, + foot_count); + } + + if (par && !par->IsDummy() && par->depth > depth) { + par = par->TeXDeeper(os, texrow, + foot, foot_texrow, + foot_count); + } + } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE); + } else { + // process footnotes > depth 0 or in environments separately + // NOTE: Currently don't support footnotes within footnotes + // even though that is possible using the \footnotemark +#ifdef HAVE_SSTREAM + ostringstream dummy; +#else + ostrstream dummy; +#endif + TexRow dummy_texrow; + int dummy_count = 0; + do { + LyXLayout const & style = + textclasslist + .Style(current_view->buffer()->params + .textclass, + par->layout); + if (par->IsDummy()) + lyxerr << "ERROR (LyXParagraph::TeXFootnote)" + << endl; + if (style.isEnvironment() + || par->pextra_type == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */ + // Allows the use of minipages within float + // environments. Shouldn't be circular because + // we don't support footnotes inside + // floats (yet). ARRae + par = par->TeXEnvironment(foot, foot_texrow, + dummy, dummy_texrow, + dummy_count); + } else { + par = par->TeXOnePar(foot, foot_texrow, + dummy, dummy_texrow, + dummy_count); + } + + if (par && !par->IsDummy() && par->depth > depth) { + par = par->TeXDeeper(foot, foot_texrow, + dummy, dummy_texrow, + dummy_count); + } + } while (par + && par->footnoteflag != LyXParagraph::NO_FOOTNOTE); + if (dummy_count) { + lyxerr << "ERROR (LyXParagraph::TeXFootnote): " + "Footnote in a Footnote -- not supported" + << endl; + } +#ifndef HAVE_OSTREAM + delete [] dummy.str(); +#endif + } + + switch (footnotekind) { + case LyXParagraph::FOOTNOTE: + if (footer_in_body) { + // This helps tell which of the multiple + // footnotetexts an error was in. + foot << "}%\n"; + foot_texrow.newline(); + } else { + os << '}'; + } + break; + case LyXParagraph::MARGIN: + os << '}'; + break; + case LyXParagraph::FIG: + if (pextra_type == PEXTRA_FLOATFLT + && (!pextra_width.empty() + || !pextra_widthp.empty())) + os << "\\end{floatingfigure}"; + else + os << "\\end{figure}"; + break; + case LyXParagraph::TAB: + os << "\\end{table}"; + break; + case LyXParagraph::WIDE_FIG: + os << "\\end{figure*}"; + break; + case LyXParagraph::WIDE_TAB: + os << "\\end{table*}"; + break; + case LyXParagraph::ALGORITHM: + os << "\\end{algorithm}"; + break; + } + if (footnotekind != LyXParagraph::FOOTNOTE + && footnotekind != LyXParagraph::MARGIN) { + // we need to ensure that real floats like tables and figures + // have their \end{} on a line of their own otherwise we can + // get incorrect results when using the endfloat.sty package. + os << "\n"; + texrow.newline(); + } -LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, - LString &foot, TexRow &foot_texrow, - int &foot_count) + lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next << endl; + return par; +} +#else +LyXParagraph * LyXParagraph::TeXFootnote(string & file, TexRow & texrow, + string & foot, TexRow & foot_texrow, + int & foot_count, + LyXDirection par_direction) { - lyxerr.debug(LString("TeXFootnote... ") - + (long)this, Error::LATEX); + lyxerr[Debug::LATEX] << "TeXFootnote... " << this << endl; if (footnoteflag == LyXParagraph::NO_FOOTNOTE) - lyxerr.print("ERROR (LyXParagraph::TeXFootnote): " - "No footnote!"); + lyxerr << "ERROR (LyXParagraph::TeXFootnote): " + "No footnote!" << endl; - LyXParagraph *par = this; - LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), - previous->GetLayout()); + LyXParagraph * par = this; + LyXLayout const & style = + textclasslist.Style(current_view->buffer()->params.textclass, + previous->GetLayout()); - if (style->needprotect && footnotekind != LyXParagraph::FOOTNOTE){ - lyxerr.print("ERROR (LyXParagraph::TeXFootnote): " - "Float other than footnote in command" - " with moving argument is illegal"); + if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){ + lyxerr << "ERROR (LyXParagraph::TeXFootnote): " + "Float other than footnote in command" + " with moving argument is illegal" << endl; } if (footnotekind != LyXParagraph::FOOTNOTE && footnotekind != LyXParagraph::MARGIN && file.length() - && !file.suffixIs('\n')) { + && !suffixIs(file, '\n')) { // we need to ensure that real floats like tables and figures // have their \begin{} on a new line otherwise we can get // incorrect results when using the endfloat.sty package @@ -3613,11 +5551,11 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, texrow.newline(); } - BufferParams *params = ¤t_view->currentBuffer()->params; + BufferParams * params = ¤t_view->buffer()->params; bool footer_in_body = true; switch (footnotekind) { case LyXParagraph::FOOTNOTE: - if (style->intitle) { + if (style.intitle) { file += "\\thanks{\n"; footer_in_body = false; } else { @@ -3633,7 +5571,7 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, foot += "\\stepcounter{footnote}"; } foot += "\\footnotetext{%\n"; - foot_texrow.start(this,0); + foot_texrow.start(this, 0); foot_texrow.newline(); ++foot_count; } @@ -3648,10 +5586,12 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, || !pextra_widthp.empty())) { char bufr[80]; if (!pextra_width.empty()) - sprintf(bufr, "\\begin{floatingfigure}{%s}\n", + sprintf(bufr, + "\\begin{floatingfigure}{%s}\n", pextra_width.c_str()); else - sprintf(bufr, "\\begin{floatingfigure}{%f\\textwidth}\n", + sprintf(bufr, + "\\begin{floatingfigure}{%f\\textwidth}\n", atoi(pextra_widthp.c_str())/100.0); file += bufr; } else { @@ -3701,19 +5641,34 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, } texrow.newline(); + + LyXDirection direction = getParDirection(); + if (direction != par_direction) { + if (direction == LYX_DIR_LEFT_TO_RIGHT) + file += "\\unsethebrew\n"; + else + file += "\\sethebrew\n"; + texrow.newline(); + } + if (footnotekind != LyXParagraph::FOOTNOTE || !footer_in_body) { // Process text for all floats except footnotes in body do { - LyXLayout *style = lyxstyle.Style(GetCurrentTextClass(), - par->layout); + LyXLayout const & style = + textclasslist + .Style(current_view->buffer()->params + .textclass, + par->layout); if (par->IsDummy()) - lyxerr.print("ERROR (LyXParagraph::TeXFootnote)"); - if (style->isEnvironment() + lyxerr << "ERROR (LyXParagraph::TeXFootnote)" + << endl; + if (style.isEnvironment() || par->pextra_type == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */ - // Allows the use of minipages within float environments. - // Shouldn't be circular because we don't support - // footnotes inside floats (yet). ARRae + // Allows the use of minipages within float + // environments. Shouldn't be circular because + // we don't support footnotes inside + // floats (yet). ARRae par = par->TeXEnvironment(file, texrow, foot, foot_texrow, foot_count); @@ -3733,19 +5688,24 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, // process footnotes > depth 0 or in environments separately // NOTE: Currently don't support footnotes within footnotes // even though that is possible using the \footnotemark - LString dummy; + string dummy; TexRow dummy_texrow; int dummy_count = 0; do { - LyXLayout *style = lyxstyle.Style(GetCurrentTextClass(), - par->layout); + LyXLayout const & style = + textclasslist + .Style(current_view->buffer()->params + .textclass, + par->layout); if (par->IsDummy()) - lyxerr.print("ERROR (LyXParagraph::TeXFootnote)"); - if (style->isEnvironment() + lyxerr << "ERROR (LyXParagraph::TeXFootnote)" + << endl; + if (style.isEnvironment() || par->pextra_type == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */ - // Allows the use of minipages within float environments. - // Shouldn't be circular because we don't support - // footnotes inside floats (yet). ARRae + // Allows the use of minipages within float + // environments. Shouldn't be circular because + // we don't support footnotes inside + // floats (yet). ARRae par = par->TeXEnvironment(foot, foot_texrow, dummy, dummy_texrow, dummy_count); @@ -3760,10 +5720,12 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, dummy, dummy_texrow, dummy_count); } - } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE); + } while (par + && par->footnoteflag != LyXParagraph::NO_FOOTNOTE); if (dummy_count) { - lyxerr.print("ERROR (LyXParagraph::TeXFootnote): " - "Footnote in a Footnote -- not supported"); + lyxerr << "ERROR (LyXParagraph::TeXFootnote): " + "Footnote in a Footnote -- not supported" + << endl; } } @@ -3812,85 +5774,191 @@ LyXParagraph * LyXParagraph::TeXFootnote(LString &file, TexRow &texrow, texrow.newline(); } - lyxerr.debug(LString("TeXFootnote...done ") + - long(par->next), Error::LATEX); + lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next << endl; return par; } +#endif -void LyXParagraph::SetPExtraType(int type, const char *width,const char *widthp) +void LyXParagraph::SetPExtraType(int type, char const * width, + char const * widthp) { - pextra_type = type; - pextra_width = width; - pextra_widthp = widthp; - - if (lyxstyle.Style(GetCurrentTextClass(), - layout)->isEnvironment()) { - LyXParagraph - *par = this, - *ppar = par; - - while (par && (par->layout == layout) && (par->depth == depth)) { - ppar = par; - par = par->Previous(); - if (par) - par = par->FirstPhysicalPar(); - while (par && par->depth > depth) { - par = par->Previous(); - if (par) - par = par->FirstPhysicalPar(); - } - } - par = ppar; - while (par && (par->layout == layout) && (par->depth == depth)) { - par->pextra_type = type; - par->pextra_width = width; - par->pextra_widthp = widthp; - par = par->NextAfterFootnote(); - if (par && (par->depth > depth)) - par->SetPExtraType(type,width,widthp); - while (par && ((par->depth > depth) || par->IsDummy())) - par = par->NextAfterFootnote(); - } - } + pextra_type = type; + pextra_width = width; + pextra_widthp = widthp; + + if (textclasslist.Style(current_view->buffer()->params.textclass, + layout).isEnvironment()) { + LyXParagraph + * par = this, + * ppar = par; + + while (par && (par->layout == layout) + && (par->depth == depth)) { + ppar = par; + par = par->Previous(); + if (par) + par = par->FirstPhysicalPar(); + while (par && par->depth > depth) { + par = par->Previous(); + if (par) + par = par->FirstPhysicalPar(); + } + } + par = ppar; + while (par && (par->layout == layout) + && (par->depth == depth)) { + par->pextra_type = type; + par->pextra_width = width; + par->pextra_widthp = widthp; + par = par->NextAfterFootnote(); + if (par && (par->depth > depth)) + par->SetPExtraType(type, width, widthp); + while (par && ((par->depth > depth) || par->IsDummy())) + par = par->NextAfterFootnote(); + } + } } + void LyXParagraph::UnsetPExtraType() { - if (pextra_type == PEXTRA_NONE) - return; + if (pextra_type == PEXTRA_NONE) + return; - pextra_type = PEXTRA_NONE; - pextra_width.clean(); - pextra_widthp.clean(); - - if (lyxstyle.Style(GetCurrentTextClass(), - layout)->isEnvironment()) { - LyXParagraph - *par = this, - *ppar = par; - - while (par && (par->layout == layout) && (par->depth == depth)) { - ppar = par; - par = par->Previous(); - if (par) - par = par->FirstPhysicalPar(); - while (par && par->depth > depth) { - par = par->Previous(); - if (par) - par = par->FirstPhysicalPar(); - } - } - par = ppar; - while (par && (par->layout == layout) && (par->depth == depth)) { - par->pextra_type = PEXTRA_NONE; - par->pextra_width.clean(); - par->pextra_widthp.clean(); - par = par->NextAfterFootnote(); - if (par && (par->depth > depth)) - par->UnsetPExtraType(); - while (par && ((par->depth > depth) || par->IsDummy())) - par = par->NextAfterFootnote(); - } - } + pextra_type = PEXTRA_NONE; + pextra_width.clear(); + pextra_widthp.clear(); + + if (textclasslist.Style(current_view->buffer()->params.textclass, + layout).isEnvironment()) { + LyXParagraph + * par = this, + * ppar = par; + + while (par && (par->layout == layout) + && (par->depth == depth)) { + ppar = par; + par = par->Previous(); + if (par) + par = par->FirstPhysicalPar(); + while (par && par->depth > depth) { + par = par->Previous(); + if (par) + par = par->FirstPhysicalPar(); + } + } + par = ppar; + while (par && (par->layout == layout) + && (par->depth == depth)) { + par->pextra_type = PEXTRA_NONE; + par->pextra_width.clear(); + par->pextra_widthp.clear(); + par = par->NextAfterFootnote(); + if (par && (par->depth > depth)) + par->UnsetPExtraType(); + while (par && ((par->depth > depth) || par->IsDummy())) + par = par->NextAfterFootnote(); + } + } +} + + +bool LyXParagraph::IsHfill(size_type pos) const +{ + return IsHfillChar(GetChar(pos)); +} + + +bool LyXParagraph::IsInset(size_type pos) const +{ + return IsInsetChar(GetChar(pos)); +} + + +bool LyXParagraph::IsFloat(size_type pos) const +{ + return IsFloatChar(GetChar(pos)); +} + + +bool LyXParagraph::IsNewline(size_type pos) const +{ + bool tmp = false; + if (pos >= 0) + tmp = IsNewlineChar(GetChar(pos)); + return tmp; +} + + +bool LyXParagraph::IsSeparator(size_type pos) const +{ + return IsSeparatorChar(GetChar(pos)); +} + + +bool LyXParagraph::IsLineSeparator(size_type pos) const +{ + return IsLineSeparatorChar(GetChar(pos)); +} + + +bool LyXParagraph::IsKomma(size_type pos) const +{ + return IsKommaChar(GetChar(pos)); +} + + +/// Used by the spellchecker +bool LyXParagraph::IsLetter(LyXParagraph::size_type pos) const +{ + unsigned char c = GetChar(pos); + if (IsLetterChar(c)) + return true; + // '\0' is not a letter, allthough every string contains "" (below) + if( c == '\0') + return false; + // We want to pass the ' and escape chars to ispell + string extra = lyxrc->isp_esc_chars + '\''; + char ch[2]; + ch[0] = c; + ch[1] = 0; + return contains(extra, ch); +} + + +bool LyXParagraph::IsWord(size_type pos ) const +{ + return IsWordChar(GetChar(pos)) ; +} + + +LyXDirection LyXParagraph::getParDirection() const +{ + if (!lyxrc->rtl_support || table) + return LYX_DIR_LEFT_TO_RIGHT; + + if (size() > 0) + return (getFont(0).direction() == LyXFont::RTL_DIR) + ? LYX_DIR_RIGHT_TO_LEFT : LYX_DIR_LEFT_TO_RIGHT; + else + return current_view->buffer()->params.getDocumentDirection(); +} + + +LyXDirection +LyXParagraph::getLetterDirection(LyXParagraph::size_type pos) const +{ + if (!lyxrc->rtl_support) + return LYX_DIR_LEFT_TO_RIGHT; + + LyXDirection direction = getFont(pos).getFontDirection(); + if (IsLineSeparator(pos) && 0 < pos && pos < Last() - 1 + && !IsLineSeparator(pos + 1) + && !(table && IsNewline(pos + 1)) + && (getFont(pos - 1).getFontDirection() != direction + || getFont(pos + 1).getFontDirection() != direction)) + return getParDirection(); + else + return direction; }