*
* LyX, The Document Processor
*
- * Copyright 2000 The LyX Team.
+ * Copyright 2000-2001 The LyX Team.
*
* @author: Jürgen Vigna
*
#pragma implementation
#endif
+// temporary until verified (08/08/2001 Jug)
+#define SPECIAL_COLUM_HANDLING 1
+
#include <algorithm>
#include <cstdlib>
#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"
using std::endl;
using std::vector;
+#ifndef CXX_GLOBAL_CSTD
+using std::strlen;
+#endif
+
namespace {
int const WIDTH_OF_LINE = 5;
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)
{
owner_ = inset;
+ cur_cell = -1;
Init(lt.rows_, lt.columns_, <);
#if 0
#ifdef WITH_WARNINGS
LyXTabular::LyXTabular(Buffer const * buf, InsetTabular * inset, LyXLex & lex)
{
owner_ = inset;
+ cur_cell = -1;
Read(buf, lex);
}
// 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;
}
-LyXTabular * LyXTabular::Clone(InsetTabular * inset)
+LyXTabular * LyXTabular::clone(InsetTabular * inset)
{
LyXTabular * result = new LyXTabular(inset, *this);
#if 0
for (int i = 0; i < rows_; ++i) {
for (int j = 0; j < columns_; ++j) {
cell_info[i][j].inset.setOwner(owner_);
- cell_info[i][j].inset.SetDrawFrame(0, InsetText::LOCKED);
+ cell_info[i][j].inset.setDrawFrame(0, InsetText::LOCKED);
cell_info[i][j].cellno = cellno++;
}
cell_info[i].back().right_line = true;
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());
}
}
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) {
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;
}
cellinfo_of_cell(cell)->p_width = width;
if (IsMultiColumn(cell)) {
- GetCellInset(cell)->SetAutoBreakRows(flag);
+ GetCellInset(cell)->setAutoBreakRows(flag);
return true;
}
return false;
// Perfect case for a template... (Lgb)
+// or perhaps not...
#if 1
template<class T>
string const write_attribute(string const & name, T const & t)
<< write_attribute("special", cell_info[i][j].align_special)
<< ">\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"
<< "</cell>\n";
}
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;
getTokenValue(line, "special", cell_info[i][j].align_special);
l_getline(is, line);
if (prefixIs(line, "\\begin_inset")) {
- cell_info[i][j].inset.Read(buf, lex);
+ cell_info[i][j].inset.read(buf, lex);
l_getline(is, line);
}
if (!prefixIs(line, "</cell>")) {
}
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)) {
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;
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();
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 0
if (column >= columns_)
column = columns_ - 1;
else if (column < 0)
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;
}
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:
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;
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 << "}";
}
os << ">";
- ret += GetCellInset(cell)->DocBook(buf, os);
+ ret += GetCellInset(cell)->docBook(buf, os);
os << "</entry>";
++cell;
}
vector<unsigned int> 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 << "| ";
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();
}
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)
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;
}
for (int cell = 0; !features.array && (cell < numberofcells); ++cell) {
if (GetVAlignment(cell) != LYX_VALIGN_TOP)
features.array = true;
- GetCellInset(cell)->Validate(features);
+ GetCellInset(cell)->validate(features);
}
}
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;
}
}