/* This file is part of
- * ======================================================
- *
+ * ======================================================
+ *
* LyX, The Document Processor
- *
- * Copyright 2000-2001 The LyX Team.
+ *
+ * Copyright 2000-2002 The LyX Team.
*
* @author: Jürgen Vigna
*
- * ======================================================
+ * ======================================================
*/
#include <config.h>
#include "layout.h"
#include "buffer.h"
#include "BufferView.h"
-#include "Painter.h"
+#include "frontends/Painter.h"
#include "LaTeXFeatures.h"
#include "insets/insettabular.h"
#include "insets/insettext.h"
#include "frontends/Alert.h"
#include "gettext.h"
#include "tabular_funcs.h"
+#include "lyxlex.h"
#include <algorithm>
#include <cstdlib>
+using std::abs;
using std::ostream;
using std::istream;
using std::getline;
/// Define a few methods for the inner structs
-LyXTabular::cellstruct::cellstruct()
+LyXTabular::cellstruct::cellstruct(BufferParams const & bg)
+ : inset(bg)
{
cellno = 0;
width_of_cell = 0;
}
-LyXTabular::rowstruct::rowstruct()
+LyXTabular::rowstruct::rowstruct()
{
top_line = true;
bottom_line = false;
}
-LyXTabular::columnstruct::columnstruct()
+LyXTabular::columnstruct::columnstruct()
{
left_line = true;
right_line = false;
/* konstruktor */
-LyXTabular::LyXTabular(InsetTabular * inset, int rows_arg, int columns_arg)
+LyXTabular::LyXTabular(BufferParams const & bp,
+ InsetTabular * inset, int rows_arg, int columns_arg)
{
owner_ = inset;
cur_cell = -1;
- Init(rows_arg, columns_arg);
+ Init(bp, rows_arg, columns_arg);
}
-LyXTabular::LyXTabular(InsetTabular * inset, LyXTabular const & lt,
- bool same_id)
+LyXTabular::LyXTabular(BufferParams const & bp,
+ InsetTabular * inset, LyXTabular const & lt,
+ bool same_id)
{
owner_ = inset;
cur_cell = -1;
- Init(lt.rows_, lt.columns_, <);
+ Init(bp, lt.rows_, lt.columns_, <);
// we really should change again to have InsetText as a pointer
// and allocate it then we would not have to do this stuff all
// double!
}
-LyXTabular * LyXTabular::clone(InsetTabular * inset, bool same_id)
+LyXTabular * LyXTabular::clone(BufferParams const & bp,
+ InsetTabular * inset, bool same_id)
{
- LyXTabular * result = new LyXTabular(inset, *this, same_id);
+ LyXTabular * result = new LyXTabular(bp, inset, *this, same_id);
#if 0
// don't know if this is good but I need to Clone also
// the text-insets here, this is for the Undo-facility!
}
-/* activates all lines and sets all widths to 0 */
-void LyXTabular::Init(int rows_arg, int columns_arg, LyXTabular const * lt)
+/* activates all lines and sets all widths to 0 */
+void LyXTabular::Init(BufferParams const & bp,
+ int rows_arg, int columns_arg, LyXTabular const * lt)
{
rows_ = rows_arg;
columns_ = columns_arg;
row_info = row_vector(rows_, rowstruct());
column_info = column_vector(columns_, columnstruct());
- cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct()));
+ cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp)));
if (lt) {
operator=(*lt);
calculate_width_of_column(i);
}
column_info.back().right_line = true;
-
+
calculate_width_of_tabular();
rowofcell = vector<int>();
}
-void LyXTabular::AppendRow(int cell)
+void LyXTabular::AppendRow(BufferParams const & bp, int cell)
{
++rows_;
-
+
int row = row_of_cell(cell);
row_vector::iterator rit = row_info.begin() + row;
row_info.insert(rit, rowstruct());
// now set the values of the row before
- row_info[row] = row_info[row+1];
+ row_info[row] = row_info[row + 1];
#if 0
cell_vvector::iterator cit = cell_info.begin() + row;
- cell_info.insert(cit, vector<cellstruct>(columns_, cellstruct()));
+ cell_info.insert(cit, vector<cellstruct>(columns_, cellstruct(bp)));
#else
cell_vvector c_info = cell_vvector(rows_, cell_vector(columns_,
- cellstruct()));
+ cellstruct(bp)));
for (int i = 0; i <= row; ++i) {
for (int j = 0; j < columns_; ++j) {
cell_info = c_info;
++row;
for (int j = 0; j < columns_; ++j) {
- cell_info[row][j].inset.clear();
+ cell_info[row][j].inset.clear(false);
+ if (bp.tracking_changes)
+ cell_info[row][j].inset.markNew(true);
}
#endif
Reinit();
void LyXTabular::DeleteRow(int row)
{
if (rows_ == 1) return; // Not allowed to delete last row
-
+
row_info.erase(row_info.begin() + row); //&row_info[row]);
cell_info.erase(cell_info.begin() + row); //&cell_info[row]);
--rows_;
}
-void LyXTabular::AppendColumn(int cell)
+void LyXTabular::AppendColumn(BufferParams const & bp, int cell)
{
++columns_;
-
+
cell_vvector c_info = cell_vvector(rows_, cell_vector(columns_,
- cellstruct()));
+ cellstruct(bp)));
int const column = column_of_cell(cell);
column_vector::iterator cit = column_info.begin() + column + 1;
column_info.insert(cit, columnstruct());
// set the column values of the column before
- column_info[column+1] = column_info[column];
+ column_info[column + 1] = column_info[column];
for (int i = 0; i < rows_; ++i) {
for (int j = 0; j <= column; ++j) {
cell_info = c_info;
//++column;
for (int i = 0; i < rows_; ++i) {
- //cell_info[i][column].inset.clear();
- cell_info[i][column + 1].inset.clear();
+ cell_info[i][column + 1].inset.clear(false);
+ if (bp.tracking_changes)
+ cell_info[i][column + 1].inset.markNew(true);
}
Reinit();
}
//if (!(columns_ - 1))
//return;
if (columns_ == 1) return; // Not allowed to delete last column
-
+
column_info.erase(column_info.begin() + column);
for (int i = 0; i < rows_; ++i) {
cell_info[i].erase(cell_info[i].begin() + column);
}
}
}
-
+
for (int i = 0; i < columns_; ++i) {
calculate_width_of_column(i);
}
}
-/* returns 1 if there is a topline, returns 0 if not */
+/* returns 1 if there is a topline, returns 0 if not */
bool LyXTabular::TopLine(int cell, bool onlycolumn) const
{
int const row = row_of_cell(cell);
-
+
if (!onlycolumn && IsMultiColumn(cell))
return cellinfo_of_cell(cell)->top_line;
return row_info[row].top_line;
bool LyXTabular::LeftLine(int cell, bool onlycolumn) const
{
- if (!onlycolumn && IsMultiColumn(cell)) {
+ if (!onlycolumn && IsMultiColumn(cell) &&
+ (IsFirstCellInRow(cell) || IsMultiColumn(cell-1)))
+ {
#ifdef SPECIAL_COLUM_HANDLING
if (cellinfo_of_cell(cell)->align_special.empty())
return cellinfo_of_cell(cell)->left_line;
- return prefixIs(frontStrip(cellinfo_of_cell(cell)->align_special), "|");
+ return prefixIs(ltrim(cellinfo_of_cell(cell)->align_special), "|");
#else
return cellinfo_of_cell(cell)->left_line;
#endif
#ifdef SPECIAL_COLUM_HANDLING
if (column_info[column_of_cell(cell)].align_special.empty())
return column_info[column_of_cell(cell)].left_line;
- return prefixIs(frontStrip(column_info[column_of_cell(cell)].align_special), "|");
+ return prefixIs(ltrim(column_info[column_of_cell(cell)].align_special), "|");
#else
return column_info[column_of_cell(cell)].left_line;
#endif
bool LyXTabular::RightLine(int cell, bool onlycolumn) const
{
- if (!onlycolumn && IsMultiColumn(cell)) {
+ if (!onlycolumn && IsMultiColumn(cell) &&
+ (IsLastCellInRow(cell) || IsMultiColumn(cell+1)))
+ {
#ifdef SPECIAL_COLUM_HANDLING
if (cellinfo_of_cell(cell)->align_special.empty())
return cellinfo_of_cell(cell)->right_line;
- return suffixIs(strip(cellinfo_of_cell(cell)->align_special), "|");
+ return suffixIs(rtrim(cellinfo_of_cell(cell)->align_special), "|");
#else
return cellinfo_of_cell(cell)->right_line;
#endif
#ifdef SPECIAL_COLUM_HANDLING
if (column_info[column_of_cell(cell)].align_special.empty())
return column_info[right_column_of_cell(cell)].right_line;
- return suffixIs(strip(column_info[column_of_cell(cell)].align_special), "|");
+ return suffixIs(rtrim(column_info[column_of_cell(cell)].align_special), "|");
#else
return column_info[right_column_of_cell(cell)].right_line;
#endif
if (GetAdditionalWidth(cell_info[row][column].cellno))
return false;
#ifdef SPECIAL_COLUM_HANDLING
- return column_info[column].right_line;
+ return RightLine(cell_info[row][column].cellno);
#else
return RightLine(cell_info[row][column].cellno, true);
#endif
// used to get it back in text.C
int const col = right_column_of_cell(cell);
int const row = row_of_cell(cell);
- if (col < columns_ - 1 && RightLine(cell, true) &&
- LeftLine(cell_info[row][col+1].cellno, true)) // column_info[col+1].left_line)
+ if (col < columns_ - 1 && RightLine(cell) &&
+ LeftLine(cell_info[row][col+1].cellno)) // column_info[col+1].left_line)
{
return WIDTH_OF_LINE;
} else {
}
-// returns the maximum over all rows
+// returns the maximum over all rows
int LyXTabular::GetWidthOfColumn(int cell) const
{
int const column1 = column_of_cell(cell);
}
-/* returns 1 if a complete update is necessary, otherwise 0 */
+/* returns 1 if a complete update is necessary, otherwise 0 */
bool LyXTabular::SetWidthOfMulticolCell(int cell, int new_width)
{
if (!IsMultiColumn(cell))
return false;
-
+
int const row = row_of_cell(cell);
int const column1 = column_of_cell(cell);
int const column2 = right_column_of_cell(cell);
+ int const old_val = cell_info[row][column2].width_of_cell;
// first set columns to 0 so we can calculate the right width
for (int i = column1; i <= column2; ++i) {
}
// set the width to MAX_WIDTH until width > 0
int width = (new_width + 2 * WIDTH_OF_LINE);
-
int i = column1;
for (; i < column2 && width > column_info[i].width_of_column; ++i) {
cell_info[row][i].width_of_cell = column_info[i].width_of_column;
if (width > 0) {
cell_info[row][i].width_of_cell = width;
}
+ if (old_val != cell_info[row][column2].width_of_cell) {
+ // in this case we have to recalculate all multicolumn cells which
+ // have this column as one of theirs but not as last one
+ calculate_width_of_column_NMC(i);
+ recalculateMulticolumnsOfColumn(i);
+ calculate_width_of_column(i);
+ }
return true;
}
-void LyXTabular::recalculateMulticolCells(int cell, int new_width)
+void LyXTabular::recalculateMulticolumnsOfColumn(int column)
{
- int const row = row_of_cell(cell);
- int const column1 = column_of_cell(cell);
- int const column2 = right_column_of_cell(cell);
-
- // first set columns to 0 so we can calculate the right width
- int i = column1;
- for (; i <= column2; ++i)
- cell_info[row][i].width_of_cell = 0;
- for (i = cell + 1; (i < numberofcells) && (!IsMultiColumn(i)); ++i)
- ;
- if (i < numberofcells)
- recalculateMulticolCells(i, GetWidthOfCell(i) - (2 * WIDTH_OF_LINE));
- SetWidthOfMulticolCell(cell, new_width);
+ // the last column does not have to be recalculated because all
+ // multicolumns will have here there last multicolumn cell which
+ // always will have the whole rest of the width of the cell.
+ if (column > (columns_ - 2))
+ return;
+ for(int row = 0; row < rows_; ++row) {
+ int mc = cell_info[row][column].multicolumn;
+ int nmc = cell_info[row][column+1].multicolumn;
+ // we only have to update multicolumns which do not have this
+ // column as their last column!
+ if (mc == CELL_BEGIN_OF_MULTICOLUMN ||
+ ((mc == CELL_PART_OF_MULTICOLUMN) &&
+ (nmc == CELL_PART_OF_MULTICOLUMN)))
+ {
+ int const cellno = cell_info[row][column].cellno;
+ SetWidthOfMulticolCell(cellno,
+ GetWidthOfCell(cellno)-(2 * WIDTH_OF_LINE));
+ }
+ }
}
-/* returns 1 if a complete update is necessary, otherwise 0 */
+/* returns 1 if a complete update is necessary, otherwise 0 */
bool LyXTabular::SetWidthOfCell(int cell, int new_width)
{
int const row = row_of_cell(cell);
width = (new_width + 2*WIDTH_OF_LINE + add_width);
cell_info[row][column1].width_of_cell = width;
tmp = calculate_width_of_column_NMC(column1);
+ if (tmp)
+ recalculateMulticolumnsOfColumn(column1);
}
if (tmp) {
- int i = 0;
- for (; i<columns_; ++i)
- calculate_width_of_column_NMC(i);
- for (i = 0; (i < numberofcells) && !IsMultiColumn(i); ++i)
- ;
- if (i < numberofcells)
- recalculateMulticolCells(i, GetWidthOfCell(i)-(2 * WIDTH_OF_LINE));
- for (i = 0; i < columns_; ++i)
+ for (int i = 0; i < columns_; ++i)
calculate_width_of_column(i);
calculate_width_of_tabular();
return true;
int const j = column_of_cell(cell);
column_info[j].p_width = width;
- if (flag) // do this only if there is a width
- SetAlignment(cell, LYX_ALIGN_LEFT);
+ // This should not ne necessary anymore
+ // if (flag) // do this only if there is a width
+ // SetAlignment(cell, LYX_ALIGN_LEFT);
for (int i = 0; i < rows_; ++i) {
int c = GetCellNumber(i, j);
flag = !GetPWidth(c).zero(); // because of multicolumns!
bool LyXTabular::SetAlignSpecial(int cell, string const & special,
- LyXTabular::Feature what)
+ LyXTabular::Feature what)
{
if (what == SET_SPECIAL_MULTI)
cellinfo_of_cell(cell)->align_special = special;
int LyXTabular::GetBeginningOfTextInCell(int cell) const
{
int x = 0;
-
+
switch (GetAlignment(cell)) {
case LYX_ALIGN_CENTER:
x += (GetWidthOfColumn(cell) - GetWidthOfCell(cell)) / 2;
x += GetWidthOfColumn(cell) - GetWidthOfCell(cell);
// + GetAdditionalWidth(cell);
break;
- default: /* LYX_ALIGN_LEFT: nothing :-) */
+ default: /* LYX_ALIGN_LEFT: nothing :-) */
break;
}
-
+
// the LaTeX Way :-(
x += WIDTH_OF_LINE;
return x;
{
int const old_column_width = column_info[column].width_of_column;
int maximum = 0;
-
+
for (int i = 0; i < rows_; ++i) {
maximum = max(cell_info[i][column].width_of_cell, maximum);
}
//
-// calculate the with of the column without regarding REAL MultiColumn
-// cells. This means MultiColumn-cells spanning more than 1 column.
+// Calculate the columns regarding ONLY the normal cells and if this
+// column is inside a multicolumn cell then use it only if its the last
+// column of this multicolumn cell as this gives an added with to the
+// column, all the rest should be adapted!
//
bool LyXTabular::calculate_width_of_column_NMC(int column)
{
int const old_column_width = column_info[column].width_of_column;
int max = 0;
for (int i = 0; i < rows_; ++i) {
- if (!IsMultiColumn(GetCellNumber(i, column), true) &&
- (cell_info[i][column].width_of_cell > max)) {
+ int cell = GetCellNumber(i, column);
+ bool ismulti = IsMultiColumn(cell, true);
+ if ((!ismulti || (column == right_column_of_cell(cell))) &&
+ (cell_info[i][column].width_of_cell > max))
+ {
max = cell_info[i][column].width_of_cell;
}
}
l_getline(is, line);
if (!prefixIs(line, "<lyxtabular ")
&& !prefixIs(line, "<LyXTabular ")) {
- OldFormatRead(lex, line);
+ OldFormatRead(buf->params, lex, line);
return;
}
row_info[--fhr].endfirsthead = true;
row_info[fhr].endhead = false;
}
- } else if (row_info[fhr-1].endhead) {
+ } else if (row_info[fhr - 1].endhead) {
endfirsthead.empty = true;
} else {
while((fhr > 0) && !row_info[--fhr].endhead) {
row_info[fr].endfoot = true;
row_info[fr].endfirsthead = false;
}
- } else if (!row_info[fr-1].endhead && !row_info[fr-1].endfirsthead) {
+ } else if (!row_info[fr - 1].endhead && !row_info[fr - 1].endfirsthead) {
while((fr > 0) && !row_info[--fr].endhead &&
!row_info[fr].endfirsthead)
{
}
// set lastfooter info
if (lfr && (lfr < rows_)) {
- if (row_info[lfr].endhead && row_info[lfr-1].endhead) {
+ if (row_info[lfr].endhead && row_info[lfr - 1].endhead) {
while((lfr > 0) && !row_info[--lfr].endhead) {
row_info[lfr].endlastfoot = true;
row_info[lfr].endhead = false;
}
} else if (row_info[lfr].endfirsthead &&
- row_info[lfr-1].endfirsthead)
+ row_info[lfr - 1].endfirsthead)
{
while((lfr > 0) && !row_info[--lfr].endfirsthead) {
row_info[lfr].endlastfoot = true;
row_info[lfr].endfirsthead = false;
}
- } else if (row_info[lfr].endfoot && row_info[lfr-1].endfoot) {
+ } else if (row_info[lfr].endfoot
+ && row_info[lfr - 1].endfoot) {
while((lfr > 0) && !row_info[--lfr].endfoot) {
row_info[lfr].endlastfoot = true;
row_info[lfr].endfoot = false;
}
- } else if (!row_info[fr-1].endhead && !row_info[fr-1].endfirsthead &&
- !row_info[fr-1].endfoot)
+ } else if (!row_info[fr - 1].endhead
+ && !row_info[fr - 1].endfirsthead &&
+ !row_info[fr - 1].endfoot)
{
while((lfr > 0) &&
!row_info[--lfr].endhead && !row_info[lfr].endfirsthead &&
}
void LyXTabular::ReadNew(Buffer const * buf, istream & is,
- LyXLex & lex, string const & l, int const version)
+ LyXLex & lex, string const & l, int const version)
{
string line(l);
int rows_arg;
int columns_arg;
if (!getTokenValue(line, "columns", columns_arg))
return;
- Init(rows_arg, columns_arg);
+ Init(buf->params, rows_arg, columns_arg);
l_getline(is, line);
if (!prefixIs(line, "<features")) {
- lyxerr << "Wrong tabular format (expected <features ...> got" <<
- line << ")" << endl;
+ lyxerr << "Wrong tabular format (expected <features ...> got"
+ << line << ')' << endl;
return;
}
getTokenValue(line, "rotate", rotate);
for (int j = 0; j < columns_; ++j) {
l_getline(is,line);
if (!prefixIs(line,"<column")) {
- lyxerr << "Wrong tabular format (expected <column ...> got" <<
- line << ")" << endl;
+ lyxerr << "Wrong tabular format (expected <column ...> got"
+ << line << ')' << endl;
return;
}
getTokenValue(line, "alignment", column_info[j].alignment);
for (int i = 0; i < rows_; ++i) {
l_getline(is, line);
if (!prefixIs(line, "<row")) {
- lyxerr << "Wrong tabular format (expected <row ...> got" <<
- line << ")" << endl;
+ lyxerr << "Wrong tabular format (expected <row ...> got"
+ << line << ')' << endl;
return;
}
getTokenValue(line, "topline", row_info[i].top_line);
for (int j = 0; j < columns_; ++j) {
l_getline(is, line);
if (!prefixIs(line, "<cell")) {
- lyxerr << "Wrong tabular format (expected <cell ...> got" <<
- line << ")" << endl;
+ lyxerr << "Wrong tabular format (expected <cell ...> got"
+ << line << ')' << endl;
return;
}
getTokenValue(line, "multicolumn", cell_info[i][j].multicolumn);
l_getline(is, line);
}
if (!prefixIs(line, "</cell>")) {
- lyxerr << "Wrong tabular format (expected </cell> got" <<
- line << ")" << endl;
+ lyxerr << "Wrong tabular format (expected </cell> got"
+ << line << ')' << endl;
return;
}
}
l_getline(is, line);
if (!prefixIs(line, "</row>")) {
- lyxerr << "Wrong tabular format (expected </row> got" <<
- line << ")" << endl;
+ lyxerr << "Wrong tabular format (expected </row> got"
+ << line << ')' << endl;
return;
}
}
}
-void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl)
+void LyXTabular::OldFormatRead(BufferParams const & bp,
+ LyXLex & lex, string const & fl)
{
int version;
int i;
int e = 0;
int f = 0;
int g = 0;
-
+
istream & is = lex.getStream();
string s(fl);
if (s.length() > 8)
>> rotate_arg >> a >> b >> c >> d;
} else
is >> rows_arg >> columns_arg;
- Init(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);
} else {
is >> rows_arg >> columns_arg >> is_long_tabular_arg
>> rotate_arg >> a >> b >> c >> d;
- Init(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);
#else
// ignore is buggy but we will use it later (Lgb)
is.ignore(); // skip '"'
-#endif
+#endif
getline(is, s1, '"');
#if 1
is >> ch; // skip '"'
Paragraph * par = new Paragraph;
Paragraph * return_par = 0;
+ par->layout(bp.getLyXTextClass().defaultLayout());
+
string tmptok;
int pos = 0;
Paragraph::depth_type depth = 0;
if (token.empty())
continue;
if (token == "\\layout"
- || token == "\\end_float"
- || token == "\\end_deeper") {
+ || token == "\\end_float" // this should not exist anymore
+ || token == "\\end_inset" // as it is substituted by this
+ || token == "\\end_deeper")
+ {
lex.pushToken(token);
-#ifndef NO_COMPABILITY
- // Here we need to insert the inset_ert_contents into the last
- // cell of the tabular.
- owner_->bufferOwner()->insertErtContents(par, pos);
-#endif
break;
}
if (owner_->bufferOwner()->parseSingleLyXformat2Token(lex, par,
}
-void LyXTabular::SetMultiColumn(int cell, int number)
+void LyXTabular::SetMultiColumn(Buffer const * 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)->top_line = row_info[row_of_cell(cell)].top_line;
cellinfo_of_cell(cell)->bottom_line = row_info[row_of_cell(cell)].bottom_line;
+ 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);
+ }
+#else
for (number--; number > 0; --number) {
cellinfo_of_cell(cell+number)->multicolumn = CELL_PART_OF_MULTICOLUMN;
}
+#endif
set_row_column_number_info();
}
{
int const row = row_of_cell(cell);
int column = column_of_cell(cell);
-
+
int result = 0;
-
+
if (cell_info[row][column].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) {
cell_info[row][column].multicolumn = CELL_NORMAL;
++column;
os << cellinfo_of_cell(cell)->align_special << "}{";
} else {
if (LeftLine(cell) &&
- (IsFirstCellInRow(cell) ||
+ (IsFirstCellInRow(cell) ||
(!IsMultiColumn(cell-1) && !LeftLine(cell, true) &&
!RightLine(cell-1, true))))
{
if (!GetPWidth(cell).zero()) {
switch (GetVAlignment(cell)) {
case LYX_VALIGN_TOP:
- os << "p";
+ os << 'p';
break;
case LYX_VALIGN_CENTER:
- os << "m";
+ os << 'm';
break;
case LYX_VALIGN_BOTTOM:
- os << "b";
+ os << 'b';
break;
}
- os << "{" << GetPWidth(cell).asLatexString() << '}';
+ os << '{'
+ << GetPWidth(cell).asLatexString()
+ << '}';
} else {
switch (GetAlignment(cell)) {
case LYX_ALIGN_LEFT:
os << "\\parbox[";
switch (GetVAlignment(cell)) {
case LYX_VALIGN_TOP:
- os << "t";
+ os << 't';
break;
case LYX_VALIGN_CENTER:
- os << "c";
+ os << 'c';
break;
case LYX_VALIGN_BOTTOM:
- os << "b";
+ os << 'b';
break;
}
os << "]{" << GetPWidth(cell).asLatexString() << "}{";
os << "\\begin{minipage}[";
switch (GetVAlignment(cell)) {
case LYX_VALIGN_TOP:
- os << "t";
+ os << 't';
break;
case LYX_VALIGN_CENTER:
- os << "m";
+ os << 'm';
break;
case LYX_VALIGN_BOTTOM:
- os << "b";
+ os << 'b';
break;
}
os << "]{" << GetPWidth(cell).asLatexString() << "}\n";
// usual cells
if (GetUsebox(cell) == BOX_PARBOX)
- os << "}";
+ os << '}';
else if (GetUsebox(cell) == BOX_MINIPAGE) {
os << "%\n\\end{minipage}";
ret += 2;
int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf,
- bool fragile, bool fp) const
+ bool fragile, bool fp) const
{
if (!is_long_tabular)
return 0;
int LyXTabular::TeXRow(ostream & os, int const i, Buffer const * buf,
- bool fragile, bool fp) const
+ bool fragile, bool fp) const
{
int ret = 0;
int cell = GetCellNumber(i, 0);
InsetText * inset = GetCellInset(cell);
bool rtl = inset->paragraph()->isRightToLeftPar(buf->params) &&
- inset->paragraph()->size() > 0 && GetPWidth(cell).zero();
+ !inset->paragraph()->empty() && GetPWidth(cell).zero();
if (rtl)
os << "\\R{";
ret += inset->latex(buf, os, fragile, fp);
if (rtl)
- os << "}";
+ os << '}';
ret += TeXCellPostamble(os, cell);
if (!IsLastCellInRow(cell)) { // not last cell in row
}
++cell;
}
- os << "\\\\\n";
+ os << "\\tabularnewline\n";
++ret;
ret += TeXBottomHLine(os, i);
return ret;
for (int i = 0; i < columns_; ++i) {
if (!column_info[i].align_special.empty()) {
os << column_info[i].align_special;
- } else {
+ } else {
if (column_info[i].left_line)
os << '|';
if (!column_info[i].p_width.zero()) {
+ switch (column_info[i].alignment) {
+ case LYX_ALIGN_LEFT:
+ os << ">{\\raggedright}";
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << ">{\\raggedleft}";
+ break;
+ case LYX_ALIGN_CENTER:
+ os << ">{\\centering}";
+ break;
+ case LYX_ALIGN_NONE:
+ case LYX_ALIGN_BLOCK:
+ case LYX_ALIGN_LAYOUT:
+ case LYX_ALIGN_SPECIAL:
+ break;
+ }
+
switch (column_info[i].valignment) {
case LYX_VALIGN_TOP:
- os << "p";
+ os << 'p';
break;
case LYX_VALIGN_CENTER:
- os << "m";
+ os << 'm';
break;
case LYX_VALIGN_BOTTOM:
- os << "b";
+ os << 'b';
break;
}
- os << "{"
+ os << '{'
<< column_info[i].p_width.asLatexString()
<< '}';
} else {
os << 'l';
break;
case LYX_ALIGN_RIGHT:
- os << 'r';
- break;
+ os << 'r';
+ break;
default:
os << 'c';
break;
++ret;
ret += TeXLongtableHeaderFooter(os, buf, fragile, fp);
-
+
//+---------------------------------------------------------------------
//+ the single row and columns (cells) +
//+---------------------------------------------------------------------
{
int ret = 0;
int cell = GetFirstCellInRow(row);
-
+
os << "<row>\n";
for (int j = 0; j < columns_; ++j) {
if (IsPartOfMultiColumn(row, j))
case LYX_VALIGN_CENTER:
os << "middle";
}
- os << "\"";
+ os << '"';
if (IsMultiColumn(cell)) {
os << " namest=\"col" << j << "\" ";
- os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< "\"";
+ os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< '"';
}
- os << ">";
- ret += GetCellInset(cell)->docbook(buf, os);
+ os << '>';
+ ret += GetCellInset(cell)->docbook(buf, os, true);
os << "</entry>\n";
++cell;
}
os << "</row>\n";
return ret;
-}
+}
-int LyXTabular::docBook(Buffer const * buf, ostream & os) const
+int LyXTabular::docbook(Buffer const * buf, ostream & os,
+ bool /*mixcont*/) const
{
int ret = 0;
os << "<tgroup cols=\"" << columns_
<< "\" colsep=\"1\" rowsep=\"1\">\n";
-
+
for (int i = 0; i < columns_; ++i) {
os << "<colspec colname=\"col" << i << "\" align=\"";
switch (column_info[i].alignment) {
ret += docbookRow(buf, os, i);
}
}
- os << "<thead>\n";
+ os << "</thead>\n";
++ret;
}
// output footer info
// ASCII export function and helpers
//--
int LyXTabular::asciiTopHLine(ostream & os, int row,
- vector<unsigned int> const & clen) const
+ vector<unsigned int> const & clen) const
{
int const fcell = GetFirstCellInRow(row);
int const n = NumberOfCellsInRow(fcell) + fcell;
int LyXTabular::asciiBottomHLine(ostream & os, int row,
- vector<unsigned int> const & clen) const
+ vector<unsigned int> const & clen) const
{
int const fcell = GetFirstCellInRow(row);
int const n = NumberOfCellsInRow(fcell) + fcell;
int LyXTabular::asciiPrintCell(Buffer const * buf, ostream & os,
- int cell, int row, int column,
- vector<unsigned int> const & clen,
- bool onlydata) const
+ int cell, int row, int column,
+ vector<unsigned int> const & clen,
+ bool onlydata) const
{
ostringstream sstr;
int ret = GetCellInset(cell)->ascii(buf, sstr, 0);
os << sstr.str();
return ret;
}
-
+
if (LeftLine(cell))
os << "| ";
else
break;
}
- for (unsigned int i = 0; i < len1; ++i)
- os << " ";
- os << sstr.str();
- for (unsigned int i = 0; i < len2; ++i)
- os << " ";
+ os << string(len1, ' ')
+ << sstr.str()
+ << string(len2, ' ');
if (RightLine(cell))
os << " |";
else
<< "this is not a cell of the tabular!" << endl;
return -1;
}
-
+
const int save_cur_cell = cur_cell;
int cell = cur_cell;
if (GetCellInset(cell) != inset) {
cell = -1;
}
}
-
+
if (cell == -1) {
for (cell = GetNumberOfCells(); cell >= 0; --cell) {
if (GetCellInset(cell) == inset)
lyxerr[Debug::INSETTEXT]
<< "LyXTabular::GetCellFromInset: "
<< "cell=" << cell
- << ", cur_cell=" << save_cur_cell
+ << ", cur_cell=" << save_cur_cell
<< ", maybe_cell=" << maybe_cell
<< endl;
// We should have found a cell at this point
<< "Cell not found!" << endl;
}
}
-
+
return cell;
}
void LyXTabular::Validate(LaTeXFeatures & features) const
{
+ features.require("NeedTabularnewline");
if (IsLongTabular())
features.require("longtable");
if (NeedRotating())
features.require("rotating");
for (int cell = 0; cell < numberofcells; ++cell) {
- if (GetVAlignment(cell) != LYX_VALIGN_TOP)
+ if ( (GetVAlignment(cell) != LYX_VALIGN_TOP) ||
+ ( !(GetPWidth(cell).zero())&&!(IsMultiColumn(cell)) )
+ )
features.require("array");
GetCellInset(cell)->validate(features);
}
return label_list;
}
-
+
LyXTabular::BoxType LyXTabular::UseParbox(int cell) const
{
Paragraph * par = GetCellInset(cell)->paragraph();
projects / lyx.git / blobdiff