#pragma implementation
#endif
+// temporary until verified (08/08/2001 Jug)
+#define SPECIAL_COLUM_HANDLING 1
+
#include <algorithm>
#include <cstdlib>
#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"
}
+LyXTabular::lttype::lttype()
+{
+ row = 0;
+ topDL = false;
+ bottomDL = false;
+}
+
+
/* konstruktor */
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)
}
-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!
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;
}
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]);
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
}
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;
}
// 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;
+ }
}
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) {
// Perfect case for a template... (Lgb)
+// or perhaps not...
#if 1
template<class T>
string const write_attribute(string const & name, T const & t)
os << "<features"
<< write_attribute("rotate", tostr(rotate))
<< write_attribute("islongtable", tostr(is_long_tabular))
- << write_attribute("endhead", endhead)
- << write_attribute("endfirsthead", endfirsthead)
- << write_attribute("endfoot", endfoot)
- << write_attribute("endlastfoot", endlastfoot)
+ << write_attribute("endhead", endhead.row)
+ << write_attribute("endfirsthead", endfirsthead.row)
+ << write_attribute("endfoot", endfoot.row)
+ << write_attribute("endlastfoot", endlastfoot.row)
<< ">\n";
for (int j = 0; j < columns_; ++j) {
os << "<column"
}
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,"<column")) {
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) {
cont_row_info = vector<int>(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;
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,
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;
bool LyXTabular::IsLastCell(int cell) const
{
- if ((cell + 1) < GetNumberOfCells())
+ if ((cell + 1) < numberofcells)
return false;
return true;
}
int LyXTabular::GetCellNumber(int row, int column) const
{
-#if 1
+#if 0
if (column >= columns_)
column = columns_ - 1;
else if (column < 0)
else if (row < 0)
row = 0;
#else
- lyx::Assert(column < 0 || column >= columns_ || row < 0 || row >= rows_);
+ lyx::Assert(column >= 0 || column < columns_ || row >= 0 || row < rows_);
#endif
return cell_info[row][column].cellno;
}
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);
}
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;
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;
++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;
}
+int LyXTabular::docbookRow(Buffer const * buf, ostream & os, int row) const
+{
+ int ret = 0;
+ int cell = GetFirstCellInRow(row);
+
+ os << "<row>\n";
+ for (int j = 0; j < columns_; ++j) {
+ if (IsPartOfMultiColumn(row, j))
+ continue;
+
+ os << "<entry align=\"";
+ switch (GetAlignment(cell)) {
+ case LYX_ALIGN_LEFT:
+ os << "left";
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << "right";
+ break;
+ default:
+ os << "center";
+ break;
+ }
+
+ 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";
+ }
+ os << "\"";
+
+ if (IsMultiColumn(cell)) {
+ os << " namest=\"col" << j << "\" ";
+ os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< "\"";
+ }
+
+ os << ">";
+ ret += GetCellInset(cell)->docbook(buf, os);
+ os << "</entry>\n";
+ ++cell;
+ }
+ os << "</row>\n";
+ return ret;
+}
+
+
int LyXTabular::DocBook(Buffer const * buf, ostream & os) const
{
int ret = 0;
os << "center";
break;
}
- os << "\"/>\n";
+ os << "\">\n";
++ret;
}
//+---------------------------------------------------------------------
- //+ the single row and columns (cells) +
+ //+ Long Tabular case +
//+---------------------------------------------------------------------
- int cell = 0;
- os << "<tbody>\n";
- for (int i = 0; i < rows_; ++i) {
- os << "<row>\n";
- for (int j = 0; j < columns_; ++j) {
- if (IsPartOfMultiColumn(i, j))
- continue;
-
- os << "<entry align=\"";
- switch (GetAlignment(cell)) {
- case LYX_ALIGN_LEFT:
- os << "left";
- break;
- case LYX_ALIGN_RIGHT:
- os << "right";
- break;
- default:
- os << "center";
- break;
+ if ( IsLongTabular() ) {
+ // Header
+ if( endhead.row || endfirsthead.row ) {
+ os << "<thead>\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 << "</thead>\n";
+ }
+
+ // Footer
+ if( endfoot.row || endlastfoot.row ) {
+ os << "<tfoot>\n";
+ if( endfoot.row ) {
+ docbookRow( buf, os, endfoot.row - 1);
}
- os << "\"";
-
- if (IsMultiColumn(cell)) {
- os << " namest=\"col" << j << "\" ";
- os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< "\"";
+ if( endlastfoot.row && endlastfoot.row != endfoot.row) {
+ docbookRow( buf, os, endlastfoot.row - 1);
}
-
- os << ">";
- ret += GetCellInset(cell)->docBook(buf, os);
- os << "</entry>";
- ++cell;
+ os << "</tfoot>\n";
+ }
+ }
+ //+---------------------------------------------------------------------
+ //+ the single row and columns (cells) +
+ //+---------------------------------------------------------------------
+
+ os << "<tbody>\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 << "</row>\n";
}
os << "</tbody>\n";
//+---------------------------------------------------------------------
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);
}
}
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:
- */