X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftabular.C;h=711e5432ab5f1044e0fa8b5c219f034386ae6ad0;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=6343b925aef8d377bc08f34a501eddf5192ad7ca;hpb=59413be9a0b999c17784d1abad01e55819ecd27a;p=lyx.git diff --git a/src/tabular.C b/src/tabular.C index 6343b925ae..711e5432ab 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -21,24 +21,29 @@ #include "buffer.h" #include "bufferparams.h" +#include "BufferView.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 "support/lstrings.h" -#include "support/tostr.h" +#include "support/convert.h" #include -using lyx::support::ltrim; -using lyx::support::prefixIs; -using lyx::support::rtrim; -using lyx::support::strToInt; -using lyx::support::suffixIs; + +namespace lyx { + +using support::prefixIs; +using support::ltrim; +using support::rtrim; +using support::suffixIs; using boost::shared_ptr; using boost::dynamic_pointer_cast; @@ -62,6 +67,8 @@ using std::strlen; namespace { int const WIDTH_OF_LINE = 5; +int const default_line_space = 10; + template string const write_attribute(string const & name, T const & t) @@ -70,28 +77,41 @@ string const write_attribute(string const & name, T const & t) return s.empty() ? s : " " + name + "=\"" + s + "\""; } +template <> string const write_attribute(string const & name, string const & t) { return t.empty() ? t : " " + name + "=\"" + t + "\""; } +template <> string const write_attribute(string const & name, bool const & b) { // we write only true attribute values so we remove a bit of the // file format bloat for tabulars. - return b ? write_attribute(name, tostr(b)) : string(); + return b ? write_attribute(name, convert(b)) : string(); } +template <> string const write_attribute(string const & name, int const & i) { // we write only true attribute values so we remove a bit of the // file format bloat for tabulars. - return i ? write_attribute(name, tostr(i)) : string(); + return i ? write_attribute(name, convert(i)) : string(); +} + + +template <> +string const write_attribute(string const & name, LyXTabular::idx_type const & i) +{ + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return i ? write_attribute(name, convert(i)) : string(); } +template <> string const write_attribute(string const & name, LyXLength const & value) { // we write only the value if we really have one same reson as above. @@ -236,7 +256,7 @@ bool getTokenValue(string const & str, char const * token, int & num) num = 0; if (!getTokenValue(str, token, tmp)) return false; - num = strToInt(tmp); + num = convert(tmp); return true; } @@ -284,6 +304,21 @@ bool getTokenValue(string const & str, char const * token, LyXLength & 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); +} + + void l_getline(istream & is, string & str) { str.erase(); @@ -365,6 +400,9 @@ LyXTabular::rowstruct::rowstruct() 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), @@ -390,14 +428,16 @@ LyXTabular::ltType::ltType() {} -LyXTabular::LyXTabular(BufferParams const & bp, int rows_arg, int columns_arg) +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, int rows_arg, int columns_arg) +void LyXTabular::init(BufferParams const & bp, row_type rows_arg, + col_type columns_arg) { rows_ = rows_arg; columns_ = columns_arg; @@ -408,21 +448,22 @@ void LyXTabular::init(BufferParams const & bp, int rows_arg, int columns_arg) column_info.reserve(10); cell_info.reserve(100); fixCellNums(); - for (int i = 0; i < rows_; ++i) + 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; column_info.back().right_line = true; is_long_tabular = false; rotate = false; + use_booktabs = false; } void LyXTabular::fixCellNums() { - int cellno = 0; - for (int i = 0; i < rows_; ++i) { - for (int j = 0; j < columns_; ++j) { + 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); @@ -435,11 +476,11 @@ void LyXTabular::fixCellNums() } -void LyXTabular::appendRow(BufferParams const & bp, int const cell) +void LyXTabular::appendRow(BufferParams const & bp, idx_type const cell) { ++rows_; - int const 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()); @@ -447,25 +488,25 @@ void LyXTabular::appendRow(BufferParams const & bp, int const cell) row_info[row] = row_info[row + 1]; cell_vvector old(rows_ - 1); - for (int i = 0; i < rows_ - 1; ++i) + for (row_type i = 0; i < rows_ - 1; ++i) swap(cell_info[i], old[i]); cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp))); - for (int i = 0; i <= row; ++i) + for (row_type i = 0; i <= row; ++i) swap(cell_info[i], old[i]); - for (int i = row + 2; i < rows_; ++i) + for (row_type i = row + 2; i < rows_; ++i) swap(cell_info[i], old[i - 1]); - if (bp.tracking_changes) - for (int j = 0; j < columns_; ++j) - cell_info[row + 1][j].inset->markNew(true); + 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 const row) +void LyXTabular::deleteRow(row_type const row) { // Not allowed to delete last row if (rows_ == 1) @@ -478,17 +519,32 @@ void LyXTabular::deleteRow(int const row) } -void LyXTabular::appendColumn(BufferParams const & bp, int const 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_; - 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 (row_type i = 0; i < rows_; ++i) { cell_info[i].insert(cell_info[i].begin() + column + 1, cellstruct(bp)); // care about multicolumns @@ -500,46 +556,68 @@ void LyXTabular::appendColumn(BufferParams const & bp, int const cell) cell_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL; } //++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)); } fixCellNums(); } -void LyXTabular::deleteColumn(int const column) +void LyXTabular::deleteColumn(col_type const 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_; fixCellNums(); } +void LyXTabular::copyColumn(BufferParams const & bp, col_type const column) +{ + ++columns_; + + column_info.insert(column_info.begin() + column, column_info[column]); + + for (row_type i = 0; i < rows_; ++i) + cell_info[i].insert(cell_info[i].begin() + column, cell_info[i][column]); + + 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() { - numberofcells = -1; - for (int row = 0; row < rows_; ++row) { - for (int column = 0; column < columns_; ++column) { + numberofcells = 0; + for (row_type row = 0; row < rows_; ++row) { + for (col_type column = 0; column < columns_; ++column) { if (cell_info[row][column].multicolumn != LyXTabular::CELL_PART_OF_MULTICOLUMN) ++numberofcells; - cell_info[row][column].cellno = numberofcells; + if (numberofcells == 0) + // FIXME: Is this intended? + cell_info[row][column].cellno = npos; + else + cell_info[row][column].cellno = + numberofcells - 1; } } - ++numberofcells; // because this is one more than as we start from 0 rowofcell.resize(numberofcells); columnofcell.resize(numberofcells); - for (int row = 0, column = 0, c = 0; + row_type row = 0; + col_type column = 0; + for (idx_type c = 0; c < numberofcells && row < rows_ && column < columns_;) { rowofcell[c] = row; columnofcell[c] = column; @@ -556,8 +634,8 @@ void LyXTabular::set_row_column_number_info() } } - for (int row = 0; row < rows_; ++row) { - for (int column = 0; column < columns_; ++column) { + for (row_type row = 0; row < rows_; ++row) { + for (col_type column = 0; column < columns_; ++column) { if (isPartOfMultiColumn(row,column)) continue; cell_info[row][column].inset->setAutoBreakRows( @@ -567,43 +645,46 @@ void LyXTabular::set_row_column_number_info() } -int LyXTabular::getNumberOfCells() const +LyXTabular::idx_type LyXTabular::getNumberOfCells() const { return numberofcells; } -int LyXTabular::numberOfCellsInRow(int const 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 const cell, bool const onlycolumn) const +bool LyXTabular::topLine(idx_type const cell, bool const wholerow) const { - if (!onlycolumn && isMultiColumn(cell)) + if (!wholerow && 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 wholerow) const { - if (!onlycolumn && isMultiColumn(cell)) + if (!wholerow && 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 wholecolumn) const { - if (!onlycolumn && isMultiColumn(cell) && + if (use_booktabs) + return false; + if (!wholecolumn && isMultiColumn(cell) && (isFirstCellInRow(cell) || isMultiColumn(cell-1))) { if (cellinfo_of_cell(cell).align_special.empty()) @@ -616,9 +697,11 @@ bool LyXTabular::leftLine(int cell, bool onlycolumn) const } -bool LyXTabular::rightLine(int cell, bool onlycolumn) const +bool LyXTabular::rightLine(idx_type cell, bool wholecolumn) const { - if (!onlycolumn && isMultiColumn(cell) && + if (use_booktabs) + return false; + if (!wholecolumn && isMultiColumn(cell) && (isLastCellInRow(cell) || isMultiColumn(cell + 1))) { if (cellinfo_of_cell(cell).align_special.empty()) @@ -631,11 +714,11 @@ bool LyXTabular::rightLine(int cell, bool onlycolumn) const } -bool LyXTabular::topAlreadyDrawn(int cell) const +bool LyXTabular::topAlreadyDrawn(idx_type cell) const { - int row = row_of_cell(cell); + row_type row = row_of_cell(cell); if (row > 0 && !getAdditionalHeight(row)) { - int column = column_of_cell(cell); + col_type column = column_of_cell(cell); --row; while (column && cell_info[row][column].multicolumn @@ -650,11 +733,11 @@ 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)); @@ -666,13 +749,13 @@ bool LyXTabular::leftAlreadyDrawn(int cell) const } -bool LyXTabular::isLastRow(int cell) const +bool LyXTabular::isLastRow(idx_type cell) const { 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; @@ -680,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; @@ -689,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; @@ -698,18 +781,21 @@ 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 // used to get it back in text.C - int const col = right_column_of_cell(cell); - int const row = row_of_cell(cell); + 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) { @@ -720,12 +806,12 @@ int LyXTabular::getAdditionalWidth(int cell) const // 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; } @@ -738,23 +824,23 @@ int LyXTabular::getWidthOfTabular() const // returns true if a complete update is necessary, otherwise false -bool LyXTabular::setWidthOfMulticolCell(int cell, int new_width) +bool LyXTabular::setWidthOfMulticolCell(idx_type cell, int new_width) { if (!isMultiColumn(cell)) return false; - int const row = row_of_cell(cell); - int const column1 = column_of_cell(cell); - int const column2 = right_column_of_cell(cell); + 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; + 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; @@ -773,14 +859,14 @@ 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 @@ -789,7 +875,7 @@ void LyXTabular::recalculateMulticolumnsOfColumn(int column) (mc == CELL_PART_OF_MULTICOLUMN && nmc == CELL_PART_OF_MULTICOLUMN)) { - int const cellno = cell_info[row][column].cellno; + idx_type const cellno = cell_info[row][column].cellno; setWidthOfMulticolCell(cellno, getWidthOfCell(cellno) - 2 * WIDTH_OF_LINE); } @@ -797,11 +883,10 @@ void LyXTabular::recalculateMulticolumnsOfColumn(int column) } -// returns 1 if a complete update is necessary, otherwise 0 -void 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; @@ -826,14 +911,15 @@ void LyXTabular::setWidthOfCell(int cell, int new_width) 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(); } } -void LyXTabular::setAlignment(int cell, LyXAlignment align, bool onlycolumn) +void LyXTabular::setAlignment(idx_type cell, LyXAlignment align, + bool onlycolumn) { if (!isMultiColumn(cell) || onlycolumn) column_info[column_of_cell(cell)].alignment = align; @@ -842,7 +928,8 @@ void LyXTabular::setAlignment(int cell, LyXAlignment align, bool onlycolumn) } -void LyXTabular::setVAlignment(int cell, VAlignment align, bool onlycolumn) +void LyXTabular::setVAlignment(idx_type cell, VAlignment align, + bool onlycolumn) { if (!isMultiColumn(cell) || onlycolumn) column_info[column_of_cell(cell)].valignment = align; @@ -851,31 +938,75 @@ void LyXTabular::setVAlignment(int cell, VAlignment align, bool onlycolumn) } -void 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) { - int const j = column_of_cell(cell); + col_type const j = column_of_cell(cell); column_info[j].p_width = width; - for (int i = 0; i < rows_; ++i) { - int const cell = getCellNumber(i, j); + for (row_type i = 0; i < rows_; ++i) { + idx_type const cell = getCellNumber(i, j); // because of multicolumns - getCellInset(cell)->setAutoBreakRows(!getPWidth(cell).zero()); + toggleFixedWidth(cur, getCellInset(cell).get(), + !getPWidth(cell).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(); } -bool LyXTabular::setMColumnPWidth(int cell, LyXLength const & width) +bool LyXTabular::setMColumnPWidth(LCursor & cur, idx_type cell, + LyXLength const & width) { if (!isMultiColumn(cell)) return false; cellinfo_of_cell(cell).p_width = width; - getCellInset(cell)->setAutoBreakRows(!width.zero()); + 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; } -void LyXTabular::setAlignSpecial(int cell, string const & special, +void LyXTabular::setAlignSpecial(idx_type cell, string const & special, LyXTabular::Feature what) { if (what == SET_SPECIAL_MULTI) @@ -885,7 +1016,7 @@ void LyXTabular::setAlignSpecial(int cell, string const & special, } -void LyXTabular::setAllLines(int cell, bool line) +void LyXTabular::setAllLines(idx_type cell, bool line) { setTopLine(cell, line); setBottomLine(cell, line); @@ -894,44 +1025,44 @@ void LyXTabular::setAllLines(int cell, bool line) } -void LyXTabular::setTopLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setTopLine(idx_type cell, bool line, bool wholerow) { - int const row = row_of_cell(cell); - if (onlycolumn || !isMultiColumn(cell)) + row_type const row = row_of_cell(cell); + if (wholerow || !isMultiColumn(cell)) row_info[row].top_line = line; else cellinfo_of_cell(cell).top_line = line; } -void LyXTabular::setBottomLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setBottomLine(idx_type cell, bool line, bool wholerow) { - if (onlycolumn || !isMultiColumn(cell)) + if (wholerow || !isMultiColumn(cell)) row_info[row_of_cell(cell)].bottom_line = line; else cellinfo_of_cell(cell).bottom_line = line; } -void LyXTabular::setLeftLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setLeftLine(idx_type cell, bool line, bool wholecolumn) { - if (onlycolumn || !isMultiColumn(cell)) + if (wholecolumn || !isMultiColumn(cell)) column_info[column_of_cell(cell)].left_line = line; else cellinfo_of_cell(cell).left_line = line; } -void LyXTabular::setRightLine(int cell, bool line, bool onlycolumn) +void LyXTabular::setRightLine(idx_type cell, bool line, bool wholecolumn) { - if (onlycolumn || !isMultiColumn(cell)) + if (wholecolumn || !isMultiColumn(cell)) column_info[right_column_of_cell(cell)].right_line = line; else 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; @@ -940,7 +1071,7 @@ LyXAlignment LyXTabular::getAlignment(int cell, bool onlycolumn) const 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; @@ -948,7 +1079,7 @@ LyXTabular::getVAlignment(int cell, bool onlycolumn) const } -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; @@ -956,13 +1087,13 @@ LyXLength const LyXTabular::getPWidth(int cell) const } -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; @@ -970,7 +1101,7 @@ LyXLength const LyXTabular::getMColumnPWidth(int cell) const } -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; @@ -978,19 +1109,19 @@ string const LyXTabular::getAlignSpecial(int cell, int what) const } -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; @@ -1013,13 +1144,13 @@ 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) row = rows_ - 1; @@ -1027,13 +1158,13 @@ int LyXTabular::getFirstCellInRow(int row) const } -bool LyXTabular::isLastCellInRow(int cell) const +bool LyXTabular::isLastCellInRow(idx_type cell) const { 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) row = rows_ - 1; @@ -1041,10 +1172,10 @@ int LyXTabular::getLastCellInRow(int row) const } -void LyXTabular::calculate_width_of_column(int column) +void LyXTabular::calculate_width_of_column(col_type 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; } @@ -1056,12 +1187,12 @@ void LyXTabular::calculate_width_of_column(int column) // 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); + 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) @@ -1077,35 +1208,35 @@ bool LyXTabular::calculate_width_of_column_NMC(int column) 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; - 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; - 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); + 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; @@ -1124,6 +1255,7 @@ void LyXTabular::write(Buffer const & buf, ostream & os) const // global longtable options 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 << " 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, LyXLex & lex) { string line; @@ -1290,39 +1357,20 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) 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" @@ -1337,7 +1385,7 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) 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" @@ -1346,12 +1394,18 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) } 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" @@ -1394,48 +1448,50 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) } -bool LyXTabular::isMultiColumn(int cell) const +bool LyXTabular::isMultiColumn(idx_type cell) const { return cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL; } -bool LyXTabular::isMultiColumnReal(int cell) const +bool LyXTabular::isMultiColumnReal(idx_type cell) const { return column_of_cell(cell) != right_column_of_cell(cell) && cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL; } -LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(int cell) const +LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(idx_type cell) const { return cell_info[row_of_cell(cell)][column_of_cell(cell)]; } -void LyXTabular::setMultiColumn(Buffer * buffer, int cell, int number) +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 (int i = 1; i < number; ++i) { + 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(false); + cs1.inset->clear(); } 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_ && cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN) @@ -1447,12 +1503,12 @@ 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; @@ -1470,6 +1526,18 @@ int LyXTabular::unsetMultiColumn(int cell) } +void LyXTabular::setBookTabs(bool what) +{ + use_booktabs = what; +} + + +bool LyXTabular::useBookTabs() const +{ + return use_booktabs; +} + + void LyXTabular::setLongTabular(bool what) { is_long_tabular = what; @@ -1494,13 +1562,13 @@ bool LyXTabular::getRotateTabular() const } -void LyXTabular::setRotateCell(int cell, bool flag) +void LyXTabular::setRotateCell(idx_type cell, bool 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; } @@ -1510,15 +1578,15 @@ 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) return false; @@ -1526,7 +1594,7 @@ bool LyXTabular::isLastCell(int cell) const } -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; @@ -1534,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; @@ -1542,9 +1610,9 @@ 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); @@ -1552,7 +1620,7 @@ int LyXTabular::getLastCellAbove(int cell) const } -int LyXTabular::getLastCellBelow(int cell) const +LyXTabular::idx_type LyXTabular::getLastCellBelow(idx_type cell) const { if (row_of_cell(cell) + 1 >= rows_) return cell; @@ -1562,20 +1630,22 @@ int LyXTabular::getLastCellBelow(int cell) const } -int LyXTabular::getCellNumber(int row, int column) const +LyXTabular::idx_type LyXTabular::getCellNumber(row_type row, + col_type column) const { - BOOST_ASSERT(column >= 0 || column < columns_ || row >= 0 || row < rows_); + 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; } -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())) @@ -1589,7 +1659,8 @@ LyXTabular::BoxType LyXTabular::getUsebox(int cell) const /// // 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; @@ -1603,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(); @@ -1611,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(); @@ -1619,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; @@ -1633,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(); @@ -1641,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(); @@ -1649,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; } @@ -1663,7 +1735,7 @@ 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; @@ -1674,7 +1746,7 @@ 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; @@ -1683,7 +1755,7 @@ bool LyXTabular::haveLTFirstHead() const 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; @@ -1694,7 +1766,7 @@ 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; @@ -1703,7 +1775,7 @@ bool LyXTabular::haveLTLastFoot() const // end longtable support functions -void 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; @@ -1711,7 +1783,7 @@ void LyXTabular::setAscentOfRow(int row, int height) } -void 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; @@ -1719,7 +1791,7 @@ void LyXTabular::setDescentOfRow(int row, int height) } -int LyXTabular::getAscentOfRow(int row) const +int LyXTabular::getAscentOfRow(row_type row) const { if (row >= rows_) return 0; @@ -1727,7 +1799,7 @@ int LyXTabular::getAscentOfRow(int row) const } -int LyXTabular::getDescentOfRow(int row) const +int LyXTabular::getDescentOfRow(row_type row) const { BOOST_ASSERT(row < rows_); return row_info[row].descent_of_row; @@ -1737,14 +1809,14 @@ int LyXTabular::getDescentOfRow(int row) const int LyXTabular::getHeightOfTabular() const { int height = 0; - for (int row = 0; row < rows_; ++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 { BOOST_ASSERT(row < rows_); BOOST_ASSERT(column < columns_); @@ -1752,25 +1824,28 @@ bool LyXTabular::isPartOfMultiColumn(int row, int column) const } -int LyXTabular::TeXTopHLine(ostream & os, int row) const +int LyXTabular::TeXTopHLine(odocstream & os, row_type row) const { - BOOST_ASSERT(row >= 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) { + 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) { + for (idx_type i = fcell; i < n; ++i) { if (topLine(i)) { - os << "\\cline{" + os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << column_of_cell(i) + 1 << '-' << right_column_of_cell(i) + 1 @@ -1785,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) { + 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) { + for (idx_type i = fcell; i < n; ++i) { if (bottomLine(i)) { - os << "\\cline{" + os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << column_of_cell(i) + 1 << '-' << right_column_of_cell(i) + 1 @@ -1818,7 +1896,7 @@ 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; @@ -1829,7 +1907,8 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const if (isMultiColumn(cell)) { os << "\\multicolumn{" << cells_in_multicolumn(cell) << "}{"; if (!cellinfo_of_cell(cell).align_special.empty()) { - os << cellinfo_of_cell(cell).align_special << "}{"; + os << from_ascii(cellinfo_of_cell(cell).align_special) + << "}{"; } else { if (leftLine(cell) && (isFirstCellInRow(cell) || @@ -1851,7 +1930,7 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const break; } os << '{' - << getPWidth(cell).asLatexString() + << from_ascii(getPWidth(cell).asLatexString()) << '}'; } else { switch (getAlignment(cell)) { @@ -1887,7 +1966,8 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const os << 'b'; break; } - os << "]{" << getPWidth(cell).asLatexString() << "}{"; + os << "]{" << from_ascii(getPWidth(cell).asLatexString()) + << "}{"; } else if (getUsebox(cell) == BOX_MINIPAGE) { os << "\\begin{minipage}["; switch (getVAlignment(cell)) { @@ -1901,14 +1981,15 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const 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; @@ -1930,7 +2011,7 @@ int LyXTabular::TeXCellPostamble(ostream & os, int cell) const } -int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, +int LyXTabular::TeXLongtableHeaderFooter(odocstream & os, Buffer const & buf, OutputParams const & runparams) const { if (!is_long_tabular) @@ -1943,7 +2024,7 @@ 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); } @@ -1965,7 +2046,7 @@ 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); } @@ -1983,7 +2064,7 @@ 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); } @@ -2005,7 +2086,7 @@ 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); } @@ -2021,7 +2102,7 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, } -bool LyXTabular::isValidRow(int row) const +bool LyXTabular::isValidRow(row_type row) const { if (!is_long_tabular) return true; @@ -2030,13 +2111,30 @@ bool LyXTabular::isValidRow(int row) const } -int LyXTabular::TeXRow(ostream & os, int i, Buffer const & buf, +int LyXTabular::TeXRow(odocstream & os, row_type i, Buffer const & buf, OutputParams const & runparams) const { - int cell = getCellNumber(i, 0); - + idx_type cell = getCellNumber(i, 0); int ret = TeXTopHLine(os, i); - for (int j = 0; j < columns_; ++j) { + 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); @@ -2055,19 +2153,47 @@ int LyXTabular::TeXRow(ostream & os, int i, Buffer const & buf, ret += TeXCellPostamble(os, cell); if (!isLastCellInRow(cell)) { // not last cell in row - os << "&\n"; - ++ret; + 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, +int LyXTabular::latex(Buffer const & buf, odocstream & os, OutputParams const & runparams) const { int ret = 0; @@ -2084,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) { @@ -2120,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) { @@ -2135,7 +2261,7 @@ int LyXTabular::latex(Buffer const & buf, ostream & os, break; } } - if (column_info[i].right_line) + if (!use_booktabs && column_info[i].right_line) os << '|'; } } @@ -2148,7 +2274,7 @@ int LyXTabular::latex(Buffer const & buf, ostream & os, //+ 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); if (is_long_tabular && row_info[i].newpage) { @@ -2175,56 +2301,14 @@ int LyXTabular::latex(Buffer const & buf, ostream & os, } -int LyXTabular::linuxdoc(Buffer const & buf, ostream & os, - const OutputParams & runparams) const -{ - os << "\n"; - int cell = 0; - int ret = 0; - for (int i = 0; i < rows_; ++i) { - for (int j = 0; j < columns_; ++j) { - if (isPartOfMultiColumn(i, j)) - continue; - shared_ptr inset = getCellInset(cell); - - ret += inset->linuxdoc(buf, os, runparams); - - if (isLastCellInRow(cell)) { - os << "@\n"; - ++ret; - } else { - os << "|"; - } - ++cell; - } - } - os << "\n"; - return ret; -} - - -int LyXTabular::docbookRow(Buffer const & buf, ostream & os, int row, +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) { + for (col_type j = 0; j < columns_; ++j) { if (isPartOfMultiColumn(row, j)) continue; @@ -2269,7 +2353,7 @@ int LyXTabular::docbookRow(Buffer const & buf, ostream & os, int row, } -int LyXTabular::docbook(Buffer const & buf, ostream & os, +int LyXTabular::docbook(Buffer const & buf, odocstream & os, OutputParams const & runparams) const { int ret = 0; @@ -2281,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"; ++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, runparams); } @@ -2321,7 +2405,7 @@ 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, runparams); } @@ -2336,7 +2420,7 @@ 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, runparams); } @@ -2354,14 +2438,14 @@ int LyXTabular::docbook(Buffer const & buf, ostream & os, } -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) { + for (idx_type i = fcell; i < n; ++i) { if (topLine(i)) { ++tmp; break; @@ -2370,8 +2454,8 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, if (!tmp) return 0; - unsigned char ch; - for (int i = fcell; i < n; ++i) { + char_type ch; + for (idx_type i = fcell; i < n; ++i) { if (topLine(i)) { if (leftLine(i)) os << "+-"; @@ -2382,12 +2466,12 @@ 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 (column < columns_ - 1 && isPartOfMultiColumn(row, ++column)) len += clen[column] + 4; - os << string(len, ch); + os << docstring(len, ch); if (topLine(i)) { if (rightLine(i)) os << "-+"; @@ -2402,14 +2486,14 @@ 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) { + for (idx_type i = fcell; i < n; ++i) { if (bottomLine(i)) { ++tmp; break; @@ -2418,8 +2502,8 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, if (!tmp) return 0; - unsigned char ch; - for (int i = fcell; i < n; ++i) { + char_type ch; + for (idx_type i = fcell; i < n; ++i) { if (bottomLine(i)) { if (leftLine(i)) os << "+-"; @@ -2430,12 +2514,12 @@ 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 (column < columns_ -1 && isPartOfMultiColumn(row, ++column)) len += clen[column] + 4; - os << string(len, ch); + os << docstring(len, ch); if (bottomLine(i)) { if (rightLine(i)) os << "-+"; @@ -2450,13 +2534,13 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, } -int LyXTabular::asciiPrintCell(Buffer const & buf, ostream & os, +int LyXTabular::asciiPrintCell(Buffer const & buf, odocstream & os, OutputParams const & runparams, - int cell, int row, int column, + idx_type cell, row_type row, col_type column, vector const & clen, bool onlydata) const { - ostringstream sstr; + odocstringstream sstr; int const ret = getCellInset(cell)->plaintext(buf, sstr, runparams); if (onlydata) { @@ -2491,7 +2575,8 @@ int LyXTabular::asciiPrintCell(Buffer const & buf, ostream & os, break; } - os << string(len1, ' ') << sstr.str() << string(len2, ' '); + os << docstring(len1, ' ') << sstr.str() + << docstring(len2, ' '); if (rightLine(cell)) os << " |"; @@ -2502,7 +2587,7 @@ int LyXTabular::asciiPrintCell(Buffer const & buf, ostream & os, } -int LyXTabular::plaintext(Buffer const & buf, ostream & os, +int LyXTabular::plaintext(Buffer const & buf, odocstream & os, OutputParams const & runparams, int const depth, bool onlydata, unsigned char delim) const @@ -2514,40 +2599,40 @@ int LyXTabular::plaintext(Buffer const & buf, ostream & os, 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); + for (row_type i = 0; i < rows_; ++i) { + idx_type cell = getCellNumber(i, j); if (isMultiColumnReal(cell)) continue; - ostringstream sstr; + 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); + 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; + 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) { + idx_type cell = 0; + for (row_type i = 0; i < rows_; ++i) { if (!onlydata && asciiTopHLine(os, i, clen)) - os << string(depth * 2, ' '); - for (int j = 0; j < columns_; ++j) { + os << docstring(depth * 2, ' '); + for (col_type j = 0; j < columns_; ++j) { if (isPartOfMultiColumn(i, j)) continue; if (onlydata && j > 0) @@ -2558,28 +2643,37 @@ int LyXTabular::plaintext(Buffer const & buf, ostream & os, } os << endl; if (!onlydata) { - os << string(depth * 2, ' '); + os << docstring(depth * 2, ' '); if (asciiBottomHLine(os, i, clen)) - os << string(depth * 2, ' '); + os << docstring(depth * 2, ' '); } } return ret; } -shared_ptr 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(int row, int column) const +shared_ptr LyXTabular::getCellInset(row_type row, + col_type column) const { return cell_info[row][column].inset; } -int LyXTabular::getCellFromInset(InsetBase const * inset) const +void LyXTabular::setCellInset(row_type row, col_type column, + shared_ptr ins) const +{ + cell_info[row][column].inset = ins; +} + + +LyXTabular::idx_type +LyXTabular::getCellFromInset(InsetBase const * inset) const { // is this inset part of the tabular? if (!inset) { @@ -2587,7 +2681,7 @@ int LyXTabular::getCellFromInset(InsetBase const * inset) const BOOST_ASSERT(false); } - for (int cell = 0, n = getNumberOfCells(); cell < n; ++cell) + for (idx_type cell = 0, n = getNumberOfCells(); cell < n; ++cell) if (getCellInset(cell).get() == inset) { lyxerr[Debug::INSETTEXT] << "LyXTabular::getCellFromInset: " << "cell=" << cell << endl; @@ -2606,11 +2700,13 @@ int LyXTabular::getCellFromInset(InsetBase const * inset) const void LyXTabular::validate(LaTeXFeatures & features) const { features.require("NeedTabularnewline"); + if (useBookTabs()) + features.require("booktabs"); if (isLongTabular()) features.require("longtable"); if (needRotating()) features.require("rotating"); - for (int cell = 0; cell < numberofcells; ++cell) { + for (idx_type cell = 0; cell < numberofcells; ++cell) { if (getVAlignment(cell) != LYX_VALIGN_TOP || (!getPWidth(cell).zero() && !isMultiColumn(cell))) features.require("array"); @@ -2619,16 +2715,7 @@ void LyXTabular::validate(LaTeXFeatures & features) const } -void LyXTabular::getLabelList(Buffer const & buffer, - std::vector & list) const -{ - for (int i = 0; i < rows_; ++i) - for (int j = 0; j < columns_; ++j) - getCellInset(i, j)->getLabelList(buffer, list); -} - - -LyXTabular::BoxType LyXTabular::useParbox(int cell) const +LyXTabular::BoxType LyXTabular::useParbox(idx_type cell) const { ParagraphList const & parlist = getCellInset(cell)->paragraphs(); ParagraphList::const_iterator cit = parlist.begin(); @@ -2641,3 +2728,6 @@ LyXTabular::BoxType LyXTabular::useParbox(int cell) const return BOX_NONE; } + + +} // namespace lyx