X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftabular.C;h=239c1ff65be9281f7f77139172c3f948b78007ca;hb=3ef684e752bb5afdbfdea51d4c3df4afe1461916;hp=296288fc1113b6bf276c0853ea9785c962ac53dc;hpb=e1940902fe50ec523fe540f6e11f2ee4045cdfac;p=lyx.git diff --git a/src/tabular.C b/src/tabular.C index 296288fc11..239c1ff65b 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -1,392 +1,623 @@ -/* This file is part of - * ====================================================== +/** + * \file tabular.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \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 * - * Copyright 2000-2002 The LyX Team. - * - * @author: Jürgen Vigna - * - * ====================================================== + * Full author contact details are available in file CREDITS. */ #include -// temporary until verified (08/08/2001 Jug) -#define SPECIAL_COLUM_HANDLING 1 - #include "tabular.h" -#include "debug.h" -#include "vspace.h" -#include "layout.h" + #include "buffer.h" +#include "bufferparams.h" #include "BufferView.h" -#include "frontends/Painter.h" +#include "cursor.h" +#include "debug.h" #include "LaTeXFeatures.h" +#include "lyxlex.h" +#include "outputparams.h" +#include "paragraph.h" +#include "paragraph_funcs.h" + #include "insets/insettabular.h" -#include "insets/insettext.h" + #include "support/lstrings.h" -#include "support/lyxmanip.h" -#include "support/LAssert.h" -#include "frontends/Alert.h" -#include "gettext.h" -#include "Lsstream.h" -#include "tabular_funcs.h" -#include "lyxlex.h" +#include "support/convert.h" + +#include + -#include -#include +namespace lyx { + +using support::prefixIs; +using support::ltrim; +using support::rtrim; +using support::suffixIs; + +using boost::shared_ptr; +using boost::dynamic_pointer_cast; using std::abs; -using std::ostream; -using std::istream; +using std::endl; using std::getline; using std::max; -using std::endl; + +using std::istream; +using std::ostream; +using std::ostringstream; using std::vector; +using std::string; #ifndef CXX_GLOBAL_CSTD using std::strlen; #endif + namespace { - int const WIDTH_OF_LINE = 5; +int const WIDTH_OF_LINE = 5; +int const default_line_space = 10; -} // namespace -/// Define a few methods for the inner structs +template +string const write_attribute(string const & name, T const & t) +{ + string const s = tostr(t); + return s.empty() ? s : " " + name + "=\"" + s + "\""; +} -LyXTabular::cellstruct::cellstruct(BufferParams const & bg) - : inset(bg) -{ - cellno = 0; - width_of_cell = 0; - multicolumn = LyXTabular::CELL_NORMAL; - alignment = LYX_ALIGN_CENTER; - valignment = LYX_VALIGN_TOP; - top_line = true; - bottom_line = false; - left_line = true; - right_line = false; - usebox = BOX_NONE; - rotate = false; +template <> +string const write_attribute(string const & name, string const & t) +{ + return t.empty() ? t : " " + name + "=\"" + t + "\""; } -LyXTabular::rowstruct::rowstruct() +template <> +string const write_attribute(string const & name, bool const & b) { - top_line = true; - bottom_line = false; - ascent_of_row = 0; - descent_of_row = 0; - endhead = false; - endfirsthead = false; - endfoot = false; - endlastfoot = false; - newpage = false; + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return b ? write_attribute(name, convert(b)) : string(); } -LyXTabular::columnstruct::columnstruct() +template <> +string const write_attribute(string const & name, int const & i) { - left_line = true; - right_line = false; - alignment = LYX_ALIGN_CENTER; - valignment = LYX_VALIGN_TOP; - width_of_column = 0; + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return i ? write_attribute(name, convert(i)) : string(); } -LyXTabular::ltType::ltType() +template <> +string const write_attribute(string const & name, LyXTabular::idx_type const & i) { - topDL = false; - bottomDL = false; - empty = false; + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return i ? write_attribute(name, convert(i)) : string(); } -/* konstruktor */ -LyXTabular::LyXTabular(BufferParams const & bp, - InsetTabular * inset, int rows_arg, int columns_arg) +template <> +string const write_attribute(string const & name, LyXLength const & value) { - owner_ = inset; - cur_cell = -1; - Init(bp, rows_arg, columns_arg); + // we write only the value if we really have one same reson as above. + return value.zero() ? string() : write_attribute(name, value.asString()); } -LyXTabular::LyXTabular(BufferParams const & bp, - InsetTabular * inset, LyXTabular const & lt, - bool same_id) +string const tostr(LyXAlignment const & num) { - owner_ = inset; - cur_cell = -1; - Init(bp, lt.rows_, lt.columns_, <); - // we really should change again to have InsetText as a pointer - // and allocate it then we would not have to do this stuff all - // double! - 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.paragraphs, true); - } - } + 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"; } -#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 + return string(); } -LyXTabular::LyXTabular(Buffer const * buf, InsetTabular * inset, LyXLex & lex) +string const tostr(LyXTabular::VAlignment const & num) { - owner_ = inset; - cur_cell = -1; - Read(buf, lex); + 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(); } -LyXTabular & LyXTabular::operator=(LyXTabular const & lt) +string const tostr(LyXTabular::BoxType const & num) { -#if 0 -#warning This whole method should look like this: (Lgb) + switch (num) { + case LyXTabular::BOX_NONE: + return "none"; + case LyXTabular::BOX_PARBOX: + return "parbox"; + case LyXTabular::BOX_MINIPAGE: + return "minipage"; + } + return string(); +} - 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; - SetLongTabular(lt.is_long_tabular); - rotate = lt.rotate; - Reinit(); -#endif - return *this; +// 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; } -LyXTabular * LyXTabular::clone(BufferParams const & bp, - InsetTabular * inset, bool same_id) +bool string2type(string const str, LyXTabular::VAlignment & num) { - LyXTabular * result = new LyXTabular(bp, inset, *this, same_id); -#if 0 - // don't know if this is good but I need to Clone also - // the text-insets here, this is for the Undo-facility! - 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); - } + 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, char const * 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 = ' '; } -#endif - return result; + while (pos < str.length() - 1 && str[++pos] != ch) + ret += str[pos]; + + return true; } -/* activates all lines and sets all widths to 0 */ -void LyXTabular::Init(BufferParams const & bp, - int rows_arg, int columns_arg, LyXTabular const * lt) +bool getTokenValue(string const & str, char const * token, int & num) { - 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(bp))); + string tmp; + num = 0; + if (!getTokenValue(str, token, tmp)) + return false; + num = convert(tmp); + return true; +} - if (lt) { - operator=(*lt); - return; + +bool getTokenValue(string const & str, char const * token, LyXAlignment & num) +{ + string tmp; + return getTokenValue(str, token, tmp) && string2type(tmp, num); +} + + +bool getTokenValue(string const & str, char const * token, + LyXTabular::VAlignment & num) +{ + string tmp; + return getTokenValue(str, token, tmp) && string2type(tmp, num); +} + + +bool getTokenValue(string const & str, char const * token, + LyXTabular::BoxType & num) +{ + string tmp; + return getTokenValue(str, token, tmp) && string2type(tmp, num); +} + + +bool getTokenValue(string const & str, char const * 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; + return getTokenValue(str, token, tmp) && string2type(tmp, flag); +} + + +bool getTokenValue(string const & str, char const * 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; + return getTokenValue(str, token, tmp) && isValidLength(tmp, &len); +} + + +bool getTokenValue(string const & str, char const * token, LyXLength & len, bool & flag) +{ + len = LyXLength(); + flag = false; + string tmp; + if (!getTokenValue(str, token, tmp)) + return false; + if (tmp == "default") { + flag = true; + return true; } + return isValidLength(tmp, &len); +} - int cellno = 0; - 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].cellno = cellno++; - } - cell_info[i].back().right_line = true; + +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(BufferParams const & bp) + : cellno(0), + width_of_cell(0), + multicolumn(LyXTabular::CELL_NORMAL), + alignment(LYX_ALIGN_CENTER), + valignment(LYX_VALIGN_TOP), + top_line(true), + bottom_line(false), + left_line(true), + right_line(false), + usebox(BOX_NONE), + rotate(false), + inset(new InsetText(bp)) +{} + + +LyXTabular::cellstruct::cellstruct(cellstruct const & cs) + : cellno(cs.cellno), + width_of_cell(cs.width_of_cell), + multicolumn(cs.multicolumn), + alignment(cs.alignment), + valignment(cs.valignment), + top_line(cs.top_line), + bottom_line(cs.bottom_line), + left_line(cs.left_line), + right_line(cs.right_line), + usebox(cs.usebox), + rotate(cs.rotate), + align_special(cs.align_special), + p_width(cs.p_width), + inset(dynamic_cast(cs.inset->clone().release())) +{} + + +LyXTabular::cellstruct & +LyXTabular::cellstruct::operator=(cellstruct cs) +{ + swap(cs); + return *this; +} + + +void +LyXTabular::cellstruct::swap(cellstruct & rhs) +{ + std::swap(cellno, rhs.cellno); + std::swap(width_of_cell, rhs.width_of_cell); + std::swap(multicolumn, rhs.multicolumn); + std::swap(alignment, rhs.alignment); + std::swap(valignment, rhs.valignment); + std::swap(top_line, rhs.top_line); + std::swap(bottom_line, rhs.bottom_line); + std::swap(left_line, rhs.left_line); + std::swap(right_line, rhs.right_line); + std::swap(usebox, rhs.usebox); + std::swap(rotate, rhs.rotate); + std::swap(align_special, rhs.align_special); + p_width.swap(rhs.p_width); + inset.swap(rhs.inset); +} + + +LyXTabular::rowstruct::rowstruct() + : ascent_of_row(0), + descent_of_row(0), + top_line(true), + bottom_line(false), + top_space_default(false), + bottom_space_default(false), + interline_space_default(false), + endhead(false), + endfirsthead(false), + endfoot(false), + endlastfoot(false), + newpage(false) +{} + + +LyXTabular::columnstruct::columnstruct() + : alignment(LYX_ALIGN_CENTER), + valignment(LYX_VALIGN_TOP), + left_line(true), + right_line(false), + width_of_column(0) +{ +} + + +LyXTabular::ltType::ltType() + : topDL(false), + bottomDL(false), + empty(false) +{} + + +LyXTabular::LyXTabular(BufferParams const & bp, row_type rows_arg, + col_type columns_arg) +{ + init(bp, rows_arg, columns_arg); +} + + +// activates all lines and sets all widths to 0 +void LyXTabular::init(BufferParams const & bp, row_type rows_arg, + col_type columns_arg) +{ + rows_ = rows_arg; + columns_ = columns_arg; + row_info = row_vector(rows_); + column_info = column_vector(columns_); + cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp))); + row_info.reserve(10); + column_info.reserve(10); + cell_info.reserve(100); + fixCellNums(); + for (row_type i = 0; i < rows_; ++i) + cell_info[i].back().right_line = true; row_info.back().bottom_line = true; row_info.front().bottom_line = true; - - for (int i = 0; i < columns_; ++i) { - calculate_width_of_column(i); - } column_info.back().right_line = true; + is_long_tabular = false; + rotate = false; + use_booktabs = false; +} - calculate_width_of_tabular(); - rowofcell = vector(); - columnofcell = vector(); +void LyXTabular::fixCellNums() +{ + idx_type cellno = 0; + for (row_type i = 0; i < rows_; ++i) { + for (col_type j = 0; j < columns_; ++j) { + // When debugging it can be nice to set + // this to true. + cell_info[i][j].inset->setDrawFrame(false); + cell_info[i][j].cellno = cellno++; + } + cell_info[i].back().right_line = true; + } + set_row_column_number_info(); - is_long_tabular = false; - rotate = false; } -void LyXTabular::AppendRow(BufferParams const & bp, int cell) +void LyXTabular::appendRow(BufferParams const & bp, idx_type const cell) { ++rows_; - int row = row_of_cell(cell); + row_type const 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]; -#if 0 - cell_vvector::iterator cit = cell_info.begin() + row; - cell_info.insert(cit, vector(columns_, cellstruct(bp))); -#else - cell_vvector c_info = cell_vvector(rows_, cell_vector(columns_, - cellstruct(bp))); + cell_vvector old(rows_ - 1); + for (row_type i = 0; i < rows_ - 1; ++i) + swap(cell_info[i], old[i]); - 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) { - 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(false); - if (bp.tracking_changes) - cell_info[row][j].inset.markNew(true); - } -#endif - Reinit(); + cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp))); + + for (row_type i = 0; i <= row; ++i) + swap(cell_info[i], old[i]); + for (row_type i = row + 2; i < rows_; ++i) + swap(cell_info[i], old[i - 1]); + + if (bp.trackChanges) + for (col_type j = 0; j < columns_; ++j) + cell_info[row + 1][j].inset->setChange(Change(Change::INSERTED)); + + set_row_column_number_info(); } -void LyXTabular::DeleteRow(int row) +void LyXTabular::deleteRow(row_type const row) { - if (rows_ == 1) return; // Not allowed to delete last row + // Not allowed to delete last row + if (rows_ == 1) + return; - row_info.erase(row_info.begin() + row); //&row_info[row]); - cell_info.erase(cell_info.begin() + row); //&cell_info[row]); + row_info.erase(row_info.begin() + row); + cell_info.erase(cell_info.begin() + row); --rows_; - Reinit(); + fixCellNums(); } -void LyXTabular::AppendColumn(BufferParams const & bp, int cell) +void LyXTabular::copyRow(BufferParams const & bp, row_type const row) +{ + ++rows_; + + row_info.insert(row_info.begin() + row, row_info[row]); + cell_info.insert(cell_info.begin() + row, cell_info[row]); + + if (bp.trackChanges) + for (col_type j = 0; j < columns_; ++j) + cell_info[row + 1][j].inset->setChange(Change(Change::INSERTED)); + + set_row_column_number_info(); +} + + +void LyXTabular::appendColumn(BufferParams const & bp, idx_type const cell) { ++columns_; - cell_vvector c_info = cell_vvector(rows_, cell_vector(columns_, - cellstruct(bp))); - int const column = column_of_cell(cell); + col_type 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]; - for (int i = 0; i < rows_; ++i) { - for (int j = 0; j <= column; ++j) { - c_info[i][j] = cell_info[i][j]; - } - for (int j = column + 1; j < columns_; ++j) { - c_info[i][j] = cell_info[i][j - 1]; - } + for (row_type i = 0; i < rows_; ++i) { + cell_info[i].insert(cell_info[i].begin() + column + 1, cellstruct(bp)); + // care about multicolumns - 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; - } + if (cell_info[i][column + 1].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) + cell_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN; + + if (column + 2 >= columns_ + || cell_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN) + cell_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL; } - cell_info = c_info; //++column; - for (int i = 0; i < rows_; ++i) { - cell_info[i][column + 1].inset.clear(false); - if (bp.tracking_changes) - cell_info[i][column + 1].inset.markNew(true); + for (row_type i = 0; i < rows_; ++i) { + cell_info[i][column + 1].inset->clear(); + if (bp.trackChanges) + cell_info[i][column + 1].inset->setChange(Change(Change::INSERTED)); } - Reinit(); + fixCellNums(); } -void LyXTabular::DeleteColumn(int column) +void LyXTabular::deleteColumn(col_type const 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 (row_type i = 0; i < rows_; ++i) cell_info[i].erase(cell_info[i].begin() + column); - } --columns_; - Reinit(); + fixCellNums(); } -void LyXTabular::reinit() +void LyXTabular::copyColumn(BufferParams const & bp, col_type const column) { - Reinit(false); -} - + ++columns_; -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_); - } - } - } + column_info.insert(column_info.begin() + column, column_info[column]); - for (int i = 0; i < columns_; ++i) { - calculate_width_of_column(i); - } - calculate_width_of_tabular(); + for (row_type i = 0; i < rows_; ++i) + cell_info[i].insert(cell_info[i].begin() + column, cell_info[i][column]); - set_row_column_number_info(); + if (bp.trackChanges) + for (row_type i = 0; i < rows_; ++i) + cell_info[i][column + 1].inset->setChange(Change(Change::INSERTED)); + fixCellNums(); } -void LyXTabular::set_row_column_number_info(bool oldformat) +void LyXTabular::set_row_column_number_info() { - numberofcells = -1; - for (int row = 0; row < rows_; ++row) { - for (int column = 0; columnsetAutoBreakRows( + !getPWidth(getCellNumber(row, column)).zero()); } } } -int LyXTabular::GetNumberOfCells() const +LyXTabular::idx_type LyXTabular::getNumberOfCells() const { return numberofcells; } -int LyXTabular::NumberOfCellsInRow(int cell) const +LyXTabular::idx_type LyXTabular::numberOfCellsInRow(idx_type const cell) const { - int const row = row_of_cell(cell); - int result = 0; - for (int i = 0; i < columns_; ++i) { + row_type const row = row_of_cell(cell); + idx_type result = 0; + for (col_type i = 0; i < columns_; ++i) if (cell_info[row][i].multicolumn != LyXTabular::CELL_PART_OF_MULTICOLUMN) ++result; - } return result; } -/* returns 1 if there is a topline, returns 0 if not */ -bool LyXTabular::TopLine(int cell, bool onlycolumn) const +bool LyXTabular::topLine(idx_type const cell, bool const onlycolumn) const { - int const row = row_of_cell(cell); - - if (!onlycolumn && IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->top_line; - return row_info[row].top_line; + if (!onlycolumn && isMultiColumn(cell) && + !(use_booktabs && row_of_cell(cell) == 0)) + 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(idx_type const 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) && + !(use_booktabs && isLastRow(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(idx_type cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell) && - (IsFirstCellInRow(cell) || IsMultiColumn(cell-1))) + if (use_booktabs) + return false; + if (!onlycolumn && isMultiColumn(cell) && + (isFirstCellInRow(cell) || isMultiColumn(cell-1))) { -#ifdef SPECIAL_COLUM_HANDLING - if (cellinfo_of_cell(cell)->align_special.empty()) - return cellinfo_of_cell(cell)->left_line; - return prefixIs(ltrim(cellinfo_of_cell(cell)->align_special), "|"); -#else - return cellinfo_of_cell(cell)->left_line; -#endif + 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(ltrim(column_info[column_of_cell(cell)].align_special), "|"); -#else - return column_info[column_of_cell(cell)].left_line; -#endif } -bool LyXTabular::RightLine(int cell, bool onlycolumn) const +bool LyXTabular::rightLine(idx_type cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell) && - (IsLastCellInRow(cell) || IsMultiColumn(cell+1))) + if (use_booktabs) + return false; + if (!onlycolumn && isMultiColumn(cell) && + (isLastCellInRow(cell) || isMultiColumn(cell + 1))) { -#ifdef SPECIAL_COLUM_HANDLING - if (cellinfo_of_cell(cell)->align_special.empty()) - return cellinfo_of_cell(cell)->right_line; - return suffixIs(rtrim(cellinfo_of_cell(cell)->align_special), "|"); -#else - return cellinfo_of_cell(cell)->right_line; -#endif + 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(rtrim(column_info[column_of_cell(cell)].align_special), "|"); -#else - return column_info[right_column_of_cell(cell)].right_line; -#endif } -bool LyXTabular::topAlreadyDrawn(int cell) const +bool LyXTabular::topAlreadyDrawn(idx_type cell) const { - int row = row_of_cell(cell); - if ((row > 0) && !GetAdditionalHeight(row)) { - int column = column_of_cell(cell); + row_type row = row_of_cell(cell); + if (row > 0 && !getAdditionalHeight(row)) { + col_type column = column_of_cell(cell); --row; while (column && cell_info[row][column].multicolumn @@ -529,33 +733,29 @@ bool LyXTabular::topAlreadyDrawn(int cell) const } -bool LyXTabular::leftAlreadyDrawn(int cell) const +bool LyXTabular::leftAlreadyDrawn(idx_type cell) const { - int column = column_of_cell(cell); + col_type column = column_of_cell(cell); if (column > 0) { - int row = row_of_cell(cell); + row_type row = row_of_cell(cell); 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 RightLine(cell_info[row][column].cellno); -#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(idx_type cell) const { - return (row_of_cell(cell) == rows_ - 1); + return row_of_cell(cell) == rows_ - 1; } -int LyXTabular::GetAdditionalHeight(int row) const +int LyXTabular::getAdditionalHeight(row_type row) const { if (!row || row >= rows_) return 0; @@ -563,7 +763,7 @@ int LyXTabular::GetAdditionalHeight(int row) const bool top = true; bool bottom = true; - for (int column = 0; column < columns_ && bottom; ++column) { + for (col_type 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; @@ -572,7 +772,7 @@ int LyXTabular::GetAdditionalHeight(int row) const bottom = row_info[row - 1].bottom_line; } } - for (int column = 0; column < columns_ && top; ++column) { + for (col_type 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; @@ -581,65 +781,66 @@ int LyXTabular::GetAdditionalHeight(int row) const top = row_info[row].top_line; } } + int const interline_space = row_info[row - 1].interline_space_default ? + default_line_space : + row_info[row - 1].interline_space.inPixels(width_of_tabular); if (top && bottom) - return WIDTH_OF_LINE; - return 0; + return interline_space + WIDTH_OF_LINE; + return interline_space; } -int LyXTabular::GetAdditionalWidth(int cell) const +int LyXTabular::getAdditionalWidth(idx_type 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) && - LeftLine(cell_info[row][col+1].cellno)) // column_info[col+1].left_line) + col_type const col = right_column_of_cell(cell); + row_type const row = row_of_cell(cell); + 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 +int LyXTabular::getWidthOfColumn(idx_type cell) const { - int const column1 = column_of_cell(cell); - int const column2 = right_column_of_cell(cell); + col_type const column1 = column_of_cell(cell); + col_type const column2 = right_column_of_cell(cell); int result = 0; - for (int i = column1; i <= column2; ++i) { + for (col_type 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(idx_type 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); + row_type const row = row_of_cell(cell); + col_type const column1 = column_of_cell(cell); + col_type 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) { + for (col_type 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 i = column1; + int width = new_width + 2 * WIDTH_OF_LINE; + col_type 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; width -= column_info[i].width_of_column; @@ -658,262 +859,282 @@ bool LyXTabular::SetWidthOfMulticolCell(int cell, int new_width) } -void LyXTabular::recalculateMulticolumnsOfColumn(int column) +void LyXTabular::recalculateMulticolumnsOfColumn(col_type column) { // 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)) + if (columns_ < 2 || column > (columns_ - 2)) return; - for(int row = 0; row < rows_; ++row) { + for (row_type 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))) + (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)); + idx_type 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) +void LyXTabular::setWidthOfCell(idx_type cell, int new_width) { - int const row = row_of_cell(cell); - int const column1 = column_of_cell(cell); + row_type const row = row_of_cell(cell); + col_type const column1 = column_of_cell(cell); bool tmp = false; 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 (isMultiColumnReal(cell)) { + 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) { - for (int i = 0; i < columns_; ++i) + for (col_type i = 0; i < columns_; ++i) calculate_width_of_column(i); calculate_width_of_tabular(); - return true; } - return false; } -bool LyXTabular::SetAlignment(int cell, LyXAlignment align, bool onlycolumn) +void LyXTabular::setAlignment(idx_type cell, LyXAlignment align, + bool onlycolumn) { - if (!IsMultiColumn(cell) || onlycolumn) + if (!isMultiColumn(cell) || onlycolumn) column_info[column_of_cell(cell)].alignment = align; if (!onlycolumn) - cellinfo_of_cell(cell)->alignment = align; - return true; + cellinfo_of_cell(cell).alignment = align; } -bool LyXTabular::SetVAlignment(int cell, VAlignment align, bool onlycolumn) +void LyXTabular::setVAlignment(idx_type 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, LyXLength const & width) +namespace { + +/** + * Allow line and paragraph breaks for fixed width cells or disallow them, + * merge cell paragraphs and reset layout to standard for variable width + * cells. + */ +void toggleFixedWidth(LCursor & cur, InsetText * inset, bool fixedWidth) +{ + inset->setAutoBreakRows(fixedWidth); + if (fixedWidth) + return; + + // merge all paragraphs to one + BufferParams const & bp = cur.bv().buffer()->params(); + while (inset->paragraphs().size() > 1) + mergeParagraph(bp, inset->paragraphs(), 0); + + // reset layout + cur.push(*inset); + // undo information has already been recorded + inset->getText(0)->setLayout(*cur.bv().buffer(), 0, cur.lastpit() + 1, + bp.getLyXTextClass().defaultLayoutName()); + cur.pop(); +} + +} + + +void LyXTabular::setColumnPWidth(LCursor & cur, idx_type cell, + LyXLength const & width) { - bool flag = !width.zero(); - int const j = column_of_cell(cell); + col_type const j = column_of_cell(cell); column_info[j].p_width = width; - // This should not ne necessary anymore - // if (flag) // do this only if there is a width - // SetAlignment(cell, LYX_ALIGN_LEFT); - for (int i = 0; i < rows_; ++i) { - int c = GetCellNumber(i, j); - flag = !GetPWidth(c).zero(); // because of multicolumns! - GetCellInset(c)->setAutoBreakRows(flag); + for (row_type i = 0; i < rows_; ++i) { + idx_type const cell = getCellNumber(i, j); + // because of multicolumns + toggleFixedWidth(cur, getCellInset(cell).get(), + !getPWidth(cell).zero()); } - return true; + // cur paragraph can become invalid after paragraphs were merged + if (cur.pit() > cur.lastpit()) + cur.pit() = cur.lastpit(); + // cur position can become invalid after newlines were removed + if (cur.pos() > cur.lastpos()) + cur.pos() = cur.lastpos(); } -bool LyXTabular::SetMColumnPWidth(int cell, LyXLength const & width) +bool LyXTabular::setMColumnPWidth(LCursor & cur, idx_type cell, + LyXLength const & width) { - bool const flag = !width.zero(); + if (!isMultiColumn(cell)) + return false; - cellinfo_of_cell(cell)->p_width = width; - if (IsMultiColumn(cell)) { - GetCellInset(cell)->setAutoBreakRows(flag); - return true; - } - return false; + cellinfo_of_cell(cell).p_width = width; + toggleFixedWidth(cur, getCellInset(cell).get(), !width.zero()); + // cur paragraph can become invalid after paragraphs were merged + if (cur.pit() > cur.lastpit()) + cur.pit() = cur.lastpit(); + // cur position can become invalid after newlines were removed + if (cur.pos() > cur.lastpos()) + cur.pos() = cur.lastpos(); + return true; } -bool LyXTabular::SetAlignSpecial(int cell, string const & special, +void LyXTabular::setAlignSpecial(idx_type 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(idx_type 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(idx_type cell, bool line, bool onlycolumn) { - int const row = row_of_cell(cell); - - if (onlycolumn || !IsMultiColumn(cell)) + row_type const row = row_of_cell(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(idx_type 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(idx_type 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(idx_type 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(idx_type 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(idx_type 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; } -LyXLength const LyXTabular::GetPWidth(int cell) const +LyXLength const LyXTabular::getPWidth(idx_type 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; } -LyXLength const LyXTabular::GetColumnPWidth(int cell) const +LyXLength const LyXTabular::getColumnPWidth(idx_type cell) const { return column_info[column_of_cell(cell)].p_width; } -LyXLength const LyXTabular::GetMColumnPWidth(int cell) const +LyXLength const LyXTabular::getMColumnPWidth(idx_type cell) const { - if (IsMultiColumn(cell)) - return cellinfo_of_cell(cell)->p_width; + 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(idx_type 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(idx_type cell) const { - int const row = row_of_cell(cell); - int const column1 = column_of_cell(cell); - int const column2 = right_column_of_cell(cell); + row_type const row = row_of_cell(cell); + col_type const column1 = column_of_cell(cell); + col_type const column2 = right_column_of_cell(cell); int result = 0; - for (int i = column1; i <= column2; ++i) { + for (col_type i = column1; i <= column2; ++i) result += cell_info[row][i].width_of_cell; - } return result; } -int LyXTabular::GetBeginningOfTextInCell(int cell) const +int LyXTabular::getBeginningOfTextInCell(idx_type 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; } @@ -923,111 +1144,107 @@ int LyXTabular::GetBeginningOfTextInCell(int cell) const } -bool LyXTabular::IsFirstCellInRow(int cell) const +bool LyXTabular::isFirstCellInRow(idx_type cell) const { return column_of_cell(cell) == 0; } -int LyXTabular::GetFirstCellInRow(int row) const +LyXTabular::idx_type LyXTabular::getFirstCellInRow(row_type 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(idx_type cell) const { - return (right_column_of_cell(cell) == (columns_ - 1)); + return right_column_of_cell(cell) == columns_ - 1; } -int LyXTabular::GetLastCellInRow(int row) const +LyXTabular::idx_type LyXTabular::getLastCellInRow(row_type 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(col_type column) { - int const old_column_width = column_info[column].width_of_column; int maximum = 0; - - for (int i = 0; i < rows_; ++i) { + for (row_type 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 columns regarding ONLY the normal cells and if this // column is inside a multicolumn cell then use it only if its the last -// column of this multicolumn cell as this gives an added with to the +// column 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) +bool LyXTabular::calculate_width_of_column_NMC(col_type column) { int const old_column_width = column_info[column].width_of_column; int max = 0; - for (int i = 0; i < rows_; ++i) { - 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)) + for (row_type i = 0; i < rows_; ++i) { + idx_type cell = getCellNumber(i, column); + bool ismulti = isMultiColumnReal(cell); + 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 (col_type i = 0; i < columns_; ++i) width_of_tabular += column_info[i].width_of_column; - } } -int LyXTabular::row_of_cell(int cell) const +LyXTabular::row_type LyXTabular::row_of_cell(idx_type cell) const { if (cell >= numberofcells) return rows_ - 1; - else if (cell < 0) + if (cell == npos) return 0; return rowofcell[cell]; } -int LyXTabular::column_of_cell(int cell) const +LyXTabular::col_type LyXTabular::column_of_cell(idx_type cell) const { if (cell >= numberofcells) return columns_ - 1; - else if (cell < 0) + if (cell == npos) return 0; return columnofcell[cell]; } -int LyXTabular::right_column_of_cell(int cell) const +LyXTabular::col_type LyXTabular::right_column_of_cell(idx_type cell) const { - int const row = row_of_cell(cell); - int column = column_of_cell(cell); - while (column < (columns_ - 1) && + row_type const row = row_of_cell(cell); + col_type 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"; - for (int j = 0; j < columns_; ++j) { + for (col_type j = 0; j < columns_; ++j) { os << "\n"; } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { os << "\n"; - for (int j = 0; j < columns_; ++j) { + for (col_type j = 0; j < columns_; ++j) { os << "\n"; os << "\\begin_inset "; - cell_info[i][j].inset.write(buf, os); - os << "\n\\end_inset \n" + cell_info[i][j].inset->write(buf, os); + os << "\n\\end_inset\n" << "\n"; } os << "\n"; @@ -1095,7 +1326,7 @@ void LyXTabular::Write(Buffer const * buf, ostream & os) const } -void LyXTabular::Read(Buffer const * buf, LyXLex & lex) +void LyXTabular::read(Buffer const & buf, LyXLex & lex) { string line; istream & is = lex.getStream(); @@ -1103,105 +1334,22 @@ void LyXTabular::Read(Buffer const * buf, LyXLex & lex) l_getline(is, line); if (!prefixIs(line, "= 2); - read(buf, is, lex, line, version); -} + BOOST_ASSERT(version >= 2); -void LyXTabular::setHeaderFooterRows(int hr, int fhr, int fr, int lfr) -{ - // set header info - while(hr > 0) { - row_info[--hr].endhead = true; - } - // 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; - } - } -} - -void LyXTabular::read(Buffer const * buf, istream & is, - LyXLex & lex, string const & l, int const version) -{ - string line(l); int rows_arg; if (!getTokenValue(line, "rows", rows_arg)) return; int columns_arg; if (!getTokenValue(line, "columns", columns_arg)) return; - Init(buf->params, rows_arg, columns_arg); + init(buf.params(), rows_arg, columns_arg); l_getline(is, line); if (!prefixIs(line, " got" @@ -1209,39 +1357,20 @@ void LyXTabular::read(Buffer const * buf, istream & is, return; } getTokenValue(line, "rotate", rotate); + getTokenValue(line, "booktabs", use_booktabs); getTokenValue(line, "islongtable", is_long_tabular); - // 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) { + 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 (col_type j = 0; j < columns_; ++j) { l_getline(is,line); if (!prefixIs(line," got" @@ -1256,7 +1385,7 @@ void LyXTabular::read(Buffer const * buf, istream & is, getTokenValue(line, "special", column_info[j].align_special); } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { l_getline(is, line); if (!prefixIs(line, " got" @@ -1265,12 +1394,18 @@ void LyXTabular::read(Buffer const * buf, istream & is, } getTokenValue(line, "topline", row_info[i].top_line); getTokenValue(line, "bottomline", row_info[i].bottom_line); + getTokenValue(line, "topspace", row_info[i].top_space, + row_info[i].top_space_default); + getTokenValue(line, "bottomspace", row_info[i].bottom_space, + row_info[i].bottom_space_default); + getTokenValue(line, "interlinespace", row_info[i].interline_space, + row_info[i].interline_space_default); 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) { + for (col_type j = 0; j < columns_; ++j) { l_getline(is, line); if (!prefixIs(line, " got" @@ -1290,7 +1425,7 @@ void LyXTabular::read(Buffer const * buf, istream & is, 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); + cell_info[i][j].inset->read(buf, lex); l_getline(is, line); } if (!prefixIs(line, "")) { @@ -1313,51 +1448,52 @@ void LyXTabular::read(Buffer const * buf, istream & is, } -bool LyXTabular::IsMultiColumn(int cell, bool real) const +bool LyXTabular::isMultiColumn(idx_type cell) const { - return ((!real || (column_of_cell(cell) != right_column_of_cell(cell))) && - (cellinfo_of_cell(cell)->multicolumn != LyXTabular::CELL_NORMAL)); + return cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL; } -LyXTabular::cellstruct * LyXTabular::cellinfo_of_cell(int cell) const +bool LyXTabular::isMultiColumnReal(idx_type cell) const { - int const row = row_of_cell(cell); - int const column = column_of_cell(cell); - return &cell_info[row][column]; + return column_of_cell(cell) != right_column_of_cell(cell) && + cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL; } -void LyXTabular::SetMultiColumn(Buffer * buffer, int cell, int number) +LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(idx_type cell) const { - cellinfo_of_cell(cell)->multicolumn = CELL_BEGIN_OF_MULTICOLUMN; - cellinfo_of_cell(cell)->alignment = column_info[column_of_cell(cell)].alignment; - cellinfo_of_cell(cell)->top_line = row_info[row_of_cell(cell)].top_line; - cellinfo_of_cell(cell)->bottom_line = row_info[row_of_cell(cell)].bottom_line; - cellinfo_of_cell(cell)->right_line = column_info[column_of_cell(cell+number-1)].right_line; -#if 1 - for (int i = 1; i < number; ++i) { - cellinfo_of_cell(cell + i)->multicolumn = CELL_PART_OF_MULTICOLUMN; - cellinfo_of_cell(cell)->inset.appendParagraphs(buffer, - cellinfo_of_cell(cell+i)->inset.paragraphs); - cellinfo_of_cell(cell + i)->inset.clear(false); - } -#else - for (number--; number > 0; --number) { - cellinfo_of_cell(cell + number)->multicolumn = CELL_PART_OF_MULTICOLUMN; + return cell_info[row_of_cell(cell)][column_of_cell(cell)]; +} + + +void LyXTabular::setMultiColumn(Buffer * buffer, idx_type cell, + idx_type number) +{ + 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.left_line = column_info[column_of_cell(cell)].left_line; + cs.right_line = column_info[column_of_cell(cell+number-1)].right_line; + for (idx_type 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(); } -#endif set_row_column_number_info(); } -int LyXTabular::cells_in_multicolumn(int cell) const +LyXTabular::idx_type LyXTabular::cells_in_multicolumn(idx_type cell) const { - int const row = row_of_cell(cell); - int column = column_of_cell(cell); - int result = 1; + row_type const row = row_of_cell(cell); + col_type column = column_of_cell(cell); + idx_type result = 1; ++column; - while ((column < columns_) && + while (column < columns_ && cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN) { ++result; @@ -1367,18 +1503,18 @@ int LyXTabular::cells_in_multicolumn(int cell) const } -int LyXTabular::UnsetMultiColumn(int cell) +LyXTabular::idx_type LyXTabular::unsetMultiColumn(idx_type cell) { - int const row = row_of_cell(cell); - int column = column_of_cell(cell); + row_type const row = row_of_cell(cell); + col_type column = column_of_cell(cell); - int result = 0; + idx_type 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; @@ -1390,65 +1526,75 @@ int LyXTabular::UnsetMultiColumn(int cell) } -void LyXTabular::SetLongTabular(bool what) +void LyXTabular::setBookTabs(bool what) +{ + use_booktabs = what; +} + + +bool LyXTabular::useBookTabs() const +{ + return use_booktabs; +} + + +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(idx_type cell, bool flag) { - cellinfo_of_cell(cell)->rotate = flag; + cellinfo_of_cell(cell).rotate = flag; } -bool LyXTabular::GetRotateCell(int cell) const +bool LyXTabular::getRotateCell(idx_type 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 (row_type i = 0; i < rows_; ++i) + for (col_type j = 0; j < columns_; ++j) if (cell_info[i][j].rotate) return true; - } - } return false; } -bool LyXTabular::IsLastCell(int cell) const +bool LyXTabular::isLastCell(idx_type cell) const { - if ((cell + 1) < numberofcells) + if (cell + 1 < numberofcells) return false; return true; } -int LyXTabular::GetCellAbove(int cell) const +LyXTabular::idx_type LyXTabular::getCellAbove(idx_type cell) const { if (row_of_cell(cell) > 0) return cell_info[row_of_cell(cell)-1][column_of_cell(cell)].cellno; @@ -1456,7 +1602,7 @@ int LyXTabular::GetCellAbove(int cell) const } -int LyXTabular::GetCellBelow(int cell) const +LyXTabular::idx_type LyXTabular::getCellBelow(idx_type cell) const { if (row_of_cell(cell) + 1 < rows_) return cell_info[row_of_cell(cell)+1][column_of_cell(cell)].cellno; @@ -1464,65 +1610,57 @@ int LyXTabular::GetCellBelow(int cell) const } -int LyXTabular::GetLastCellAbove(int cell) const +LyXTabular::idx_type LyXTabular::getLastCellAbove(idx_type cell) const { - if (row_of_cell(cell) <= 0) + 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 +LyXTabular::idx_type LyXTabular::getLastCellBelow(idx_type 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 +LyXTabular::idx_type LyXTabular::getCellNumber(row_type row, + col_type 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 + BOOST_ASSERT(column != npos && column < columns_ && + row != npos && row < rows_); return cell_info[row][column].cellno; } -void LyXTabular::SetUsebox(int cell, BoxType type) +void LyXTabular::setUsebox(idx_type 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(idx_type cell) const { if (column_info[column_of_cell(cell)].p_width.zero() && - !(IsMultiColumn(cell) && !cellinfo_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); + if (cellinfo_of_cell(cell).usebox > 1) + return cellinfo_of_cell(cell).usebox; + return useParbox(cell); } /// // This are functions used for the longtable support /// -void LyXTabular::SetLTHead(int row, bool flag, ltType const & hd, bool first) +void LyXTabular::setLTHead(row_type row, bool flag, ltType const & hd, + bool first) { if (first) { endfirsthead = hd; @@ -1536,7 +1674,7 @@ void LyXTabular::SetLTHead(int row, bool flag, ltType const & hd, bool first) } -bool LyXTabular::GetRowOfLTHead(int row, ltType & hd) const +bool LyXTabular::getRowOfLTHead(row_type row, ltType & hd) const { hd = endhead; hd.set = haveLTHead(); @@ -1544,7 +1682,7 @@ bool LyXTabular::GetRowOfLTHead(int row, ltType & hd) const } -bool LyXTabular::GetRowOfLTFirstHead(int row, ltType & hd) const +bool LyXTabular::getRowOfLTFirstHead(row_type row, ltType & hd) const { hd = endfirsthead; hd.set = haveLTFirstHead(); @@ -1552,7 +1690,8 @@ bool LyXTabular::GetRowOfLTFirstHead(int row, ltType & hd) const } -void LyXTabular::SetLTFoot(int row, bool flag, ltType const & fd, bool last) +void LyXTabular::setLTFoot(row_type row, bool flag, ltType const & fd, + bool last) { if (last) { endlastfoot = fd; @@ -1566,7 +1705,7 @@ void LyXTabular::SetLTFoot(int row, bool flag, ltType const & fd, bool last) } -bool LyXTabular::GetRowOfLTFoot(int row, ltType & fd) const +bool LyXTabular::getRowOfLTFoot(row_type row, ltType & fd) const { fd = endfoot; fd.set = haveLTFoot(); @@ -1574,7 +1713,7 @@ bool LyXTabular::GetRowOfLTFoot(int row, ltType & fd) const } -bool LyXTabular::GetRowOfLTLastFoot(int row, ltType & fd) const +bool LyXTabular::getRowOfLTLastFoot(row_type row, ltType & fd) const { fd = endlastfoot; fd.set = haveLTLastFoot(); @@ -1582,13 +1721,13 @@ bool LyXTabular::GetRowOfLTLastFoot(int row, ltType & fd) const } -void LyXTabular::SetLTNewPage(int row, bool what) +void LyXTabular::setLTNewPage(row_type row, bool what) { row_info[row].newpage = what; } -bool LyXTabular::GetLTNewPage(int row) const +bool LyXTabular::getLTNewPage(row_type row) const { return row_info[row].newpage; } @@ -1596,10 +1735,9 @@ bool LyXTabular::GetLTNewPage(int row) const bool LyXTabular::haveLTHead() const { - for(int i=0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) if (row_info[i].endhead) return true; - } return false; } @@ -1608,20 +1746,18 @@ bool LyXTabular::haveLTFirstHead() const { if (endfirsthead.empty) return false; - for(int i=0; i < rows_; ++i) { + for (row_type 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) { + for (row_type i = 0; i < rows_; ++i) if (row_info[i].endfoot) return true; - } return false; } @@ -1630,35 +1766,32 @@ bool LyXTabular::haveLTLastFoot() const { if (endlastfoot.empty) return false; - for(int i=0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) if (row_info[i].endlastfoot) return true; - } return false; } // end longtable support functions -bool LyXTabular::SetAscentOfRow(int row, int height) +void LyXTabular::setAscentOfRow(row_type row, int height) { - if ((row >= rows_) || (row_info[row].ascent_of_row == height)) - return false; + if (row >= rows_ || row_info[row].ascent_of_row == height) + return; row_info[row].ascent_of_row = height; - return true; } -bool LyXTabular::SetDescentOfRow(int row, int height) +void LyXTabular::setDescentOfRow(row_type row, int height) { - if ((row >= rows_) || (row_info[row].descent_of_row == height)) - return false; + 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(row_type row) const { if (row >= rows_) return 0; @@ -1666,52 +1799,53 @@ int LyXTabular::GetAscentOfRow(int row) const } -int LyXTabular::GetDescentOfRow(int row) const +int LyXTabular::getDescentOfRow(row_type row) const { - if (row >= rows_) - return 0; + BOOST_ASSERT(row < rows_); return row_info[row].descent_of_row; } -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); + for (row_type row = 0; row < rows_; ++row) + height += getAscentOfRow(row) + getDescentOfRow(row) + + getAdditionalHeight(row); return height; } -bool LyXTabular::IsPartOfMultiColumn(int row, int column) const +bool LyXTabular::isPartOfMultiColumn(row_type row, col_type column) const { - if ((row >= rows_) || (column >= columns_)) - return false; - return (cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN); + BOOST_ASSERT(row < rows_); + BOOST_ASSERT(column < columns_); + return cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN; } -int LyXTabular::TeXTopHLine(ostream & os, int row) const +int LyXTabular::TeXTopHLine(odocstream & os, row_type row) const { - if ((row < 0) || (row >= rows_)) - return 0; + // FIXME: assert or return 0 as in TeXBottomHLine()? + BOOST_ASSERT(row != npos); + BOOST_ASSERT(row < rows_); - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; - int tmp = 0; + idx_type const fcell = getFirstCellInRow(row); + idx_type const n = numberOfCellsInRow(fcell) + fcell; + idx_type tmp = 0; - for (int i = fcell; i < n; ++i) { - if (TopLine(i)) + for (idx_type i = fcell; i < n; ++i) { + if (topLine(i)) ++tmp; } - if (tmp == (n - fcell)) { - os << "\\hline "; + if (use_booktabs && row == 0) { + os << "\\toprule "; + } else if (tmp == n - fcell) { + os << (use_booktabs ? "\\midrule " : "\\hline "); } else if (tmp) { - for (int i = fcell; i < n; ++i) { - if (TopLine(i)) { - os << "\\cline{" + for (idx_type i = fcell; i < n; ++i) { + if (topLine(i)) { + os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << column_of_cell(i) + 1 << '-' << right_column_of_cell(i) + 1 @@ -1726,25 +1860,28 @@ int LyXTabular::TeXTopHLine(ostream & os, int row) const } -int LyXTabular::TeXBottomHLine(ostream & os, int row) const +int LyXTabular::TeXBottomHLine(odocstream & os, row_type row) const { - if ((row < 0) || (row >= rows_)) + // FIXME: return 0 or assert as in TeXTopHLine()? + if (row == npos || row >= rows_) return 0; - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; - int tmp = 0; + idx_type const fcell = getFirstCellInRow(row); + idx_type const n = numberOfCellsInRow(fcell) + fcell; + idx_type tmp = 0; - for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) + for (idx_type i = fcell; i < n; ++i) { + if (bottomLine(i)) ++tmp; } - if (tmp == (n - fcell)) { - os << "\\hline"; + if (use_booktabs && row == rows_ - 1) { + os << "\\bottomrule"; + } else if (tmp == n - fcell) { + os << (use_booktabs ? "\\midrule" : "\\hline"); } else if (tmp) { - for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) { - os << "\\cline{" + for (idx_type i = fcell; i < n; ++i) { + if (bottomLine(i)) { + os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << column_of_cell(i) + 1 << '-' << right_column_of_cell(i) + 1 @@ -1759,32 +1896,33 @@ int LyXTabular::TeXBottomHLine(ostream & os, int row) const } -int LyXTabular::TeXCellPreamble(ostream & os, int cell) const +int LyXTabular::TeXCellPreamble(odocstream & os, idx_type 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 << from_ascii(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).zero()) { - switch (GetVAlignment(cell)) { + if (!getPWidth(cell).zero()) { + switch (getVAlignment(cell)) { case LYX_VALIGN_TOP: os << 'p'; break; - case LYX_VALIGN_CENTER: + case LYX_VALIGN_MIDDLE: os << 'm'; break; case LYX_VALIGN_BOTTOM: @@ -1792,10 +1930,10 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const break; } os << '{' - << GetPWidth(cell).asLatexString() + << from_ascii(getPWidth(cell).asLatexString()) << '}'; } else { - switch (GetAlignment(cell)) { + switch (getAlignment(cell)) { case LYX_ALIGN_LEFT: os << 'l'; break; @@ -1807,63 +1945,65 @@ 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'; break; - case LYX_VALIGN_CENTER: + case LYX_VALIGN_MIDDLE: os << 'c'; break; case LYX_VALIGN_BOTTOM: os << 'b'; break; } - os << "]{" << GetPWidth(cell).asLatexString() << "}{"; - } else if (GetUsebox(cell) == BOX_MINIPAGE) { + os << "]{" << from_ascii(getPWidth(cell).asLatexString()) + << "}{"; + } else if (getUsebox(cell) == BOX_MINIPAGE) { os << "\\begin{minipage}["; - switch (GetVAlignment(cell)) { + switch (getVAlignment(cell)) { case LYX_VALIGN_TOP: os << 't'; break; - case LYX_VALIGN_CENTER: + case LYX_VALIGN_MIDDLE: os << 'm'; break; case LYX_VALIGN_BOTTOM: os << 'b'; break; } - os << "]{" << GetPWidth(cell).asLatexString() << "}\n"; + os << "]{" << from_ascii(getPWidth(cell).asLatexString()) + << "}\n"; ++ret; } return ret; } -int LyXTabular::TeXCellPostamble(ostream & os, int cell) const +int LyXTabular::TeXCellPostamble(odocstream & os, idx_type cell) const { int ret = 0; // usual cells - if (GetUsebox(cell) == BOX_PARBOX) + if (getUsebox(cell) == BOX_PARBOX) os << '}'; - else if (GetUsebox(cell) == BOX_MINIPAGE) { + 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; } @@ -1871,9 +2011,8 @@ int LyXTabular::TeXCellPostamble(ostream & os, int cell) const } -int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf, - LatexRunParams const & runparams, - bool fp) const +int LyXTabular::TeXLongtableHeaderFooter(odocstream & os, Buffer const & buf, + OutputParams const & runparams) const { if (!is_long_tabular) return 0; @@ -1885,9 +2024,9 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf, os << "\\hline\n"; ++ret; } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (row_info[i].endhead) { - ret += TeXRow(os, i, buf, runparams, fp); + ret += TeXRow(os, i, buf, runparams); } } if (endhead.bottomDL) { @@ -1907,9 +2046,9 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf, os << "\\hline\n"; ++ret; } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (row_info[i].endfirsthead) { - ret += TeXRow(os, i, buf, runparams, fp); + ret += TeXRow(os, i, buf, runparams); } } if (endfirsthead.bottomDL) { @@ -1925,9 +2064,9 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf, os << "\\hline\n"; ++ret; } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (row_info[i].endfoot) { - ret += TeXRow(os, i, buf, runparams, fp); + ret += TeXRow(os, i, buf, runparams); } } if (endfoot.bottomDL) { @@ -1947,9 +2086,9 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf, os << "\\hline\n"; ++ret; } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (row_info[i].endlastfoot) { - ret += TeXRow(os, i, buf, runparams, fp); + ret += TeXRow(os, i, buf, runparams); } } if (endlastfoot.bottomDL) { @@ -1963,53 +2102,99 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const * buf, } -bool LyXTabular::isValidRow(int const row) const +bool LyXTabular::isValidRow(row_type 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); + 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, bool fp) const +int LyXTabular::TeXRow(odocstream & os, row_type i, Buffer const & buf, + OutputParams 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)) + idx_type cell = getCellNumber(i, 0); + int ret = TeXTopHLine(os, i); + if (row_info[i].top_space_default) { + if (use_booktabs) + os << "\\addlinespace\n"; + else + os << "\\noalign{\\vskip\\doublerulesep}\n"; + } else if(!row_info[i].top_space.zero()) { + if (use_booktabs) + os << "\\addlinespace[" + << from_ascii(row_info[i].top_space.asLatexString()) + << "]\n"; + else { + os << "\\noalign{\\vskip" + << from_ascii(row_info[i].top_space.asLatexString()) + << "}\n"; + } + ++ret; + } + + for (col_type j = 0; j < columns_; ++j) { + if (isPartOfMultiColumn(i, j)) continue; ret += TeXCellPreamble(os, cell); - InsetText * inset = GetCellInset(cell); + shared_ptr inset = getCellInset(cell); - bool rtl = inset->paragraphs.begin()->isRightToLeftPar(buf->params) && - !inset->paragraphs.begin()->empty() && GetPWidth(cell).zero(); + Paragraph const & par = inset->paragraphs().front(); + bool rtl = par.isRightToLeftPar(buf.params()) + && !par.empty() + && getPWidth(cell).zero(); if (rtl) os << "\\R{"; - ret += inset->latex(buf, os, runparams, fp); + ret += inset->latex(buf, os, runparams); if (rtl) os << '}'; ret += TeXCellPostamble(os, cell); - if (!IsLastCellInRow(cell)) { // not last cell in row - os << "&\n"; - ++ret; + if (!isLastCellInRow(cell)) { // not last cell in row + os << " & "; } ++cell; } - os << "\\tabularnewline\n"; + os << "\\tabularnewline"; + if (row_info[i].bottom_space_default) { + if (use_booktabs) + os << "\\addlinespace"; + else + os << "[\\doublerulesep]"; + } else if (!row_info[i].bottom_space.zero()) { + if (use_booktabs) + os << "\\addlinespace"; + os << '[' + << from_ascii(row_info[i].bottom_space.asLatexString()) + << ']'; + } + os << '\n'; ++ret; ret += TeXBottomHLine(os, i); + if (row_info[i].interline_space_default) { + if (use_booktabs) + os << "\\addlinespace\n"; + else + os << "\\noalign{\\vskip\\doublerulesep}\n"; + } else if (!row_info[i].interline_space.zero()) { + if (use_booktabs) + os << "\\addlinespace[" + << from_ascii(row_info[i].interline_space.asLatexString()) + << "]\n"; + else + os << "\\noalign{\\vskip" + << from_ascii(row_info[i].interline_space.asLatexString()) + << "}\n"; + ++ret; + } return ret; } -int LyXTabular::latex(Buffer const * buf, ostream & os, - LatexRunParams const & runparams, bool fp) const +int LyXTabular::latex(Buffer const & buf, odocstream & os, + OutputParams const & runparams) const { int ret = 0; @@ -2025,11 +2210,11 @@ int LyXTabular::latex(Buffer const * buf, ostream & os, os << "\\begin{longtable}{"; else os << "\\begin{tabular}{"; - for (int i = 0; i < columns_; ++i) { + for (col_type i = 0; i < columns_; ++i) { if (!column_info[i].align_special.empty()) { - os << column_info[i].align_special; + os << from_ascii(column_info[i].align_special); } else { - if (column_info[i].left_line) + if (!use_booktabs && column_info[i].left_line) os << '|'; if (!column_info[i].p_width.zero()) { switch (column_info[i].alignment) { @@ -2053,7 +2238,7 @@ int LyXTabular::latex(Buffer const * buf, ostream & os, case LYX_VALIGN_TOP: os << 'p'; break; - case LYX_VALIGN_CENTER: + case LYX_VALIGN_MIDDLE: os << 'm'; break; case LYX_VALIGN_BOTTOM: @@ -2061,7 +2246,7 @@ int LyXTabular::latex(Buffer const * buf, ostream & os, break; } os << '{' - << column_info[i].p_width.asLatexString() + << from_ascii(column_info[i].p_width.asLatexString()) << '}'; } else { switch (column_info[i].alignment) { @@ -2076,22 +2261,22 @@ int LyXTabular::latex(Buffer const * buf, ostream & os, break; } } - if (column_info[i].right_line) + if (!use_booktabs && column_info[i].right_line) os << '|'; } } os << "}\n"; ++ret; - ret += TeXLongtableHeaderFooter(os, buf, runparams, fp); + ret += TeXLongtableHeaderFooter(os, buf, runparams); //+--------------------------------------------------------------------- //+ the single row and columns (cells) + //+--------------------------------------------------------------------- - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (isValidRow(i)) { - ret += TeXRow(os, i, buf, runparams, fp); + ret += TeXRow(os, i, buf, runparams); if (is_long_tabular && row_info[i].newpage) { os << "\\newpage\n"; ++ret; @@ -2116,18 +2301,19 @@ int LyXTabular::latex(Buffer const * buf, ostream & os, } -int LyXTabular::docbookRow(Buffer const * buf, ostream & os, int row) const +int LyXTabular::docbookRow(Buffer const & buf, odocstream & os, row_type row, + OutputParams const & runparams) const { int ret = 0; - int cell = GetFirstCellInRow(row); + idx_type cell = getFirstCellInRow(row); os << "\n"; - for (int j = 0; j < columns_; ++j) { - if (IsPartOfMultiColumn(row, j)) + for (col_type j = 0; j < columns_; ++j) { + if (isPartOfMultiColumn(row, j)) continue; os << "'; - ret += GetCellInset(cell)->docbook(buf, os, true); + ret += getCellInset(cell)->docbook(buf, os, runparams); os << "\n"; ++cell; } @@ -2167,8 +2353,8 @@ int LyXTabular::docbookRow(Buffer const * buf, ostream & os, int row) const } -int LyXTabular::docbook(Buffer const * buf, ostream & os, - bool /*mixcont*/) const +int LyXTabular::docbook(Buffer const & buf, odocstream & os, + OutputParams const & runparams) const { int ret = 0; @@ -2179,7 +2365,7 @@ int LyXTabular::docbook(Buffer const * buf, ostream & os, os << "\n"; - for (int i = 0; i < columns_; ++i) { + for (col_type i = 0; i < columns_; ++i) { os << "\n"; + os << '"'; + if (runparams.flavor == OutputParams::XML) + os << '/'; + os << ">\n"; ++ret; } @@ -2204,9 +2393,9 @@ int LyXTabular::docbook(Buffer const * buf, ostream & os, if (haveLTHead() || haveLTFirstHead()) { os << "\n"; ++ret; - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (row_info[i].endhead || row_info[i].endfirsthead) { - ret += docbookRow(buf, os, i); + ret += docbookRow(buf, os, i, runparams); } } os << "\n"; @@ -2216,9 +2405,9 @@ int LyXTabular::docbook(Buffer const * buf, ostream & os, if (haveLTFoot() || haveLTLastFoot()) { os << "\n"; ++ret; - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (row_info[i].endfoot || row_info[i].endlastfoot) { - ret += docbookRow(buf, os, i); + ret += docbookRow(buf, os, i, runparams); } } os << "\n"; @@ -2231,9 +2420,9 @@ int LyXTabular::docbook(Buffer const * buf, ostream & os, os << "\n"; ++ret; - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { if (isValidRow(i)) { - ret += docbookRow(buf, os, i); + ret += docbookRow(buf, os, i, runparams); } } os << "\n"; @@ -2248,18 +2437,16 @@ int LyXTabular::docbook(Buffer const * buf, ostream & os, return ret; } -//-- -// ASCII export function and helpers -//-- -int LyXTabular::asciiTopHLine(ostream & os, int row, + +int LyXTabular::asciiTopHLine(odocstream & os, row_type row, vector const & clen) const { - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; - int tmp = 0; + idx_type const fcell = getFirstCellInRow(row); + idx_type const n = numberOfCellsInRow(fcell) + fcell; + idx_type tmp = 0; - for (int i = fcell; i < n; ++i) { - if (TopLine(i)) { + for (idx_type i = fcell; i < n; ++i) { + if (topLine(i)) { ++tmp; break; } @@ -2267,10 +2454,10 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, if (!tmp) return 0; - unsigned char ch; - for (int i = fcell; i < n; ++i) { - if (TopLine(i)) { - if (LeftLine(i)) + char_type ch; + for (idx_type i = fcell; i < n; ++i) { + if (topLine(i)) { + if (leftLine(i)) os << "+-"; else os << "--"; @@ -2279,13 +2466,14 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, os << " "; ch = ' '; } - int column = column_of_cell(i); + col_type column = column_of_cell(i); int len = clen[column]; - while (IsPartOfMultiColumn(row, ++column)) + while (column < columns_ - 1 + && isPartOfMultiColumn(row, ++column)) len += clen[column] + 4; - os << string(len, ch); - if (TopLine(i)) { - if (RightLine(i)) + os << docstring(len, ch); + if (topLine(i)) { + if (rightLine(i)) os << "-+"; else os << "--"; @@ -2298,15 +2486,15 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, } -int LyXTabular::asciiBottomHLine(ostream & os, int row, +int LyXTabular::asciiBottomHLine(odocstream & os, row_type row, vector const & clen) const { - int const fcell = GetFirstCellInRow(row); - int const n = NumberOfCellsInRow(fcell) + fcell; - int tmp = 0; + idx_type const fcell = getFirstCellInRow(row); + idx_type const n = numberOfCellsInRow(fcell) + fcell; + idx_type tmp = 0; - for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) { + for (idx_type i = fcell; i < n; ++i) { + if (bottomLine(i)) { ++tmp; break; } @@ -2314,10 +2502,10 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, if (!tmp) return 0; - unsigned char ch; - for (int i = fcell; i < n; ++i) { - if (BottomLine(i)) { - if (LeftLine(i)) + char_type ch; + for (idx_type i = fcell; i < n; ++i) { + if (bottomLine(i)) { + if (leftLine(i)) os << "+-"; else os << "--"; @@ -2326,13 +2514,14 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, os << " "; ch = ' '; } - int column = column_of_cell(i); + col_type column = column_of_cell(i); int len = clen[column]; - while (IsPartOfMultiColumn(row, ++column)) + while (column < columns_ -1 + && isPartOfMultiColumn(row, ++column)) len += clen[column] + 4; - os << string(len, ch); - if (BottomLine(i)) { - if (RightLine(i)) + os << docstring(len, ch); + if (bottomLine(i)) { + if (rightLine(i)) os << "-+"; else os << "--"; @@ -2345,31 +2534,33 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, } -int LyXTabular::asciiPrintCell(Buffer const * buf, ostream & os, - int cell, int row, int column, +int LyXTabular::asciiPrintCell(Buffer const & buf, odocstream & os, + OutputParams const & runparams, + idx_type cell, row_type row, col_type column, vector const & clen, bool onlydata) const { - ostringstream sstr; - int ret = GetCellInset(cell)->ascii(buf, sstr, 0); + odocstringstream sstr; + int const ret = getCellInset(cell)->plaintext(buf, sstr, runparams); 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 (column < columns_ -1 + && isPartOfMultiColumn(row, ++column)) len2 += clen[column] + 4; len2 -= len1; - switch (GetAlignment(cell)) { + switch (getAlignment(cell)) { default: case LYX_ALIGN_LEFT: len1 = 0; @@ -2384,10 +2575,10 @@ int LyXTabular::asciiPrintCell(Buffer const * buf, ostream & os, break; } - os << string(len1, ' ') - << sstr.str() - << string(len2, ' '); - if (RightLine(cell)) + os << docstring(len1, ' ') << sstr.str() + << docstring(len2, ' '); + + if (rightLine(cell)) os << " |"; else os << " "; @@ -2396,176 +2587,147 @@ int LyXTabular::asciiPrintCell(Buffer const * buf, ostream & os, } -int LyXTabular::ascii(Buffer const * buf, ostream & os, int const depth, - bool onlydata, unsigned char delim) const +int LyXTabular::plaintext(Buffer const & buf, odocstream & os, + OutputParams const & runparams, + 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_); if (!onlydata) { // first all non (real) multicolumn cells! - for (int j = 0; j < columns_; ++j) { + for (col_type j = 0; j < columns_; ++j) { clen[j] = 0; - for (int i = 0; i < rows_; ++i) { - int cell = GetCellNumber(i, j); - if (IsMultiColumn(cell, true)) + for (row_type i = 0; i < rows_; ++i) { + idx_type cell = getCellNumber(i, j); + if (isMultiColumnReal(cell)) continue; - ostringstream sstr; - GetCellInset(cell)->ascii(buf, sstr, 0); + odocstringstream sstr; + getCellInset(cell)->plaintext(buf, sstr, runparams); 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)) + for (col_type j = 0; j < columns_; ++j) { + for (row_type i = 0; i < rows_; ++i) { + idx_type cell = getCellNumber(i, j); + if (!isMultiColumnReal(cell) || isPartOfMultiColumn(i, j)) continue; - ostringstream sstr; - GetCellInset(cell)->ascii(buf, sstr, 0); + odocstringstream sstr; + getCellInset(cell)->plaintext(buf, sstr, runparams); int len = int(sstr.str().length()); - int const n = cells_in_multicolumn(cell); - for (int k = j; (len > 0) && (k < (j + n - 1)); ++k) + idx_type const n = cells_in_multicolumn(cell); + for (col_type 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) { - if (!onlydata) { - if (asciiTopHLine(os, i, clen)) { - for (int j = 0; j < depth; ++j) - os << " "; - } - } - for (int j = 0; j < columns_; ++j) { - if (IsPartOfMultiColumn(i,j)) + idx_type cell = 0; + for (row_type i = 0; i < rows_; ++i) { + if (!onlydata && asciiTopHLine(os, i, clen)) + os << docstring(depth * 2, ' '); + for (col_type j = 0; j < columns_; ++j) { + if (isPartOfMultiColumn(i, j)) continue; if (onlydata && j > 0) os << delim; - ret += asciiPrintCell(buf, os, cell, i, j, clen, onlydata); + ret += asciiPrintCell(buf, os, runparams, + cell, i, j, clen, onlydata); ++cell; } os << endl; if (!onlydata) { - for (int j = 0; j < depth; ++j) - os << " "; - if (asciiBottomHLine(os, i, clen)) { - for (int j = 0; j < depth; ++j) - os << " "; - } + os << docstring(depth * 2, ' '); + if (asciiBottomHLine(os, i, clen)) + os << docstring(depth * 2, ' '); } } return ret; } -//-- -// end ascii export -//-- -InsetText * LyXTabular::GetCellInset(int cell) const +shared_ptr LyXTabular::getCellInset(idx_type cell) const +{ + return cell_info[row_of_cell(cell)][column_of_cell(cell)].inset; +} + + +shared_ptr LyXTabular::getCellInset(row_type row, + col_type column) const { - cur_cell = cell; - return & cell_info[row_of_cell(cell)][column_of_cell(cell)].inset; + return cell_info[row][column].inset; } -InsetText * LyXTabular::GetCellInset(int row, int column) const +void LyXTabular::setCellInset(row_type row, col_type column, + shared_ptr ins) const { - cur_cell = GetCellNumber(row, column); - return & cell_info[row][column].inset; + cell_info[row][column].inset = ins; } -int LyXTabular::GetCellFromInset(Inset const * inset, int maybe_cell) const +LyXTabular::idx_type +LyXTabular::getCellFromInset(InsetBase const * inset) const { // is this inset part of the tabular? - if (!inset || inset->owner() != owner_) { - lyxerr[Debug::INSETTEXT] - << "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 (!inset) { + lyxerr << "Error: this is not a cell of the tabular!" << endl; + BOOST_ASSERT(false); } - if (cell == -1) { - for (cell = GetNumberOfCells(); cell >= 0; --cell) { - if (GetCellInset(cell) == inset) - break; + for (idx_type cell = 0, n = getNumberOfCells(); cell < n; ++cell) + if (getCellInset(cell).get() == inset) { + lyxerr[Debug::INSETTEXT] << "LyXTabular::getCellFromInset: " + << "cell=" << cell << endl; + return cell; } - 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; + // We should have found a cell at this point + lyxerr << "LyXTabular::getCellFromInset: Cell of inset " + << inset << " not found!" << endl; + BOOST_ASSERT(false); + // shut up compiler + return 0; } -void LyXTabular::Validate(LaTeXFeatures & features) const +void LyXTabular::validate(LaTeXFeatures & features) const { features.require("NeedTabularnewline"); - if (IsLongTabular()) + if (useBookTabs()) + features.require("booktabs"); + if (isLongTabular()) features.require("longtable"); - if (NeedRotating()) + if (needRotating()) features.require("rotating"); - for (int cell = 0; cell < numberofcells; ++cell) { - if ( (GetVAlignment(cell) != LYX_VALIGN_TOP) || - ( !(GetPWidth(cell).zero())&&!(IsMultiColumn(cell)) ) - ) + for (idx_type 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); } } -vector const LyXTabular::getLabelList() const -{ - vector label_list; - for (int i = 0; i < rows_; ++i) - for (int j = 0; j < columns_; ++j) { - vector const l = - GetCellInset(i, j)->getLabelList(); - label_list.insert(label_list.end(), - l.begin(), l.end()); - } - return label_list; -} - - -LyXTabular::BoxType LyXTabular::UseParbox(int cell) const +LyXTabular::BoxType LyXTabular::useParbox(idx_type cell) const { - ParagraphList const & parlist = GetCellInset(cell)->paragraphs; - ParagraphList::iterator cit = parlist.begin(); - ParagraphList::iterator end = parlist.end(); + ParagraphList const & parlist = getCellInset(cell)->paragraphs(); + ParagraphList::const_iterator cit = parlist.begin(); + ParagraphList::const_iterator end = parlist.end(); - for (; cit != end; ++cit) { - for (int i = 0; i < cit->size(); ++i) { + for (; cit != end; ++cit) + for (int i = 0; i < cit->size(); ++i) if (cit->isNewline(i)) return BOX_PARBOX; - } - } + return BOX_NONE; } + + +} // namespace lyx