X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftabular.C;h=5213651290be0272b317d78b35e5836db4a69e27;hb=c130d5dbfd3f4d4a2721c9be786b7fa45b806aca;hp=3d68635b218d858c59564110881b35e661ed2bd8;hpb=4c6091b63f6ac4dae69ddcee26bf22e4f35a3cdf;p=features.git diff --git a/src/tabular.C b/src/tabular.C index 3d68635b21..5213651290 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -3,7 +3,7 @@ * * LyX, The Document Processor * - * Copyright 2000 The LyX Team. + * Copyright 2000-2001 The LyX Team. * * @author: Jürgen Vigna * @@ -16,6 +16,9 @@ #pragma implementation #endif +// temporary until verified (08/08/2001 Jug) +#define SPECIAL_COLUM_HANDLING 1 + #include #include @@ -23,13 +26,14 @@ #include "debug.h" #include "vspace.h" #include "layout.h" -#include "lyx_gui_misc.h" +#include "frontends/Alert.h" #include "buffer.h" #include "BufferView.h" #include "Painter.h" #include "LaTeXFeatures.h" #include "support/lstrings.h" #include "support/lyxmanip.h" +#include "support/LAssert.h" #include "insets/insettabular.h" #include "insets/insettext.h" #include "gettext.h" @@ -41,6 +45,10 @@ using std::max; using std::endl; using std::vector; +#ifndef CXX_GLOBAL_CSTD +using std::strlen; +#endif + namespace { int const WIDTH_OF_LINE = 5; @@ -85,18 +93,40 @@ LyXTabular::columnstruct::columnstruct() } +LyXTabular::lttype::lttype() +{ + row = 0; + topDL = false; + bottomDL = false; +} + + /* konstruktor */ LyXTabular::LyXTabular(InsetTabular * inset, int rows_arg, int columns_arg) { owner_ = inset; + cur_cell = -1; Init(rows_arg, columns_arg); } -LyXTabular::LyXTabular(InsetTabular * inset, LyXTabular const & lt) +LyXTabular::LyXTabular(InsetTabular * inset, LyXTabular const & lt, + bool same_id) { owner_ = inset; + cur_cell = -1; Init(lt.rows_, lt.columns_, <); + // we really should change again to have InsetText as a pointer + // and allocate it then we would not have to do this stuff all + // double! + if (same_id) { + for (int i = 0; i < rows_; ++i) { + for (int j = 0; j < columns_; ++j) { + cell_info[i][j].inset.id(lt.cell_info[i][j].inset.id()); + cell_info[i][j].inset.setParagraphData(lt.cell_info[i][j].inset.paragraph(),true); + } + } + } #if 0 #ifdef WITH_WARNINGS #warning Jürgen, can you make it the other way round. So that copy assignment depends on the copy constructor and not the other way. (Lgb) @@ -109,17 +139,24 @@ LyXTabular::LyXTabular(InsetTabular * inset, LyXTabular const & lt) LyXTabular::LyXTabular(Buffer const * buf, InsetTabular * inset, LyXLex & lex) { owner_ = inset; + cur_cell = -1; Read(buf, lex); } LyXTabular & LyXTabular::operator=(LyXTabular const & lt) { +#if 0 +#warning This while method should look like this: (Lgb) + + LyXTabular tmp(lt); + tmp.swap(*this); +#else // If this and lt is not of the same size we have a serious bug // So then it is ok to throw an exception, or for now // call abort() lyx::Assert(rows_ == lt.rows_ && columns_ == lt.columns_); - + cur_cell = -1; cell_info = lt.cell_info; row_info = lt.row_info; column_info = lt.column_info; @@ -134,14 +171,14 @@ LyXTabular & LyXTabular::operator=(LyXTabular const & lt) rotate = lt.rotate; Reinit(); - +#endif return *this; } -LyXTabular * LyXTabular::Clone(InsetTabular * inset) +LyXTabular * LyXTabular::clone(InsetTabular * inset, bool same_id) { - LyXTabular * result = new LyXTabular(inset, *this); + LyXTabular * result = new LyXTabular(inset, *this, same_id); #if 0 // don't know if this is good but I need to Clone also // the text-insets here, this is for the Undo-facility! @@ -174,7 +211,7 @@ void LyXTabular::Init(int rows_arg, int columns_arg, LyXTabular const * lt) for (int i = 0; i < rows_; ++i) { for (int j = 0; j < columns_; ++j) { cell_info[i][j].inset.setOwner(owner_); - cell_info[i][j].inset.SetDrawFrame(0, InsetText::LOCKED); + cell_info[i][j].inset.setDrawFrame(0, InsetText::LOCKED); cell_info[i][j].cellno = cellno++; } cell_info[i].back().right_line = true; @@ -194,10 +231,10 @@ void LyXTabular::Init(int rows_arg, int columns_arg, LyXTabular const * lt) set_row_column_number_info(); is_long_tabular = false; rotate = false; - endhead = 0; - endfirsthead = 0; - endfoot = 0; - endlastfoot = 0; + endhead.row = 0; + endfirsthead.row = 0; + endfoot.row = 0; + endlastfoot.row = 0; } @@ -241,9 +278,6 @@ void LyXTabular::AppendRow(int cell) void LyXTabular::DeleteRow(int row) { - // Why make it so hard? (Lgb) - //if (!(rows_ - 1)) - //return; if (rows_ == 1) return; // Not allowed to delete last row row_info.erase(row_info.begin() + row); //&row_info[row]); @@ -369,7 +403,7 @@ void LyXTabular::set_row_column_number_info(bool oldformat) cell_info[row][column].right_line = cell_info[row][column+cn-1].right_line; } - cell_info[row][column].inset.SetAutoBreakRows( + cell_info[row][column].inset.setAutoBreakRows( !GetPWidth(GetCellNumber(row, column)).empty()); } } @@ -421,17 +455,43 @@ bool LyXTabular::BottomLine(int cell, bool onlycolumn) const bool LyXTabular::LeftLine(int cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell)) + if (!onlycolumn && IsMultiColumn(cell)) { +#ifdef SPECIAL_COLUM_HANDLING + if (cellinfo_of_cell(cell)->align_special.empty()) + return cellinfo_of_cell(cell)->left_line; + return prefixIs(frontStrip(cellinfo_of_cell(cell)->align_special), "|"); +#else return cellinfo_of_cell(cell)->left_line; +#endif + } +#ifdef SPECIAL_COLUM_HANDLING + if (column_info[column_of_cell(cell)].align_special.empty()) + return column_info[column_of_cell(cell)].left_line; + return prefixIs(frontStrip(column_info[column_of_cell(cell)].align_special), "|"); +#else return column_info[column_of_cell(cell)].left_line; +#endif } bool LyXTabular::RightLine(int cell, bool onlycolumn) const { - if (!onlycolumn && IsMultiColumn(cell)) + if (!onlycolumn && IsMultiColumn(cell)) { +#ifdef SPECIAL_COLUM_HANDLING + if (cellinfo_of_cell(cell)->align_special.empty()) + return cellinfo_of_cell(cell)->right_line; + return suffixIs(strip(cellinfo_of_cell(cell)->align_special), "|"); +#else return cellinfo_of_cell(cell)->right_line; +#endif + } +#ifdef SPECIAL_COLUM_HANDLING + if (column_info[column_of_cell(cell)].align_special.empty()) + return column_info[right_column_of_cell(cell)].right_line; + return suffixIs(strip(column_info[column_of_cell(cell)].align_special), "|"); +#else return column_info[right_column_of_cell(cell)].right_line; +#endif } @@ -464,7 +524,11 @@ bool LyXTabular::LeftAlreadyDrawed(int cell) const LyXTabular::CELL_PART_OF_MULTICOLUMN)); if (GetAdditionalWidth(cell_info[row][column].cellno)) return false; +#ifdef SPECIAL_COLUM_HANDLING return column_info[column].right_line; +#else + return RightLine(cell_info[row][column].cellno, true); +#endif } return false; } @@ -513,11 +577,14 @@ int LyXTabular::GetAdditionalWidth(int cell) const // internally already set in SetWidthOfCell // used to get it back in text.C int const col = right_column_of_cell(cell); - if (col < columns_ - 1 && column_info[col].right_line && - column_info[col+1].left_line) + int const row = row_of_cell(cell); + if (col < columns_ - 1 && RightLine(cell, true) && + LeftLine(cell_info[row][col+1].cellno, true)) // column_info[col+1].left_line) + { return WIDTH_OF_LINE; - else + } else { return 0; + } } @@ -594,17 +661,28 @@ bool LyXTabular::SetWidthOfCell(int cell, int new_width) int const column1 = column_of_cell(cell); bool tmp = false; int width = 0; + int add_width = 0; - if (GetWidthOfCell(cell) == (new_width+2*WIDTH_OF_LINE)) +#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 + { + // 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); } else { - width = (new_width + 2*WIDTH_OF_LINE); + width = (new_width + 2*WIDTH_OF_LINE + add_width); cell_info[row][column1].width_of_cell = width; - if (column_info[column1].right_line && (column1 < columns_-1) && - column_info[column1+1].left_line) // additional width - cell_info[row][column1].width_of_cell += WIDTH_OF_LINE; tmp = calculate_width_of_column_NMC(column1); } if (tmp) { @@ -655,7 +733,7 @@ bool LyXTabular::SetColumnPWidth(int cell, string const & width) for (int i = 0; i < rows_; ++i) { int c = GetCellNumber(i, j); flag = !GetPWidth(c).empty(); // because of multicolumns! - GetCellInset(c)->SetAutoBreakRows(flag); + GetCellInset(c)->setAutoBreakRows(flag); } return true; } @@ -667,7 +745,7 @@ bool LyXTabular::SetMColumnPWidth(int cell, string const & width) cellinfo_of_cell(cell)->p_width = width; if (IsMultiColumn(cell)) { - GetCellInset(cell)->SetAutoBreakRows(flag); + GetCellInset(cell)->setAutoBreakRows(flag); return true; } return false; @@ -921,6 +999,7 @@ int LyXTabular::right_column_of_cell(int cell) const // Perfect case for a template... (Lgb) +// or perhaps not... #if 1 template string const write_attribute(string const & name, T const & t) @@ -1027,10 +1106,10 @@ void LyXTabular::Write(Buffer const * buf, ostream & os) const os << "\n"; for (int j = 0; j < columns_; ++j) { os << "\n"; os << "\\begin_inset "; - cell_info[i][j].inset.Write(buf, os); + cell_info[i][j].inset.write(buf, os); os << "\n\\end_inset \n" << "\n"; } @@ -1146,8 +1225,8 @@ bool getTokenValue(string const & str, const char * token, string & ret) 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] != '=') + if (pos == string::npos || pos + token_length + 1 >= str.length() + || str[pos + token_length] != '=') return false; ret.erase(); pos += token_length + 1; @@ -1266,11 +1345,14 @@ void LyXTabular::ReadNew(Buffer const * buf, istream & is, } getTokenValue(line, "rotate", rotate); getTokenValue(line, "islongtable", is_long_tabular); - getTokenValue(line, "endhead", endhead); - getTokenValue(line, "endfirsthead", endfirsthead); - getTokenValue(line, "endfoot", endfoot); - getTokenValue(line, "endlastfoot", endlastfoot); - + getTokenValue(line, "endhead", endhead.row); + getTokenValue(line, "endfirsthead", endfirsthead.row); + getTokenValue(line, "endfoot", endfoot.row); + getTokenValue(line, "endlastfoot", endlastfoot.row); + endhead.row = abs(endhead.row); + endfirsthead.row = abs(endfirsthead.row); + endfoot.row = abs(endfoot.row); + endlastfoot.row = abs(endlastfoot.row); for (int j = 0; j < columns_; ++j) { l_getline(is,line); if (!prefixIs(line,"")) { @@ -1369,7 +1451,7 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) lyxerr << "Tabular format < 5 is not supported anymore\n" "Get an older version of LyX (< 1.1.x) for conversion!" << endl; - WriteAlert(_("Warning:"), + Alert::alert(_("Warning:"), _("Tabular format < 5 is not supported anymore\n"), _("Get an older version of LyX (< 1.1.x) for conversion!")); if (version > 2) { @@ -1401,10 +1483,10 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) cont_row_info = vector(rows_arg); SetLongTabular(is_long_tabular_arg); SetRotateTabular(rotate_arg); - endhead = a + 1; - endfirsthead = b + 1; - endfoot = c + 1; - endlastfoot = d + 1; + endhead.row = a + 1; + endfirsthead.row = b + 1; + endfoot.row = c + 1; + endlastfoot.row = d + 1; for (i = 0; i < rows_; ++i) { a = b = c = d = e = f = g = 0; is >> a >> b >> c >> d; @@ -1473,27 +1555,32 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) } set_row_column_number_info(true); - LyXParagraph * par = new LyXParagraph; - LyXParagraph * return_par = 0; + Paragraph * par = new Paragraph; + Paragraph * return_par = 0; string tmptok; int pos = 0; - char depth = 0; + Paragraph::depth_type depth = 0; LyXFont font(LyXFont::ALL_INHERIT); - font.setLanguage(owner_->BufferOwner()->GetLanguage()); + font.setLanguage(owner_->bufferOwner()->getLanguage()); - while (lex.IsOK()) { + while (lex.isOK()) { lex.nextToken(); - string const token = lex.GetString(); + string const token = lex.getString(); if (token.empty()) continue; if (token == "\\layout" || token == "\\end_float" || token == "\\end_deeper") { lex.pushToken(token); +#ifndef NO_COMPABILITY + // Here we need to insert the inset_ert_contents into the last + // cell of the tabular. + owner_->bufferOwner()->insertErtContents(par, pos, font); +#endif break; } - if (owner_->BufferOwner()->parseSingleLyXformat2Token(lex, par, + if (owner_->bufferOwner()->parseSingleLyXformat2Token(lex, par, return_par, token, pos, depth, font)) { @@ -1515,9 +1602,9 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) int row; for (int i = 0; i < par->size(); ++i) { - if (par->IsNewline(i)) { + if (par->isNewline(i)) { ++cell; - if (cell > GetNumberOfCells()) { + if (cell > numberofcells) { lyxerr << "Some error in reading old table format occured!" << endl << "Terminating when reading cell[" << cell << "]!" << endl; @@ -1538,12 +1625,12 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) if (!cell_info[row_of_cell(cell)][column_of_cell(cell)].usebox) { // insert a space instead - par->Erase(i); - par->InsertChar(i, ' '); + par->erase(i); + par->insertChar(i, ' '); } } - par->CopyIntoMinibuffer(*owner_->BufferOwner(), i); - inset->par->InsertFromMinibuffer(inset->par->size()); + par->copyIntoMinibuffer(*owner_->bufferOwner(), i); + inset->paragraph()->insertFromMinibuffer(inset->paragraph()->size()); } delete par; Reinit(); @@ -1669,7 +1756,7 @@ bool LyXTabular::NeedRotating() const bool LyXTabular::IsLastCell(int cell) const { - if ((cell + 1) < GetNumberOfCells()) + if ((cell + 1) < numberofcells) return false; return true; } @@ -1713,6 +1800,7 @@ int LyXTabular::GetLastCellBelow(int cell) const int LyXTabular::GetCellNumber(int row, int column) const { +#if 0 if (column >= columns_) column = columns_ - 1; else if (column < 0) @@ -1721,7 +1809,9 @@ int LyXTabular::GetCellNumber(int row, int column) const row = rows_ - 1; else if (row < 0) row = 0; - +#else + lyx::Assert(column >= 0 || column < columns_ || row >= 0 || row < rows_); +#endif return cell_info[row][column].cellno; } @@ -1742,78 +1832,59 @@ LyXTabular::BoxType LyXTabular::GetUsebox(int cell) const return UseParbox(cell); } - -void LyXTabular::SetLTHead(int cell, bool first) +bool LyXTabular::checkLTType(int row, ltType const & ltt) const { - int const row = row_of_cell(cell); - int const val = (row + 1) * (column_of_cell(cell) ? 1 : -1); + if (!ltt.row || (ltt.row > rows_)) + return false; + return (row == (ltt.row - 1)); +} + +void LyXTabular::SetLTHead(ltType const & hd, bool first) +{ if (first) { - if (endfirsthead == val) - endfirsthead = 0; - else - endfirsthead = val; + endfirsthead = hd; } else { - if (endhead == val) - endhead = 0; - else - endhead = val; + endhead = hd; } } -bool LyXTabular::GetRowOfLTHead(int cell, int & row) const +bool LyXTabular::GetRowOfLTHead(int row, ltType & hd) const { - row = endhead; - if (abs(endhead) > rows_) - return false; - return (row_of_cell(cell) == abs(endhead) - 1); + hd = endhead; + return checkLTType(row, hd); } -bool LyXTabular::GetRowOfLTFirstHead(int cell, int & row) const +bool LyXTabular::GetRowOfLTFirstHead(int row, ltType & hd) const { - row = endfirsthead; - if (abs(endfirsthead) > rows_) - return false; - return (row_of_cell(cell) == abs(endfirsthead) - 1); + hd = endfirsthead; + return checkLTType(row, hd); } -void LyXTabular::SetLTFoot(int cell, bool last) +void LyXTabular::SetLTFoot(ltType const & fd, bool last) { - int const row = row_of_cell(cell); - int const val = (row + 1) * (column_of_cell(cell) ? 1 : -1); - if (last) { - if (endlastfoot == val) - endlastfoot = 0; - else - endlastfoot = val; + endlastfoot = fd; } else { - if (endfoot == val) - endfoot = 0; - else - endfoot = val; + endfoot = fd; } } -bool LyXTabular::GetRowOfLTFoot(int cell, int & row) const +bool LyXTabular::GetRowOfLTFoot(int row, ltType & fd) const { - row = endfoot; - if ((endfoot + 1) > rows_) - return false; - return (row_of_cell(cell) == abs(endfoot) - 1); + fd = endfoot; + return checkLTType(row, fd); } -bool LyXTabular::GetRowOfLTLastFoot(int cell, int & row) const +bool LyXTabular::GetRowOfLTLastFoot(int row, ltType & fd) const { - row = endlastfoot; - if (abs(endlastfoot) > rows_) - return false; - return (row_of_cell(cell) == (abs(endlastfoot)-1)); + fd = endlastfoot; + return checkLTType(row, fd); } @@ -1961,8 +2032,13 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const if (!cellinfo_of_cell(cell)->align_special.empty()) { os << cellinfo_of_cell(cell)->align_special << "}{"; } else { - if (LeftLine(cell)) + if (LeftLine(cell) && + (IsFirstCellInRow(cell) || + (!IsMultiColumn(cell-1) && !LeftLine(cell, true) && + !RightLine(cell-1, true)))) + { os << '|'; + } if (!GetPWidth(cell).empty()) { switch (GetVAlignment(cell)) { case LYX_VALIGN_TOP: @@ -2072,40 +2148,42 @@ int LyXTabular::Latex(Buffer const * buf, else os << "\\begin{tabular}{"; for (int i = 0; i < columns_; ++i) { - if (column_info[i].left_line) - os << '|'; if (!column_info[i].align_special.empty()) { os << column_info[i].align_special; - } else if (!column_info[i].p_width.empty()) { - switch (column_info[i].valignment) { - case LYX_VALIGN_TOP: - os << "p"; - break; - case LYX_VALIGN_CENTER: - os << "m"; - break; - case LYX_VALIGN_BOTTOM: - os << "b"; - break; + } else { + if (column_info[i].left_line) + os << '|'; + if (!column_info[i].p_width.empty()) { + switch (column_info[i].valignment) { + case LYX_VALIGN_TOP: + os << "p"; + break; + case LYX_VALIGN_CENTER: + os << "m"; + break; + case LYX_VALIGN_BOTTOM: + os << "b"; + break; } - os << "{" - << column_info[i].p_width - << '}'; - } else { - switch (column_info[i].alignment) { - case LYX_ALIGN_LEFT: - os << 'l'; - break; - case LYX_ALIGN_RIGHT: + os << "{" + << column_info[i].p_width + << '}'; + } else { + switch (column_info[i].alignment) { + case LYX_ALIGN_LEFT: + os << 'l'; + break; + case LYX_ALIGN_RIGHT: os << 'r'; break; - default: - os << 'c'; - break; + default: + os << 'c'; + break; + } } + if (column_info[i].right_line) + os << '|'; } - if (column_info[i].right_line) - os << '|'; } os << "}\n"; ++ret; @@ -2116,41 +2194,25 @@ int LyXTabular::Latex(Buffer const * buf, for (int i = 0; i < rows_; ++i) { ret += TeXTopHLine(os, i); - int bret = ret; - if (IsLongTabular()) { - if ((endhead < 0) && (i == (abs(endhead)-1))) { - os << "\\endhead\n"; - ++ret; - } - if ((endfirsthead < 0) && (i == (abs(endfirsthead)-1))) { - os << "\\endfirsthead\n"; - ++ret; - } - if ((endfoot < 0) && (i == (abs(endfoot)-1))) { - os << "\\endfoot\n"; - ++ret; - } - if ((endlastfoot < 0) && (i == (abs(endlastfoot)-1))) { - os << "\\endlastfoot\n"; - ++ret; - } - } +#warning Implement top double lines for LT Header/Footers +#if 0 if (ret > bret) { ret += TeXBottomHLine(os, i-1); ret += TeXTopHLine(os, i); } +#endif for (int j = 0; j < columns_; ++j) { if (IsPartOfMultiColumn(i,j)) continue; ret += TeXCellPreamble(os, cell); InsetText * inset = GetCellInset(cell); - bool rtl = inset->par->isRightToLeftPar(buf->params) && - inset->par->size() > 0 && GetPWidth(cell).empty(); + bool rtl = inset->paragraph()->isRightToLeftPar(buf->params) && + inset->paragraph()->size() > 0 && GetPWidth(cell).empty(); if (rtl) os << "\\R{"; - ret += inset->Latex(buf, os, fragile, fp); + ret += inset->latex(buf, os, fragile, fp); if (rtl) os << "}"; @@ -2162,27 +2224,33 @@ int LyXTabular::Latex(Buffer const * buf, ++cell; } os << "\\\\\n"; + ++ret; ret += TeXBottomHLine(os, i); - bret = ret; if (IsLongTabular()) { - if ((endhead > 0) && (i == (endhead - 1))) { + if (i == (endhead.row - 1)) { + if (endhead.bottomDL) + ret += TeXBottomHLine(os, i); os << "\\endhead\n"; ++ret; } - if ((endfirsthead > 0) && (i == (endfirsthead - 1))) { + if (i == (endfirsthead.row - 1)) { + if (endfirsthead.bottomDL) + ret += TeXBottomHLine(os, i); os << "\\endfirsthead\n"; ++ret; } - if ((endfoot > 0) && (i == (endfoot - 1))) { + if (i == (endfoot.row - 1)) { + if (endfoot.bottomDL) + ret += TeXBottomHLine(os, i); os << "\\endfoot\n"; ++ret; } - if ((endlastfoot > 0) && (i == (endlastfoot - 1))) { + if (i == (endlastfoot.row - 1)) { + if (endlastfoot.bottomDL) + ret += TeXBottomHLine(os, i); os << "\\endlastfoot\n"; ++ret; } -// if (ret > bret) -// ret += TeXBottomHLine(os, i); if (row_info[i].newpage) { os << "\\newpage\n"; ++ret; @@ -2207,6 +2275,57 @@ int LyXTabular::Latex(Buffer const * buf, } +int LyXTabular::docbookRow(Buffer const * buf, ostream & os, int row) const +{ + int ret = 0; + int cell = GetFirstCellInRow(row); + + os << "\n"; + for (int j = 0; j < columns_; ++j) { + if (IsPartOfMultiColumn(row, j)) + continue; + + os << ""; + ret += GetCellInset(cell)->docbook(buf, os); + os << "\n"; + ++cell; + } + os << "\n"; + return ret; +} + + int LyXTabular::DocBook(Buffer const * buf, ostream & os) const { int ret = 0; @@ -2231,59 +2350,50 @@ int LyXTabular::DocBook(Buffer const * buf, ostream & os) const os << "center"; break; } - os << "\"/>\n"; + os << "\">\n"; ++ret; } //+--------------------------------------------------------------------- - //+ the single row and columns (cells) + + //+ Long Tabular case + //+--------------------------------------------------------------------- - int cell = 0; - os << "\n"; - for (int i = 0; i < rows_; ++i) { - os << "\n"; - for (int j = 0; j < columns_; ++j) { - if (IsPartOfMultiColumn(i, j)) - continue; - - os << "\n"; + if( endfirsthead.row ) { + docbookRow( buf, os, endfirsthead.row - 1); } - - os << "\" valign=\""; - switch (GetVAlignment(cell)) { - case LYX_VALIGN_TOP: - os << "top"; - break; - case LYX_VALIGN_BOTTOM: - os << "bottom"; - break; - case LYX_VALIGN_CENTER: - os << "middle"; + if( endhead.row && endhead.row != endfirsthead.row) { + docbookRow(buf, os, endhead.row - 1); } - os << "\""; - - if (IsMultiColumn(cell)) { - os << " namest=\"col" << j << "\" "; - os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< "\""; + os << "\n"; + } + + // Footer + if( endfoot.row || endlastfoot.row ) { + os << "\n"; + if( endfoot.row ) { + docbookRow( buf, os, endfoot.row - 1); } - - os << ">"; - ret += GetCellInset(cell)->DocBook(buf, os); - os << ""; - ++cell; + if( endlastfoot.row && endlastfoot.row != endfoot.row) { + docbookRow( buf, os, endlastfoot.row - 1); + } + os << "\n"; + } + } + //+--------------------------------------------------------------------- + //+ the single row and columns (cells) + + //+--------------------------------------------------------------------- + + os << "\n"; + for (int i = 0; i < rows_; ++i) { + if(!IsLongTabular() || ( + i != endhead.row - 1 && i != endfirsthead.row - 1 && + i != endfoot.row - 1 && i != endlastfoot.row - 1)) { + docbookRow( buf, os, i); } - os << "\n"; } os << "\n"; //+--------------------------------------------------------------------- @@ -2407,7 +2517,7 @@ int LyXTabular::AsciiPrintCell(Buffer const * buf, ostream & os, vector const & clen) const { ostringstream sstr; - int ret = GetCellInset(cell)->Ascii(buf, sstr, 0); + int ret = GetCellInset(cell)->ascii(buf, sstr, 0); if (LeftLine(cell)) os << "| "; @@ -2466,7 +2576,7 @@ int LyXTabular::Ascii(Buffer const * buf, ostream & os) const if (IsMultiColumn(cell, true)) continue; ostringstream sstr; - GetCellInset(cell)->Ascii(buf, sstr, 0); + GetCellInset(cell)->ascii(buf, sstr, 0); if (clen[j] < sstr.str().length()) clen[j] = sstr.str().length(); } @@ -2478,7 +2588,7 @@ int LyXTabular::Ascii(Buffer const * buf, ostream & os) const if (!IsMultiColumn(cell, true) || IsPartOfMultiColumn(i, j)) continue; ostringstream sstr; - GetCellInset(cell)->Ascii(buf, sstr, 0); + GetCellInset(cell)->ascii(buf, sstr, 0); int len = int(sstr.str().length()); int const n = cells_in_multicolumn(cell); for (int k = j; (len > 0) && (k < (j + n - 1)); ++k) @@ -2505,26 +2615,28 @@ int LyXTabular::Ascii(Buffer const * buf, ostream & os) const InsetText * LyXTabular::GetCellInset(int cell) const { + cur_cell = cell; return & cell_info[row_of_cell(cell)][column_of_cell(cell)].inset; } InsetText * LyXTabular::GetCellInset(int row, int column) const { - return GetCellInset(GetCellNumber(row, column)); + cur_cell = GetCellNumber(row, column); + return & cell_info[row][column].inset; } void LyXTabular::Validate(LaTeXFeatures & features) const { if (IsLongTabular()) - features.longtable = true; + features.require("longtable"); if (NeedRotating()) - features.rotating = true; - for (int cell = 0; !features.array && (cell < numberofcells); ++cell) { + features.require("rotating"); + for (int cell = 0; !features.isRequired("array") && (cell < numberofcells); ++cell) { if (GetVAlignment(cell) != LYX_VALIGN_TOP) - features.array = true; - GetCellInset(cell)->Validate(features); + features.require("array"); + GetCellInset(cell)->validate(features); } } @@ -2545,20 +2657,13 @@ std::vector const LyXTabular::getLabelList() const LyXTabular::BoxType LyXTabular::UseParbox(int cell) const { - LyXParagraph * par = GetCellInset(cell)->par; + Paragraph * par = GetCellInset(cell)->paragraph(); for (; par; par = par->next()) { for (int i = 0; i < par->size(); ++i) { - if (par->GetChar(i) == LyXParagraph::META_NEWLINE) + if (par->getChar(i) == Paragraph::META_NEWLINE) return BOX_PARBOX; } } return BOX_NONE; } - -/* Emacs: - * Local variables: - * tab-width: 4 - * End: - * vi:set tabstop=4: - */