#include "debug.h"
#include "vspace.h"
#include "layout.h"
+#include "lyx_gui_misc.h"
+#include "buffer.h"
+#include "BufferView.h"
+#include "Painter.h"
+#include "LaTeXFeatures.h"
#include "support/lstrings.h"
#include "support/lyxmanip.h"
-#include "lyx_gui_misc.h"
+#include "insets/insettabular.h"
#include "insets/insettext.h"
using std::ostream;
using std::getline;
using std::max;
using std::endl;
+using std::vector;
static int const WIDTH_OF_LINE = 5;
+extern BufferView * current_view;
+
/// Define a few methods for the inner structs
LyXTabular::cellstruct::cellstruct()
bottom_line = false;
rotate = false;
linebreaks = false;
- inset = 0;
}
-LyXTabular::cellstruct::~cellstruct()
-{
- delete inset;
-}
-
-LyXTabular::cellstruct &
- LyXTabular::cellstruct::operator=(cellstruct const & cs)
-{
- cellno = cs.cellno;
- width_of_cell = cs.width_of_cell;
- multicolumn = cs.multicolumn;
- alignment = cs.alignment;
- top_line = cs.top_line;
- bottom_line = cs.bottom_line;
- rotate = cs.rotate;
- linebreaks = cs.linebreaks;
- return *this;
-}
LyXTabular::rowstruct::rowstruct()
{
newpage = false;
}
-// Nothing to do, but gcc 2.7.2.3 wants one... (JMarc)
-LyXTabular::rowstruct::~rowstruct()
-{
-}
-
-LyXTabular::rowstruct &
- LyXTabular::rowstruct::operator=(rowstruct const & rs)
-{
- top_line = rs.top_line;
- bottom_line = rs.bottom_line;
- ascent_of_row = rs.ascent_of_row;
- descent_of_row = rs.descent_of_row;
- newpage = rs.newpage;
- return *this;
-}
LyXTabular::columnstruct::columnstruct()
{
width_of_column = 0;
}
-LyXTabular::columnstruct::~columnstruct()
-{
-}
-
-LyXTabular::columnstruct &
- LyXTabular::columnstruct::operator=(columnstruct const & cs)
-{
- left_line = cs.left_line;
- right_line = cs.right_line;
- alignment = cs.alignment;
- width_of_column = cs.width_of_column;
- p_width = cs.p_width;
- align_special = cs.align_special;
- return *this;
-}
/* konstruktor */
-LyXTabular::LyXTabular(int rows_arg, int columns_arg, Buffer *buf)
+LyXTabular::LyXTabular(InsetTabular * inset, int rows_arg, int columns_arg)
{
- buffer = buf;
- Init(buf, rows_arg, columns_arg);
+ owner_ = inset;
+ Init(rows_arg, columns_arg);
}
-LyXTabular::LyXTabular(LyXTabular const & lt, Buffer * buf)
+LyXTabular::LyXTabular(InsetTabular * inset, LyXTabular const & lt)
{
- buffer = buf;
- Init(buf, lt.rows_, lt.columns_);
+ owner_ = inset;
+ Init(lt.rows_, lt.columns_);
operator=(lt);
}
-LyXTabular::LyXTabular(LyXLex & lex, Buffer *buf)
+
+LyXTabular::LyXTabular(Buffer const * buf, InsetTabular * inset, LyXLex & lex)
{
- buffer = buf;
- Read(lex);
+ owner_ = inset;
+ Read(buf, lex);
}
{
delete[] rowofcell;
delete[] columnofcell;
-// delete[] column_info;
-// delete[] row_info;
-// for (int i = 0; i < rows_; ++i) {
-// delete[] cell_info[i];
-// }
-// delete[] cell_info;
}
// call abort()
Assert(rows_ == lt.rows_ && columns_ == lt.columns_);
- int row = 0, column = 0;
-
- for (row = 0; row < rows_; ++row) {
- for (column = 0; column < columns_; ++column) {
- cell_info[row][column] = lt.cell_info[row][column];
- }
- }
-
- for (row = 0; row < rows_; ++row) {
- row_info[row] = lt.row_info[row];
- }
-
- for (column = 0; column < columns_; ++column) {
- column_info[column] = lt.column_info[column];
- }
+ cell_info = lt.cell_info;
+ row_info = lt.row_info;
+ column_info = lt.column_info;
+ // long tabular stuff
SetLongTabular(lt.is_long_tabular);
+ endhead = lt.endhead;
+ endfoot = lt.endfoot;
+ endfirsthead = lt.endfirsthead;
+ endlastfoot = lt.endlastfoot;
+
rotate = lt.rotate;
+
Reinit();
return *this;
}
-LyXTabular * LyXTabular::Clone(Buffer * buf)
-{
- LyXTabular * result = new LyXTabular(rows_, columns_, buf);
- int row, column;;
-
- for (row = 0; row < rows_; ++row) {
- for (column = 0; column < columns_; ++column) {
- result->cell_info[row][column] = cell_info[row][column];
- }
- }
-
- for (row = 0; row < rows_; ++row) {
- result->row_info[row] = row_info[row];
- }
- for (column = 0; column < columns_; ++column) {
- result->column_info[column].left_line = column_info[column].left_line;
- result->column_info[column].right_line = column_info[column].right_line;
- result->column_info[column].alignment = column_info[column].alignment;
- result->column_info[column].p_width = column_info[column].p_width;
- result->column_info[column].align_special = column_info[column].align_special;
+LyXTabular * LyXTabular::Clone(InsetTabular * inset)
+{
+ LyXTabular * result = new LyXTabular(inset, *this);
+ ///
+ // don't know if this is good but I need to Clone also
+ // the text-insets here, this is for the Undo-facility!
+ ///
+ int i,j;
+ for(i=0; i < rows_; ++i) {
+ for(j=0; j < columns_; ++j) {
+ result->cell_info[i][j].inset = cell_info[i][j].inset;
+ result->cell_info[i][j].inset.setOwner(inset);
+ }
}
-
- result->SetLongTabular(is_long_tabular);
- result->rotate = rotate;
- result->Reinit();
return result;
}
/* activates all lines and sets all widths to 0 */
-void LyXTabular::Init(Buffer * buf, int rows_arg, int columns_arg)
+void LyXTabular::Init(int rows_arg, int columns_arg)
{
int i, j;
int cellno = 0;
cell_info = vector<vector<cellstruct> >
(rows_, vector<cellstruct>(columns_, cellstruct()));
+ // Jürgen, use iterators.
for (i = 0; i < rows_; ++i) {
for (j = 0; j < columns_; ++j) {
- cell_info[i][j].inset = new InsetText(buf);
+ cell_info[i][j].inset.setOwner(owner_);
+ cell_info[i][j].inset.SetDrawFrame(0, InsetText::LOCKED);
cell_info[i][j].cellno = cellno++;
}
}
}
-void LyXTabular::AppendRow(int /* cell */)
+void LyXTabular::AppendRow(int cell )
{
-#if 0
+ ++rows_;
+
int row = row_of_cell(cell);
- rowstruct * row_info2 = new rowstruct[rows_ + 1];
- cellstruct ** cell_info2 = new cellstruct * [rows_ + 1];
- int i;
- for (i = 0; i <= row; ++i) {
- cell_info2[i] = cell_info[i];
- row_info2[i] = row_info[i];
+ row_vector::iterator rit = row_info.begin() + row;
+ row_info.insert(rit, rowstruct());
+
+#if 0
+ cell_vvector::iterator cit = cell_info.begin() + row;
+ cell_info.insert(cit, vector<cellstruct>(columns_, cellstruct()));
+#else
+ cell_vvector c_info = cell_vvector(rows_, cell_vector(columns_,
+ cellstruct()));
+
+ for(int i = 0; i <= row; ++i) {
+ for(int j = 0; j < columns_; ++j) {
+ c_info[i][j] = cell_info[i][j];
+ }
}
- for (i = rows_ - 1; i >= row; --i) {
- cell_info2[i + 1] = cell_info[i];
- row_info2[i + 1] = row_info[i];
+ for(int i = row+1; i < rows_; ++i) {
+ for(int j = 0; j < columns_; ++j) {
+ c_info[i][j] = cell_info[i-1][j];
+ }
}
- row_info2[row + 1].top_line = row_info[i].top_line;
- cell_info2[row + 1] = new cellstruct[columns_](buffer);
- for (i = 0; i < columns_; ++i) {
- cell_info2[row + 1][i].width_of_cell = 0;
- cell_info2[row + 1][i] = cell_info2[row][i];
+ cell_info = c_info;
+ ++row;
+ for (int j = 0; j < columns_; ++j) {
+ cell_info[row][j].inset.clear();
}
-
- delete[] cell_info;
- cell_info = cell_info2;
- delete[] row_info;
- row_info = row_info2;
-
- ++rows_;
-
- Reinit();
#endif
+ Reinit();
}
-void LyXTabular::DeleteRow(int /*cell*/)
+void LyXTabular::DeleteRow(int row)
{
-#if 0
- int row = row_of_cell(cell);
- rowstruct * row_info2 = new rowstruct[rows_ - 1];
- cellstruct ** cell_info2 = new cellstruct * [rows_ - 1];
-
- delete[] cell_info[row];
- int i = 0;
- for (; i < row; ++i) {
- cell_info2[i] = cell_info[i];
- row_info2[i] = row_info[i];
- }
- for (i = row; i < rows_ - 1; ++i) {
- cell_info2[i] = cell_info[i + 1];
- row_info2[i] = row_info[i + 1];
- }
-
- delete[] cell_info;
- cell_info = cell_info2;
- delete[] row_info;
- row_info = row_info2;
-
+ if (!(rows_ - 1))
+ return;
+ row_info.erase(row_info.begin() + row); //&row_info[row]);
+ cell_info.erase(cell_info.begin() + row); //&cell_info[row]);
--rows_;
-
Reinit();
-#endif
}
-void LyXTabular::AppendColumn(int /*cell*/)
+void LyXTabular::AppendColumn(int cell)
{
-#if 0
- int j;
- columnstruct * column_info2 = new columnstruct[columns_ + 1];
- int column = right_column_of_cell(cell);
+ ++columns_;
+
+ cell_vvector c_info = cell_vvector(rows_, cell_vector(columns_,
+ cellstruct()));
+ int column = column_of_cell(cell);
+ int i, j;
+ column_vector::iterator cit = column_info.begin() + column;
+ column_info.insert(cit, columnstruct());
- int i = 0;
- for (; i <= column; ++i) {
- column_info2[i] = column_info[i];
- }
- for (i = columns_ - 1; i >= column; --i) {
- column_info2[i + 1] = column_info[i];
- }
-
- delete[] column_info;
- column_info = column_info2;
-
for (i = 0; i < rows_; ++i) {
- cellstruct * tmp = cell_info[i];
- cell_info[i] = new cellstruct[columns_ + 1](buffer);
for (j = 0; j <= column; ++j) {
- cell_info[i][j] = tmp[j];
+ c_info[i][j] = cell_info[i][j];
}
- for (j = column; j < columns_; ++j) {
- cell_info[i][j + 1] = tmp[j];
+ for (j = column+1; j < columns_; ++j) {
+ c_info[i][j] = cell_info[i][j-1];
}
// care about multicolumns
- if (cell_info[i][column + 1].multicolumn
- == LyXTabular::CELL_BEGIN_OF_MULTICOLUMN){
- cell_info[i][column + 1].multicolumn =
- LyXTabular::CELL_PART_OF_MULTICOLUMN;
+ if (cell_info[i][column+1].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) {
+ cell_info[i][column+1].multicolumn = CELL_PART_OF_MULTICOLUMN;
}
- if (column + 1 == columns_
- || cell_info[i][column + 2].multicolumn
- != LyXTabular::CELL_PART_OF_MULTICOLUMN){
- cell_info[i][column + 1].multicolumn =
- LyXTabular::CELL_NORMAL;
+ if (((column+1) == columns_) ||
+ (cell_info[i][column+2].multicolumn != CELL_PART_OF_MULTICOLUMN)) {
+ cell_info[i][column+1].multicolumn = LyXTabular::CELL_NORMAL;
}
- delete[] tmp;
}
-
- ++columns_;
- Reinit();
-#endif
-}
-
-
-void LyXTabular::DeleteColumn(int /*cell*/)
-{
-#if 0
- int column1 = column_of_cell(cell);
- int column2 = right_column_of_cell(cell);
-
- if (column1 == 0 && column2 == columns_ - 1)
- return;
-
- for (int column = column1; column <= column2; ++column) {
- delete_column(column1);
+ cell_info = c_info;
+ ++column;
+ for (i = 0; i < rows_; ++i) {
+ cell_info[i][column].inset.clear();
}
Reinit();
-#endif
}
-void LyXTabular::delete_column(int /*column*/)
+void LyXTabular::DeleteColumn(int column)
{
-#if 0
- int i, j;
- columnstruct * column_info2 = new columnstruct[columns_-1];
-
- for (i = 0; i < column; ++i) {
- column_info2[i] = column_info[i];
- }
- for (i = column; i < columns_ - 1; ++i) {
- column_info2[i] = column_info[i + 1];
- }
-
- delete[] column_info;
- column_info = column_info2;
-
- for (i = 0; i < rows_; ++i) {
- cellstruct * tmp = cell_info[i];
- cell_info[i] = new cellstruct[columns_ - 1](buffer);
- for (j = 0; j < column; ++j) {
- cell_info[i][j] = tmp[j];
- }
- for (j = column; j < columns_ - 1; ++j) {
- cell_info[i][j] = tmp[j + 1];
- }
- delete[] tmp;
+ if (!(columns_ - 1))
+ return;
+ column_info.erase(column_info.begin() + column);
+ for (int i = 0; i < rows_; ++i) {
+ cell_info[i].erase(cell_info[i].begin() + column);
}
-
--columns_;
Reinit();
-#endif
}
int j;
int i = 0;
+
+ // Jürgen, use iterators.
for (; i < rows_; ++i) {
for (j = 0; j < columns_; ++j) {
cell_info[i][j].width_of_cell = 0;
+ cell_info[i][j].inset.setOwner(owner_);
}
}
++row;
}
}
+ for (row = 0; row < rows_; ++row) {
+ for (column = 0; column<columns_; ++column) {
+ if (IsPartOfMultiColumn(row,column))
+ continue;
+ cell_info[row][column].inset.SetAutoBreakRows(
+ !GetPWidth(GetCellNumber(row, column)).empty());
+ }
+ }
}
+
int LyXTabular::GetNumberOfCells() const
{
return numberofcells;
}
-int LyXTabular::AppendCellAfterCell(int append_cell, int question_cell)
-{
- return (right_column_of_cell(append_cell) ==
- right_column_of_cell(question_cell));
-}
-
-
-int LyXTabular::DeleteCellIfColumnIsDeleted(int cell, int delete_column_cell)
-{
- if (column_of_cell(delete_column_cell) == 0 &&
- right_column_of_cell(delete_column_cell) == columns_ - 1)
- return 0;
- else
- return
- (column_of_cell(cell) >= column_of_cell(delete_column_cell) &&
- column_of_cell(cell) <= right_column_of_cell(delete_column_cell));
-}
-
-
/* returns 1 if there is a topline, returns 0 if not */
bool LyXTabular::TopLine(int cell) const
{
return width_of_tabular;
}
+
/* returns 1 if a complete update is necessary, otherwise 0 */
bool LyXTabular::SetWidthOfMulticolCell(int cell, int new_width)
{
return true;
}
-bool LyXTabular::SetPWidth(int cell, string width)
+
+bool LyXTabular::SetPWidth(int cell, string const & width)
{
+ bool flag = !width.empty();
+
if (IsMultiColumn(cell)) {
cellinfo_of_cell(cell)->p_width = width;
+ GetCellInset(cell)->SetAutoBreakRows(flag);
} else {
- column_info[column_of_cell(cell)].p_width = width;
- if (!width.empty()) // do this only if there is a width
+ int j = column_of_cell(cell);
+ int c;
+ column_info[j].p_width = width;
+ if (flag) // do this only if there is a width
SetAlignment(cell, LYX_ALIGN_LEFT);
+ for(int i=0; i < rows_; ++i) {
+ c = GetCellNumber(i, j);
+ flag = !GetPWidth(c).empty(); // because of multicolumns!
+ GetCellInset(c)->SetAutoBreakRows(flag);
+ }
}
return true;
}
-bool LyXTabular::SetAlignSpecial(int cell, string special, int what)
+
+bool LyXTabular::SetAlignSpecial(int cell, string const & special, int what)
{
if (what == SET_SPECIAL_MULTI)
cellinfo_of_cell(cell)->align_special = special;
return true;
}
+
bool LyXTabular::SetAllLines(int cell, bool line)
{
SetTopLine(cell, line);
return true;
}
+
bool LyXTabular::SetTopLine(int cell, bool line)
{
int row = row_of_cell(cell);
return column_info[column_of_cell(cell)].alignment;
}
+
string LyXTabular::GetPWidth(int cell) const
{
if (IsMultiColumn(cell))
return column_info[column_of_cell(cell)].p_width;
}
+
string LyXTabular::GetAlignSpecial(int cell, int what) const
{
if (what == SET_SPECIAL_MULTI)
return column_info[column_of_cell(cell)].align_special;
}
+
int LyXTabular::GetWidthOfCell(int cell) const
{
int row = row_of_cell(cell);
return result;
}
-
int LyXTabular::GetBeginningOfTextInCell(int cell) const
{
int x = 0;
return (column_of_cell(cell) == 0);
}
+
+int LyXTabular::GetFirstCellInRow(int row) const
+{
+ if (row > (rows_-1))
+ row = rows_ - 1;
+ return cell_info[row][0].cellno;
+}
+
bool LyXTabular::IsLastCellInRow(int cell) const
{
return (right_column_of_cell(cell) == (columns_ - 1));
}
+int LyXTabular::GetLastCellInRow(int row) const
+{
+ if (row > (rows_-1))
+ row = rows_ - 1;
+ return cell_info[row][columns_-1].cellno;
+}
+
+
bool LyXTabular::calculate_width_of_column(int column)
{
int old_column_width = column_info[column].width_of_column;
return (column_info[column].width_of_column != old_column_width);
}
+
bool LyXTabular::calculate_width_of_column_NMC(int column)
{
int old_column_width = column_info[column].width_of_column;
int max = 0;
for (int i = 0; i < rows_; ++i) {
- if (!IsMultiColumn(GetCellNumber(column, i)) &&
+ if (!IsMultiColumn(GetCellNumber(i, column)) &&
(cell_info[i][column].width_of_cell > max)) {
max = cell_info[i][column].width_of_cell;
}
return (column_info[column].width_of_column != old_column_width);
}
+
void LyXTabular::calculate_width_of_tabular()
{
width_of_tabular = 0;
}
-void LyXTabular::Write(ostream & os) const
+void LyXTabular::Write(Buffer const * buf, ostream & os) const
{
int i, j;
"\" special=\"" << cell_info[i][j].align_special <<
"\">" << endl;
os << "\\begin_inset ";
- cell_info[i][j].inset->Write(os);
+ cell_info[i][j].inset.Write(buf, os);
os << "\n\\end_inset " << endl;
os << "</Cell>" << endl;
os << "</Column>" << endl;
os << "</LyXTabular>" << endl;
}
-static bool getTokenValue(string const str, const char * token, string & ret)
+
+static
+bool getTokenValue(string const str, const char * token, string & ret)
{
int pos = str.find(token);
char ch = str[pos+strlen(token)];
return true;
}
-static bool getTokenValue(string const str, const char * token, int & num)
+
+static
+bool getTokenValue(string const str, const char * token, int & num)
{
string ret;
int pos = str.find(token);
return true;
}
-static bool getTokenValue(string const str, const char * token, bool & flag)
+
+static
+bool getTokenValue(string const str, const char * token, bool & flag)
{
string ret;
int pos = str.find(token);
return true;
}
+
void l_getline(istream & is, string & str)
{
getline(is, str);
getline(is, str);
}
-void LyXTabular::Read(LyXLex & lex)
+
+void LyXTabular::Read(Buffer const * buf, LyXLex & lex)
{
string line;
istream & is = lex.getStream();
l_getline(is, line);
if (!prefixIs(line, "<LyXTabular ")) {
- OldFormatRead(is, line);
+ OldFormatRead(lex, line);
return;
}
return;
if (!getTokenValue(line, "columns", columns_arg))
return;
- Init(buffer, rows_arg, columns_arg);
+ Init(rows_arg, columns_arg);
l_getline(is, line);
if (!prefixIs(line, "<Features ")) {
lyxerr << "Wrong tabular format (expected <Feture ...> got" <<
(void)getTokenValue(line, "special", cell_info[i][j].align_special);
l_getline(is, line);
if (prefixIs(line, "\\begin_inset")) {
- cell_info[i][j].inset->Read(lex);
+ cell_info[i][j].inset.Read(buf, lex);
l_getline(is, line);
}
if (line != "</Cell>") {
set_row_column_number_info();
}
-void LyXTabular::OldFormatRead(istream & is, string fl)
+
+void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl)
{
int version;
int i, j;
int g = 0;
int h = 0;
- string s;
- s = fl;
+ istream & is = lex.getStream();
+ string s(fl);
if (s.length() > 8)
version = atoi(s.c_str() + 8);
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!"
>> rotate_arg >> a >> b >> c >> d;
} else
is >> rows_arg >> columns_arg;
- Init(buffer, rows_arg, columns_arg);
+ Init(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);
getline(is, tmp);
}
}
- set_row_column_number_info();
- return;
- }
- is >> rows_arg >> columns_arg >> is_long_tabular_arg
- >> rotate_arg >> a >> b >> c >> d;
- Init(buffer, rows_arg, columns_arg);
- SetLongTabular(is_long_tabular_arg);
- SetRotateTabular(rotate_arg);
- endhead = a;
- endfirsthead = b;
- endfoot = c;
- endlastfoot = d;
- for (i = 0; i < rows_; ++i) {
- a = b = c = d = e = f = g = h = 0;
- is >> a >> b >> c >> d;
- row_info[i].top_line = a;
- row_info[i].bottom_line = b;
-// row_info[i].is_cont_row = c;
- row_info[i].newpage = d;
- }
- for (i = 0; i < columns_; ++i) {
- string s1;
- string s2;
- is >> a >> b >> c;
- char ch; // skip '"'
- is >> ch;
- getline(is, s1, '"');
- is >> ch; // skip '"'
- getline(is, s2, '"');
- column_info[i].alignment = static_cast<char>(a);
- column_info[i].left_line = b;
- column_info[i].right_line = c;
- column_info[i].p_width = s1;
- column_info[i].align_special = s2;
- }
- for (i = 0; i < rows_; ++i) {
- for (j = 0; j < columns_; ++j) {
+ } else {
+ is >> rows_arg >> columns_arg >> is_long_tabular_arg
+ >> rotate_arg >> a >> b >> c >> d;
+ Init(rows_arg, columns_arg);
+ cont_row_info = vector<int>(rows_arg);
+ SetLongTabular(is_long_tabular_arg);
+ SetRotateTabular(rotate_arg);
+ endhead = a;
+ endfirsthead = b;
+ endfoot = c;
+ endlastfoot = d;
+ for (i = 0; i < rows_; ++i) {
+ a = b = c = d = e = f = g = h = 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 >> d >> e >> f >> g;
- char ch;
- is >> ch; // skip '"'
+ is >> a >> b >> c;
+ char ch; // skip '"'
+ is >> ch;
getline(is, s1, '"');
is >> ch; // skip '"'
getline(is, s2, '"');
- cell_info[i][j].multicolumn = static_cast<char>(a);
- cell_info[i][j].alignment = static_cast<char>(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].has_cont_row = static_cast<bool>(e);
- cell_info[i][j].rotate = static_cast<bool>(f);
- cell_info[i][j].linebreaks = static_cast<bool>(g);
- cell_info[i][j].align_special = s1;
- cell_info[i][j].p_width = s2;
+ column_info[i].alignment = static_cast<char>(a);
+ column_info[i].left_line = b;
+ column_info[i].right_line = c;
+ column_info[i].p_width = 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;
+ char ch;
+ is >> ch; // skip '"'
+ getline(is, s1, '"');
+ is >> ch; // skip '"'
+ getline(is, s2, '"');
+ cell_info[i][j].multicolumn = static_cast<char>(a);
+ cell_info[i][j].alignment = static_cast<char>(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].rotate = static_cast<bool>(f);
+ cell_info[i][j].linebreaks = static_cast<bool>(g);
+ cell_info[i][j].align_special = s1;
+ cell_info[i][j].p_width = s2;
+ }
}
}
set_row_column_number_info();
-}
-
-// cell < 0 will tex the preamble
-// returns the number of printed newlines
-int LyXTabular::TexEndOfCell(ostream & os, int cell) const
-{
- int i;
- int ret = 0;
- int tmp; // tmp2;
- int fcell, nvcell;
- if (IsLastCell(cell)) {
- // the very end at the very beginning
- if (GetLinebreaks(cell))
- os << "\\smallskip{}}";
- if (IsMultiColumn(cell))
- os << '}';
- if (GetRotateCell(cell)) {
- os << "\n\\end{sideways}";
- ++ret;
- }
- os << "\\\\\n";
- ++ret;
-
- tmp = 0;
- fcell = cell;
- while (!IsFirstCellInRow(fcell)) --fcell;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (BottomLine(fcell + i))
- ++tmp;
- }
- if (tmp == NumberOfCellsInRow(fcell)) {
- os << "\\hline ";
- } else {
- tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (BottomLine(fcell + i)) {
- os << "\\cline{"
- << column_of_cell(fcell + i) + 1
- << '-'
- << right_column_of_cell(fcell + i) + 1
- << "} ";
- tmp = 1;
- }
- }
- }
- if (tmp){
- os << '\n';
- ++ret;
- }
- if (is_long_tabular)
- os << "\\end{longtable}";
- else
- os << "\\end{tabular}";
- if (rotate) {
- os << "\n\\end{sideways}";
- ++ret;
- }
- } else {
- nvcell = cell + 1;
- if (cell < 0){
- // preamble
- if (rotate) {
- os << "\\begin{sideways}\n";
- ++ret;
- }
- if (is_long_tabular)
- os << "\\begin{longtable}{";
- else
- os << "\\begin{tabular}{";
- for (i = 0; i < columns_; ++i) {
- if (column_info[i].left_line)
- os << '|';
- if (!column_info[i].align_special.empty()) {
- os << column_info[i].align_special;
- } else if (!column_info[i].p_width.empty()) {
- os << "p{"
- << column_info[i].p_width
- << '}';
- } else {
- switch (column_info[i].alignment) {
- case LYX_ALIGN_LEFT:
- os << 'l';
- break;
- case LYX_ALIGN_RIGHT:
- os << 'r';
- break;
- default:
- os << 'c';
- break;
- }
- }
- if (column_info[i].right_line)
- os << '|';
- }
- os << "}\n";
- ++ret;
- tmp = 0;
- if (GetNumberOfCells()) {
- fcell = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (TopLine(fcell + i))
- ++tmp;
- }
- if (tmp == NumberOfCellsInRow(fcell)){
- os << "\\hline ";
- } else {
- tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (TopLine(fcell + i)) {
- os << "\\cline{"
- << column_of_cell(fcell + i) + 1
- << '-'
- << right_column_of_cell(fcell + i) + 1
- << "} ";
- tmp = 1;
- }
- }
- }
- if (tmp){
- os << '\n';
- ++ret;
- }
- }
- if (GetRotateCell(0)) {
- os << "\\begin{sideways}\n";
- ++ret;
- }
- } else {
- // usual cells
- if (GetLinebreaks(cell))
- os << "\\smallskip{}}";
- if (IsMultiColumn(cell)){
- os << '}';
- }
- if (GetRotateCell(cell)) {
- os << "\n\\end{sideways}";
- ++ret;
- }
- if (IsLastCellInRow(cell)) {
- int row = row_of_cell(cell);
- string hline1, hline2;
- bool print_hline = true;
- bool flag1 = IsLongTabular() &&
- ((row == endhead) || (row == endfirsthead) ||
- (row == endfoot) || (row == endlastfoot));
- ++row;
- bool flag2 = IsLongTabular() &&
- ((row <= endhead) || (row <= endfirsthead) ||
- (row <= endfoot) || (row <= endlastfoot));
- --row;
- // print the bottom hline only if (otherwise it is doubled):
- // - is no LongTabular
- // - there IS a first-header
- // - the next row is no special header/footer
- // & this row is no special header/footer
- // - the next row is a special header/footer
- // & this row is a special header/footer
- bool pr_top_hline = (flag1 && flag2) || (!flag1 && !flag2) ||
- (endfirsthead == endhead);
- os << "\\\\\n";
- ++ret;
- tmp = 0;
- fcell = cell;
- while (!IsFirstCellInRow(fcell))
- --fcell;
- for (i = 0; i < NumberOfCellsInRow(cell); ++i) {
- if (BottomLine(fcell + i))
- ++tmp;
- }
- if (tmp == NumberOfCellsInRow(cell)){
- os << "\\hline ";
- hline1 = "\\hline ";
- } else {
- tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (BottomLine(fcell + i)){
- os << "\\cline{"
- << column_of_cell(fcell + i) + 1
- << '-'
- << right_column_of_cell(fcell + i) + 1
- << "} ";
- hline1 += "\\cline{";
- hline1 += tostr(column_of_cell(fcell + i) + 1);
- hline1 += '-';
- hline1 += tostr(right_column_of_cell(fcell + i) + 1);
- hline1 += "} ";
- tmp = 1;
- }
- }
- }
- if (tmp){
- os << '\n';
- ++ret;
- }
- if (IsLongTabular() && (row == endfoot)) {
- os << "\\endfoot\n";
- ++ret;
- print_hline = false; // no double line below footer
- }
- if (IsLongTabular() && (row == endlastfoot)) {
- os << "\\endlastfoot\n";
- ++ret;
- print_hline = false; // no double line below footer
- }
- if (IsLongTabular() && row_info[row].newpage) {
- os << "\\newpage\n";
- ++ret;
- print_hline = false; // no line below a \\newpage-command
- }
- tmp = 0;
- if ((nvcell < numberofcells) &&
- (cell < GetNumberOfCells() - 1) && !IsLastCell(cell)) {
- fcell = nvcell;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (TopLine(fcell + i))
- ++tmp;
- }
- if (tmp == NumberOfCellsInRow(fcell)) {
- if (print_hline)
- os << "\\hline ";
- hline2 = "\\hline ";
- } else {
- tmp = 0;
- for (i = 0; i < NumberOfCellsInRow(fcell); ++i) {
- if (TopLine(fcell + i)) {
- if (print_hline) {
- os << "\\cline{"
- << column_of_cell(fcell + i) + 1
- << '-'
- << right_column_of_cell(fcell + i) + 1
- << "} ";
- }
- hline2 += "\\cline{";
- hline2 += tostr(column_of_cell(fcell+i)+1);
- hline2 += '-';
- hline2 += tostr(right_column_of_cell(fcell+i)+1);
- hline2 += "} ";
- tmp = 1;
- }
- }
- }
- if (tmp && print_hline){
- os << '\n';
- ++ret;
- }
- }
- // the order here is important as if one defines two
- // or more things in one line only the first entry is
- // displayed the other are set to an empty-row. This
- // is important if I have a footer and want that the
- // lastfooter is NOT displayed!!!
- bool sflag2 = (row == endhead) || (row == endfirsthead) ||
- (row == endfoot) || (row == endlastfoot);
- --row;
- row += 2;
- bool sflag1 = IsLongTabular() && (row != endhead) &&
- (row != endfirsthead) &&
- ((row == endfoot) || (row == endlastfoot));
- --row;
- if (IsLongTabular() && (row == endhead)) {
- os << "\\endhead\n";
- ++ret;
- }
- if (IsLongTabular() && (row == endfirsthead)) {
- os << "\\endfirsthead\n";
- ++ret;
- }
- if (sflag1) { // add the \hline for next foot row
- if (!hline1.empty()) {
- os << hline1 + '\n';
- ++ret;
- }
- }
- // add the \hline for the first row
- if (pr_top_hline && sflag2) {
- if (!hline2.empty()) {
- os << hline2 + '\n';
- ++ret;
- }
- }
- if (nvcell < numberofcells && GetRotateCell(nvcell)) {
- os << "\\begin{sideways}\n";
- ++ret;
- }
- } else {
- os << "&\n";
- ++ret;
- if (nvcell < numberofcells && GetRotateCell(nvcell)) {
- os << "\\begin{sideways}\n";
- ++ret;
- }
- }
- }
- if (nvcell < numberofcells && IsMultiColumn(nvcell)) {
- os << "\\multicolumn{"
- << cells_in_multicolumn(nvcell)
- << "}{";
- if (!cellinfo_of_cell(cell+1)->align_special.empty()) {
- os << cellinfo_of_cell(cell+1)->align_special
- << "}{";
- } else {
- if (LeftLine(nvcell))
- os << '|';
- if (!GetPWidth(nvcell).empty()) {
- os << "p{"
- << GetPWidth(nvcell)
- << '}';
- } else {
- switch (GetAlignment(nvcell)) {
- case LYX_ALIGN_LEFT: os << 'l'; break;
- case LYX_ALIGN_RIGHT: os << 'r'; break;
- default: os << 'c'; break;
- }
- }
- if (RightLine(nvcell))
- os << '|';
- //if (column_of_cell(cell+2)!= 0 && LeftLine(cell+2))
- if (((nvcell + 1) < numberofcells) &&
- ((nvcell+1) < numberofcells) &&
- (column_of_cell(nvcell+1)!= 0) &&
- LeftLine(nvcell+1))
- os << '|';
-
- os << "}{";
- }
- }
- if (nvcell < numberofcells && GetLinebreaks(nvcell)) {
- os << "\\parbox[t]{"
- << GetPWidth(nvcell)
- << "}{\\smallskip{}";
+ LyXParagraph * par = new LyXParagraph;
+ LyXParagraph * return_par = 0;
+ LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
+ LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE;
+ string token, tmptok;
+ int pos = 0;
+ char depth = 0;
+ LyXFont font(LyXFont::ALL_SANE);
+
+ while (lex.IsOK()) {
+ lex.nextToken();
+ token = lex.GetString();
+ if (token.empty())
+ continue;
+ if ((token == "\\layout") || (token == "\\end_float") ||
+ (token == "\\end_deeper"))
+ {
+ lex.pushToken(token);
+ break;
+ }
+ if (owner_->BufferOwner()->parseSingleLyXformat2Token(lex, par,
+ return_par,
+ token, pos,
+ depth, font,
+ footnoteflag,
+ footnotekind))
+ {
+ // 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;
}
}
- return ret;
-}
-
-
-#if 0
-// cell <0 will tex the preamble
-// returns the number of printed newlines
-int LyXTabular::RoffEndOfCell(ostream & os, int cell)
-{
- int ret = 0;
-
- if (cell == GetNumberOfCells() - 1){
- // the very end at the very beginning
-// if (CellHasContRow(cell) >= 0) {
-// os << "\nT}";
-// ++ret;
-// }
- os << "\n";
- ++ret;
- if (row_info[row_of_cell(cell)].bottom_line) {
- os << "_\n";
- ++ret;
- }
- os << ".TE\n.pl 1c";
- } else {
- if (cell < 0) {
- int fcell = 0;
- // preamble
- os << "\n.pl 500c\n.TS\n";
- for (int j = 0; j < rows_; ++j) {
- for (int i = 0; i < columns_; ++i, ++fcell) {
- if (column_info[i].left_line)
- os << " | ";
- if (cell_info[j][i].multicolumn == CELL_PART_OF_MULTICOLUMN)
- os << "s";
- else {
- switch (column_info[i].alignment) {
- case LYX_ALIGN_LEFT:
- os << "l";
- break;
- case LYX_ALIGN_RIGHT:
- os << "r";
- break;
- default:
- os << "c";
- break;
- }
- }
- if (!column_info[i].p_width.empty())
- os << "w(" << column_info[i].p_width << ")";
- if (column_info[i].right_line)
- os << " | ";
- }
- if ((j + 1) < rows_) {
- os << "\n";
- ++ret;
- }
- }
- os << ".\n";
- ++ret;
- if (row_info[0].top_line) {
- os << "_\n";
- ++ret;
- }
-// if (CellHasContRow(0) >= 0) {
-// os << "T{\n";
-// ++ret;
-// }
- } else {
- // usual cells
-// if (CellHasContRow(cell) >= 0) {
-// os << "\nT}";
-// ++ret;
-// }
- if (right_column_of_cell(cell) == columns_ -1){
- os << "\n";
- ++ret;
- int row = row_of_cell(cell);
- if (row_info[row++].bottom_line) {
- os << "_\n";
- ++ret;
- }
- if ((row < rows_) && row_info[row].top_line) {
- os << "_\n";
- ++ret;
- }
- } else
- os << "\t";
-// if ((cell < GetNumberOfCells() - 1) &&
-// (CellHasContRow(cell+1) >= 0)) {
-// os << "T{\n";
-// ++ret;
-// }
- }
+ // 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->Last(); ++i) {
+ if (par->IsNewline(i)) {
+ ++cell;
+ if (cell > GetNumberOfCells()) {
+ lyxerr << "Some error in reading old table format occured!" <<
+ endl << "Terminating when reading cell[" << cell << "]!" <<
+ endl;
+ 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)].linebreaks)
+ {
+ // insert a space instead
+ par->Erase(i);
+ par->InsertChar(i, ' ');
+ }
+ }
+ par->CopyIntoMinibuffer(current_view->buffer()->params, i);
+ inset->par->InsertFromMinibuffer(inset->par->Last());
}
- return ret;
+ Reinit();
}
-#endif
-char const *LyXTabular::GetDocBookAlign(int cell, bool isColumn) const
+char const * LyXTabular::GetDocBookAlign(int cell, bool isColumn) const
{
- int i;
- if (isColumn)
- i = cell;
- else
- i = column_of_cell(cell);
+ int i = isColumn ? cell : column_of_cell(cell);
+
+ //if (isColumn)
+ //i = cell;
+ //else
+ //i = column_of_cell(cell);
if (!isColumn && IsMultiColumn(cell)) {
if (!cellinfo_of_cell(cell)->align_special.empty()) {
return cellinfo_of_cell(cell)->align_special.c_str();
}
-LyXTabular::cellstruct* LyXTabular::cellinfo_of_cell(int cell) const
+LyXTabular::cellstruct * LyXTabular::cellinfo_of_cell(int cell) const
{
int row = row_of_cell(cell);
int column = column_of_cell(cell);
void LyXTabular::SetMultiColumn(int cell, int number)
{
- int new_width = cellinfo_of_cell(cell)->width_of_cell;
-
- cellinfo_of_cell(cell)->multicolumn = LyXTabular::CELL_BEGIN_OF_MULTICOLUMN;
+ 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;
for (number--; number > 0; --number) {
- cellinfo_of_cell(cell+number)->multicolumn =
- LyXTabular::CELL_PART_OF_MULTICOLUMN;
- new_width += cellinfo_of_cell(cell+number)->width_of_cell;
+ cellinfo_of_cell(cell+number)->multicolumn = CELL_PART_OF_MULTICOLUMN;
}
set_row_column_number_info();
- SetWidthOfCell(cell, new_width);
}
int column = column_of_cell(cell);
int result = 1;
++column;
- while (column < columns_ && cell_info[row][column].multicolumn
- == LyXTabular::CELL_PART_OF_MULTICOLUMN){
+ while ((column < columns_) &&
+ cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN)
+ {
++result;
++column;
}
}
-int LyXTabular::UnsetMultiColumn(int cell)
+int LyXTabular::UnsetMultiColumn(int cell)
{
int row = row_of_cell(cell);
int column = column_of_cell(cell);
int result = 0;
- if (cell_info[row][column].multicolumn
- == LyXTabular::CELL_BEGIN_OF_MULTICOLUMN){
- cell_info[row][column].multicolumn = LyXTabular::CELL_NORMAL;
+ if (cell_info[row][column].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) {
+ cell_info[row][column].multicolumn = CELL_NORMAL;
++column;
- while (column < columns_ &&
- cell_info[row][column].multicolumn
- == LyXTabular::CELL_PART_OF_MULTICOLUMN){
- cell_info[row][column].multicolumn =
- LyXTabular::CELL_NORMAL;
+ while ((column < columns_) &&
+ (cell_info[row][column].multicolumn ==CELL_PART_OF_MULTICOLUMN))
+ {
+ cell_info[row][column].multicolumn = CELL_NORMAL;
++column;
++result;
}
return is_long_tabular;
}
+
void LyXTabular::SetRotateTabular(int what)
{
rotate = what;
}
+
bool LyXTabular::GetRotateTabular() const
{
return rotate;
}
+
void LyXTabular::SetRotateCell(int cell, int what)
{
cellinfo_of_cell(cell)->rotate = what;
}
+
bool LyXTabular::GetRotateCell(int cell) const
{
return cellinfo_of_cell(cell)->rotate;
}
+
bool LyXTabular::NeedRotating() const
{
if (rotate)
bool LyXTabular::IsLastCell(int cell) const
{
- if (cell < GetNumberOfCells())
+ if ((cell+1) < GetNumberOfCells())
return false;
return true;
}
+
int LyXTabular::GetCellAbove(int cell) const
{
if (row_of_cell(cell) > 0)
return cell;
}
-int LyXTabular::GetCellNumber(int column, int row) const
+
+int LyXTabular::GetCellBelow(int cell) const
+{
+ if (row_of_cell(cell)+1 < rows_)
+ return cell_info[row_of_cell(cell)+1][column_of_cell(cell)].cellno;
+ return cell;
+}
+
+
+int LyXTabular::GetLastCellAbove(int cell) const
+{
+ if (row_of_cell(cell) <= 0)
+ return cell;
+ if (!IsMultiColumn(cell))
+ return GetCellAbove(cell);
+ return cell_info[row_of_cell(cell)-1][right_column_of_cell(cell)].cellno;
+}
+
+
+int LyXTabular::GetLastCellBelow(int cell) const
+{
+ if (row_of_cell(cell)+1 >= rows_)
+ return cell;
+ if (!IsMultiColumn(cell))
+ return GetCellBelow(cell);
+ return cell_info[row_of_cell(cell)+1][right_column_of_cell(cell)].cellno;
+}
+
+
+int LyXTabular::GetCellNumber(int row, int column) const
{
if (column >= columns_)
column = columns_ - 1;
return cell_info[row][column].cellno;
}
+
void LyXTabular::SetLinebreaks(int cell, bool what)
{
cellinfo_of_cell(cell)->linebreaks = what;
}
+
bool LyXTabular::GetLinebreaks(int cell) const
{
if (column_info[column_of_cell(cell)].p_width.empty() &&
return cellinfo_of_cell(cell)->linebreaks;
}
+
void LyXTabular::SetLTHead(int cell, bool first)
{
int row = row_of_cell(cell);
}
}
+
bool LyXTabular::GetRowOfLTHead(int cell) const
{
if ((endhead+1) > rows_)
return (row_of_cell(cell) == endhead);
}
+
bool LyXTabular::GetRowOfLTFirstHead(int cell) const
{
if ((endfirsthead+1) > rows_)
return (row_of_cell(cell) == endfirsthead);
}
+
void LyXTabular::SetLTFoot(int cell, bool last)
{
int row = row_of_cell(cell);
}
}
+
bool LyXTabular::GetRowOfLTFoot(int cell) const
{
if ((endfoot+1) > rows_)
return (row_of_cell(cell) == endlastfoot);
}
+
void LyXTabular::SetLTNewPage(int cell, bool what)
{
row_info[row_of_cell(cell)].newpage = what;
}
+
bool LyXTabular::GetLTNewPage(int cell) const
{
return row_info[row_of_cell(cell)].newpage;
}
-void LyXTabular::SetAscentOfRow(int row, int height)
+
+bool LyXTabular::SetAscentOfRow(int row, int height)
{
- if (row >= rows_)
- return;
+ if ((row >= rows_) || (row_info[row].ascent_of_row == height))
+ return false;
row_info[row].ascent_of_row = height;
+ return true;
}
-void LyXTabular::SetDescentOfRow(int row, int height)
+
+bool LyXTabular::SetDescentOfRow(int row, int height)
{
- if (row >= rows_)
- return;
+ if ((row >= rows_) || (row_info[row].descent_of_row == height))
+ return false;
row_info[row].descent_of_row = height;
+ return true;
}
+
int LyXTabular::GetAscentOfRow(int row) const
{
if (row >= rows_)
return row_info[row].ascent_of_row;
}
+
int LyXTabular::GetDescentOfRow(int row) const
{
if (row >= rows_)
return row_info[row].descent_of_row;
}
+
int LyXTabular::GetHeightOfTabular() const
{
- int
- height,
- row;
+ int height = 0;
- for(row=0,height=0;(row<rows_); ++row)
+ for(int row = 0; row < rows_; ++row)
height += GetAscentOfRow(row) + GetDescentOfRow(row) +
- GetAdditionalHeight(GetCellNumber(0,row));
+ GetAdditionalHeight(GetCellNumber(row, 0));
return height;
}
+
bool LyXTabular::IsPartOfMultiColumn(int row, int column) const
{
if ((row >= rows_) || (column >= columns_))
return (cell_info[row][column].multicolumn==CELL_PART_OF_MULTICOLUMN);
}
-int LyXTabular::Latex(ostream &) const
+
+int LyXTabular::TeXTopHLine(ostream & os, int row) const
{
+ int fcell = GetFirstCellInRow(row);
+ int n = NumberOfCellsInRow(fcell) + fcell;
+ int tmp=0;
+ int i;
+
+ for (i = fcell; i < n; ++i) {
+ if (TopLine(i))
+ ++tmp;
+ }
+ if (tmp == (n - fcell)){
+ os << "\\hline ";
+ } else {
+ for (i = fcell; i < n; ++i) {
+ if (TopLine(i)) {
+ os << "\\cline{"
+ << column_of_cell(i) + 1
+ << '-'
+ << right_column_of_cell(i) + 1
+ << "} ";
+ }
+ }
+ }
+ if (tmp) {
+ os << endl;
+ return 1;
+ }
+ return 0;
+}
+
+
+int LyXTabular::TeXBottomHLine(ostream & os, int row) const
+{
+ int fcell = GetFirstCellInRow(row);
+ int n = NumberOfCellsInRow(fcell) + fcell;
+ int tmp = 0;
+ int i;
+
+ for (i = fcell; i < n; ++i) {
+ if (BottomLine(i))
+ ++tmp;
+ }
+ if (tmp == (n-fcell)){
+ os << "\\hline";
+ } else {
+ for (i = fcell; i < n; ++i) {
+ if (BottomLine(i)) {
+ os << "\\cline{"
+ << column_of_cell(i) + 1
+ << '-'
+ << right_column_of_cell(i) + 1
+ << "} ";
+ }
+ }
+ }
+ if (tmp) {
+ os << endl;
+ return 1;
+ }
return 0;
}
+
+int LyXTabular::TeXCellPreamble(ostream & os, int cell) const
+{
+ int ret = 0;
+
+ if (GetRotateCell(cell)) {
+ os << "\\begin{sideways}" << endl;
+ ++ret;
+ }
+ if (IsMultiColumn(cell)) {
+ os << "\\multicolumn{" << cells_in_multicolumn(cell) << "}{";
+ if (!cellinfo_of_cell(cell+1)->align_special.empty()) {
+ os << cellinfo_of_cell(cell+1)->align_special << "}{";
+ } else {
+ if (LeftLine(cell))
+ os << '|';
+ if (!GetPWidth(cell).empty()) {
+ os << "p{" << GetPWidth(cell) << '}';
+ } else {
+ switch (GetAlignment(cell)) {
+ case LYX_ALIGN_LEFT:
+ os << 'l';
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << 'r';
+ break;
+ default:
+ os << 'c';
+ break;
+ }
+ }
+ if (RightLine(cell))
+ os << '|';
+ if (((cell + 1) < numberofcells) && !IsFirstCellInRow(cell+1) &&
+ LeftLine(cell+1))
+ os << '|';
+ os << "}{";
+ }
+ }
+ if (GetLinebreaks(cell)) {
+ os << "\\parbox[t]{" << GetPWidth(cell) << "}{\\smallskip{}";
+ }
+ return ret;
+}
+
+
+int LyXTabular::TeXCellPostamble(ostream & os, int cell) const
+{
+ int ret = 0;
+
+ // usual cells
+ if (GetLinebreaks(cell))
+ os << "\\smallskip{}}";
+ if (IsMultiColumn(cell)){
+ os << '}';
+ }
+ if (GetRotateCell(cell)) {
+ os << endl << "\\end{sideways}";
+ ++ret;
+ }
+ return ret;
+}
+
+
+int LyXTabular::Latex(Buffer const * buf, ostream & os, bool fragile, bool fp) const
+{
+ int ret = 0;
+ int i,j;
+ int cell = 0;
+
+ //+---------------------------------------------------------------------
+ //+ first the opening preamble +
+ //+---------------------------------------------------------------------
+
+ if (rotate) {
+ os << "\\begin{sideways}" << endl;
+ ++ret;
+ }
+ if (is_long_tabular)
+ os << "\\begin{longtable}{";
+ else
+ os << "\\begin{tabular}{";
+ for (i = 0; i < columns_; ++i) {
+ if (column_info[i].left_line)
+ os << '|';
+ if (!column_info[i].align_special.empty()) {
+ os << column_info[i].align_special;
+ } else if (!column_info[i].p_width.empty()) {
+ os << "p{"
+ << column_info[i].p_width
+ << '}';
+ } else {
+ switch (column_info[i].alignment) {
+ case LYX_ALIGN_LEFT:
+ os << 'l';
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << 'r';
+ break;
+ default:
+ os << 'c';
+ break;
+ }
+ }
+ if (column_info[i].right_line)
+ os << '|';
+ }
+ os << "}" << endl;
+ ++ret;
+
+ //+---------------------------------------------------------------------
+ //+ the single row and columns (cells) +
+ //+---------------------------------------------------------------------
+
+ for(i=0; i < rows_; ++i) {
+ ret += TeXTopHLine(os, i);
+ for(j=0; j < columns_; ++j) {
+ if (IsPartOfMultiColumn(i,j))
+ continue;
+ ret += TeXCellPreamble(os, cell);
+ ret += GetCellInset(cell)->Latex(buf, os, fragile, fp);
+ ret += TeXCellPostamble(os, cell);
+ if (!IsLastCellInRow(cell)) { // not last cell in row
+ os << "&" << endl;
+ ++ret;
+ }
+ ++cell;
+ }
+ os << "\\\\" << endl;
+ ret += TeXBottomHLine(os, i);
+ if (IsLongTabular()) {
+ if (i == endhead) {
+ os << "\\endhead\n";
+ ++ret;
+ }
+ if (i == endfirsthead) {
+ os << "\\endfirsthead\n";
+ ++ret;
+ }
+ if (i == endfoot) {
+ os << "\\endfoot\n";
+ ++ret;
+ }
+ if (i == endlastfoot) {
+ os << "\\endlastfoot\n";
+ ++ret;
+ }
+ if (row_info[i].newpage) {
+ os << "\\newpage\n";
+ ++ret;
+ }
+ }
+ }
+
+ //+---------------------------------------------------------------------
+ //+ the closing of the tabular +
+ //+---------------------------------------------------------------------
+
+ if (is_long_tabular)
+ os << "\\end{longtable}";
+ else
+ os << "\\end{tabular}";
+ if (rotate) {
+ os << "\n\\end{sideways}";
+ ++ret;
+ }
+
+ return ret;
+}
+
+
InsetText * LyXTabular::GetCellInset(int cell) const
{
- return cell_info[row_of_cell(cell)][column_of_cell(cell)].inset;
+ return & cell_info[row_of_cell(cell)][column_of_cell(cell)].inset;
+}
+
+void LyXTabular::Validate(LaTeXFeatures & features) const
+{
+ if (IsLongTabular())
+ features.longtable = true;
+ if (NeedRotating())
+ features.rotating = true;
+ for(int cell = 0; cell < numberofcells; ++cell)
+ GetCellInset(cell)->Validate(features);
}