#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"
}
-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!
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]);
c_info[i][j] = cell_info[i][j - 1];
}
// care about multicolumns
- if (cell_info[i][column + 1].multicolumn==CELL_BEGIN_OF_MULTICOLUMN) {
- cell_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
+ if (c_info[i][column + 1].multicolumn==CELL_BEGIN_OF_MULTICOLUMN) {
+ c_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
}
if ((column + 1) == columns_ ||
- cell_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN) {
- cell_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL;
+ c_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN) {
+ c_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL;
}
}
cell_info = c_info;
}
-void LyXTabular::Reinit()
-{
- for (int i = 0; i < rows_; ++i) {
- for (int j = 0; j < columns_; ++j) {
- cell_info[i][j].width_of_cell = 0;
- cell_info[i][j].inset.setOwner(owner_);
+void LyXTabular::reinit()
+{
+ Reinit(false);
+}
+
+
+void LyXTabular::Reinit(bool reset_widths)
+{
+ if (reset_widths) {
+ for (int i = 0; i < rows_; ++i) {
+ for (int j = 0; j < columns_; ++j) {
+ cell_info[i][j].width_of_cell = 0;
+ cell_info[i][j].inset.setOwner(owner_);
+ }
}
}
cell_info[row][column+cn-1].right_line;
}
cell_info[row][column].inset.setAutoBreakRows(
- !GetPWidth(GetCellNumber(row, column)).empty());
+ !GetPWidth(GetCellNumber(row, column)).zero());
}
}
}
}
-bool LyXTabular::SetColumnPWidth(int cell, string const & width)
+bool LyXTabular::SetColumnPWidth(int cell, LyXLength const & width)
{
- bool flag = !width.empty();
+ bool flag = !width.zero();
int const j = column_of_cell(cell);
column_info[j].p_width = width;
SetAlignment(cell, LYX_ALIGN_LEFT);
for (int i = 0; i < rows_; ++i) {
int c = GetCellNumber(i, j);
- flag = !GetPWidth(c).empty(); // because of multicolumns!
+ flag = !GetPWidth(c).zero(); // because of multicolumns!
GetCellInset(c)->setAutoBreakRows(flag);
}
return true;
}
-bool LyXTabular::SetMColumnPWidth(int cell, string const & width)
+bool LyXTabular::SetMColumnPWidth(int cell, LyXLength const & width)
{
- bool const flag = !width.empty();
+ bool const flag = !width.zero();
cellinfo_of_cell(cell)->p_width = width;
if (IsMultiColumn(cell)) {
}
-string const LyXTabular::GetPWidth(int cell) const
+LyXLength const LyXTabular::GetPWidth(int cell) const
{
if (IsMultiColumn(cell))
return cellinfo_of_cell(cell)->p_width;
}
-string const LyXTabular::GetColumnPWidth(int cell) const
+LyXLength const LyXTabular::GetColumnPWidth(int cell) const
{
return column_info[column_of_cell(cell)].p_width;
}
-string const LyXTabular::GetMColumnPWidth(int cell) const
+LyXLength const LyXTabular::GetMColumnPWidth(int cell) const
{
if (IsMultiColumn(cell))
return cellinfo_of_cell(cell)->p_width;
- return string();
+ return LyXLength();
}
return write_attribute(name, int(b));
}
+template <>
+string const write_attribute(string const & name, LyXLength const & value)
+{
+ return write_attribute(name, value.asString());
+}
#else
string const write_attribute(string const & name, int value)
string str = " " + name + "=\"" + tostr(static_cast<int>(value)) + "\"";
return str;
}
+
+
+string const write_attribute(string const & name, LyXLength const & value)
+{
+ string str = " " + name + "=\"" + value.asString() + "\"";
+ return str;
+}
#endif
<< write_attribute("valignment", tostr(column_info[j].valignment))
<< write_attribute("leftline", tostr(column_info[j].left_line))
<< write_attribute("rightline", tostr(column_info[j].right_line))
- << write_attribute("width",
- VSpace(column_info[j].p_width)
- .asLyXCommand())
+ << write_attribute("width", column_info[j].p_width.asString())
<< write_attribute("special", column_info[j].align_special)
<< ">\n";
}
ret += ch;
ch = ' ';
}
- while((pos < str.length() - 1) && (str[++pos] != ch))
+ while ((pos < str.length() - 1) && (str[++pos] != ch))
ret += str[pos];
return true;
}
+bool getTokenValue(string const & str, const char * token, LyXLength & len)
+{
+ string tmp;
+ if (!getTokenValue(str, token, tmp))
+ return false;
+ return isValidLength(tmp, &len);
+}
+
+
inline
void l_getline(istream & is, string & str)
{
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) {
column_info[i].alignment = static_cast<LyXAlignment>(a);
column_info[i].left_line = b;
column_info[i].right_line = c;
- column_info[i].p_width = s1;
+ column_info[i].p_width = LyXLength(s1);
column_info[i].align_special = s2;
}
for (i = 0; i < rows_; ++i) {
cell_info[i][j].rotate = static_cast<bool>(f);
cell_info[i][j].usebox = static_cast<BoxType>(g);
cell_info[i][j].align_special = s1;
- cell_info[i][j].p_width = s2;
+ cell_info[i][j].p_width = LyXLength(s2);
}
}
}
if (cont_row_info[row]) {
DeleteRow(row);
cont_row_info.erase(cont_row_info.begin() + row); //&cont_row_info[row]);
- while(!IsFirstCellInRow(--cell));
+ while (!IsFirstCellInRow(--cell));
} else {
inset = GetCellInset(cell);
continue;
LyXTabular::BoxType LyXTabular::GetUsebox(int cell) const
{
- if (column_info[column_of_cell(cell)].p_width.empty() &&
- !(IsMultiColumn(cell) && !cellinfo_of_cell(cell)->p_width.empty()))
+ if (column_info[column_of_cell(cell)].p_width.zero() &&
+ !(IsMultiColumn(cell) && !cellinfo_of_cell(cell)->p_width.zero()))
return BOX_NONE;
if (cellinfo_of_cell(cell)->usebox > 1)
return cellinfo_of_cell(cell)->usebox;
{
os << '|';
}
- if (!GetPWidth(cell).empty()) {
+ if (!GetPWidth(cell).zero()) {
switch (GetVAlignment(cell)) {
case LYX_VALIGN_TOP:
os << "p";
os << "b";
break;
}
- os << "{" << GetPWidth(cell) << '}';
+ os << "{" << GetPWidth(cell).asLatexString() << '}';
} else {
switch (GetAlignment(cell)) {
case LYX_ALIGN_LEFT:
os << "b";
break;
}
- os << "]{" << GetPWidth(cell) << "}{";
+ os << "]{" << GetPWidth(cell).asLatexString() << "}{";
} else if (GetUsebox(cell) == BOX_MINIPAGE) {
os << "\\begin{minipage}[";
switch (GetVAlignment(cell)) {
os << "b";
break;
}
- os << "]{" << GetPWidth(cell) << "}\n";
+ os << "]{" << GetPWidth(cell).asLatexString() << "}\n";
++ret;
}
return ret;
} else {
if (column_info[i].left_line)
os << '|';
- if (!column_info[i].p_width.empty()) {
+ if (!column_info[i].p_width.zero()) {
switch (column_info[i].valignment) {
case LYX_VALIGN_TOP:
os << "p";
break;
}
os << "{"
- << column_info[i].p_width
+ << column_info[i].p_width.asLatexString()
<< '}';
} else {
switch (column_info[i].alignment) {
InsetText * inset = GetCellInset(cell);
bool rtl = inset->paragraph()->isRightToLeftPar(buf->params) &&
- inset->paragraph()->size() > 0 && GetPWidth(cell).empty();
+ inset->paragraph()->size() > 0 && GetPWidth(cell).zero();
if (rtl)
os << "\\R{";
++cell;
}
os << "\\\\\n";
+ ++ret;
ret += TeXBottomHLine(os, i);
if (IsLongTabular()) {
if (i == (endhead.row - 1)) {
}
int column = column_of_cell(i);
int len = clen[column];
- while(IsPartOfMultiColumn(row, ++column))
+ while (IsPartOfMultiColumn(row, ++column))
len += clen[column] + 4;
print_n_chars(os, ch, len);
if (TopLine(i)) {
}
int column = column_of_cell(i);
int len = clen[column];
- while(IsPartOfMultiColumn(row, ++column))
+ while (IsPartOfMultiColumn(row, ++column))
len += clen[column] + 4;
print_n_chars(os, ch, len);
if (BottomLine(i)) {
int LyXTabular::AsciiPrintCell(Buffer const * buf, ostream & os,
- int cell, int row, int column,
- vector<unsigned int> const & clen) const
+ int cell, int row, int column,
+ vector<unsigned int> const & clen) const
{
ostringstream sstr;
int ret = GetCellInset(cell)->ascii(buf, sstr, 0);
unsigned int len1 = sstr.str().length();
unsigned int len2 = clen[column];
- while(IsPartOfMultiColumn(row, ++column))
+ while (IsPartOfMultiColumn(row, ++column))
len2 += clen[column] + 4;
len2 -= len1;
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:
- */