X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftabular.C;h=5213651290be0272b317d78b35e5836db4a69e27;hb=c130d5dbfd3f4d4a2721c9be786b7fa45b806aca;hp=86091c6e36a02486ec4f65ffa911810f50349877;hpb=7521b5d20f42102cf444e3fd8718a088a60d0098;p=features.git diff --git a/src/tabular.C b/src/tabular.C index 86091c6e36..5213651290 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -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" @@ -89,6 +93,14 @@ LyXTabular::columnstruct::columnstruct() } +LyXTabular::lttype::lttype() +{ + row = 0; + topDL = false; + bottomDL = false; +} + + /* konstruktor */ LyXTabular::LyXTabular(InsetTabular * inset, int rows_arg, int columns_arg) { @@ -98,11 +110,23 @@ LyXTabular::LyXTabular(InsetTabular * inset, int rows_arg, int 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) @@ -152,9 +176,9 @@ LyXTabular & LyXTabular::operator=(LyXTabular const & lt) } -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! @@ -207,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; } @@ -254,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]); @@ -434,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 } @@ -477,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; } @@ -526,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; + } } @@ -607,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) { @@ -934,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) @@ -1040,10 +1106,10 @@ void LyXTabular::Write(Buffer const * buf, ostream & os) const os << "\n"; for (int j = 0; j < columns_; ++j) { os << " 2) { @@ -1414,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; @@ -1495,15 +1564,20 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) LyXFont font(LyXFont::ALL_INHERIT); 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, @@ -1530,7 +1604,7 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) for (int i = 0; i < par->size(); ++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; @@ -1682,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; } @@ -1726,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) @@ -1734,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; } @@ -1755,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); } @@ -2090,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; @@ -2134,29 +2194,13 @@ 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; @@ -2180,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; @@ -2225,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; @@ -2249,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"; //+--------------------------------------------------------------------- @@ -2530,11 +2622,6 @@ InsetText * LyXTabular::GetCellInset(int cell) const InsetText * LyXTabular::GetCellInset(int row, int column) const { -#ifdef WITH_WARNINGS -#warning Juergen, should we check whether the row/column values are correct? -// If we do not need to do that, the tests in GetCellNumber should be -// changed to asserts. -#endif cur_cell = GetCellNumber(row, column); return & cell_info[row][column].inset; } @@ -2543,12 +2630,12 @@ InsetText * LyXTabular::GetCellInset(int row, int column) const 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; + features.require("array"); GetCellInset(cell)->validate(features); } } @@ -2574,16 +2661,9 @@ LyXTabular::BoxType LyXTabular::UseParbox(int cell) const for (; par; par = par->next()) { for (int i = 0; i < par->size(); ++i) { - if (par->getChar(i) == Paragraph::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: - */