#include "support/LAssert.h"
#include "frontends/Alert.h"
#include "gettext.h"
+#include "Lsstream.h"
#include "tabular_funcs.h"
#include "lyxlex.h"
}
-LyXTabular::lttype::lttype()
+LyXTabular::ltType::ltType()
{
topDL = false;
bottomDL = false;
for (int i = 0; i < rows_; ++i) {
for (int j = 0; j < columns_; ++j) {
cell_info[i][j].inset.id(lt.cell_info[i][j].inset.id());
- cell_info[i][j].inset.setParagraphData(lt.cell_info[i][j].inset.paragraph(),true);
+ cell_info[i][j].inset.setParagraphData(lt.cell_info[i][j].inset.paragraphs, true);
}
}
}
LyXTabular & LyXTabular::operator=(LyXTabular const & lt)
{
#if 0
-#warning This while method should look like this: (Lgb)
+#warning This whole method should look like this: (Lgb)
LyXTabular tmp(lt);
tmp.swap(*this);
}
-bool LyXTabular::TopAlreadyDrawed(int cell) const
+bool LyXTabular::topAlreadyDrawn(int cell) const
{
int row = row_of_cell(cell);
if ((row > 0) && !GetAdditionalHeight(row)) {
}
-bool LyXTabular::LeftAlreadyDrawed(int cell) const
+bool LyXTabular::leftAlreadyDrawn(int cell) const
{
int column = column_of_cell(cell);
if (column > 0) {
l_getline(is, line);
if (!prefixIs(line, "<lyxtabular ")
&& !prefixIs(line, "<LyXTabular ")) {
- OldFormatRead(buf->params, lex, line);
+ lyx::Assert(false);
return;
}
int version;
if (!getTokenValue(line, "version", version))
return;
- if (version == 1)
- ReadOld(buf, is, lex, line);
- else if (version >= 2)
- ReadNew(buf, is, lex, line, version);
+ lyx::Assert(version >= 2);
+ read(buf, is, lex, line, version);
}
void LyXTabular::setHeaderFooterRows(int hr, int fhr, int fr, int lfr)
}
}
-void LyXTabular::ReadNew(Buffer const * buf, istream & is,
- LyXLex & lex, string const & l, int const version)
+void LyXTabular::read(Buffer const * buf, istream & is,
+ LyXLex & lex, string const & l, int const version)
{
string line(l);
int rows_arg;
}
-void LyXTabular::OldFormatRead(BufferParams const & bp,
- LyXLex & lex, string const & fl)
-{
- int version;
- int i;
- int j;
- int rows_arg = 0;
- int columns_arg = 0;
- int is_long_tabular_arg = false;
- int rotate_arg = false;
- int a = -1;
- int b = -1;
- int c = -1;
- int d = -1;
- int e = 0;
- int f = 0;
- int g = 0;
-
- istream & is = lex.getStream();
- string s(fl);
- if (s.length() > 8)
- version = lyx::atoi(s.substr(8, string::npos));
- else
- version = 1;
-
- vector<int> cont_row_info;
-
- if (version < 5) {
- lyxerr << "Tabular format < 5 is not supported anymore\n"
- "Get an older version of LyX (< 1.1.x) for conversion!"
- << endl;
- Alert::alert(_("Warning:"),
- _("Tabular format < 5 is not supported anymore\n"),
- _("Get an older version of LyX (< 1.1.x) for conversion!"));
- if (version > 2) {
- is >> rows_arg >> columns_arg >> is_long_tabular_arg
- >> rotate_arg >> a >> b >> c >> d;
- } else
- is >> rows_arg >> columns_arg;
- Init(bp, rows_arg, columns_arg);
- cont_row_info = vector<int>(rows_arg);
- SetLongTabular(is_long_tabular_arg);
- SetRotateTabular(rotate_arg);
- string tmp;
- for (i = 0; i < rows_; ++i) {
- getline(is, tmp);
- cont_row_info[i] = false;
- }
- for (i = 0; i < columns_; ++i) {
- getline(is, tmp);
- }
- for (i = 0; i < rows_; ++i) {
- for (j = 0; j < columns_; ++j) {
- getline(is, tmp);
- }
- }
- } else {
- is >> rows_arg >> columns_arg >> is_long_tabular_arg
- >> rotate_arg >> a >> b >> c >> d;
- Init(bp, rows_arg, columns_arg);
- cont_row_info = vector<int>(rows_arg);
- SetLongTabular(is_long_tabular_arg);
- SetRotateTabular(rotate_arg);
- setHeaderFooterRows(a+1, b+1 , c+1, d+1);
- for (i = 0; i < rows_; ++i) {
- a = b = c = d = e = f = g = 0;
- is >> a >> b >> c >> d;
- row_info[i].top_line = a;
- row_info[i].bottom_line = b;
- cont_row_info[i] = c;
- row_info[i].newpage = d;
- }
- for (i = 0; i < columns_; ++i) {
- string s1;
- string s2;
- is >> a >> b >> c;
-#if 1
- char ch; // skip '"'
- is >> ch;
-#else
- // ignore is buggy but we will use it later (Lgb)
- is.ignore(); // skip '"'
-#endif
- getline(is, s1, '"');
-#if 1
- is >> ch; // skip '"'
-#else
- // ignore is buggy but we will use it later (Lgb)
- is.ignore(); // skip '"'
-#endif
- getline(is, s2, '"');
- column_info[i].alignment = static_cast<LyXAlignment>(a);
- column_info[i].left_line = b;
- column_info[i].right_line = c;
- column_info[i].p_width = LyXLength(s1);
- column_info[i].align_special = s2;
- }
- for (i = 0; i < rows_; ++i) {
- for (j = 0; j < columns_; ++j) {
- string s1;
- string s2;
- is >> a >> b >> c >> d >> e >> f >> g;
-#if 1
- char ch;
- is >> ch; // skip '"'
-#else
- // ignore is buggy but we will use it later (Lgb)
- is.ignore(); // skip '"'
-#endif
- getline(is, s1, '"');
-#if 1
- is >> ch; // skip '"'
-#else
- // ignore is buggy but we will use it later (Lgb)
- is.ignore(); // skip '"'
-#endif
- getline(is, s2, '"');
- cell_info[i][j].multicolumn = static_cast<char>(a);
- cell_info[i][j].alignment = static_cast<LyXAlignment>(b);
- cell_info[i][j].top_line = static_cast<char>(c);
- cell_info[i][j].bottom_line = static_cast<char>(d);
- cell_info[i][j].left_line = column_info[j].left_line;
- cell_info[i][j].right_line = column_info[j].right_line;
- cell_info[i][j].rotate = static_cast<bool>(f);
- cell_info[i][j].usebox = static_cast<BoxType>(g);
- cell_info[i][j].align_special = s1;
- cell_info[i][j].p_width = LyXLength(s2);
- }
- }
- }
- set_row_column_number_info(true);
-
- Paragraph * par = new Paragraph;
- Paragraph * return_par = 0;
-
- par->layout(bp.getLyXTextClass().defaultLayout());
-
- string tmptok;
- int pos = 0;
- Paragraph::depth_type depth = 0;
- LyXFont font(LyXFont::ALL_INHERIT);
- font.setLanguage(owner_->bufferOwner()->getLanguage());
-
- while (lex.isOK()) {
- lex.nextToken();
- string const token = lex.getString();
- if (token.empty())
- continue;
- if (token == "\\layout"
- || token == "\\end_float" // this should not exist anymore
- || token == "\\end_inset" // as it is substituted by this
- || token == "\\end_deeper")
- {
- lex.pushToken(token);
- break;
- }
- if (owner_->bufferOwner()->parseSingleLyXformat2Token(lex, par,
- return_par,
- token, pos,
- depth, font)) {
- // the_end read
- lex.pushToken(token);
- break;
- }
- if (return_par) {
- lex.printError("New Paragraph allocated! This should not happen!");
- lex.pushToken(token);
- delete par;
- par = return_par;
- break;
- }
- }
- // now we have the par we should fill the insets with this!
- int cell = 0;
- InsetText * inset = GetCellInset(cell);
- int row;
-
- for (int i = 0; i < par->size(); ++i) {
- if (par->isNewline(i)) {
- ++cell;
- if (cell > numberofcells) {
- lyxerr << "Some error in reading old table format occured!" <<
- endl << "Terminating when reading cell[" << cell << "]!" <<
- endl;
- delete par;
- return;
- }
- row = row_of_cell(cell);
- if (cont_row_info[row]) {
- DeleteRow(row);
- cont_row_info.erase(cont_row_info.begin() + row); //&cont_row_info[row]);
- while (!IsFirstCellInRow(--cell));
- } else {
- inset = GetCellInset(cell);
- continue;
- }
- inset = GetCellInset(cell);
- row = row_of_cell(cell);
- if (!cell_info[row_of_cell(cell)][column_of_cell(cell)].usebox)
- {
- // insert a space instead
- par->erase(i);
- par->insertChar(i, ' ');
- }
- }
- par->copyIntoMinibuffer(*owner_->bufferOwner(), i);
- inset->paragraph()->insertFromMinibuffer(inset->paragraph()->size());
- }
- delete par;
- Reinit();
-}
-
-
bool LyXTabular::IsMultiColumn(int cell, bool real) const
{
return ((!real || (column_of_cell(cell) != right_column_of_cell(cell))) &&
}
-void LyXTabular::SetMultiColumn(Buffer const * buffer, int cell, int number)
+void LyXTabular::SetMultiColumn(Buffer * buffer, int cell, int number)
{
cellinfo_of_cell(cell)->multicolumn = CELL_BEGIN_OF_MULTICOLUMN;
cellinfo_of_cell(cell)->alignment = column_info[column_of_cell(cell)].alignment;
cellinfo_of_cell(cell)->right_line = column_info[column_of_cell(cell+number-1)].right_line;
#if 1
for (int i = 1; i < number; ++i) {
- cellinfo_of_cell(cell+i)->multicolumn = CELL_PART_OF_MULTICOLUMN;
- cellinfo_of_cell(cell)->inset.appendParagraphs(buffer->params,
- cellinfo_of_cell(cell+i)->inset.paragraph());
- cellinfo_of_cell(cell+i)->inset.clear(false);
+ cellinfo_of_cell(cell + i)->multicolumn = CELL_PART_OF_MULTICOLUMN;
+ cellinfo_of_cell(cell)->inset.appendParagraphs(buffer,
+ cellinfo_of_cell(cell+i)->inset.paragraphs);
+ cellinfo_of_cell(cell + i)->inset.clear(false);
}
#else
for (number--; number > 0; --number) {
- cellinfo_of_cell(cell+number)->multicolumn = CELL_PART_OF_MULTICOLUMN;
+ cellinfo_of_cell(cell + number)->multicolumn = CELL_PART_OF_MULTICOLUMN;
}
#endif
set_row_column_number_info();
int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf,
- bool fragile, bool fp) const
+ LatexRunParams const & runparams,
+ bool fp) const
{
if (!is_long_tabular)
return 0;
}
for (int i = 0; i < rows_; ++i) {
if (row_info[i].endhead) {
- ret += TeXRow(os, i, buf, fragile, fp);
+ ret += TeXRow(os, i, buf, runparams, fp);
}
}
if (endhead.bottomDL) {
}
for (int i = 0; i < rows_; ++i) {
if (row_info[i].endfirsthead) {
- ret += TeXRow(os, i, buf, fragile, fp);
+ ret += TeXRow(os, i, buf, runparams, fp);
}
}
if (endfirsthead.bottomDL) {
}
for (int i = 0; i < rows_; ++i) {
if (row_info[i].endfoot) {
- ret += TeXRow(os, i, buf, fragile, fp);
+ ret += TeXRow(os, i, buf, runparams, fp);
}
}
if (endfoot.bottomDL) {
}
for (int i = 0; i < rows_; ++i) {
if (row_info[i].endlastfoot) {
- ret += TeXRow(os, i, buf, fragile, fp);
+ ret += TeXRow(os, i, buf, runparams, fp);
}
}
if (endlastfoot.bottomDL) {
int LyXTabular::TeXRow(ostream & os, int const i, Buffer const * buf,
- bool fragile, bool fp) const
+ LatexRunParams const & runparams, bool fp) const
{
int ret = 0;
int cell = GetCellNumber(i, 0);
ret += TeXCellPreamble(os, cell);
InsetText * inset = GetCellInset(cell);
- bool rtl = inset->paragraph()->isRightToLeftPar(buf->params) &&
- !inset->paragraph()->empty() && GetPWidth(cell).zero();
+ bool rtl = inset->paragraphs.begin()->isRightToLeftPar(buf->params) &&
+ !inset->paragraphs.begin()->empty() && GetPWidth(cell).zero();
if (rtl)
os << "\\R{";
- ret += inset->latex(buf, os, fragile, fp);
+ ret += inset->latex(buf, os, runparams, fp);
if (rtl)
os << '}';
}
-int LyXTabular::latex(Buffer const * buf,
- ostream & os, bool fragile, bool fp) const
+int LyXTabular::latex(Buffer const * buf, ostream & os,
+ LatexRunParams const & runparams, bool fp) const
{
int ret = 0;
os << "}\n";
++ret;
- ret += TeXLongtableHeaderFooter(os, buf, fragile, fp);
+ ret += TeXLongtableHeaderFooter(os, buf, runparams, fp);
//+---------------------------------------------------------------------
//+ the single row and columns (cells) +
for (int i = 0; i < rows_; ++i) {
if (isValidRow(i)) {
- ret += TeXRow(os, i, buf, fragile, fp);
+ ret += TeXRow(os, i, buf, runparams, fp);
if (is_long_tabular && row_info[i].newpage) {
os << "\\newpage\n";
++ret;
LyXTabular::BoxType LyXTabular::UseParbox(int cell) const
{
- Paragraph * par = GetCellInset(cell)->paragraph();
+ ParagraphList const & parlist = GetCellInset(cell)->paragraphs;
+ ParagraphList::iterator cit = parlist.begin();
+ ParagraphList::iterator end = parlist.end();
- for (; par; par = par->next()) {
- for (int i = 0; i < par->size(); ++i) {
- if (par->getChar(i) == Paragraph::META_NEWLINE)
+ for (; cit != end; ++cit) {
+ for (int i = 0; i < cit->size(); ++i) {
+ if (cit->isNewline(i))
return BOX_PARBOX;
}
}