X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftabular.C;h=10e0b797ae4f84c7e10221b1a97a1c68d1d56022;hb=24f8676130d1e0769db394b7142dae7eeb1d955e;hp=5213651290be0272b317d78b35e5836db4a69e27;hpb=c130d5dbfd3f4d4a2721c9be786b7fa45b806aca;p=lyx.git diff --git a/src/tabular.C b/src/tabular.C index 5213651290..10e0b797ae 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -1,43 +1,49 @@ -/* This file is part of - * ====================================================== - * - * LyX, The Document Processor - * - * Copyright 2000-2001 The LyX Team. +/** + * \file tabular.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * @author: Jürgen Vigna + * \author Lars Gullik Bjønnes + * \author Matthias Ettrich + * \author José Matos + * \author Jean-Marc Lasgouttes + * \author Angus Leeming + * \author John Levon + * \author André Pönitz + * \author Jürgen Vigna * - * ====================================================== + * Full author contact details are available in file CREDITS. */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - -// temporary until verified (08/08/2001 Jug) -#define SPECIAL_COLUM_HANDLING 1 - -#include -#include - #include "tabular.h" +#include "LaTeXFeatures.h" +#include "Lsstream.h" +#include "buffer.h" #include "debug.h" +#include "gettext.h" +#include "lyxlex.h" #include "vspace.h" -#include "layout.h" -#include "frontends/Alert.h" -#include "buffer.h" -#include "BufferView.h" -#include "Painter.h" -#include "LaTeXFeatures.h" -#include "support/lstrings.h" -#include "support/lyxmanip.h" -#include "support/LAssert.h" + #include "insets/insettabular.h" #include "insets/insettext.h" -#include "gettext.h" +#include "support/LAssert.h" +#include "support/LIstream.h" +#include "support/lstrings.h" +#include "support/lyxmanip.h" +#include "support/tostr.h" + +#include "frontends/Alert.h" +#include "frontends/Painter.h" + +#include +#include + +using namespace lyx::support; + +using std::abs; using std::ostream; using std::istream; using std::getline; @@ -51,13 +57,254 @@ using std::strlen; namespace { - int const WIDTH_OF_LINE = 5; +int const WIDTH_OF_LINE = 5; + +template +string const write_attribute(string const & name, T const & t) +{ + string const s = tostr(t); + return s.empty() ? s : " " + name + "=\"" + s + "\""; +} + +string const write_attribute(string const & name, string const & t) +{ + return t.empty() ? t : " " + name + "=\"" + t + "\""; +} + + +string const write_attribute(string const & name, bool const & b) +{ + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return b ? write_attribute(name, tostr(b)) : string(); +} + + +string const write_attribute(string const & name, int const & i) +{ + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return i ? write_attribute(name, tostr(i)) : string(); +} + + +string const write_attribute(string const & name, LyXLength const & value) +{ + // we write only the value if we really have one same reson as above. + return value.zero() ? string() : write_attribute(name, value.asString()); +} + + +string const tostr(LyXAlignment const & num) +{ + switch (num) { + case LYX_ALIGN_NONE: + return "none"; + case LYX_ALIGN_BLOCK: + return "block"; + case LYX_ALIGN_LEFT: + return "left"; + case LYX_ALIGN_CENTER: + return "center"; + case LYX_ALIGN_RIGHT: + return "right"; + case LYX_ALIGN_LAYOUT: + return "layout"; + case LYX_ALIGN_SPECIAL: + return "special"; + } + return string(); +} + + +string const tostr(LyXTabular::VAlignment const & num) +{ + switch (num) { + case LyXTabular::LYX_VALIGN_TOP: + return "top"; + case LyXTabular::LYX_VALIGN_MIDDLE: + return "middle"; + case LyXTabular::LYX_VALIGN_BOTTOM: + return "bottom"; + } + return string(); +} + + +string const tostr(LyXTabular::BoxType const & num) +{ + switch (num) { + case LyXTabular::BOX_NONE: + return "none"; + case LyXTabular::BOX_PARBOX: + return "parbox"; + case LyXTabular::BOX_MINIPAGE: + return "minipage"; + } + return string(); +} + +// I would have liked a fromstr template a lot better. (Lgb) +bool string2type(string const str, LyXAlignment & num) +{ + if (str == "none") + num = LYX_ALIGN_NONE; + else if (str == "block") + num = LYX_ALIGN_BLOCK; + else if (str == "left") + num = LYX_ALIGN_LEFT; + else if (str == "center") + num = LYX_ALIGN_CENTER; + else if (str == "right") + num = LYX_ALIGN_RIGHT; + else + return false; + return true; +} + + +bool string2type(string const str, LyXTabular::VAlignment & num) +{ + if (str == "top") + num = LyXTabular::LYX_VALIGN_TOP; + else if (str == "middle" ) + num = LyXTabular::LYX_VALIGN_MIDDLE; + else if (str == "bottom") + num = LyXTabular::LYX_VALIGN_BOTTOM; + else + return false; + return true; +} + + +bool string2type(string const str, LyXTabular::BoxType & num) +{ + if (str == "none") + num = LyXTabular::BOX_NONE; + else if (str == "parbox") + num = LyXTabular::BOX_PARBOX; + else if (str == "minipage") + num = LyXTabular::BOX_MINIPAGE; + else + return false; + return true; +} + + +bool string2type(string const str, bool & num) +{ + if (str == "true") + num = true; + else if (str == "false") + num = false; + else + return false; + return true; +} + + +bool getTokenValue(string const & str, const char * token, string & ret) +{ + ret.erase(); + size_t token_length = strlen(token); + string::size_type pos = str.find(token); + + if (pos == string::npos || pos + token_length + 1 >= str.length() + || str[pos + token_length] != '=') + return false; + pos += token_length + 1; + char ch = str[pos]; + if ((ch != '"') && (ch != '\'')) { // only read till next space + ret += ch; + ch = ' '; + } + while ((pos < str.length() - 1) && (str[++pos] != ch)) + ret += str[pos]; + + return true; +} + + +bool getTokenValue(string const & str, const char * token, int & num) +{ + string tmp; + num = 0; + if (!getTokenValue(str, token, tmp)) + return false; + num = strToInt(tmp); + return true; +} + + +bool getTokenValue(string const & str, const char * token, LyXAlignment & num) +{ + string tmp; + if (!getTokenValue(str, token, tmp)) + return false; + return string2type(tmp, num); +} + + +bool getTokenValue(string const & str, const char * token, + LyXTabular::VAlignment & num) +{ + string tmp; + if (!getTokenValue(str, token, tmp)) + return false; + return string2type(tmp, num); +} + + +bool getTokenValue(string const & str, const char * token, + LyXTabular::BoxType & num) +{ + string tmp; + if (!getTokenValue(str, token, tmp)) + return false; + return string2type(tmp, num); +} + + +bool getTokenValue(string const & str, const char * token, bool & flag) +{ + // set the flag always to false as this should be the default for bools + // not in the file-format. + flag = false; + string tmp; + if (!getTokenValue(str, token, tmp)) + return false; + return string2type(tmp, flag); +} + + +bool getTokenValue(string const & str, const char * token, LyXLength & len) +{ + // set the lenght to be zero() as default as this it should be if not + // in the file format. + len = LyXLength(); + string tmp; + if (!getTokenValue(str, token, tmp)) + return false; + return isValidLength(tmp, &len); +} + + +void l_getline(istream & is, string & str) +{ + str.erase(); + while (str.empty()) { + getline(is, str); + if (!str.empty() && str[str.length() - 1] == '\r') + str.erase(str.length() - 1); + } +} } // namespace /// 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; @@ -73,17 +320,21 @@ LyXTabular::cellstruct::cellstruct() } -LyXTabular::rowstruct::rowstruct() +LyXTabular::rowstruct::rowstruct() { top_line = true; bottom_line = false; ascent_of_row = 0; descent_of_row = 0; + endhead = false; + endfirsthead = false; + endfoot = false; + endlastfoot = false; newpage = false; } -LyXTabular::columnstruct::columnstruct() +LyXTabular::columnstruct::columnstruct() { left_line = true; right_line = false; @@ -93,114 +344,49 @@ LyXTabular::columnstruct::columnstruct() } -LyXTabular::lttype::lttype() +LyXTabular::ltType::ltType() { - row = 0; topDL = false; bottomDL = false; + empty = 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) { owner_ = inset; cur_cell = -1; - Init(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! - if (same_id) { - 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); - } - } - } -#if 0 -#ifdef WITH_WARNINGS -#warning Jürgen, can you make it the other way round. So that copy assignment depends on the copy constructor and not the other way. (Lgb) -#endif - operator=(lt); -#endif + init(bp, lt.rows_, lt.columns_, <); } -LyXTabular::LyXTabular(Buffer const * buf, InsetTabular * inset, LyXLex & lex) +LyXTabular::LyXTabular(Buffer const & buf, InsetTabular * inset, LyXLex & lex) { owner_ = inset; cur_cell = -1; - Read(buf, lex); -} - - -LyXTabular & LyXTabular::operator=(LyXTabular const & lt) -{ -#if 0 -#warning This while method should look like this: (Lgb) - - LyXTabular tmp(lt); - tmp.swap(*this); -#else - // If this and lt is not of the same size we have a serious bug - // So then it is ok to throw an exception, or for now - // call abort() - lyx::Assert(rows_ == lt.rows_ && columns_ == lt.columns_); - cur_cell = -1; - 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(); -#endif - return *this; -} - - -LyXTabular * LyXTabular::clone(InsetTabular * inset, bool same_id) -{ - LyXTabular * result = new LyXTabular(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! - for (int i = 0; i < rows_; ++i) { - for (int j = 0; j < columns_; ++j) { - result->cell_info[i][j].inset = cell_info[i][j].inset; - result->cell_info[i][j].inset.setOwner(inset); - } - } -#endif - return result; + read(buf, lex); } -/* 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); @@ -211,7 +397,7 @@ void LyXTabular::Init(int rows_arg, int columns_arg, LyXTabular const * lt) for (int i = 0; i < rows_; ++i) { for (int j = 0; j < columns_; ++j) { cell_info[i][j].inset.setOwner(owner_); - cell_info[i][j].inset.setDrawFrame(0, InsetText::LOCKED); + cell_info[i][j].inset.setDrawFrame(InsetText::LOCKED); cell_info[i][j].cellno = cellno++; } cell_info[i].back().right_line = true; @@ -219,140 +405,144 @@ void LyXTabular::Init(int rows_arg, int columns_arg, LyXTabular const * lt) row_info.back().bottom_line = true; row_info.front().bottom_line = true; - for (int i = 0; i < columns_; ++i) { + for (int i = 0; i < columns_; ++i) calculate_width_of_column(i); - } + column_info.back().right_line = true; - + calculate_width_of_tabular(); - rowofcell = vector(); - columnofcell = vector(); + rowofcell.clear(); + columnofcell.clear(); set_row_column_number_info(); is_long_tabular = false; rotate = false; - endhead.row = 0; - endfirsthead.row = 0; - endfoot.row = 0; - endlastfoot.row = 0; } -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(columns_, cellstruct())); + cell_info.insert(cit, vector(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) { + for (int i = 0; i <= row; ++i) + for (int j = 0; j < columns_; ++j) c_info[i][j] = cell_info[i][j]; - } - } - for (int i = row + 1; i < rows_; ++i) { - for (int j = 0; j < columns_; ++j) { + + for (int i = row + 1; i < rows_; ++i) + for (int j = 0; j < columns_; ++j) c_info[i][j] = cell_info[i-1][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) +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]); + // Not allowed to delete last row + if (rows_ == 1) + return; + + row_info.erase(row_info.begin() + row); + cell_info.erase(cell_info.begin() + row); --rows_; Reinit(); } -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) { + for (int j = 0; j <= column; ++j) c_info[i][j] = cell_info[i][j]; - } - for (int j = column + 1; j < columns_; ++j) { + + for (int 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==CELL_BEGIN_OF_MULTICOLUMN) { - cell_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN; - } - if ((column + 1) == columns_ || - cell_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN) { - cell_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL; - } + if (c_info[i][column + 1].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) + c_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN; + + if (column + 2 >= columns_ + || c_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN) + c_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL; } 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(); } -void LyXTabular::DeleteColumn(int column) +void LyXTabular::deleteColumn(int column) { - // Similar to DeleteRow - //if (!(columns_ - 1)) - //return; - if (columns_ == 1) return; // Not allowed to delete last column - + // Not allowed to delete last column + if (columns_ == 1) + return; + column_info.erase(column_info.begin() + column); - for (int i = 0; i < rows_; ++i) { + for (int i = 0; i < rows_; ++i) cell_info[i].erase(cell_info[i].begin() + column); - } --columns_; Reinit(); } -void LyXTabular::Reinit() -{ - for (int i = 0; i < rows_; ++i) { - for (int j = 0; j < columns_; ++j) { - cell_info[i][j].width_of_cell = 0; - cell_info[i][j].inset.setOwner(owner_); +void LyXTabular::reinit() +{ + Reinit(false); +} + + +void LyXTabular::Reinit(bool reset_widths) +{ + if (reset_widths) { + for (int i = 0; i < rows_; ++i) { + for (int j = 0; j < columns_; ++j) { + cell_info[i][j].width_of_cell = 0; + cell_info[i][j].inset.setOwner(owner_); + } } } - - for (int i = 0; i < columns_; ++i) { + + for (int i = 0; i < columns_; ++i) calculate_width_of_column(i); - } + calculate_width_of_tabular(); set_row_column_number_info(); @@ -363,7 +553,7 @@ void LyXTabular::set_row_column_number_info(bool oldformat) { numberofcells = -1; for (int row = 0; row < rows_; ++row) { - for (int column = 0; columntop_line; - return row_info[row].top_line; + if (!onlycolumn && isMultiColumn(cell)) + return cellinfo_of_cell(cell).top_line; + return row_info[row_of_cell(cell)].top_line; } -bool LyXTabular::BottomLine(int cell, bool onlycolumn) const +bool LyXTabular::bottomLine(int cell, bool onlycolumn) const { - // no bottom line underneath non-existent cells if you please - // Isn't that a programming error? Is so this should - // be an Assert instead. (Lgb) - if (cell >= numberofcells) - return false; - - if (!onlycolumn && IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->bottom_line; + if (!onlycolumn && isMultiColumn(cell)) + return cellinfo_of_cell(cell).bottom_line; return row_info[row_of_cell(cell)].bottom_line; } -bool LyXTabular::LeftLine(int cell, bool onlycolumn) const +bool LyXTabular::leftLine(int cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell)) { -#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), "|"); -#else - return cellinfo_of_cell(cell)->left_line; -#endif + if (!onlycolumn && isMultiColumn(cell) && + (isFirstCellInRow(cell) || isMultiColumn(cell-1))) + { + if (cellinfo_of_cell(cell).align_special.empty()) + return cellinfo_of_cell(cell).left_line; + return prefixIs(ltrim(cellinfo_of_cell(cell).align_special), "|"); } -#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), "|"); -#else - return column_info[column_of_cell(cell)].left_line; -#endif + return prefixIs(ltrim(column_info[column_of_cell(cell)].align_special), "|"); } -bool LyXTabular::RightLine(int cell, bool onlycolumn) const +bool LyXTabular::rightLine(int cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell)) { -#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), "|"); -#else - return cellinfo_of_cell(cell)->right_line; -#endif + if (!onlycolumn && isMultiColumn(cell) && + (isLastCellInRow(cell) || isMultiColumn(cell+1))) + { + if (cellinfo_of_cell(cell).align_special.empty()) + return cellinfo_of_cell(cell).right_line; + return suffixIs(rtrim(cellinfo_of_cell(cell).align_special), "|"); } -#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), "|"); -#else - return column_info[right_column_of_cell(cell)].right_line; -#endif + return suffixIs(rtrim(column_info[column_of_cell(cell)].align_special), "|"); } -bool LyXTabular::TopAlreadyDrawed(int cell) const +bool LyXTabular::topAlreadyDrawn(int cell) const { int row = row_of_cell(cell); - if ((row > 0) && !GetAdditionalHeight(row)) { + if (row > 0 && !getAdditionalHeight(row)) { int column = column_of_cell(cell); --row; while (column @@ -514,7 +684,7 @@ bool LyXTabular::TopAlreadyDrawed(int cell) const } -bool LyXTabular::LeftAlreadyDrawed(int cell) const +bool LyXTabular::leftAlreadyDrawn(int cell) const { int column = column_of_cell(cell); if (column > 0) { @@ -522,25 +692,21 @@ bool LyXTabular::LeftAlreadyDrawed(int cell) const while (--column && (cell_info[row][column].multicolumn == LyXTabular::CELL_PART_OF_MULTICOLUMN)); - if (GetAdditionalWidth(cell_info[row][column].cellno)) + if (getAdditionalWidth(cell_info[row][column].cellno)) return false; -#ifdef SPECIAL_COLUM_HANDLING - return column_info[column].right_line; -#else - return RightLine(cell_info[row][column].cellno, true); -#endif + return rightLine(cell_info[row][column].cellno); } return false; } -bool LyXTabular::IsLastRow(int cell) const +bool LyXTabular::isLastRow(int cell) const { return (row_of_cell(cell) == rows_ - 1); } -int LyXTabular::GetAdditionalHeight(int row) const +int LyXTabular::getAdditionalHeight(int row) const { if (!row || row >= rows_) return 0; @@ -548,7 +714,7 @@ int LyXTabular::GetAdditionalHeight(int row) const bool top = true; bool bottom = true; - for (int column = 0; column < columns_ - 1 && bottom; ++column) { + for (int column = 0; column < columns_ && bottom; ++column) { switch (cell_info[row - 1][column].multicolumn) { case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN: bottom = cell_info[row - 1][column].bottom_line; @@ -557,8 +723,8 @@ int LyXTabular::GetAdditionalHeight(int row) const bottom = row_info[row - 1].bottom_line; } } - for (int column = 0; column < columns_ - 1 && top; ++column) { - switch (cell_info[row][column].multicolumn){ + for (int column = 0; column < columns_ && top; ++column) { + switch (cell_info[row][column].multicolumn) { case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN: top = cell_info[row][column].top_line; break; @@ -572,58 +738,56 @@ int LyXTabular::GetAdditionalHeight(int row) const } -int LyXTabular::GetAdditionalWidth(int cell) const +int LyXTabular::getAdditionalWidth(int cell) const { - // internally already set in SetWidthOfCell + // internally already set in setWidthOfCell // 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 { - return 0; } + return 0; } -// returns the maximum over all rows -int LyXTabular::GetWidthOfColumn(int cell) const +// returns the maximum over all rows +int LyXTabular::getWidthOfColumn(int cell) const { int const column1 = column_of_cell(cell); int const column2 = right_column_of_cell(cell); int result = 0; - for (int i = column1; i <= column2; ++i) { + for (int i = column1; i <= column2; ++i) result += column_info[i].width_of_column; - } return result; } -int LyXTabular::GetWidthOfTabular() const +int LyXTabular::getWidthOfTabular() const { return width_of_tabular; } -/* returns 1 if a complete update is necessary, otherwise 0 */ -bool LyXTabular::SetWidthOfMulticolCell(int cell, int new_width) +// returns true if a complete update is necessary, otherwise false +bool LyXTabular::setWidthOfMulticolCell(int cell, int new_width) { - if (!IsMultiColumn(cell)) + 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) { cell_info[row][i].width_of_cell = 0; } // set the width to MAX_WIDTH until width > 0 - int width = (new_width + 2 * WIDTH_OF_LINE); - + 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; @@ -632,30 +796,43 @@ bool LyXTabular::SetWidthOfMulticolCell(int cell, int new_width) 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 */ -bool LyXTabular::SetWidthOfCell(int cell, int new_width) +// returns 1 if a complete update is necessary, otherwise 0 +void LyXTabular::setWidthOfCell(int cell, int new_width) { int const row = row_of_cell(cell); int const column1 = column_of_cell(cell); @@ -663,307 +840,281 @@ bool LyXTabular::SetWidthOfCell(int cell, int new_width) int width = 0; int add_width = 0; -#ifdef SPECIAL_COLUM_HANDLING - if (RightLine(cell_info[row][column1].cellno, true) && - (column1 < columns_-1) && - LeftLine(cell_info[row][column1+1].cellno, true)) -#else - if (column_info[column1].right_line && (column1 < columns_-1) && - column_info[column1+1].left_line) // additional width -#endif + if (rightLine(cell_info[row][column1].cellno, true) && + column1 < columns_ - 1 && + leftLine(cell_info[row][column1+1].cellno, true)) { - // additional width add_width = WIDTH_OF_LINE; } - if (GetWidthOfCell(cell) == (new_width+2*WIDTH_OF_LINE+add_width)) { - return false; - } - if (IsMultiColumn(cell, true)) { - tmp = SetWidthOfMulticolCell(cell, new_width); + + if (getWidthOfCell(cell) == new_width + 2 * WIDTH_OF_LINE + add_width) + return; + + if (isMultiColumn(cell, true)) { + tmp = setWidthOfMulticolCell(cell, new_width); } else { - width = (new_width + 2*WIDTH_OF_LINE + add_width); + 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 (; ialignment = align; - return true; + cellinfo_of_cell(cell).alignment = align; } -bool LyXTabular::SetVAlignment(int cell, VAlignment align, bool onlycolumn) +void LyXTabular::setVAlignment(int cell, VAlignment align, bool onlycolumn) { - if (!IsMultiColumn(cell) || onlycolumn) + if (!isMultiColumn(cell) || onlycolumn) column_info[column_of_cell(cell)].valignment = align; if (!onlycolumn) - cellinfo_of_cell(cell)->valignment = align; - return true; + cellinfo_of_cell(cell).valignment = align; } -bool LyXTabular::SetColumnPWidth(int cell, string const & width) +void LyXTabular::setColumnPWidth(int cell, LyXLength const & width) { - bool flag = !width.empty(); 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); for (int i = 0; i < rows_; ++i) { - int c = GetCellNumber(i, j); - flag = !GetPWidth(c).empty(); // because of multicolumns! - GetCellInset(c)->setAutoBreakRows(flag); + int const cell = getCellNumber(i, j); + // because of multicolumns + getCellInset(cell).setAutoBreakRows(!getPWidth(cell).zero()); } - return true; } -bool LyXTabular::SetMColumnPWidth(int cell, string const & width) +bool LyXTabular::setMColumnPWidth(int cell, LyXLength const & width) { - bool const flag = !width.empty(); + bool const flag = !width.zero(); - cellinfo_of_cell(cell)->p_width = width; - if (IsMultiColumn(cell)) { - GetCellInset(cell)->setAutoBreakRows(flag); + cellinfo_of_cell(cell).p_width = width; + if (isMultiColumn(cell)) { + getCellInset(cell).setAutoBreakRows(flag); return true; } return false; } -bool LyXTabular::SetAlignSpecial(int cell, string const & special, - LyXTabular::Feature what) +void LyXTabular::setAlignSpecial(int cell, string const & special, + LyXTabular::Feature what) { if (what == SET_SPECIAL_MULTI) - cellinfo_of_cell(cell)->align_special = special; + cellinfo_of_cell(cell).align_special = special; else column_info[column_of_cell(cell)].align_special = special; - return true; } -bool LyXTabular::SetAllLines(int cell, bool line) +void LyXTabular::setAllLines(int cell, bool line) { - SetTopLine(cell, line); - SetBottomLine(cell, line); - SetRightLine(cell, line); - SetLeftLine(cell, line); - return true; + setTopLine(cell, line); + setBottomLine(cell, line); + setRightLine(cell, line); + setLeftLine(cell, line); } -bool LyXTabular::SetTopLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setTopLine(int cell, bool line, bool onlycolumn) { int const row = row_of_cell(cell); - - if (onlycolumn || !IsMultiColumn(cell)) + if (onlycolumn || !isMultiColumn(cell)) row_info[row].top_line = line; else - cellinfo_of_cell(cell)->top_line = line; - return true; + cellinfo_of_cell(cell).top_line = line; } -bool LyXTabular::SetBottomLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setBottomLine(int cell, bool line, bool onlycolumn) { - if (onlycolumn || !IsMultiColumn(cell)) + if (onlycolumn || !isMultiColumn(cell)) row_info[row_of_cell(cell)].bottom_line = line; else - cellinfo_of_cell(cell)->bottom_line = line; - return true; + cellinfo_of_cell(cell).bottom_line = line; } -bool LyXTabular::SetLeftLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setLeftLine(int cell, bool line, bool onlycolumn) { - if (onlycolumn || !IsMultiColumn(cell)) + if (onlycolumn || !isMultiColumn(cell)) column_info[column_of_cell(cell)].left_line = line; else - cellinfo_of_cell(cell)->left_line = line; - return true; + cellinfo_of_cell(cell).left_line = line; } -bool LyXTabular::SetRightLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setRightLine(int cell, bool line, bool onlycolumn) { - if (onlycolumn || !IsMultiColumn(cell)) + if (onlycolumn || !isMultiColumn(cell)) column_info[right_column_of_cell(cell)].right_line = line; else - cellinfo_of_cell(cell)->right_line = line; - return true; + cellinfo_of_cell(cell).right_line = line; } -LyXAlignment LyXTabular::GetAlignment(int cell, bool onlycolumn) const +LyXAlignment LyXTabular::getAlignment(int cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->alignment; - else - return column_info[column_of_cell(cell)].alignment; + if (!onlycolumn && isMultiColumn(cell)) + return cellinfo_of_cell(cell).alignment; + return column_info[column_of_cell(cell)].alignment; } LyXTabular::VAlignment -LyXTabular::GetVAlignment(int cell, bool onlycolumn) const +LyXTabular::getVAlignment(int cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->valignment; - else - return column_info[column_of_cell(cell)].valignment; + if (!onlycolumn && isMultiColumn(cell)) + return cellinfo_of_cell(cell).valignment; + return column_info[column_of_cell(cell)].valignment; } -string const LyXTabular::GetPWidth(int cell) const +LyXLength const LyXTabular::getPWidth(int cell) const { - if (IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->p_width; + if (isMultiColumn(cell)) + return cellinfo_of_cell(cell).p_width; return column_info[column_of_cell(cell)].p_width; } -string const LyXTabular::GetColumnPWidth(int cell) const +LyXLength const LyXTabular::getColumnPWidth(int cell) const { return column_info[column_of_cell(cell)].p_width; } -string const LyXTabular::GetMColumnPWidth(int cell) const +LyXLength const LyXTabular::getMColumnPWidth(int cell) const { - if (IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->p_width; - return string(); + if (isMultiColumn(cell)) + return cellinfo_of_cell(cell).p_width; + return LyXLength(); } -string const LyXTabular::GetAlignSpecial(int cell, int what) const +string const LyXTabular::getAlignSpecial(int cell, int what) const { if (what == SET_SPECIAL_MULTI) - return cellinfo_of_cell(cell)->align_special; + return cellinfo_of_cell(cell).align_special; return column_info[column_of_cell(cell)].align_special; } -int LyXTabular::GetWidthOfCell(int cell) const +int LyXTabular::getWidthOfCell(int cell) const { int const row = row_of_cell(cell); int const column1 = column_of_cell(cell); int const column2 = right_column_of_cell(cell); int result = 0; - for (int i = column1; i <= column2; ++i) { + for (int i = column1; i <= column2; ++i) result += cell_info[row][i].width_of_cell; - } return result; } -int LyXTabular::GetBeginningOfTextInCell(int cell) const +int LyXTabular::getBeginningOfTextInCell(int cell) const { int x = 0; - - switch (GetAlignment(cell)){ + + switch (getAlignment(cell)) { case LYX_ALIGN_CENTER: - x += (GetWidthOfColumn(cell) - GetWidthOfCell(cell)) / 2; + x += (getWidthOfColumn(cell) - getWidthOfCell(cell)) / 2; break; case LYX_ALIGN_RIGHT: - x += GetWidthOfColumn(cell) - GetWidthOfCell(cell); - // + GetAdditionalWidth(cell); + 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; } -bool LyXTabular::IsFirstCellInRow(int cell) const +bool LyXTabular::isFirstCellInRow(int cell) const { return column_of_cell(cell) == 0; } -int LyXTabular::GetFirstCellInRow(int row) const +int LyXTabular::getFirstCellInRow(int row) const { - if (row > (rows_-1)) + if (row > rows_ - 1) row = rows_ - 1; return cell_info[row][0].cellno; } -bool LyXTabular::IsLastCellInRow(int cell) const + +bool LyXTabular::isLastCellInRow(int cell) const { - return (right_column_of_cell(cell) == (columns_ - 1)); + return right_column_of_cell(cell) == columns_ - 1; } -int LyXTabular::GetLastCellInRow(int row) const +int LyXTabular::getLastCellInRow(int row) const { - if (row > (rows_-1)) + if (row > rows_ - 1) row = rows_ - 1; return cell_info[row][columns_-1].cellno; } -bool LyXTabular::calculate_width_of_column(int column) +void LyXTabular::calculate_width_of_column(int column) { - int const old_column_width = column_info[column].width_of_column; int maximum = 0; - - for (int i = 0; i < rows_; ++i) { + for (int i = 0; i < rows_; ++i) maximum = max(cell_info[i][column].width_of_cell, maximum); - } column_info[column].width_of_column = maximum; - return (column_info[column].width_of_column != old_column_width); } // -// 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 width 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; } } column_info[column].width_of_column = max; - return (column_info[column].width_of_column != old_column_width); + return column_info[column].width_of_column != old_column_width; } void LyXTabular::calculate_width_of_tabular() { width_of_tabular = 0; - for (int i = 0; i < columns_; ++i) { + for (int i = 0; i < columns_; ++i) width_of_tabular += column_info[i].width_of_column; - } } @@ -971,175 +1122,87 @@ int LyXTabular::row_of_cell(int cell) const { if (cell >= numberofcells) return rows_ - 1; - else if (cell < 0) + if (cell < 0) return 0; return rowofcell[cell]; } -int LyXTabular::column_of_cell(int cell) const -{ - if (cell >= numberofcells) - return columns_ - 1; - else if (cell < 0) - return 0; - return columnofcell[cell]; -} - - -int LyXTabular::right_column_of_cell(int cell) const -{ - int const row = row_of_cell(cell); - int column = column_of_cell(cell); - while (column < (columns_ - 1) && - cell_info[row][column + 1].multicolumn == LyXTabular::CELL_PART_OF_MULTICOLUMN) - ++column; - return column; -} - - -// Perfect case for a template... (Lgb) -// or perhaps not... -#if 1 -template -string const write_attribute(string const & name, T const & t) -{ - string str = " " + name + "=\"" + tostr(t) + "\""; - return str; -} - -template <> -string const write_attribute(string const & name, bool const & b) -{ - return write_attribute(name, int(b)); -} - -#else - -string const write_attribute(string const & name, int value) -{ - string str = " " + name + "=\"" + tostr(value) + "\""; - return str; -} - - -string const write_attribute(string const & name, string const & value) -{ - string str = " " + name + "=\"" + value + "\""; - return str; -} - - -string const write_attribute(string const & name, bool value) -{ - string str = " " + name + "=\"" + tostr(static_cast(value)) + "\""; - return str; -} -#endif - - -template<> -inline -string const tostr(LyXAlignment const & num) -{ - switch(num) { - case LYX_ALIGN_NONE: - return "none"; - case LYX_ALIGN_BLOCK: - return "block"; - case LYX_ALIGN_LEFT: - return "left"; - case LYX_ALIGN_CENTER: - return "center"; - case LYX_ALIGN_RIGHT: - return "right"; - case LYX_ALIGN_LAYOUT: - return "layout"; - case LYX_ALIGN_SPECIAL: - return "special"; - } - return string(); -} - - -template<> -inline -string const tostr(LyXTabular::VAlignment const & num) +int LyXTabular::column_of_cell(int cell) const { - switch(num) { - case LyXTabular::LYX_VALIGN_TOP: - return "top"; - case LyXTabular::LYX_VALIGN_CENTER: - return "center"; - case LyXTabular::LYX_VALIGN_BOTTOM: - return "bottom"; - } - return string(); + if (cell >= numberofcells) + return columns_ - 1; + if (cell < 0) + return 0; + return columnofcell[cell]; } -template<> -inline -string const tostr(LyXTabular::BoxType const & num) +int LyXTabular::right_column_of_cell(int cell) const { - switch(num) { - case LyXTabular::BOX_NONE: - return "none"; - case LyXTabular::BOX_PARBOX: - return "parbox"; - case LyXTabular::BOX_MINIPAGE: - return "minipage"; - } - return string(); + int const row = row_of_cell(cell); + int column = column_of_cell(cell); + while (column < columns_ - 1 && + cell_info[row][column + 1].multicolumn == LyXTabular::CELL_PART_OF_MULTICOLUMN) + ++column; + return column; } -void LyXTabular::Write(Buffer const * buf, ostream & os) const +void LyXTabular::write(Buffer const & buf, ostream & os) const { // header line os << "\n"; // global longtable options os << "\n"; for (int j = 0; j < columns_; ++j) { os << "\n"; } for (int i = 0; i < rows_; ++i) { os << "\n"; for (int j = 0; j < columns_; ++j) { os << "\n"; @@ -1154,157 +1217,85 @@ void LyXTabular::Write(Buffer const * buf, ostream & os) const } -namespace { - -// I would have liked a fromstr template a lot better. (Lgb) - -inline -bool string2type(string const str, LyXAlignment & num) -{ - if (str == "none") - num = LYX_ALIGN_NONE; - else if (str == "block") - num = LYX_ALIGN_BLOCK; - else if (str == "left") - num = LYX_ALIGN_LEFT; - else if (str == "center") - num = LYX_ALIGN_CENTER; - else if (str == "right") - num = LYX_ALIGN_RIGHT; - else - return false; - return true; -} - - -inline -bool string2type(string const str, LyXTabular::VAlignment & num) -{ - if (str == "top") - num = LyXTabular::LYX_VALIGN_TOP; - else if (str == "center") - num = LyXTabular::LYX_VALIGN_CENTER; - else if (str == "bottom") - num = LyXTabular::LYX_VALIGN_BOTTOM; - else - return false; - return true; -} - - -inline -bool string2type(string const str, LyXTabular::BoxType & num) -{ - if (str == "none") - num = LyXTabular::BOX_NONE; - else if (str == "parbox") - num = LyXTabular::BOX_PARBOX; - else if (str == "minipage") - num = LyXTabular::BOX_MINIPAGE; - else - return false; - return true; -} - - -inline -bool string2type(string const str, bool & num) -{ - if (str == "true") - num = true; - else if (str == "false") - num = false; - else - return false; - return true; -} - - -bool getTokenValue(string const & str, const char * token, string & ret) +void LyXTabular::setHeaderFooterRows(int hr, int fhr, int fr, int lfr) { - size_t token_length = strlen(token); - string::size_type pos = str.find(token); - - if (pos == string::npos || pos + token_length + 1 >= str.length() - || str[pos + token_length] != '=') - return false; - ret.erase(); - pos += token_length + 1; - char ch = str[pos]; - if ((ch != '"') && (ch != '\'')) { // only read till next space - ret += ch; - ch = ' '; + // set header info + while (hr > 0) { + row_info[--hr].endhead = true; } - while((pos < str.length() - 1) && (str[++pos] != ch)) - ret += str[pos]; - - return true; -} - - -bool getTokenValue(string const & str, const char * token, int & num) -{ - string tmp; - if (!getTokenValue(str, token, tmp)) - return false; - num = strToInt(tmp); - return true; -} - - -bool getTokenValue(string const & str, const char * token, LyXAlignment & num) -{ - string tmp; - if (!getTokenValue(str, token, tmp)) - return false; - return string2type(tmp, num); -} - - -bool getTokenValue(string const & str, const char * token, - LyXTabular::VAlignment & num) -{ - string tmp; - if (!getTokenValue(str, token, tmp)) - return false; - return string2type(tmp, num); -} - - -bool getTokenValue(string const & str, const char * token, - LyXTabular::BoxType & num) -{ - string tmp; - if (!getTokenValue(str, token, tmp)) - return false; - return string2type(tmp, num); -} - - -bool getTokenValue(string const & str, const char * token, bool & flag) -{ - string tmp; - if (!getTokenValue(str, token, tmp)) - return false; - return string2type(tmp, flag); -} - - -inline -void l_getline(istream & is, string & str) -{ - str.erase(); - while (str.empty()) { - getline(is, str); - if (!str.empty() && str[str.length() - 1] == '\r') - str.erase(str.length() - 1); + // set firstheader info + if (fhr && fhr < rows_) { + if (row_info[fhr].endhead) { + while (fhr > 0) { + row_info[--fhr].endfirsthead = true; + row_info[fhr].endhead = false; + } + } else if (row_info[fhr - 1].endhead) { + endfirsthead.empty = true; + } else { + while (fhr > 0 && !row_info[--fhr].endhead) { + row_info[fhr].endfirsthead = true; + } + } + } + // set footer info + if (fr && fr < rows_) { + if (row_info[fr].endhead && row_info[fr-1].endhead) { + while (fr > 0 && !row_info[--fr].endhead) { + row_info[fr].endfoot = true; + row_info[fr].endhead = false; + } + } else if (row_info[fr].endfirsthead && row_info[fr-1].endfirsthead) { + while (fr > 0 && !row_info[--fr].endfirsthead) { + row_info[fr].endfoot = true; + row_info[fr].endfirsthead = false; + } + } else if (!row_info[fr - 1].endhead && !row_info[fr - 1].endfirsthead) { + while (fr > 0 && !row_info[--fr].endhead && + !row_info[fr].endfirsthead) + { + row_info[fr].endfoot = true; + } + } + } + // set lastfooter info + if (lfr && lfr < rows_) { + 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) + { + 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) { + 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) + { + while (lfr > 0 && + !row_info[--lfr].endhead && !row_info[lfr].endfirsthead && + !row_info[lfr].endfoot) + { + row_info[lfr].endlastfoot = true; + } + } else if (haveLTFoot()) { + endlastfoot.empty = true; + } } } -} // namespace anon - -void LyXTabular::Read(Buffer const * buf, LyXLex & lex) +void LyXTabular::read(Buffer const & buf, LyXLex & lex) { string line; istream & is = lex.getStream(); @@ -1312,52 +1303,66 @@ void LyXTabular::Read(Buffer const * buf, LyXLex & lex) l_getline(is, line); if (!prefixIs(line, "= 2); -void LyXTabular::ReadNew(Buffer const * buf, istream & is, - LyXLex & lex, string const & l) -{ - string line(l); int rows_arg; if (!getTokenValue(line, "rows", rows_arg)) return; 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, " got" << - line << ")" << endl; + lyxerr << "Wrong tabular format (expected got" + << line << ')' << endl; return; } getTokenValue(line, "rotate", rotate); getTokenValue(line, "islongtable", is_long_tabular); - getTokenValue(line, "endhead", endhead.row); - getTokenValue(line, "endfirsthead", endfirsthead.row); - getTokenValue(line, "endfoot", endfoot.row); - getTokenValue(line, "endlastfoot", endlastfoot.row); - endhead.row = abs(endhead.row); - endfirsthead.row = abs(endfirsthead.row); - endfoot.row = abs(endfoot.row); - endlastfoot.row = abs(endlastfoot.row); + // compatibility read for old longtable options. Now we can make any + // row part of the header/footer type we want before it was strict + // sequential from the first row down (as LaTeX does it!). So now when + // we find a header/footer line we have to go up the rows and set it + // on all preceding rows till the first or one with already a h/f option + // set. If we find a firstheader on the same line as a header or a + // lastfooter on the same line as a footer then this should be set empty. + // (Jug 20011220) + if (version < 3) { + int hrow; + int fhrow; + int frow; + int lfrow; + + getTokenValue(line, "endhead", hrow); + getTokenValue(line, "endfirsthead", fhrow); + getTokenValue(line, "endfoot", frow); + getTokenValue(line, "endlastfoot", lfrow); + setHeaderFooterRows(abs(hrow), abs(fhrow), abs(frow), abs(lfrow)); + } else { + getTokenValue(line, "firstHeadTopDL", endfirsthead.topDL); + getTokenValue(line, "firstHeadBottomDL", endfirsthead.bottomDL); + getTokenValue(line, "firstHeadEmpty", endfirsthead.empty); + getTokenValue(line, "headTopDL", endhead.topDL); + getTokenValue(line, "headBottomDL", endhead.bottomDL); + getTokenValue(line, "footTopDL", endfoot.topDL); + getTokenValue(line, "footBottomDL", endfoot.bottomDL); + getTokenValue(line, "lastFootTopDL", endlastfoot.topDL); + getTokenValue(line, "lastFootBottomDL", endlastfoot.bottomDL); + getTokenValue(line, "lastFootEmpty", endlastfoot.empty); + } for (int j = 0; j < columns_; ++j) { l_getline(is,line); if (!prefixIs(line," got" << - line << ")" << endl; + lyxerr << "Wrong tabular format (expected got" + << line << ')' << endl; return; } getTokenValue(line, "alignment", column_info[j].alignment); @@ -1371,295 +1376,86 @@ void LyXTabular::ReadNew(Buffer const * buf, istream & is, for (int i = 0; i < rows_; ++i) { l_getline(is, line); if (!prefixIs(line, " got" << - line << ")" << endl; + lyxerr << "Wrong tabular format (expected got" + << line << ')' << endl; return; } getTokenValue(line, "topline", row_info[i].top_line); getTokenValue(line, "bottomline", row_info[i].bottom_line); + getTokenValue(line, "endfirsthead", row_info[i].endfirsthead); + getTokenValue(line, "endhead", row_info[i].endhead); + getTokenValue(line, "endfoot", row_info[i].endfoot); + getTokenValue(line, "endlastfoot", row_info[i].endlastfoot); getTokenValue(line, "newpage", row_info[i].newpage); for (int j = 0; j < columns_; ++j) { l_getline(is, line); if (!prefixIs(line, " got" << - line << ")" << endl; + lyxerr << "Wrong tabular format (expected got" + << line << ')' << endl; return; } getTokenValue(line, "multicolumn", cell_info[i][j].multicolumn); getTokenValue(line, "alignment", cell_info[i][j].alignment); getTokenValue(line, "valignment", cell_info[i][j].valignment); - getTokenValue(line, "topline", cell_info[i][j].top_line); - getTokenValue(line, "bottomline", cell_info[i][j].bottom_line); - getTokenValue(line, "leftline", cell_info[i][j].left_line); - getTokenValue(line, "rightline", cell_info[i][j].right_line); - getTokenValue(line, "rotate", cell_info[i][j].rotate); - getTokenValue(line, "usebox", cell_info[i][j].usebox); - getTokenValue(line, "width", cell_info[i][j].p_width); - getTokenValue(line, "special", cell_info[i][j].align_special); - l_getline(is, line); - if (prefixIs(line, "\\begin_inset")) { - cell_info[i][j].inset.read(buf, lex); - l_getline(is, line); - } - if (!prefixIs(line, "")) { - lyxerr << "Wrong tabular format (expected got" << - line << ")" << endl; - return; - } - } - l_getline(is, line); - if (!prefixIs(line, "")) { - lyxerr << "Wrong tabular format (expected got" << - line << ")" << endl; - return; - } - } - while (!prefixIs(line, "")) { - l_getline(is, line); - } - set_row_column_number_info(); -} - - -void LyXTabular::OldFormatRead(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 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(rows_arg, columns_arg); - cont_row_info = vector(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(rows_arg, columns_arg); - cont_row_info = vector(rows_arg); - SetLongTabular(is_long_tabular_arg); - SetRotateTabular(rotate_arg); - endhead.row = a + 1; - endfirsthead.row = b + 1; - endfoot.row = c + 1; - endlastfoot.row = 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(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; -#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(a); - cell_info[i][j].alignment = static_cast(b); - cell_info[i][j].top_line = static_cast(c); - cell_info[i][j].bottom_line = static_cast(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(f); - cell_info[i][j].usebox = static_cast(g); - cell_info[i][j].align_special = s1; - cell_info[i][j].p_width = s2; - } - } - } - set_row_column_number_info(true); - - Paragraph * par = new Paragraph; - Paragraph * return_par = 0; - - 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" - || 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, font); -#endif - 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; + getTokenValue(line, "topline", cell_info[i][j].top_line); + getTokenValue(line, "bottomline", cell_info[i][j].bottom_line); + getTokenValue(line, "leftline", cell_info[i][j].left_line); + getTokenValue(line, "rightline", cell_info[i][j].right_line); + getTokenValue(line, "rotate", cell_info[i][j].rotate); + getTokenValue(line, "usebox", cell_info[i][j].usebox); + getTokenValue(line, "width", cell_info[i][j].p_width); + getTokenValue(line, "special", cell_info[i][j].align_special); + l_getline(is, line); + if (prefixIs(line, "\\begin_inset")) { + cell_info[i][j].inset.read(buf, lex); + l_getline(is, line); } - 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, ' '); + if (!prefixIs(line, "")) { + lyxerr << "Wrong tabular format (expected got" + << line << ')' << endl; + return; } } - par->copyIntoMinibuffer(*owner_->bufferOwner(), i); - inset->paragraph()->insertFromMinibuffer(inset->paragraph()->size()); + l_getline(is, line); + if (!prefixIs(line, "")) { + lyxerr << "Wrong tabular format (expected got" + << line << ')' << endl; + return; + } } - delete par; - Reinit(); + while (!prefixIs(line, "")) { + l_getline(is, line); + } + set_row_column_number_info(); } -bool LyXTabular::IsMultiColumn(int cell, bool real) const +bool LyXTabular::isMultiColumn(int cell, bool real) const { - return ((!real || (column_of_cell(cell) != right_column_of_cell(cell))) && - (cellinfo_of_cell(cell)->multicolumn != LyXTabular::CELL_NORMAL)); + return (!real || column_of_cell(cell) != right_column_of_cell(cell)) && + cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL; } -LyXTabular::cellstruct * LyXTabular::cellinfo_of_cell(int cell) const +LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(int cell) const { - int const row = row_of_cell(cell); - int const column = column_of_cell(cell); - return &cell_info[row][column]; + return cell_info[row_of_cell(cell)][column_of_cell(cell)]; } -void LyXTabular::SetMultiColumn(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)->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 = CELL_PART_OF_MULTICOLUMN; + cellstruct & cs = cellinfo_of_cell(cell); + cs.multicolumn = CELL_BEGIN_OF_MULTICOLUMN; + cs.alignment = column_info[column_of_cell(cell)].alignment; + cs.top_line = row_info[row_of_cell(cell)].top_line; + cs.bottom_line = row_info[row_of_cell(cell)].bottom_line; + cs.right_line = column_info[column_of_cell(cell+number-1)].right_line; + for (int i = 1; i < number; ++i) { + cellstruct & cs1 = cellinfo_of_cell(cell + i); + cs1.multicolumn = CELL_PART_OF_MULTICOLUMN; + cs.inset.appendParagraphs(buffer, cs1.inset.paragraphs); + cs1.inset.clear(false); } set_row_column_number_info(); } @@ -1671,7 +1467,7 @@ int LyXTabular::cells_in_multicolumn(int cell) const int column = column_of_cell(cell); int result = 1; ++column; - while ((column < columns_) && + while (column < columns_ && cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN) { ++result; @@ -1681,18 +1477,18 @@ int LyXTabular::cells_in_multicolumn(int cell) const } -int LyXTabular::UnsetMultiColumn(int cell) +int LyXTabular::unsetMultiColumn(int cell) { 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; - while ((column < columns_) && - (cell_info[row][column].multicolumn ==CELL_PART_OF_MULTICOLUMN)) + while (column < columns_ && + cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN) { cell_info[row][column].multicolumn = CELL_NORMAL; ++column; @@ -1704,65 +1500,63 @@ int LyXTabular::UnsetMultiColumn(int cell) } -void LyXTabular::SetLongTabular(bool what) +void LyXTabular::setLongTabular(bool what) { is_long_tabular = what; } -bool LyXTabular::IsLongTabular() const +bool LyXTabular::isLongTabular() const { return is_long_tabular; } -void LyXTabular::SetRotateTabular(bool flag) +void LyXTabular::setRotateTabular(bool flag) { rotate = flag; } -bool LyXTabular::GetRotateTabular() const +bool LyXTabular::getRotateTabular() const { return rotate; } -void LyXTabular::SetRotateCell(int cell, bool flag) +void LyXTabular::setRotateCell(int cell, bool flag) { - cellinfo_of_cell(cell)->rotate = flag; + cellinfo_of_cell(cell).rotate = flag; } -bool LyXTabular::GetRotateCell(int cell) const +bool LyXTabular::getRotateCell(int cell) const { - return cellinfo_of_cell(cell)->rotate; + return cellinfo_of_cell(cell).rotate; } -bool LyXTabular::NeedRotating() const +bool LyXTabular::needRotating() const { if (rotate) return true; - for (int i = 0; i < rows_; ++i) { - for (int j = 0; j < columns_; ++j) { + for (int i = 0; i < rows_; ++i) + for (int j = 0; j < columns_; ++j) if (cell_info[i][j].rotate) return true; - } - } return false; } -bool LyXTabular::IsLastCell(int cell) const +bool LyXTabular::isLastCell(int cell) const { - if ((cell + 1) < numberofcells) + if (cell + 1 < numberofcells) return false; return true; } -int LyXTabular::GetCellAbove(int cell) const +int LyXTabular::getCellAbove(int cell) const { if (row_of_cell(cell) > 0) return cell_info[row_of_cell(cell)-1][column_of_cell(cell)].cellno; @@ -1770,7 +1564,7 @@ int LyXTabular::GetCellAbove(int cell) const } -int LyXTabular::GetCellBelow(int cell) 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; @@ -1778,147 +1572,184 @@ int LyXTabular::GetCellBelow(int cell) const } -int LyXTabular::GetLastCellAbove(int cell) const +int LyXTabular::getLastCellAbove(int cell) const { if (row_of_cell(cell) <= 0) return cell; - if (!IsMultiColumn(cell)) - return GetCellAbove(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 +int LyXTabular::getLastCellBelow(int cell) const { if (row_of_cell(cell) + 1 >= rows_) return cell; - if (!IsMultiColumn(cell)) - return GetCellBelow(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 +int LyXTabular::getCellNumber(int row, int column) const { -#if 0 - if (column >= columns_) - column = columns_ - 1; - else if (column < 0) - column = 0; - if (row >= rows_) - row = rows_ - 1; - else if (row < 0) - row = 0; -#else - lyx::Assert(column >= 0 || column < columns_ || row >= 0 || row < rows_); -#endif + Assert(column >= 0 || column < columns_ || row >= 0 || row < rows_); return cell_info[row][column].cellno; } -void LyXTabular::SetUsebox(int cell, BoxType type) +void LyXTabular::setUsebox(int cell, BoxType type) { - cellinfo_of_cell(cell)->usebox = type; + cellinfo_of_cell(cell).usebox = type; } -LyXTabular::BoxType LyXTabular::GetUsebox(int cell) const +LyXTabular::BoxType LyXTabular::getUsebox(int cell) const { - if (column_info[column_of_cell(cell)].p_width.empty() && - !(IsMultiColumn(cell) && !cellinfo_of_cell(cell)->p_width.empty())) + if (column_info[column_of_cell(cell)].p_width.zero() && + !(isMultiColumn(cell) && !cellinfo_of_cell(cell).p_width.zero())) return BOX_NONE; - if (cellinfo_of_cell(cell)->usebox > 1) - return cellinfo_of_cell(cell)->usebox; - return UseParbox(cell); -} - -bool LyXTabular::checkLTType(int row, ltType const & ltt) const -{ - if (!ltt.row || (ltt.row > rows_)) - return false; - return (row == (ltt.row - 1)); + if (cellinfo_of_cell(cell).usebox > 1) + return cellinfo_of_cell(cell).usebox; + return useParbox(cell); } -void LyXTabular::SetLTHead(ltType const & hd, bool first) +/// +// This are functions used for the longtable support +/// +void LyXTabular::setLTHead(int row, bool flag, ltType const & hd, bool first) { if (first) { endfirsthead = hd; + if (hd.set) + row_info[row].endfirsthead = flag; } else { endhead = hd; + if (hd.set) + row_info[row].endhead = flag; } } -bool LyXTabular::GetRowOfLTHead(int row, ltType & hd) const +bool LyXTabular::getRowOfLTHead(int row, ltType & hd) const { hd = endhead; - return checkLTType(row, hd); + hd.set = haveLTHead(); + return row_info[row].endhead; } -bool LyXTabular::GetRowOfLTFirstHead(int row, ltType & hd) const +bool LyXTabular::getRowOfLTFirstHead(int row, ltType & hd) const { hd = endfirsthead; - return checkLTType(row, hd); + hd.set = haveLTFirstHead(); + return row_info[row].endfirsthead; } -void LyXTabular::SetLTFoot(ltType const & fd, bool last) +void LyXTabular::setLTFoot(int row, bool flag, ltType const & fd, bool last) { if (last) { endlastfoot = fd; + if (fd.set) + row_info[row].endlastfoot = flag; } else { endfoot = fd; + if (fd.set) + row_info[row].endfoot = flag; } } -bool LyXTabular::GetRowOfLTFoot(int row, ltType & fd) const +bool LyXTabular::getRowOfLTFoot(int row, ltType & fd) const { fd = endfoot; - return checkLTType(row, fd); + fd.set = haveLTFoot(); + return row_info[row].endfoot; } -bool LyXTabular::GetRowOfLTLastFoot(int row, ltType & fd) const +bool LyXTabular::getRowOfLTLastFoot(int row, ltType & fd) const { fd = endlastfoot; - return checkLTType(row, fd); + fd.set = haveLTLastFoot(); + return row_info[row].endlastfoot; +} + + +void LyXTabular::setLTNewPage(int row, bool what) +{ + row_info[row].newpage = what; } -void LyXTabular::SetLTNewPage(int cell, bool what) +bool LyXTabular::getLTNewPage(int row) const { - row_info[row_of_cell(cell)].newpage = what; + return row_info[row].newpage; } -bool LyXTabular::GetLTNewPage(int cell) const +bool LyXTabular::haveLTHead() const { - return row_info[row_of_cell(cell)].newpage; + for (int i = 0; i < rows_; ++i) + if (row_info[i].endhead) + return true; + return false; } -bool LyXTabular::SetAscentOfRow(int row, int height) +bool LyXTabular::haveLTFirstHead() const { - if ((row >= rows_) || (row_info[row].ascent_of_row == height)) + if (endfirsthead.empty) return false; - row_info[row].ascent_of_row = height; - return true; + for (int i = 0; i < rows_; ++i) + if (row_info[i].endfirsthead) + return true; + return false; +} + + +bool LyXTabular::haveLTFoot() const +{ + for (int i = 0; i < rows_; ++i) + if (row_info[i].endfoot) + return true; + return false; } -bool LyXTabular::SetDescentOfRow(int row, int height) +bool LyXTabular::haveLTLastFoot() const { - if ((row >= rows_) || (row_info[row].descent_of_row == height)) + if (endlastfoot.empty) return false; + for (int i = 0; i < rows_; ++i) + if (row_info[i].endlastfoot) + return true; + return false; +} + + +// end longtable support functions + +void LyXTabular::setAscentOfRow(int row, int height) +{ + if (row >= rows_ || row_info[row].ascent_of_row == height) + return; + row_info[row].ascent_of_row = height; +} + + +void LyXTabular::setDescentOfRow(int row, int height) +{ + if (row >= rows_ || row_info[row].descent_of_row == height) + return; row_info[row].descent_of_row = height; - return true; } -int LyXTabular::GetAscentOfRow(int row) const +int LyXTabular::getAscentOfRow(int row) const { if (row >= rows_) return 0; @@ -1926,7 +1757,7 @@ int LyXTabular::GetAscentOfRow(int row) const } -int LyXTabular::GetDescentOfRow(int row) const +int LyXTabular::getDescentOfRow(int row) const { if (row >= rows_) return 0; @@ -1934,43 +1765,42 @@ int LyXTabular::GetDescentOfRow(int row) const } -int LyXTabular::GetHeightOfTabular() const +int LyXTabular::getHeightOfTabular() const { int height = 0; - for (int row = 0; row < rows_; ++row) - height += GetAscentOfRow(row) + GetDescentOfRow(row) + - GetAdditionalHeight(row); + height += getAscentOfRow(row) + getDescentOfRow(row) + + getAdditionalHeight(row); return height; } -bool LyXTabular::IsPartOfMultiColumn(int row, int column) const +bool LyXTabular::isPartOfMultiColumn(int row, int column) const { - if ((row >= rows_) || (column >= columns_)) + if (row >= rows_ || column >= columns_) return false; - return (cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN); + return cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN; } int LyXTabular::TeXTopHLine(ostream & os, int row) const { - if ((row < 0) || (row >= rows_)) + if (row < 0 || row >= rows_) return 0; - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; + int const fcell = getFirstCellInRow(row); + int const n = numberOfCellsInRow(fcell) + fcell; int tmp = 0; for (int i = fcell; i < n; ++i) { - if (TopLine(i)) + if (topLine(i)) ++tmp; } - if (tmp == (n - fcell)){ + if (tmp == n - fcell) { os << "\\hline "; } else if (tmp) { for (int i = fcell; i < n; ++i) { - if (TopLine(i)) { + if (topLine(i)) { os << "\\cline{" << column_of_cell(i) + 1 << '-' @@ -1988,22 +1818,22 @@ int LyXTabular::TeXTopHLine(ostream & os, int row) const int LyXTabular::TeXBottomHLine(ostream & os, int row) const { - if ((row < 0) || (row >= rows_)) + if (row < 0 || row >= rows_) return 0; - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; + int const fcell = getFirstCellInRow(row); + int const n = numberOfCellsInRow(fcell) + fcell; int tmp = 0; for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) + if (bottomLine(i)) ++tmp; } - if (tmp == (n-fcell)){ + if (tmp == n - fcell) { os << "\\hline"; } else if (tmp) { for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) { + if (bottomLine(i)) { os << "\\cline{" << column_of_cell(i) + 1 << '-' @@ -2023,37 +1853,39 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const { int ret = 0; - if (GetRotateCell(cell)) { + if (getRotateCell(cell)) { os << "\\begin{sideways}\n"; ++ret; } - if (IsMultiColumn(cell)) { + if (isMultiColumn(cell)) { os << "\\multicolumn{" << cells_in_multicolumn(cell) << "}{"; - if (!cellinfo_of_cell(cell)->align_special.empty()) { - os << cellinfo_of_cell(cell)->align_special << "}{"; + if (!cellinfo_of_cell(cell).align_special.empty()) { + os << cellinfo_of_cell(cell).align_special << "}{"; } else { - if (LeftLine(cell) && - (IsFirstCellInRow(cell) || - (!IsMultiColumn(cell-1) && !LeftLine(cell, true) && - !RightLine(cell-1, true)))) + if (leftLine(cell) && + (isFirstCellInRow(cell) || + (!isMultiColumn(cell - 1) && !leftLine(cell, true) && + !rightLine(cell - 1, true)))) { os << '|'; } - if (!GetPWidth(cell).empty()) { - switch (GetVAlignment(cell)) { + if (!getPWidth(cell).zero()) { + switch (getVAlignment(cell)) { case LYX_VALIGN_TOP: - os << "p"; + os << 'p'; break; - case LYX_VALIGN_CENTER: - os << "m"; + case LYX_VALIGN_MIDDLE: + os << 'm'; break; case LYX_VALIGN_BOTTOM: - os << "b"; + os << 'b'; break; } - os << "{" << GetPWidth(cell) << '}'; + os << '{' + << getPWidth(cell).asLatexString() + << '}'; } else { - switch (GetAlignment(cell)) { + switch (getAlignment(cell)) { case LYX_ALIGN_LEFT: os << 'l'; break; @@ -2065,42 +1897,42 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const break; } } - if (RightLine(cell)) + if (rightLine(cell)) os << '|'; - if (((cell + 1) < numberofcells) && !IsFirstCellInRow(cell+1) && - LeftLine(cell+1)) + if (((cell + 1) < numberofcells) && !isFirstCellInRow(cell+1) && + leftLine(cell+1)) os << '|'; os << "}{"; } } - if (GetUsebox(cell) == BOX_PARBOX) { + if (getUsebox(cell) == BOX_PARBOX) { os << "\\parbox["; - switch (GetVAlignment(cell)) { + switch (getVAlignment(cell)) { case LYX_VALIGN_TOP: - os << "t"; + os << 't'; break; - case LYX_VALIGN_CENTER: - os << "c"; + case LYX_VALIGN_MIDDLE: + os << 'c'; break; case LYX_VALIGN_BOTTOM: - os << "b"; + os << 'b'; break; } - os << "]{" << GetPWidth(cell) << "}{"; - } else if (GetUsebox(cell) == BOX_MINIPAGE) { + os << "]{" << getPWidth(cell).asLatexString() << "}{"; + } else if (getUsebox(cell) == BOX_MINIPAGE) { os << "\\begin{minipage}["; - switch (GetVAlignment(cell)) { + switch (getVAlignment(cell)) { case LYX_VALIGN_TOP: - os << "t"; + os << 't'; break; - case LYX_VALIGN_CENTER: - os << "m"; + case LYX_VALIGN_MIDDLE: + os << 'm'; break; case LYX_VALIGN_BOTTOM: - os << "b"; + os << 'b'; break; } - os << "]{" << GetPWidth(cell) << "}\n"; + os << "]{" << getPWidth(cell).asLatexString() << "}\n"; ++ret; } return ret; @@ -2112,16 +1944,16 @@ int LyXTabular::TeXCellPostamble(ostream & os, int cell) const int ret = 0; // usual cells - if (GetUsebox(cell) == BOX_PARBOX) - os << "}"; - else if (GetUsebox(cell) == BOX_MINIPAGE) { + if (getUsebox(cell) == BOX_PARBOX) + os << '}'; + else if (getUsebox(cell) == BOX_MINIPAGE) { os << "%\n\\end{minipage}"; ret += 2; } - if (IsMultiColumn(cell)){ + if (isMultiColumn(cell)) { os << '}'; } - if (GetRotateCell(cell)) { + if (getRotateCell(cell)) { os << "%\n\\end{sideways}"; ++ret; } @@ -2129,11 +1961,146 @@ int LyXTabular::TeXCellPostamble(ostream & os, int cell) const } -int LyXTabular::Latex(Buffer const * buf, - ostream & os, bool fragile, bool fp) const +int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, + LatexRunParams const & runparams) const +{ + if (!is_long_tabular) + return 0; + + int ret = 0; + // output header info + if (haveLTHead()) { + if (endhead.topDL) { + os << "\\hline\n"; + ++ret; + } + for (int i = 0; i < rows_; ++i) { + if (row_info[i].endhead) { + ret += TeXRow(os, i, buf, runparams); + } + } + if (endhead.bottomDL) { + os << "\\hline\n"; + ++ret; + } + os << "\\endhead\n"; + ++ret; + if (endfirsthead.empty) { + os << "\\endfirsthead\n"; + ++ret; + } + } + // output firstheader info + if (haveLTFirstHead()) { + if (endfirsthead.topDL) { + os << "\\hline\n"; + ++ret; + } + for (int i = 0; i < rows_; ++i) { + if (row_info[i].endfirsthead) { + ret += TeXRow(os, i, buf, runparams); + } + } + if (endfirsthead.bottomDL) { + os << "\\hline\n"; + ++ret; + } + os << "\\endfirsthead\n"; + ++ret; + } + // output footer info + if (haveLTFoot()) { + if (endfoot.topDL) { + os << "\\hline\n"; + ++ret; + } + for (int i = 0; i < rows_; ++i) { + if (row_info[i].endfoot) { + ret += TeXRow(os, i, buf, runparams); + } + } + if (endfoot.bottomDL) { + os << "\\hline\n"; + ++ret; + } + os << "\\endfoot\n"; + ++ret; + if (endlastfoot.empty) { + os << "\\endlastfoot\n"; + ++ret; + } + } + // output lastfooter info + if (haveLTLastFoot()) { + if (endlastfoot.topDL) { + os << "\\hline\n"; + ++ret; + } + for (int i = 0; i < rows_; ++i) { + if (row_info[i].endlastfoot) { + ret += TeXRow(os, i, buf, runparams); + } + } + if (endlastfoot.bottomDL) { + os << "\\hline\n"; + ++ret; + } + os << "\\endlastfoot\n"; + ++ret; + } + return ret; +} + + +bool LyXTabular::isValidRow(int const row) const +{ + if (!is_long_tabular) + return true; + return (!row_info[row].endhead && !row_info[row].endfirsthead && + !row_info[row].endfoot && !row_info[row].endlastfoot); +} + + +int LyXTabular::TeXRow(ostream & os, int const i, Buffer const & buf, + LatexRunParams const & runparams) const +{ + int ret = 0; + int cell = getCellNumber(i, 0); + + ret += TeXTopHLine(os, i); + for (int j = 0; j < columns_; ++j) { + if (isPartOfMultiColumn(i, j)) + continue; + ret += TeXCellPreamble(os, cell); + InsetText & inset = getCellInset(cell); + + bool rtl = inset.paragraphs.begin()->isRightToLeftPar(buf.params) && + !inset.paragraphs.begin()->empty() && getPWidth(cell).zero(); + + if (rtl) + os << "\\R{"; + ret += inset.latex(buf, os, runparams); + if (rtl) + os << '}'; + + ret += TeXCellPostamble(os, cell); + if (!isLastCellInRow(cell)) { // not last cell in row + os << "&\n"; + ++ret; + } + ++cell; + } + os << "\\tabularnewline\n"; + ++ret; + ret += TeXBottomHLine(os, i); + return ret; +} + + +int LyXTabular::latex(Buffer const & buf, ostream & os, + LatexRunParams const & runparams) const { int ret = 0; - int cell = 0; //+--------------------------------------------------------------------- //+ first the opening preamble + @@ -2150,23 +2117,40 @@ int LyXTabular::Latex(Buffer const * buf, 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.empty()) { + 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"; + case LYX_VALIGN_MIDDLE: + os << 'm'; break; case LYX_VALIGN_BOTTOM: - os << "b"; + os << 'b'; break; } - os << "{" - << column_info[i].p_width + os << '{' + << column_info[i].p_width.asLatexString() << '}'; } else { switch (column_info[i].alignment) { @@ -2174,8 +2158,8 @@ int LyXTabular::Latex(Buffer const * buf, os << 'l'; break; case LYX_ALIGN_RIGHT: - os << 'r'; - break; + os << 'r'; + break; default: os << 'c'; break; @@ -2188,70 +2172,16 @@ int LyXTabular::Latex(Buffer const * buf, os << "}\n"; ++ret; + ret += TeXLongtableHeaderFooter(os, buf, runparams); + //+--------------------------------------------------------------------- //+ the single row and columns (cells) + //+--------------------------------------------------------------------- for (int i = 0; i < rows_; ++i) { - ret += TeXTopHLine(os, i); -#warning Implement top double lines for LT Header/Footers -#if 0 - if (ret > bret) { - ret += TeXBottomHLine(os, i-1); - ret += TeXTopHLine(os, i); - } -#endif - for (int j = 0; j < columns_; ++j) { - if (IsPartOfMultiColumn(i,j)) - continue; - ret += TeXCellPreamble(os, cell); - InsetText * inset = GetCellInset(cell); - - bool rtl = inset->paragraph()->isRightToLeftPar(buf->params) && - inset->paragraph()->size() > 0 && GetPWidth(cell).empty(); - - if (rtl) - os << "\\R{"; - ret += inset->latex(buf, os, fragile, fp); - if (rtl) - os << "}"; - - ret += TeXCellPostamble(os, cell); - if (!IsLastCellInRow(cell)) { // not last cell in row - os << "&\n"; - ++ret; - } - ++cell; - } - os << "\\\\\n"; - ++ret; - ret += TeXBottomHLine(os, i); - if (IsLongTabular()) { - if (i == (endhead.row - 1)) { - if (endhead.bottomDL) - ret += TeXBottomHLine(os, i); - os << "\\endhead\n"; - ++ret; - } - if (i == (endfirsthead.row - 1)) { - if (endfirsthead.bottomDL) - ret += TeXBottomHLine(os, i); - os << "\\endfirsthead\n"; - ++ret; - } - if (i == (endfoot.row - 1)) { - if (endfoot.bottomDL) - ret += TeXBottomHLine(os, i); - os << "\\endfoot\n"; - ++ret; - } - if (i == (endlastfoot.row - 1)) { - if (endlastfoot.bottomDL) - ret += TeXBottomHLine(os, i); - os << "\\endlastfoot\n"; - ++ret; - } - if (row_info[i].newpage) { + if (isValidRow(i)) { + ret += TeXRow(os, i, buf, runparams); + if (is_long_tabular && row_info[i].newpage) { os << "\\newpage\n"; ++ret; } @@ -2275,18 +2205,59 @@ int LyXTabular::Latex(Buffer const * buf, } -int LyXTabular::docbookRow(Buffer const * buf, ostream & os, int row) const +int LyXTabular::linuxdoc(Buffer const & buf, ostream & os) const +{ + os << "\n"; + int cell = 0; + int ret = 0; + for (int i = 0; i < rows_; ++i) { + for (int j = 0; j < columns_; ++j) { + if (isPartOfMultiColumn(i, j)) + continue; + InsetText & inset = getCellInset(cell); + + ret += inset.linuxdoc(buf, os); + + if (isLastCellInRow(cell)) { + os << "@\n"; + ++ret; + } else { + os << "|"; + } + ++cell; + } + } + os << "\n"; + return ret; +} + + +int LyXTabular::docbookRow(Buffer const & buf, ostream & os, int row) const { int ret = 0; - int cell = GetFirstCellInRow(row); - + int cell = getFirstCellInRow(row); + os << "\n"; for (int j = 0; j < columns_; ++j) { - if (IsPartOfMultiColumn(row, j)) + if (isPartOfMultiColumn(row, j)) continue; os << ""; - ret += GetCellInset(cell)->docbook(buf, os); + os << '>'; + ret += getCellInset(cell).docbook(buf, os, true); os << "\n"; ++cell; } os << "\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; @@ -2336,7 +2308,7 @@ int LyXTabular::DocBook(Buffer const * buf, ostream & os) const os << "\n"; - + for (int i = 0; i < columns_; ++i) { os << "\n"; - if( endfirsthead.row ) { - docbookRow( buf, os, endfirsthead.row - 1); - } - if( endhead.row && endhead.row != endfirsthead.row) { - docbookRow(buf, os, endhead.row - 1); + // output header info + if (haveLTHead() || haveLTFirstHead()) { + os << "\n"; + ++ret; + for (int i = 0; i < rows_; ++i) { + if (row_info[i].endhead || row_info[i].endfirsthead) { + ret += docbookRow(buf, os, i); } - os << "\n"; } - - // Footer - if( endfoot.row || endlastfoot.row ) { - os << "\n"; - if( endfoot.row ) { - docbookRow( buf, os, endfoot.row - 1); - } - if( endlastfoot.row && endlastfoot.row != endfoot.row) { - docbookRow( buf, os, endlastfoot.row - 1); + os << "\n"; + ++ret; + } + // output footer info + if (haveLTFoot() || haveLTLastFoot()) { + os << "\n"; + ++ret; + for (int i = 0; i < rows_; ++i) { + if (row_info[i].endfoot || row_info[i].endlastfoot) { + ret += docbookRow(buf, os, i); } - os << "\n"; } + os << "\n"; + ++ret; } + //+--------------------------------------------------------------------- //+ the single row and columns (cells) + //+--------------------------------------------------------------------- os << "\n"; + ++ret; for (int i = 0; i < rows_; ++i) { - if(!IsLongTabular() || ( - i != endhead.row - 1 && i != endfirsthead.row - 1 && - i != endfoot.row - 1 && i != endlastfoot.row - 1)) { - docbookRow( buf, os, i); + if (isValidRow(i)) { + ret += docbookRow(buf, os, i); } } os << "\n"; + ++ret; //+--------------------------------------------------------------------- //+ the closing of the tabular + //+--------------------------------------------------------------------- @@ -2407,26 +2379,15 @@ int LyXTabular::DocBook(Buffer const * buf, ostream & os) const } -namespace { - - inline - void print_n_chars(ostream & os, unsigned char ch, int n) - { - os << string(n, ch); - } - -} // namespace anon - - -int LyXTabular::AsciiTopHLine(ostream & os, int row, - vector const & clen) const +int LyXTabular::asciiTopHLine(ostream & os, int row, + vector const & clen) const { - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; + int const fcell = getFirstCellInRow(row); + int const n = numberOfCellsInRow(fcell) + fcell; int tmp = 0; for (int i = fcell; i < n; ++i) { - if (TopLine(i)) { + if (topLine(i)) { ++tmp; break; } @@ -2436,8 +2397,8 @@ int LyXTabular::AsciiTopHLine(ostream & os, int row, unsigned char ch; for (int i = fcell; i < n; ++i) { - if (TopLine(i)) { - if (LeftLine(i)) + if (topLine(i)) { + if (leftLine(i)) os << "+-"; else os << "--"; @@ -2448,11 +2409,11 @@ int LyXTabular::AsciiTopHLine(ostream & os, int row, } int column = column_of_cell(i); int len = clen[column]; - while(IsPartOfMultiColumn(row, ++column)) + while (isPartOfMultiColumn(row, ++column)) len += clen[column] + 4; - print_n_chars(os, ch, len); - if (TopLine(i)) { - if (RightLine(i)) + os << string(len, ch); + if (topLine(i)) { + if (rightLine(i)) os << "-+"; else os << "--"; @@ -2465,15 +2426,15 @@ int LyXTabular::AsciiTopHLine(ostream & os, int row, } -int LyXTabular::AsciiBottomHLine(ostream & os, int row, - vector const & clen) const +int LyXTabular::asciiBottomHLine(ostream & os, int row, + vector const & clen) const { - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; + int const fcell = getFirstCellInRow(row); + int const n = numberOfCellsInRow(fcell) + fcell; int tmp = 0; for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) { + if (bottomLine(i)) { ++tmp; break; } @@ -2483,8 +2444,8 @@ int LyXTabular::AsciiBottomHLine(ostream & os, int row, unsigned char ch; for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) { - if (LeftLine(i)) + if (bottomLine(i)) { + if (leftLine(i)) os << "+-"; else os << "--"; @@ -2495,11 +2456,11 @@ int LyXTabular::AsciiBottomHLine(ostream & os, int row, } int column = column_of_cell(i); int len = clen[column]; - while(IsPartOfMultiColumn(row, ++column)) + while (isPartOfMultiColumn(row, ++column)) len += clen[column] + 4; - print_n_chars(os, ch, len); - if (BottomLine(i)) { - if (RightLine(i)) + os << string(len, ch); + if (bottomLine(i)) { + if (rightLine(i)) os << "-+"; else os << "--"; @@ -2512,25 +2473,31 @@ int LyXTabular::AsciiBottomHLine(ostream & os, int row, } -int LyXTabular::AsciiPrintCell(Buffer const * buf, ostream & os, - int cell, int row, int column, - vector const & clen) const +int LyXTabular::asciiPrintCell(Buffer const & buf, ostream & os, + int cell, int row, int column, + vector const & clen, + bool onlydata) const { ostringstream sstr; - int ret = GetCellInset(cell)->ascii(buf, sstr, 0); + int ret = getCellInset(cell).ascii(buf, sstr, 0); + + if (onlydata) { + os << sstr.str(); + return ret; + } - if (LeftLine(cell)) + if (leftLine(cell)) os << "| "; else os << " "; unsigned int len1 = sstr.str().length(); unsigned int len2 = clen[column]; - while(IsPartOfMultiColumn(row, ++column)) + while (isPartOfMultiColumn(row, ++column)) len2 += clen[column] + 4; len2 -= len1; - switch (GetAlignment(cell)) { + switch (getAlignment(cell)) { default: case LYX_ALIGN_LEFT: len1 = 0; @@ -2545,12 +2512,9 @@ int LyXTabular::AsciiPrintCell(Buffer const * buf, ostream & os, break; } - for (unsigned int i = 0; i < len1; ++i) - os << " "; - os << sstr.str(); - for (unsigned int i = 0; i < len2; ++i) - os << " "; - if (RightLine(cell)) + os << string(len1, ' ') << sstr.str() << string(len2, ' '); + + if (rightLine(cell)) os << " |"; else os << " "; @@ -2559,111 +2523,157 @@ int LyXTabular::AsciiPrintCell(Buffer const * buf, ostream & os, } -int LyXTabular::Ascii(Buffer const * buf, ostream & os) const +int LyXTabular::ascii(Buffer const & buf, ostream & os, int const depth, + bool onlydata, unsigned char delim) const { int ret = 0; - //+--------------------------------------------------------------------- - //+ first calculate the width of the single columns + - //+--------------------------------------------------------------------- + // first calculate the width of the single columns vector clen(columns_); - // first all non (real) multicolumn cells! - for (int j = 0; j < columns_; ++j) { - clen[j] = 0; - for (int i = 0; i < rows_; ++i) { - int cell = GetCellNumber(i, j); - if (IsMultiColumn(cell, true)) - continue; - ostringstream sstr; - GetCellInset(cell)->ascii(buf, sstr, 0); - if (clen[j] < sstr.str().length()) - clen[j] = sstr.str().length(); + if (!onlydata) { + // first all non (real) multicolumn cells! + for (int j = 0; j < columns_; ++j) { + clen[j] = 0; + for (int i = 0; i < rows_; ++i) { + int cell = getCellNumber(i, j); + if (isMultiColumn(cell, true)) + continue; + ostringstream sstr; + getCellInset(cell).ascii(buf, sstr, 0); + if (clen[j] < sstr.str().length()) + clen[j] = sstr.str().length(); + } } - } - // then all (real) multicolumn cells! - for (int j = 0; j < columns_; ++j) { - for (int i = 0; i < rows_; ++i) { - int cell = GetCellNumber(i, j); - if (!IsMultiColumn(cell, true) || IsPartOfMultiColumn(i, j)) - continue; - ostringstream sstr; - GetCellInset(cell)->ascii(buf, sstr, 0); - int len = int(sstr.str().length()); - int const n = cells_in_multicolumn(cell); - for (int k = j; (len > 0) && (k < (j + n - 1)); ++k) - len -= clen[k]; - if (len > int(clen[j + n - 1])) - clen[j + n - 1] = len; + // then all (real) multicolumn cells! + for (int j = 0; j < columns_; ++j) { + for (int i = 0; i < rows_; ++i) { + int cell = getCellNumber(i, j); + if (!isMultiColumn(cell, true) || isPartOfMultiColumn(i, j)) + continue; + ostringstream sstr; + getCellInset(cell).ascii(buf, sstr, 0); + int len = int(sstr.str().length()); + int const n = cells_in_multicolumn(cell); + for (int k = j; len > 0 && k < j + n - 1; ++k) + len -= clen[k]; + if (len > int(clen[j + n - 1])) + clen[j + n - 1] = len; + } } } int cell = 0; for (int i = 0; i < rows_; ++i) { - AsciiTopHLine(os, i, clen); + if (!onlydata && asciiTopHLine(os, i, clen)) + for (int j = 0; j < depth; ++j) + os << " "; for (int j = 0; j < columns_; ++j) { - if (IsPartOfMultiColumn(i,j)) + if (isPartOfMultiColumn(i, j)) continue; - ret += AsciiPrintCell(buf, os, cell, i, j, clen); + if (onlydata && j > 0) + os << delim; + ret += asciiPrintCell(buf, os, cell, i, j, clen, onlydata); ++cell; } os << endl; - AsciiBottomHLine(os, i, clen); + if (!onlydata) { + for (int j = 0; j < depth; ++j) + os << " "; + if (asciiBottomHLine(os, i, clen)) + for (int j = 0; j < depth; ++j) + os << " "; + } } return ret; } -InsetText * LyXTabular::GetCellInset(int cell) const +InsetText & LyXTabular::getCellInset(int cell) const { cur_cell = cell; - return & cell_info[row_of_cell(cell)][column_of_cell(cell)].inset; + return cell_info[row_of_cell(cell)][column_of_cell(cell)].inset; +} + + +InsetText & LyXTabular::getCellInset(int row, int column) const +{ + cur_cell = getCellNumber(row, column); + return cell_info[row][column].inset; } -InsetText * LyXTabular::GetCellInset(int row, int column) const +int LyXTabular::getCellFromInset(InsetOld const * inset, int maybe_cell) const { - cur_cell = GetCellNumber(row, column); - return & cell_info[row][column].inset; + // is this inset part of the tabular? + if (!inset || inset->owner() != owner_) { + lyxerr << "Error: 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 = maybe_cell; + if (cell == -1 || &getCellInset(cell) != inset) + cell = -1; + } + + if (cell == -1) { + for (cell = getNumberOfCells(); cell >= 0; --cell) + if (&getCellInset(cell) == inset) + break; + + lyxerr[Debug::INSETTEXT] + << "LyXTabular::getCellFromInset: " + << "cell=" << cell + << ", cur_cell=" << save_cur_cell + << ", maybe_cell=" << maybe_cell + << endl; + // We should have found a cell at this point + if (cell == -1) { + lyxerr << "LyXTabular::getCellFromInset: " + << "Cell not found!" << endl; + } + } + + return cell; } -void LyXTabular::Validate(LaTeXFeatures & features) const +void LyXTabular::validate(LaTeXFeatures & features) const { - if (IsLongTabular()) + features.require("NeedTabularnewline"); + if (isLongTabular()) features.require("longtable"); - if (NeedRotating()) + if (needRotating()) features.require("rotating"); - for (int cell = 0; !features.isRequired("array") && (cell < numberofcells); ++cell) { - if (GetVAlignment(cell) != LYX_VALIGN_TOP) + for (int cell = 0; cell < numberofcells; ++cell) { + if (getVAlignment(cell) != LYX_VALIGN_TOP || + (!getPWidth(cell).zero() && !isMultiColumn(cell))) features.require("array"); - GetCellInset(cell)->validate(features); + getCellInset(cell).validate(features); } } -std::vector const LyXTabular::getLabelList() const +void LyXTabular::getLabelList(std::vector & list) const { - std::vector label_list; for (int i = 0; i < rows_; ++i) - for (int j = 0; j < columns_; ++j) { - std::vector const l = - GetCellInset(i, j)->getLabelList(); - label_list.insert(label_list.end(), - l.begin(), l.end()); - } - return label_list; + for (int j = 0; j < columns_; ++j) + getCellInset(i, j).getLabelList(list); } - -LyXTabular::BoxType LyXTabular::UseParbox(int cell) const + +LyXTabular::BoxType LyXTabular::useParbox(int cell) const { - Paragraph * par = GetCellInset(cell)->paragraph(); + ParagraphList const & parlist = getCellInset(cell).paragraphs; + ParagraphList::const_iterator cit = parlist.begin(); + ParagraphList::const_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; - } - } + return BOX_NONE; }