/* This file is part of
- * ======================================================
+ * ======================================================
*
* LyX, The Document Processor
*
- * Copyright 1995 Matthias Ettrich
+ * Copyright 1995 Matthias Ettrich
* Copyright 1995-1999 The LyX Team.
*
- * ======================================================*/
+ * ====================================================== */
#include <config.h>
#endif
#include "lyxparagraph.h"
+#include "support/textutils.h"
#include "lyxrc.h"
#include "layout.h"
#include "tex-strings.h"
#include "bufferparams.h"
#include "support/FileInfo.h"
-#include "error.h"
+#include "debug.h"
#include "LaTeXFeatures.h"
#include "insets/insetinclude.h"
#include "support/filetools.h"
#include "lyx_gui_misc.h"
#include "texrow.h"
-#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(string & file, int const depth); // Jug 990923
extern unsigned char GetCurrentTextClass(); // this should be fixed/removed
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
/* 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,
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 = 0;
previous = 0;
+#ifndef NEW_TABLE
fonttable = 0;
insettable = 0;
+#endif
footnoteflag = LyXParagraph::NO_FOOTNOTE;
align = LYX_ALIGN_BLOCK;
/* this konstruktor inserts the new paragraph in a list */
-LyXParagraph::LyXParagraph(LyXParagraph *par)
+LyXParagraph::LyXParagraph(LyXParagraph * par)
{
- size = INITIAL_SIZE_PAR;
- last = 0;
- text = new char[size];
- for (int i=0; i<10; i++) setCounter(i, 0);
+#warning we also need a reserve here
+#warning this would be a nice place to shrink par
+ for (int i = 0; i < 10; ++i) setCounter(i, 0);
appendix = false;
enumdepth = 0;
itemdepth = 0;
next->previous = this;
previous = par;
previous->next = this;
+#ifndef NEW_TABLE
fonttable = 0;
insettable = 0;
+#endif
footnoteflag = LyXParagraph::NO_FOOTNOTE;
footnotekind = LyXParagraph::FOOTNOTE;
id = paragraph_id++;
bibkey = 0; // ale970302
- // ale970302
-// fprintf(stderr, "new bib "); fflush(stderr);
-// if (par->bibkey) {
-// bibkey = new InsetBibKey(par->bibkey);
-// }
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
- string extra = lyxrc->isp_esc_chars + '\'';
- char ch[2];
- ch[0] = c;
- ch[1] = 0;
- return contains(extra, ch);
-}
-
-void LyXParagraph::writeFile(FILE *file, BufferParams ¶ms,
+void LyXParagraph::writeFile(FILE * file, BufferParams & params,
char footflag, char dth)
{
LyXFont font1, font2;
- Inset *inset;
+ Inset * inset;
int column = 0;
int h = 0;
char c = 0;
/* First write the layout */
fprintf(file, "\n\\layout %s\n",
- lyxstyle.NameOfLayout(params.textclass,layout).c_str());
+ textclasslist.NameOfLayout(params.textclass, layout)
+ .c_str());
/* maybe some vertical spaces */
if (added_space_top.kind() != VSpace::NONE)
fprintf(file, " \\pextra_hfill %d",
pextra_hfill);
if (pextra_start_minipage)
- fprintf(file, " \\pextra_start_minipage %d",
+ fprintf(file,
+ " \\pextra_start_minipage %d",
pextra_start_minipage);
}
if (!pextra_width.empty()) {
fprintf(file, " \\pextra_width %s",
- VSpace(pextra_width).asLyXCommand().c_str());
+ VSpace(pextra_width)
+ .asLyXCommand().c_str());
} else if (!pextra_widthp.empty()) {
- fprintf(file, " \\pextra_widthp %s",pextra_widthp.c_str());
+ fprintf(file, " \\pextra_widthp %s",
+ pextra_widthp.c_str());
}
- fprintf(file,"\n");
+ fprintf(file, "\n");
}
}
else {
font1 = LyXFont(LyXFont::ALL_INHERIT);
column = 0;
- for (int i = 0; i < last; i++) {
+ for (size_type i = 0; i < size(); i++) {
if (!i){
fprintf(file, "\n");
column = 0;
}
-
+
// Write font changes
font2 = GetFontSettings(i);
if (font2 != font1) {
c = GetChar(i);
switch (c) {
- case LYX_META_INSET:
+ case META_INSET:
inset = GetInset(i);
if (inset)
if (inset->DirectWrite()) {
column = 0;
}
break;
- case LYX_META_NEWLINE:
+ case META_NEWLINE:
fprintf(file, "\n\\newline \n");
column = 0;
break;
- case LYX_META_HFILL:
+ case META_HFILL:
fprintf(file, "\n\\hfill \n");
column = 0;
break;
- case LYX_META_PROTECTED_SEPARATOR:
+ case META_PROTECTED_SEPARATOR:
fprintf(file, "\n\\protected_separator \n");
column = 0;
break;
column = 0;
break;
case '.':
- if (i + 1 < last && GetChar(i + 1) == ' ') {
+ if (i + 1 < size() && GetChar(i + 1) == ' ') {
fprintf(file, ".\n");
column = 0;
} else
fprintf(file, ".");
break;
default:
- if ((column > 70 && c==' ')
+ if ((column > 70 && c == ' ')
|| column > 79){
fprintf(file, "\n");
column = 0;
if (c != '\0')
fprintf(file, "%c", c);
else
- lyxerr.print("ERROR (LyXParagraph::writeFile):"
- " NULL char in structure.");
+ lyxerr << "ERROR (LyXParagraph::writeFile):"
+ " NULL char in structure." << endl;
column++;
break;
}
}
-void LyXParagraph::validate(LaTeXFeatures &features)
+void LyXParagraph::validate(LaTeXFeatures & features)
{
// this will be useful later
- LyXLayout *layout = lyxstyle.Style(GetCurrentTextClass(),
+ LyXLayout const & layout = textclasslist.Style(GetCurrentTextClass(),
GetLayout());
// check the params.
// then the layouts
features.layout[GetLayout()] = true;
+#ifdef NEW_TABLE
+ 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::LATEX] << "Noun enabled. Font: "
+ << (*cit).font.stateText()
+ << endl;
+ }
+ switch ((*cit).font.color()) {
+ case LyXFont::NONE:
+ case LyXFont::INHERIT_COLOR:
+ case LyXFont::IGNORE_COLOR: break;
+ default:
+ features.color = true;
+ lyxerr[Debug::LATEX] << "Color enabled. Font: "
+ << (*cit).font.stateText()
+ << endl;
+ }
+ }
+#else
// then the fonts
- FontTable *tmpfonttable = fonttable;
+ FontTable * tmpfonttable = fonttable;
while (tmpfonttable) {
if (tmpfonttable->font.noun() == LyXFont::ON) {
- lyxerr.debug(string("font.noun: ")
- + tostr(tmpfonttable->font.noun()),
- Error::LATEX);
+ lyxerr[Debug::LATEX] << "font.noun: "
+ << tmpfonttable->font.noun()
+ << endl;
features.noun = true;
- lyxerr.debug("Noun enabled. Font: "
- +tmpfonttable->font.stateText(),
- Error::LATEX);
+ lyxerr[Debug::LATEX] << "Noun enabled. Font: "
+ << tmpfonttable->font.stateText()
+ << endl;
}
switch (tmpfonttable->font.color()) {
case LyXFont::NONE:
break;
default:
features.color = true;
- lyxerr.debug("Color enabled. Font: "
- +tmpfonttable->font.stateText(),
- Error::LATEX);
+ lyxerr[Debug::LATEX] << "Color enabled. Font: "
+ << tmpfonttable->font.stateText()
+ << endl;
}
tmpfonttable = tmpfonttable->next;
}
-
+#endif
+#ifdef NEW_TABLE
+ for (InsetList::const_iterator cit = insetlist.begin();
+ cit != insetlist.end(); ++cit) {
+ (*cit).inset->Validate(features);
+ }
+#else
// then the insets
- InsetTable *tmpinsettable = insettable;
+ InsetTable * tmpinsettable = insettable;
while (tmpinsettable) {
if (tmpinsettable->inset) {
tmpinsettable->inset->Validate(features);
}
tmpinsettable = tmpinsettable->next;
}
+#endif
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;
/* first few functions needed for cut and paste and paragraph breaking */
-void LyXParagraph::CopyIntoMinibuffer(int pos)
+void LyXParagraph::CopyIntoMinibuffer(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)->Clone();
} else {
}
}
-
-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) */
-
+ // 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)
+#ifdef NEW_TABLE
+ for (InsetList::iterator it = insetlist.begin();
+ it != insetlist.end(); ++it) {
+ if ((*it).pos == pos) {
+ (*it).inset = 0;
+ break;
+ }
+ }
+#else
/* find the entry */
- InsetTable *tmpi = insettable;
+ InsetTable * tmpi = insettable;
while (tmpi && tmpi->pos != pos) {
- tmpi=tmpi->next;
+ tmpi= tmpi->next;
}
if (tmpi) { /* This should always be true */
tmpi->inset = 0;
}
+#endif
} else {
minibuffer_inset = 0;
minibuffer_char = ' ';
}
-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);
}
noindent = false;
pextra_type = PEXTRA_NONE;
- pextra_width.erase();
- pextra_widthp.erase();
+ pextra_width.clear();
+ pextra_widthp.clear();
pextra_alignment = MINIPAGE_ALIGN_TOP;
pextra_hfill = false;
pextra_start_minipage = false;
- labelstring.erase();
- labelwidthstring.erase();
+ labelstring.clear();
+ labelwidthstring.clear();
layout = 0;
bibkey = 0;
if (next)
next->previous = previous;
- if (text)
- delete[] text;
-
- InsetTable *tmpinset;
+#ifndef NEW_TABLE
+ InsetTable * tmpinset;
while (insettable) {
tmpinset = insettable;
insettable = insettable->next;
}
}
- FontTable *tmpfont;
+ FontTable * tmpfont;
while (fonttable) {
tmpfont = fonttable;
fonttable = fonttable->next;
delete tmpfont;
}
+#endif
/* table stuff -- begin*/
if (table)
}
-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) {
+ 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 (pos < size()) { // last is free for insertation, but should be empty
+#ifdef NEW_TABLE
/* if it is an inset, delete the inset entry */
- if (text[pos] == LYX_META_INSET) {
+ 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;
+ }
+ }
+ }
+#else
+ /* if it is an inset, delete the inset entry */
+ if (text[pos] == LyXParagraph::META_INSET) {
/* find the entry */
InsetTable *tmpi = insettable;
InsetTable *tmpi2 = tmpi;
while (tmpi && tmpi->pos != pos) {
- tmpi2=tmpi;
- tmpi=tmpi->next;
+ tmpi2= tmpi;
+ tmpi= tmpi->next;
}
if (tmpi) { // this should always be true
if (tmpi->inset) // delete the inset if it exists
delete tmpi;
}
}
-
- // Shift rest of text
- for (i = pos; i < last - 1; i++) {
- text[i]=text[i+1];
+#endif
+ text.erase(text.begin() + pos);
+#ifdef NEW_TABLE
+ /* 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) {
+ fontlist.erase(it);
+ break;
+ }
+ }
}
- last--;
+ /* 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 */
+ for(InsetList::iterator it = insetlist.begin();
+ it != insetlist.end(); ++it) {
+ if ((*it).pos > pos)
+ (*it).pos--;
+ }
+#else
/* erase entries in the tables */
int found = 0;
- FontTable *tmp = fonttable;
- FontTable *prev = 0;
+ FontTable * tmp = fonttable;
+ FontTable * prev = 0;
while (tmp && !found) {
if (pos >= tmp->pos && pos <= tmp->pos_end)
found = 1;
}
/* update the inset table */
- InsetTable *tmpi = insettable;
+ InsetTable * tmpi = insettable;
while (tmpi) {
if (tmpi->pos > pos)
tmpi->pos--;
- tmpi=tmpi->next;
+ tmpi= tmpi->next;
}
-
+#endif
} else {
- lyxerr.print("ERROR (LyXParagraph::Erase): can't erase non-existant char.");
- }
-}
-
-
-/* pos is needed to specify the paragraph correctly. Remember the
-* closed footnotes */
-void LyXParagraph::Enlarge(int pos, int number)
-{
- 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);
- else
- lyxerr.print("ERROR (LyXParagraph::Enlarge): position does not exist.");
- 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;
+ lyxerr << "ERROR (LyXParagraph::Erase): "
+ "can't erase non-existant char." << endl;
}
}
-/* make the allocated memory fit to the needed size */
-/* used to make a paragraph smaller */
-void LyXParagraph::FitSize()
+void LyXParagraph::InsertChar(LyXParagraph::size_type pos, char c)
{
- 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;
- }
-}
-
-
-void LyXParagraph::InsertChar(int pos, char c)
-{
- 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);
+ if (pos > size()) {
+ if (next
+ && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ NextAfterFootnote()->InsertChar(pos - text.size() - 1,
+ c);
else
- lyxerr.debug("ERROR (LyXParagraph::InsertChar): "
- "position does not exist.");
+ lyxerr.debug() << "ERROR (LyXParagraph::InsertChar): "
+ "position does not exist." << 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;
+ text.insert(text.begin() + pos, c);
+#ifdef NEW_TABLE
+ // 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++;
}
-
- // Shift rest of character
- for (i = last; i>pos; i--) {
- text[i]=text[i-1];
+ // update the inset table
+ for(InsetList::iterator it = insetlist.begin();
+ it != insetlist.end(); ++it) {
+ if ((*it).pos >= pos)
+ (*it).pos++;
}
-
- text[pos]=c;
- last++;
-
+#else
/* update the font table */
- FontTable *tmp = fonttable;
+ FontTable * tmp = fonttable;
while (tmp) {
if (tmp->pos >= pos)
tmp->pos++;
}
/* update the inset table */
- InsetTable *tmpi = insettable;
+ InsetTable * tmpi = insettable;
while (tmpi) {
if (tmpi->pos >= pos)
tmpi->pos++;
- tmpi=tmpi->next;
+ tmpi= tmpi->next;
}
+#endif
}
-void LyXParagraph::InsertInset(int pos, Inset *inset)
+void LyXParagraph::InsertInset(LyXParagraph::size_type pos,
+ Inset * inset)
{
/* > 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);
+ if (pos > size()) {
+ if (next
+ && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
+ NextAfterFootnote()
+ ->InsertInset(pos - text.size() - 1, inset);
else
- lyxerr.print("ERROR (LyXParagraph::InsertInset): "
- "position does not exist: " + tostr(pos));
+ lyxerr << "ERROR (LyXParagraph::InsertInset): "
+ "position does not exist: " << pos << endl;
return;
}
-
- if (text[pos]!=LYX_META_INSET) {
- lyxerr.print("ERROR (LyXParagraph::InsertInset): "
- "there is no LYX_META_INSET");
+ if (text[pos] != LyXParagraph::META_INSET) {
+ lyxerr << "ERROR (LyXParagraph::InsertInset): "
+ "there is no LyXParagraph::META_INSET" << endl;
return;
}
+#ifdef NEW_TABLE
+ if (inset) {
+ InsetTable tmp;
+ tmp.pos = pos;
+ tmp.inset = inset;
+ insetlist.push_back(tmp);
+ }
+
+#else
if (inset) {
/* add a new entry in the inset table */
- InsetTable *tmpi = new InsetTable;
+ InsetTable * tmpi = new InsetTable;
tmpi->pos = pos;
tmpi->inset = inset;
tmpi->next = insettable;
insettable = tmpi;
}
+#endif
}
-Inset* LyXParagraph::GetInset(int pos)
+Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos)
{
- 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(string("ERROR (LyXParagraph::GetInset): position does not exist: ") + tostr(pos));
+ lyxerr << "ERROR (LyXParagraph::GetInset): "
+ "position does not exist: "
+ << pos << endl;
}
return 0;
}
-
+#ifdef NEW_TABLE
+ /* 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
+ // 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 0;
+#else
/* find the inset */
- InsetTable *tmpi = insettable;
+ InsetTable * tmpi = insettable;
while (tmpi && tmpi->pos != pos)
tmpi = tmpi->next;
if (tmpi)
return tmpi->inset;
else {
- lyxerr.print(string("ERROR (LyXParagraph::GetInset): "
- "Inset does not exist: ") + tostr(pos));
+ 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
// seen any, please enlighten me. (Lgb)
// as well replace it with a space to prevent crashes. (Asger)
return 0;
}
+#endif
}
// Gets uninstantiated font setting at position.
// Optimized after profiling. (Asger)
-LyXFont LyXParagraph::GetFontSettings(int pos)
+LyXFont LyXParagraph::GetFontSettings(LyXParagraph::size_type pos)
{
- if (pos < last) {
- FontTable *tmp = fonttable;
+ if (pos < size()) {
+#ifdef NEW_TABLE
+ for(FontList::iterator it = fontlist.begin();
+ it != fontlist.end(); ++it) {
+ if (pos >= (*it).pos && pos <= (*it).pos_end)
+ return (*it).font;
+ }
+#else
+ FontTable * tmp = fonttable;
while (tmp) {
if (pos >= tmp->pos && pos <= tmp->pos_end)
return tmp->font;
tmp = tmp->next;
}
+#endif
}
-
/* > 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);
+ 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?
// We want strict error checking, but it's ok to only
// have it when debugging. (Asger)
- lyxerr.print(
- string("ERROR (LyXParagraph::GetFontSettings): "
- "position does not exist. ") + tostr(pos));
+ lyxerr << "ERROR (LyXParagraph::GetFontSettings): "
+ "position does not exist. "
+ << pos << " (" << static_cast<int>(pos)
+ << ")\n";
}
} else if (pos) {
return GetFontSettings(pos - 1);
// 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)
{
LyXFont tmpfont;
- LyXLayout *layout = lyxstyle.Style(GetCurrentTextClass(),
+ LyXLayout const & layout = textclasslist.Style(GetCurrentTextClass(),
GetLayout());
-
- int main_body=0;
- if (layout->labeltype == LABEL_MANUAL)
+ 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;
}
// check for environment font information
while (par && par_depth && !tmpfont.resolved()) {
par = par->DepthHook(par_depth - 1);
if (par) {
- tmpfont.realize(lyxstyle.
+ tmpfont.realize(textclasslist.
Style(GetCurrentTextClass(),
- par->GetLayout())->font);
+ par->GetLayout()).font);
par_depth = par->GetDepth();
}
}
- tmpfont.realize(lyxstyle.TextClass(GetCurrentTextClass())->defaultfont);
+ tmpfont.realize(textclasslist.TextClass(GetCurrentTextClass()).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;
+#ifdef NEW_TABLE
+ 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;
+ }
+ }
+#else
+ 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)
+ if (size > maxsize && size<= LyXFont::SIZE_HUGER)
maxsize = size;
}
tmp = tmp->next;
}
+#endif
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(string("FATAL ERROR (LyXParagraph::GetChar):"
- " bad position ") + tostr(pos));
+ lyxerr << "FATAL ERROR (LyXParagraph::GetChar):"
+ " bad position " << pos << endl;
abort();
}
#endif
- 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) {
+ 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<int>(pos)
+ << ")\n";
+ }
return '\0';
- } else { // pos==last
+ } 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
}
}
-string LyXParagraph::GetWord(int & lastpos)
+char LyXParagraph::GetChar(LyXParagraph::size_type pos) const
+{
+#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 << "FATAL ERROR (LyXParagraph::GetChar):"
+ " bad position " << pos << endl;
+ abort();
+ }
+#endif
+
+ 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): "
+ "position does not exist."
+ << pos << " (" << static_cast<int>(pos)
+ << ")\n";
+ }
+ 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
+ }
+}
+string LyXParagraph::GetWord(LyXParagraph::size_type & lastpos)
//Added 98/9/21 by REH
// return an string of the current word, and the end of the word
// in lastpos.
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(string("FATAL ERROR (LyXParagraph::GetWord):"
- " bad position ") + tostr(lastpos));
+ lyxerr << "FATAL ERROR (LyXParagraph::GetWord):"
+ " bad position " << lastpos << endl;
abort();
}
#endif
//i think the devcode aborts before this, but why not be
// versatile?
- if (lastpos < 0) lastpos=0;
+ if (lastpos < 0) lastpos= 0;
// move back until we have a letter
//since someone might have typed a punctuation first
int firstpos = lastpos;
- while ((firstpos >=0) && !IsLetter(firstpos))
+ while ((firstpos >= 0) && !IsLetter(firstpos))
firstpos--;
// now find the beginning by looking for a nonletter
- while ((firstpos>=0) && IsLetter(firstpos))
+ while ((firstpos>= 0) && IsLetter(firstpos))
firstpos--;
// the above is now pointing to the preceeding non-letter
firstpos++;
- lastpos=firstpos;
+ lastpos= firstpos;
// so copy characters into theword until we get a nonletter
// note that this can easily exceed lastpos, wich means
}
-
-int LyXParagraph::Last()
+
+LyXParagraph::size_type LyXParagraph::Last()
{
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);
+ 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
}
-int LyXParagraph::PositionInParFromPos(int pos)
+int LyXParagraph::PositionInParFromPos(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()->PositionInParFromPos(pos - last - 1);
+ 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
}
-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 (pos > size()) {
if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
- NextAfterFootnote()->SetFont(pos - last - 1, font);
+ 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)
-
+#ifdef NEW_TABLE
// Next search font table
- FontTable *tmp2;
+ for(FontList::iterator it = fontlist.begin();
+ it != fontlist.end(); ++it) {
+ if (pos >= (*it).pos && pos <= (*it).pos_end) {
+ // found it
+ // we found a font entry. maybe we have to
+ // split it and create a new one
+
+ if ((*it).pos != (*it).pos_end) {
+ // more than one character
+ if (pos == (*it).pos) {
+ // maybe we could enlarge
+ // the left fonttable
+ for(FontList::iterator fit = fontlist.begin();
+ fit != fontlist.end(); ++fit) {
+ if (pos - 1 >= (*fit).pos
+ && pos - 1 <= (*fit).pos_end
+ && (*fit).font == font) {
+ // put the position
+ // under the font
+ (*fit).pos_end++;
+ (*it).pos++;
+ return;
+ }
+ }
+ // Add a new entry in the
+ // fonttable for the position
+ FontTable tmp;
+ tmp.pos = pos + 1;
+ tmp.pos_end = (*it).pos_end;
+ tmp.font = (*it).font;
+ (*it).pos_end = pos;
+ fontlist.push_back(tmp);
+ } else if (pos == (*it).pos_end) {
+ // Add a new entry in the
+ // fonttable for the position
+ FontTable tmp;
+ tmp.pos = (*it).pos;
+ tmp.pos_end = (*it).pos_end - 1;
+ tmp.font = (*it).font;
+ (*it).pos = (*it).pos_end;
+ fontlist.push_back(tmp);
+ } else {
+ // Add a new entry in the
+ // fonttable for the position
+ FontTable tmp;
+ tmp.pos = (*it).pos;
+ tmp.pos_end = pos - 1;
+ tmp.font = (*it).font;
+ fontlist.push_back(tmp);
+
+ tmp.pos = pos + 1;
+ tmp.pos_end = (*it).pos_end;
+ tmp.font = (*it).font;
+ fontlist.push_back(tmp);
+
+ (*it).pos = pos;
+ (*it).pos_end = pos;
+ }
+ }
+ (*it).font = font;
+ return;
+ }
+ }
+
+ // 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
+ for(FontList::iterator it = fontlist.begin();
+ it != fontlist.end(); ++it) {
+ if (pos - 1 >= (*it).pos && pos - 1 <= (*it).pos_end
+ && (*it).font == font) {
+ (*it).pos_end++;
+ return;
+ }
+ }
+ // Add a new entry in the
+ // fonttable for the position
+ FontTable tmp;
+ tmp.pos = pos;
+ tmp.pos_end = pos;
+ tmp.font = patternfont;
+ fontlist.push_back(tmp);
+#else
+ // Next search font table
+ FontTable * tmp2;
bool found = false;
- FontTable *tmp = fonttable;
+ FontTable * tmp = fonttable;
while (tmp && !found) {
if (pos >= tmp->pos && pos <= tmp->pos_end)
found = true;
tmp->font = patternfont;
tmp->next = fonttable;
fonttable = tmp;
- }
- else {
+ } else {
/* we found a font entry. maybe we have to split it and create
* a new one */
}
}
}
-
tmp->font = font;
+#endif
}
/* this function is able to hide closed footnotes */
-LyXParagraph *LyXParagraph::Next()
+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! */
}
}
-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! */
+ return next; /* this should never happen! */
}
else
return next;
}
-LyXParagraph *LyXParagraph::PreviousBeforeFootnote()
+LyXParagraph * LyXParagraph::NextAfterFootnote() const
{
- LyXParagraph *tmp;
+ 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 * 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! */
+ 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;
}
-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))
/* this function is able to hide closed footnotes */
-LyXParagraph *LyXParagraph::Previous()
+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();
return previous;
}
-
-void LyXParagraph::BreakParagraph(int pos, int flag)
-{
- int i, pos_end, pos_first;
+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 * par = ParFromPos(pos);
+ LyXParagraph * firstpar = FirstPhysicalPar();
- LyXParagraph *tmp = new LyXParagraph(par);
+ LyXParagraph * tmp = new LyXParagraph(par);
tmp->footnoteflag = footnoteflag;
tmp->footnotekind = footnotekind;
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!!) */
- tmp->Enlarge(0, pos_end - pos);
+ pos_end = pos_first + par->text.size() - 1;
+ tmp->text.reserve(pos_end - pos);
for (i = pos; i <= pos_end; i++) {
par->CutIntoMinibuffer(i - pos_first);
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 */
}
-void LyXParagraph::MakeSameLayout(LyXParagraph *par)
+void LyXParagraph::MakeSameLayout(LyXParagraph * par)
{
par = par->FirstPhysicalPar();
footnoteflag = par->footnoteflag;
}
-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;
}
-LyXParagraph *LyXParagraph::Clone()
+LyXParagraph * LyXParagraph::Clone()
{
- int i;
-
/* create a new paragraph */
- LyXParagraph *result = new LyXParagraph();
+ LyXParagraph * result = new LyXParagraph;
result->MakeSameLayout(this);
/* 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);
-
- for (i = 0; i < last; i++) {
+ result->text.reserve(size());
+ for (size_type i = 0; i < size(); i++) {
CopyIntoMinibuffer(i);
result->InsertFromMinibuffer(i);
}
}
-bool LyXParagraph::HasSameLayout(LyXParagraph* par)
+bool LyXParagraph::HasSameLayout(LyXParagraph * par)
{
par = par->FirstPhysicalPar();
}
-void LyXParagraph::BreakParagraphConservative(int pos)
+void LyXParagraph::BreakParagraphConservative(LyXParagraph::size_type pos)
{
- int i, pos_end, pos_first;
-
+ size_type i, pos_end, pos_first;
+
/* create a new paragraph */
- LyXParagraph *par = ParFromPos(pos);
+ LyXParagraph * par = ParFromPos(pos);
- LyXParagraph *tmp = new LyXParagraph(par);
+ LyXParagraph * tmp = new LyXParagraph(par);
tmp->MakeSameLayout(par);
pos_first = 0;
while (ParFromPos(pos_first) != par)
pos_first++;
-
- pos_end = pos_first + par->last - 1;
-
+ pos_end = pos_first + par->text.size() - 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);
-
+ tmp->text.reserve(pos_end - pos);
+
for (i = pos; i <= pos_end; i++) {
par->CutIntoMinibuffer(i - pos_first);
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());
}
}
/* 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();
+ LyXParagraph * the_next = Next();
- LyXParagraph *firstpar = FirstPhysicalPar();
+ LyXParagraph * firstpar = FirstPhysicalPar();
/* 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);
-
+
+ size_type pos_end = the_next->text.size() - 1;
+ size_type pos_insert = Last();
+ size_type i;
+
/* ok, now copy the paragraph */
for (i = 0; i <= pos_end; i++) {
the_next->CutIntoMinibuffer(i);
}
-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;
}
-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;
}
-int LyXParagraph::GetLayout()
+LyXTextClass::LayoutList::size_type LyXParagraph::GetLayout()
{
return FirstPhysicalPar()->layout;
}
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::LayoutList::size_type new_layout)
{
- LyXParagraph
- *par = FirstPhysicalPar(),
- *ppar = 0,
- *npar = 0;
+ LyXParagraph * par = FirstPhysicalPar();
+ LyXParagraph * ppar = 0;
+ LyXParagraph * npar = 0;
par->layout = new_layout;
/* table stuff -- begin*/
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)) {
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::LayoutList::size_type new_layout)
{
LyXParagraph
- *par = FirstPhysicalPar(),
- *ppar = 0,
- *npar = 0;
+ * par = FirstPhysicalPar(),
+ * ppar = 0,
+ * npar = 0;
par->layout = new_layout;
- par->labelwidthstring.erase();
+ 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*/
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)) {
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 (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 "=="
+ 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)
- )
+ 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! */
}
-LyXParagraph* LyXParagraph::DepthHook(int deth)
+LyXParagraph * LyXParagraph::DepthHook(int deth)
{
- LyXParagraph *newpar = this;
+ LyXParagraph * newpar = this;
if (deth < 0)
return 0;
if (!newpar) {
if (Previous() || GetDepth())
- lyxerr.print("ERROR (LyXParagraph::DepthHook): "
- "no hook.");
+ lyxerr << "ERROR (LyXParagraph::DepthHook): "
+ "no hook." << endl;
newpar = this;
}
return newpar->FirstPhysicalPar();
int LyXParagraph::AutoDeleteInsets()
{
- InsetTable *tmpi = insettable;
- InsetTable *tmpi2 = tmpi;
- int i=0;
+#ifdef NEW_TABLE
+ int i = 0;
+ for (InsetList::iterator it = insetlist.begin();
+ it != insetlist.end(); ++it) {
+ if ((*it).inset->AutoDelete()) {
+ ++i;
+ Erase((*it).pos);
+ }
+ }
+ return i;
+#else
+ InsetTable * tmpi = insettable;
+ InsetTable * tmpi2 = tmpi;
+ int i = 0;
while (tmpi) {
tmpi2 = tmpi;
tmpi = tmpi->next;
Erase(tmpi2->pos);
} else {}
else
- lyxerr.print(
- "ERROR (LyXParagraph::AutoDeleteInsets): "
- "cannot auto-delete insets");
+ lyxerr << "ERROR (LyXParagraph::AutoDeleteInsets): "
+ "cannot auto-delete insets" << endl;
}
return i;
+#endif
}
-Inset* LyXParagraph::ReturnNextInsetPointer(int &pos)
+Inset * LyXParagraph::ReturnNextInsetPointer(LyXParagraph::size_type & pos)
{
- InsetTable *tmpi = insettable;
- InsetTable *tmpi2 = 0;
+#ifdef NEW_TABLE
+ InsetTable * tmp = 0;
+ for (InsetList::iterator it = insetlist.begin();
+ it != insetlist.end(); ++it) {
+ if ((*it).pos >= pos && (!tmp || (*it).pos < tmp->pos)) {
+ tmp = &(*it);
+ }
+ }
+ if (tmp) {
+ pos = tmp->pos;
+ return tmp->inset;
+ }
+ return 0;
+
+#else
+ InsetTable * tmpi = insettable;
+ InsetTable * tmpi2 = 0;
while (tmpi){
if (tmpi->pos >= pos) {
if (!tmpi2 || tmpi->pos < tmpi2->pos)
tmpi2 = tmpi;
}
- tmpi=tmpi->next;
+ tmpi= tmpi->next;
}
if (tmpi2){
pos = tmpi2->pos;
}
else
return 0;
+#endif
}
/* returns -1 if inset not found */
-int LyXParagraph::GetPositionOfInset(Inset* inset)
+int LyXParagraph::GetPositionOfInset(Inset * inset)
{
+#ifdef NEW_TABLE
+ for (InsetList::iterator it = insetlist.begin();
+ it != insetlist.end(); ++it) {
+ if ((*it).inset == inset) {
+ return (*it).pos;
+ }
+ }
+ // Think about footnotes
+ if (footnoteflag == LyXParagraph::NO_FOOTNOTE
+ && next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
+ int further = NextAfterFootnote()->GetPositionOfInset(inset);
+ if (further != -1)
+ return size() + 1 + further;
+ }
+ return -1;
+#else
/* find the entry */
- InsetTable *tmpi = insettable;
+ InsetTable * tmpi = insettable;
while (tmpi && tmpi->inset != inset) {
- tmpi=tmpi->next;
+ tmpi = tmpi->next;
}
if (tmpi && tmpi->inset)
return tmpi->pos;
/* think about footnotes */
if (footnoteflag == LyXParagraph::NO_FOOTNOTE
&& next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
- int further =
+ int further =
NextAfterFootnote()->GetPositionOfInset(inset);
if (further != -1)
- return last + 1 + further;
+ return text.size() + 1 + further;
}
return -1;
}
+#endif
}
-void LyXParagraph::readSimpleWholeFile(FILE *myfile)
+void LyXParagraph::readSimpleWholeFile(FILE * myfile)
{
- char 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)) {
+ char c = 0;
do {
c = fgetc(myfile);
- InsertChar(last,c);
+ InsertChar(text.size(), c);
} while (!feof(myfile));
}
}
-LyXParagraph* LyXParagraph::TeXOnePar(string &file, TexRow &texrow,
- string &foot, TexRow &foot_texrow,
- int &foot_count)
+LyXParagraph * LyXParagraph::TeXOnePar(string & file, TexRow & texrow,
+ string & foot, TexRow & foot_texrow,
+ int & foot_count)
{
- lyxerr.debug(string("TeXOnePar... ") + tostr(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(GetCurrentTextClass(),
+ 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();
}
texrow.newline();
}
- switch (style->latextype) {
+ 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)
// 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(GetCurrentTextClass(),
+ 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}";
}
- switch (style->latextype) {
+ switch (style.latextype) {
case LATEX_ITEM_ENVIRONMENT:
case LATEX_LIST_ENVIRONMENT:
if (par && (depth < par->depth)) {
}
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(string("TeXOnePar...done ") + tostr(par), Error::LATEX);
+ lyxerr[Debug::LATEX] << "TeXOnePar...done " << par << endl;
return par;
}
// This one spits out the text of the paragraph
-bool LyXParagraph::SimpleTeXOnePar(string &file, TexRow &texrow)
+bool LyXParagraph::SimpleTeXOnePar(string & file, TexRow & texrow)
{
- lyxerr.debug(string("SimpleTeXOnePar... ") + tostr(this),
- Error::LATEX);
+ lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl;
if (table)
return SimpleTeXOneTablePar(file, texrow);
char c;
- int main_body;
- int column;
+ size_type main_body;
bool return_value = false;
- //bool underbar = false;
- LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(), GetLayout());
LyXFont basefont;
/* maybe we have to create a optional argument */
- if (style->labeltype != LABEL_MANUAL)
+ if (style.labeltype != LABEL_MANUAL)
main_body = 0;
else
main_body = BeginningOfMainBody();
basefont = getFont(-1); // Get layout font
}
- column = 0;
+ int column = 0;
if (main_body >= 0
- && !last
+ && !text.size()
&& !IsDummy()) {
- if (style->isCommand()) {
+ if (style.isCommand()) {
file += '{';
column++;
} else if (align != LYX_ALIGN_LAYOUT) {
bool open_font = false;
texrow.start(this, 0);
-
- for (int i = 0; i < last; i++) {
+
+ for (size_type i = 0; i < size(); ++i) {
column++;
// First char in paragraph or after label?
if (i == main_body && !IsDummy()) {
file += ']';
column++;
}
- if (style->isCommand()) {
+ if (style.isCommand()) {
file += '{';
column++;
} else if (align != LYX_ALIGN_LAYOUT) {
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;
+ column+= 13;
break;
case LYX_ALIGN_RIGHT:
file += "\\raggedleft ";
- column+=12;
+ column+= 12;
break;
case LYX_ALIGN_CENTER:
file += "\\centering ";
- column+=11;
+ column+= 11;
break;
}
}
// 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);
}
-
// We end font definition before blanks
if (!font.equalExceptLatex(running_font) && open_font) {
- column += running_font.latexWriteEndChanges(file, basefont);
+ column += running_font.latexWriteEndChanges(file,
+ basefont);
running_font = basefont;
open_font = false;
}
if (c == ' '){
// Do not print the separation of the optional argument
if (i != main_body - 1) {
- SimpleTeXBlanks(file, texrow, i, column, font, style);
+ SimpleTeXBlanks(file, texrow, i,
+ column, font, style);
}
}
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';
} else {
}
/* needed if there is an optional argument but no contents */
- if (main_body > 0 && main_body == last) {
+ if (main_body > 0 && main_body == size()) {
file += "]~";
return_value = false;
}
- lyxerr.debug(string("SimpleTeXOnePar...done ") + tostr(this),
- Error::LATEX);
+ lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
return return_value;
}
// This one spits out the text of a table paragraph
-bool LyXParagraph::SimpleTeXOneTablePar(string &file, TexRow &texrow)
+bool LyXParagraph::SimpleTeXOneTablePar(string & file, TexRow & texrow)
{
- lyxerr.debug(string("SimpleTeXOneTablePar... ")+
- tostr(this), Error::LATEX);
+ lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar... " << this << endl;
char c;
- int column, tmp;
+ int tmp;
bool return_value = false;
int current_cell_number = -1;
- LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
- LyXFont basefont;
-
- basefont = getFont(-1); // Get layout font
+ LyXLayout const & style =
+ textclasslist.Style(GetCurrentTextClass(), GetLayout());
+ LyXFont 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;
+ int column = 0;
if (!IsDummy()) { // it is dummy if it is in a float!!!
- if (style->isCommand()) {
+ if (style.isCommand()) {
file += '{';
column++;
} else if (align != LYX_ALIGN_LAYOUT) {
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;
+ column+= 13;
break;
case LYX_ALIGN_RIGHT:
file += "\\raggedleft ";
- column+=12;
+ column+= 12;
break;
case LYX_ALIGN_CENTER:
file += "\\centering ";
- column+=11;
+ column+= 11;
break;
}
}
current_cell_number = -1;
- tmp = table->TexEndOfCell(file,current_cell_number);
- for (;tmp>0;tmp--)
+ tmp = table->TexEndOfCell(file, current_cell_number);
+ for (; tmp >0 ; --tmp)
texrow.newline();
texrow.start(this, 0);
- for (int i = 0; i < last; i++) {
+ for (size_type i = 0; i < size(); ++i) {
c = GetChar(i);
if (table->IsContRow(current_cell_number+1)) {
- if (c == LYX_META_NEWLINE)
+ if (c == LyXParagraph::META_NEWLINE)
current_cell_number++;
continue;
}
// 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
+ 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);
running_font = basefont;
open_font = false;
}
// 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()
if (open_font) {
running_font = basefont;
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
current_cell_number--;
break;
}
- int tmp = table->TexEndOfCell(file, current_cell_number);
+ int tmp = table->TexEndOfCell(file,
+ current_cell_number);
if (tmp>0) {
column = 0;
} else if (tmp < 0) {
}
current_cell_number++;
tmp = table->TexEndOfCell(file, current_cell_number);
- for (;tmp>0;tmp--)
+ for (; tmp > 0; --tmp)
texrow.newline();
- lyxerr.debug(string("SimpleTeXOneTablePar...done ")+ tostr(this), Error::LATEX);
+ lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar...done " << this << endl;
return return_value;
}
// This one spits out the text off ContRows in tables
-bool LyXParagraph::TeXContTableRows(string &file, int i,
+bool LyXParagraph::TeXContTableRows(string & file,
+ LyXParagraph::size_type i,
int current_cell_number,
- int &column, TexRow &texrow)
+ int & column, TexRow & texrow)
{
- lyxerr.debug(string("TeXContTableRows... ") +
- tostr(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());
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(),
+ GetLayout());
LyXFont basefont;
basefont = getFont(-1); // Get layout font
// Do we have an open font change?
bool open_font = false;
- lastpos = i;
- cell = table->CellHasContRow(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 (; (i<last) && (current_cell_number<cell); i++) {
+ for (; (i < size()) && (current_cell_number<cell); ++i) {
c = GetChar(i);
- if (c == LYX_META_NEWLINE)
+ if (c == LyXParagraph::META_NEWLINE)
current_cell_number++;
}
lastpos = i;
- c=GetChar(i);
+ c = GetChar(i);
if (table->Linebreaks(table->FirstVirtualCell(cell))) {
file += " \\\\\n";
texrow.newline();
column = 0;
- } else if ((c != ' ') && (c != LYX_META_NEWLINE)) {
+ } 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
LyXFont font = getFont(i);
// 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);
+ 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
}
// 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);
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
running_font = basefont;
cell = table->CellHasContRow(current_cell_number);
}
- lyxerr.debug(string("TeXContTableRows...done ")+ tostr(this), Error::LATEX);
+ lyxerr[Debug::LATEX] << "TeXContTableRows...done " << this << endl;
return return_value;
}
-bool LyXParagraph::linuxDocConvertChar(char c, string &sgml_string)
+bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string)
{
bool retval = false;
switch (c) {
- case LYX_META_HFILL:
- sgml_string.erase();
+ case LyXParagraph::META_HFILL:
+ sgml_string.clear();
break;
- case LYX_META_PROTECTED_SEPARATOR:
+ case LyXParagraph::META_PROTECTED_SEPARATOR:
sgml_string = ' ';
break;
- case LYX_META_NEWLINE:
+ case LyXParagraph::META_NEWLINE:
sgml_string = '\n';
break;
case '&':
sgml_string = ' ';
break;
case '\0': /* Ignore :-) */
- sgml_string.erase();
+ sgml_string.clear();
break;
default:
sgml_string = c;
return retval;
}
-void LyXParagraph::SimpleDocBookOneTablePar(string &file, string &extra,
+void LyXParagraph::SimpleDocBookOneTablePar(string & file, string & extra,
int & desc_on, int depth)
{
if (!table)
return;
- lyxerr.debug(string("SimpleDocbookOneTablePar... ") +
- tostr(this), Error::LATEX);
+ lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar... " << this << endl;
int column, tmp;
- //bool return_value = false; // unused
int current_cell_number = -1;
- LyXFont font1,font2;
+ LyXFont font1, font2;
char c;
Inset *inset;
- int main_body; //, j; // unused
- string emph="emphasis";
- bool emph_flag=false;
- int char_line_count=0;
+ size_type main_body;
+ string emph = "emphasis";
+ bool emph_flag= false;
+ int char_line_count= 0;
- LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(), GetLayout());
- if (style->labeltype != LABEL_MANUAL)
+ if (style.labeltype != LABEL_MANUAL)
main_body = 0;
else
main_body = BeginningOfMainBody();
/* 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;
addNewlineAndDepth(file, depth);
addNewlineAndDepth(file, ++depth);
}
current_cell_number = -1;
- tmp = table->DocBookEndOfCell(file,current_cell_number, depth);
+ tmp = table->DocBookEndOfCell(file, current_cell_number, depth);
/* parsing main loop */
- for (int i = 0; i < last; i++) {
+ for (size_type i = 0; i < size(); ++i) {
c = GetChar(i);
if (table->IsContRow(current_cell_number+1)) {
- if (c == LYX_META_NEWLINE)
+ if (c == LyXParagraph::META_NEWLINE)
current_cell_number++;
continue;
}
if (font1.emph() != font2.emph() && i) {
if (font2.emph() == LyXFont::ON) {
file += "<emphasis>";
- emph_flag=true;
+ emph_flag= true;
} else if (emph_flag) {
file += "</emphasis>";
- emph_flag=false;
+ emph_flag= false;
}
}
- if (c == LYX_META_NEWLINE) {
+ if (c == LyXParagraph::META_NEWLINE) {
// we have only to control for emphasis open here!
if (emph_flag) {
file += "</emphasis>";
- emph_flag=false;
+ emph_flag= false;
}
font1 = font2 = getFont(-1);
current_cell_number++;
current_cell_number--;
break;
}
- tmp=table->DocBookEndOfCell(file, current_cell_number,
+ 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);
string tmp_out;
inset->DocBook(tmp_out);
// This code needs some explanation:
// Two insets are treated specially
// label if it is the first element in a command paragraph
- // desc_on==3
+ // 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)
+ if(desc_on != 3 || i != 0) {
+ if(tmp_out[0] == '@') {
+ if(desc_on == 4)
extra += frontStrip(tmp_out, '@');
else
file += frontStrip(tmp_out, '@');
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++;
} else {
string sgml_string;
if (linuxDocConvertChar(c, sgml_string)
- && !style->free_spacing) {
+ && !style.free_spacing) {
// in freespacing mode, spaces are
// non-breaking characters
// char is ' '
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 += "</emphasis>";
}
if (footnoteflag == LyXParagraph::NO_FOOTNOTE)
file += "</INFORMALTABLE>";
file += '\n';
- lyxerr.debug(string("SimpleDocbookOneTablePar...done ") +
- tostr(this), Error::LATEX);
+ lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar...done "
+ << this << endl;
}
-void LyXParagraph::DocBookContTableRows(string &file, string &extra,
- int & desc_on, int i,
+
+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(string("DocBookContTableRows... ") +
- tostr(this), Error::LATEX);
- int cell, lastpos; //tmp; //unused
- LyXFont font1,font2;
+ lyxerr[Debug::LATEX] << "DocBookContTableRows... " << this << endl;
+
+ int cell;
+ LyXFont font1, font2;
char c;
- Inset *inset;
- int main_body; // , j; // unused
- string emph="emphasis";
- bool emph_flag=false;
- int char_line_count=0;
+ Inset * inset;
+ size_type main_body;
+ size_type lastpos;
+ string emph= "emphasis";
+ bool emph_flag= false;
+ int char_line_count= 0;
- LyXLayout * style = lyxstyle.Style(GetCurrentTextClass(), GetLayout());
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(),
+ GetLayout());
- if (style->labeltype != LABEL_MANUAL)
+ if (style.labeltype != LABEL_MANUAL)
main_body = 0;
else
main_body = BeginningOfMainBody();
/* gets paragraph main font */
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);
while(cell >= 0) {
// first find the right position
i = lastpos;
- for (; (i<last) && (current_cell_number<cell); i++) {
+ for (; i < size() && current_cell_number < cell; ++i) {
c = GetChar(i);
- if (c == LYX_META_NEWLINE)
+ if (c == LyXParagraph::META_NEWLINE)
current_cell_number++;
}
lastpos = i;
- c=GetChar(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 != LYX_META_NEWLINE)) {
+ 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);
if (font1.emph() != font2.emph() && i) {
if (font2.emph() == LyXFont::ON) {
file += "<emphasis>";
- emph_flag=true;
+ emph_flag= true;
} else if (emph_flag) {
file += "</emphasis>";
- emph_flag=false;
+ emph_flag= false;
}
}
- if (c == LYX_META_INSET) {
+ if (c == LyXParagraph::META_INSET) {
inset = GetInset(i);
string tmp_out;
inset->DocBook(tmp_out);
// This code needs some explanation:
// Two insets are treated specially
// label if it is the first element in a command paragraph
- // desc_on==3
+ // 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)
+ if(desc_on != 3 || i != 0) {
+ if(tmp_out[0] == '@') {
+ if(desc_on == 4)
extra += frontStrip(tmp_out, '@');
else
file += frontStrip(tmp_out, '@');
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++;
} else {
string sgml_string;
if (linuxDocConvertChar(c, sgml_string)
- && !style->free_spacing) {
+ && !style.free_spacing) {
// in freespacing mode, spaces are
// non-breaking characters
// char is ' '
// we have only to control for emphasis open here!
if (emph_flag) {
file += "</emphasis>";
- emph_flag=false;
+ emph_flag= false;
}
font1 = font2 = getFont(-1);
cell = table->CellHasContRow(current_cell_number);
}
- lyxerr.debug(string("DocBookContTableRows...done ") +
- tostr(this), Error::LATEX);
+ lyxerr[Debug::LATEX] << "DocBookContTableRows...done " << this << endl;
}
-
-//
-void LyXParagraph::SimpleTeXBlanks(string &file, TexRow &texrow,
- int const i, int &column, LyXFont const &font,
- LyXLayout const * const style)
+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 < last-1)
+ && 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
+ && !style.free_spacing
// In typewriter mode, we want to avoid
// ! . ? : at the end of a line
&& !(font.family() == LyXFont::TYPEWRITER_FAMILY
texrow.start(this, i+1);
column = 0;
} else if (font.latex() == LyXFont::OFF) {
- if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
+ if (style.free_spacing) {
file += '~';
} else {
file += ' ';
}
-//
-void LyXParagraph::SimpleTeXSpecialChars(string &file, TexRow &texrow,
- LyXFont &font, LyXFont &running_font, LyXFont &basefont,
- bool &open_font, LyXLayout const * const style,
- int &i, int &column, char const c)
+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) {
int len = file.length();
- int tmp = inset->Latex(file, style->isCommand());
+ int tmp = inset->Latex(file, style.isCommand());
if (tmp) {
column = 0;
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);
open_font = false;
}
basefont = getFont(-1);
running_font = basefont;
break;
- case LYX_META_HFILL:
+ case LyXParagraph::META_HFILL:
file += "\\hfill{}";
column += 7;
break;
// but I'll leave it as a switch statement
// so its simpler to extend. (ARRae)
switch (c) {
- case LYX_META_PROTECTED_SEPARATOR:
+ case LyXParagraph::META_PROTECTED_SEPARATOR:
file += ' ';
break;
} else {
// Plain mode (i.e. not LaTeX)
switch (c) {
- case LYX_META_PROTECTED_SEPARATOR:
+ case LyXParagraph::META_PROTECTED_SEPARATOR:
file += '~';
break;
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 += '}';
file += c;
//... but we should avoid ligatures
if ((c == '>' || c == '<')
- && i <= last-2
+ && i <= size() - 2
&& GetChar(i+1) == c){
file += "\\textcompwordmark{}";
column += 19;
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;
break;
case '£':
- if (current_view->currentBuffer()->params.inputenc == "default") {
+ if (current_view->buffer()->params.inputenc == "default") {
file += "\\pounds{}";
column += 8;
} else {
/* idea for labels --- begin*/
/* 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 */
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 */
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 */
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;
}
-bool LyXParagraph::RoffContTableRows(FILE *fp, int i, int actcell)
+bool LyXParagraph::RoffContTableRows(FILE * fp,
+ LyXParagraph::size_type i,
+ int actcell)
{
if (!table)
return false;
- LyXFont
- font1 = LyXFont(LyXFont::ALL_INHERIT),
- font2;
- Inset
- *inset;
- int
- lastpos, cell;
- char
- c;
- string
- fname2;
- FILE
- *fp2;
-
- fname2 = TmpFileName(string(),"RAT2");
- lastpos = i;
- cell = table->CellHasContRow(actcell);
+ LyXFont font1 = LyXFont(LyXFont::ALL_INHERIT);
+ LyXFont font2;
+ Inset * inset;
+ char c;
+ FILE * fp2;
+
+ 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 (; (i<last) && (actcell<cell); i++) {
+ for (; i < size() && actcell < cell; ++i) {
c = GetChar(i);
- if (c == LYX_META_NEWLINE)
+ if (c == LyXParagraph::META_NEWLINE)
actcell++;
}
lastpos = i;
- c=GetChar(i);
- if ((c != ' ') && (c != LYX_META_NEWLINE))
- fprintf(fp," ");
- for (; (i < last) && ((c=GetChar(i)) != LYX_META_NEWLINE); i++) {
+ c = GetChar(i);
+ if ((c != ' ') && (c != LyXParagraph::META_NEWLINE))
+ fprintf(fp, " ");
+ for (; i < size()
+ && (c = GetChar(i)) != LyXParagraph::META_NEWLINE;
+ ++i) {
font2 = GetFontSettings(i);
if (font1.latex() != font2.latex()) {
if (font2.latex() != LyXFont::OFF)
}
c = GetChar(i);
switch (c) {
- case LYX_META_INSET:
+ case LyXParagraph::META_INSET:
if ((inset = GetInset(i))) {
- if (!(fp2=fopen(fname2.c_str(),"w+"))) {
- WriteAlert(_("LYX_ERROR:"), _("Cannot open temporary file:"), fname2);
+ if (!(fp2= fopen(fname2.c_str(), "w+"))) {
+ WriteAlert(_("LYX_ERROR:"),
+ _("Cannot open temporary file:"),
+ fname2);
return false;
}
inset->Latex(fp2,-1);
c = fgetc(fp2);
while(!feof(fp2)) {
if (c == '\\')
- fprintf(fp,"\\\\");
+ fprintf(fp, "\\\\");
else
- fputc(c,fp);
+ fputc(c, fp);
c = fgetc(fp2);
}
fclose(fp2);
}
break;
- case LYX_META_NEWLINE:
+ case LyXParagraph::META_NEWLINE:
break;
- case LYX_META_HFILL:
+ case LyXParagraph::META_HFILL:
break;
- case LYX_META_PROTECTED_SEPARATOR:
+ case LyXParagraph::META_PROTECTED_SEPARATOR:
break;
case '\\':
fprintf(fp, "\\\\");
if (c != '\0')
fprintf(fp, "%c", c);
else
- lyxerr.debug("RoffAsciiTable: NULL char in structure.");
+ lyxerr.debug() << "RoffAsciiTable: NULL char in structure." << endl;
break;
}
}
return true;
}
-LyXParagraph * LyXParagraph::TeXDeeper(string &file, TexRow &texrow,
- string &foot, TexRow &foot_texrow,
- int &foot_count)
+
+LyXParagraph * LyXParagraph::TeXDeeper(string & file, TexRow & texrow,
+ string & foot, TexRow & foot_texrow,
+ int & foot_count)
{
- lyxerr.debug(string("TeXDeeper... ") + tostr(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(GetCurrentTextClass(),
+ par->layout).isEnvironment()
|| par->pextra_type != PEXTRA_NONE)
{
par = par->TeXEnvironment(file, texrow,
foot_count);
}
}
- lyxerr.debug(string("TeXDeeper...done ") + tostr(par), Error::LATEX);
+ lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl;
return par;
}
-LyXParagraph* LyXParagraph::TeXEnvironment(string &file, TexRow &texrow,
- string &foot, TexRow &foot_texrow,
- int &foot_count)
+LyXParagraph * LyXParagraph::TeXEnvironment(string & file, TexRow & texrow,
+ string & foot, TexRow & foot_texrow,
+ int & foot_count)
{
- bool
- eindent_open = false;
- bool
- foot_this_level = false;
+ 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;
+ static bool minipage_open = false;
+ static int minipage_open_depth = 0;
+ char par_sep = current_view->buffer()->params.paragraph_separation;
- lyxerr.debug(string("TeXEnvironment... ") + tostr(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(GetCurrentTextClass(),
+ layout);
if (pextra_type == PEXTRA_INDENT) {
if (!pextra_width.empty()) {
file += "\\hfill{}\n";
texrow.newline();
}
- if (par_sep == LYX_PARSEP_INDENT) {
+ if (par_sep == BufferParams::PARSEP_INDENT) {
file += "{\\setlength\\parindent{0pt}\n";
texrow.newline();
}
file += "\\columnwidth}\n";
}
texrow.newline();
- if (par_sep == LYX_PARSEP_INDENT) {
+ if (par_sep == BufferParams::PARSEP_INDENT) {
file += "\\setlength\\parindent{\\LyXMinipageIndent}\n";
texrow.newline();
}
//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
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 + "}{"
+ file += "\\begin{" + style.latexname() + "}{"
+ bibitemWidthest() + "}\n";
- } else if (style->latextype == LATEX_ITEM_ENVIRONMENT) {
+ } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) {
#ifdef FANCY_FOOTNOTE_CODE
if (foot_count < 0) {
// flag that footnote[mark][text] should be
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) {
+ 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(GetCurrentTextClass(),
+ par->layout).isParagraph()
&& !par->table
&& !suffixIs(file, "\n\n")) {
// There should be at least one '\n' already
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();
}
file += "\\columnwidth}\n";
}
texrow.newline();
- if (par_sep == LYX_PARSEP_INDENT) {
+ if (par_sep == BufferParams::PARSEP_INDENT) {
file += "\\setlength\\parindent{\\LyXMinipageIndent}\n";
texrow.newline();
}
&& 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.erase();
+ foot.clear();
foot_texrow.reset();
foot_count = 0;
}
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();
}
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(string("TeXEnvironment...done ")
- + tostr(par), Error::LATEX);
+ lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl;
return par; // ale970302
}
-LyXParagraph * LyXParagraph::TeXFootnote(string &file, TexRow &texrow,
- string &foot, TexRow &foot_texrow,
- int &foot_count)
+LyXParagraph * LyXParagraph::TeXFootnote(string & file, TexRow & texrow,
+ string & foot, TexRow & foot_texrow,
+ int & foot_count)
{
- lyxerr.debug(string("TeXFootnote... ")
- + tostr(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(),
+ LyXParagraph * par = this;
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(),
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
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 {
foot += "\\stepcounter{footnote}";
}
foot += "\\footnotetext{%\n";
- foot_texrow.start(this,0);
+ foot_texrow.start(this, 0);
foot_texrow.newline();
++foot_count;
}
|| !footer_in_body) {
// Process text for all floats except footnotes in body
do {
- LyXLayout *style = lyxstyle.Style(GetCurrentTextClass(),
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(),
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
TexRow dummy_texrow;
int dummy_count = 0;
do {
- LyXLayout *style = lyxstyle.Style(GetCurrentTextClass(),
+ LyXLayout const & style = textclasslist.Style(GetCurrentTextClass(),
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
}
} 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;
}
}
texrow.newline();
}
- lyxerr.debug(string("TeXFootnote...done ") +
- tostr(par->next), Error::LATEX);
+ lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next << endl;
return par;
}
-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()) {
+ if (textclasslist.Style(GetCurrentTextClass(),
+ layout).isEnvironment()) {
LyXParagraph
- *par = this,
- *ppar = par;
+ * par = this,
+ * ppar = par;
while (par && (par->layout == layout) && (par->depth == depth)) {
ppar = par;
par->pextra_widthp = widthp;
par = par->NextAfterFootnote();
if (par && (par->depth > depth))
- par->SetPExtraType(type,width,widthp);
+ par->SetPExtraType(type, width, widthp);
while (par && ((par->depth > depth) || par->IsDummy()))
par = par->NextAfterFootnote();
}
}
}
+
void LyXParagraph::UnsetPExtraType()
{
if (pextra_type == PEXTRA_NONE)
return;
pextra_type = PEXTRA_NONE;
- pextra_width.erase();
- pextra_widthp.erase();
+ pextra_width.clear();
+ pextra_widthp.clear();
- if (lyxstyle.Style(GetCurrentTextClass(),
- layout)->isEnvironment()) {
+ if (textclasslist.Style(GetCurrentTextClass(),
+ layout).isEnvironment()) {
LyXParagraph
- *par = this,
- *ppar = par;
+ * par = this,
+ * ppar = par;
while (par && (par->layout == layout) && (par->depth == depth)) {
ppar = par;
par = ppar;
while (par && (par->layout == layout) && (par->depth == depth)) {
par->pextra_type = PEXTRA_NONE;
- par->pextra_width.erase();
- par->pextra_widthp.erase();
+ par->pextra_width.clear();
+ par->pextra_widthp.clear();
par = par->NextAfterFootnote();
if (par && (par->depth > depth))
par->UnsetPExtraType();
}
}
}
+
+
+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) ) ;
+}
projects / lyx.git / blobdiff