// I would have liked a fromstr template a lot better. (Lgb)
-bool string2type(string const str, LyXAlignment & num)
+bool string2type(string const & str, LyXAlignment & num)
{
if (str == "none")
num = LYX_ALIGN_NONE;
}
-bool string2type(string const str, Tabular::HAlignment & num)
+bool string2type(string const & str, Tabular::HAlignment & num)
{
if (str == "left")
num = Tabular::LYX_LONGTABULAR_ALIGN_LEFT;
}
-bool string2type(string const str, Tabular::VAlignment & num)
+bool string2type(string const & str, Tabular::VAlignment & num)
{
if (str == "top")
num = Tabular::LYX_VALIGN_TOP;
}
-bool string2type(string const str, Tabular::BoxType & num)
+bool string2type(string const & str, Tabular::BoxType & num)
{
if (str == "none")
num = Tabular::BOX_NONE;
}
-bool string2type(string const str, bool & num)
+bool string2type(string const & str, bool & num)
{
if (str == "true")
num = true;
}
-InsetTableCell splitCell(InsetTableCell & head, docstring const align_d, bool & hassep)
+InsetTableCell splitCell(InsetTableCell & head, docstring const & align_d, bool & hassep)
{
InsetTableCell tail = InsetTableCell(head);
DocIterator const dit = separatorPos(&head, align_d);
{
}
-Tabular::CellData & Tabular::CellData::operator=(CellData cs)
-{
- swap(cs);
+Tabular::CellData & Tabular::CellData::operator=(CellData const & cs)
+{
+ if (&cs == this)
+ return *this;
+ cellno = cs.cellno;
+ width = cs.width;
+ multicolumn = cs.multicolumn;
+ multirow = cs.multirow;
+ mroffset = cs.mroffset;
+ alignment = cs.alignment;
+ valignment = cs.valignment;
+ decimal_hoffset = cs.decimal_hoffset;
+ decimal_width = cs.decimal_width;
+ voffset = cs.voffset;
+ top_line = cs.top_line;
+ bottom_line = cs.bottom_line;
+ left_line = cs.left_line;
+ right_line = cs.right_line;
+ usebox = cs.usebox;
+ rotate = cs.rotate;
+ align_special = cs.align_special;
+ p_width = cs.p_width;
+ inset.reset(static_cast<InsetTableCell *>(cs.inset->clone()));
return *this;
}
-void Tabular::CellData::swap(CellData & rhs)
-{
- std::swap(cellno, rhs.cellno);
- std::swap(width, rhs.width);
- std::swap(multicolumn, rhs.multicolumn);
- std::swap(multirow, rhs.multirow);
- std::swap(mroffset, rhs.mroffset);
- std::swap(alignment, rhs.alignment);
- std::swap(valignment, rhs.valignment);
- std::swap(decimal_hoffset, rhs.decimal_hoffset);
- std::swap(decimal_width, rhs.decimal_width);
- std::swap(voffset, rhs.voffset);
- std::swap(top_line, rhs.top_line);
- std::swap(bottom_line, rhs.bottom_line);
- std::swap(left_line, rhs.left_line);
- std::swap(right_line, rhs.right_line);
- std::swap(usebox, rhs.usebox);
- std::swap(rotate, rhs.rotate);
- std::swap(align_special, rhs.align_special);
- p_width.swap(rhs.p_width);
- inset.swap(rhs.inset);
-}
-
-
Tabular::RowData::RowData()
: ascent(0),
descent(0),
for (col_type c = 0; c < ncols(); ++c) {
cell_info[row + 1].insert(cell_info[row + 1].begin() + c,
copy ? CellData(cell_info[row][c]) : CellData(buffer_));
- if (buffer().params().trackChanges)
+ if (buffer().params().track_changes)
cell_info[row + 1][c].inset->setChange(Change(Change::INSERTED));
if (cell_info[row][c].multirow == CELL_BEGIN_OF_MULTIROW)
cell_info[row + 1][c].multirow = CELL_PART_OF_MULTIROW;
setBottomLine(j, false);
}
// mark track changes
- if (buffer().params().trackChanges)
+ if (buffer().params().track_changes)
cellInfo(i).inset->setChange(Change(Change::INSERTED));
}
}
if (direction == Tabular::LEFT)
col = col - 1;
+ std::swap(column_info[col], column_info[col + 1]);
+
for (row_type r = 0; r < nrows(); ++r) {
std::swap(cell_info[r][col], cell_info[r][col + 1]);
std::swap(cell_info[r][col].left_line, cell_info[r][col + 1].left_line);
// FIXME track changes is broken for tabular features (#8469)
idx_type const i = cellIndex(r, col);
idx_type const j = cellIndex(r, col + 1);
- if (buffer().params().trackChanges) {
+ if (buffer().params().track_changes) {
cellInfo(i).inset->setChange(Change(Change::INSERTED));
cellInfo(j).inset->setChange(Change(Change::INSERTED));
}
if (direction == Tabular::UP)
row = row - 1;
+ std::swap(row_info[row], row_info[row + 1]);
+
for (col_type c = 0; c < ncols(); ++c) {
std::swap(cell_info[row][c], cell_info[row + 1][c]);
std::swap(cell_info[row][c].top_line, cell_info[row + 1][c].top_line);
// FIXME track changes is broken for tabular features (#8469)
idx_type const i = cellIndex(row, c);
idx_type const j = cellIndex(row + 1, c);
- if (buffer().params().trackChanges) {
+ if (buffer().params().track_changes) {
cellInfo(i).inset->setChange(Change(Change::INSERTED));
cellInfo(j).inset->setChange(Change(Change::INSERTED));
}
for (row_type r = 0; r < nrows(); ++r) {
cell_info[r].insert(cell_info[r].begin() + col + 1,
copy ? CellData(cell_info[r][col]) : CellData(buffer_));
- if (bp.trackChanges)
+ if (bp.track_changes)
cell_info[r][col + 1].inset->setChange(Change(Change::INSERTED));
if (cell_info[r][col].multicolumn == CELL_BEGIN_OF_MULTICOLUMN)
cell_info[r][col + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
setBottomLine(i, bottomLine(j));
setTopLine(i, topLine(j));
setLeftLine(i, leftLine(j));
- if (rightLine(j) && rightLine(j)) {
+ if (rightLine(i) && rightLine(j)) {
setRightLine(i, true);
setRightLine(j, false);
}
- if (buffer().params().trackChanges)
+ if (buffer().params().track_changes)
cellInfo(i).inset->setChange(Change(Change::INSERTED));
}
}
col_type const c = cellColumn(cell);
column_info[c].p_width = width;
- // reset the vertical alignment to top if the fixed with
+ // reset the vertical alignment to top if the fixed width
// is removed or zero because only fixed width columns can
// have a vertical alignment
if (column_info[c].p_width.zero())
// because of multicolumns
toggleFixedWidth(cur, cellInset(cell).get(),
!getPWidth(cell).zero());
+ if (isMultiRow(cell))
+ setAlignment(cell, LYX_ALIGN_LEFT, false);
}
// cur paragraph can become invalid after paragraphs were merged
if (cur.pit() > cur.lastpit())
<< ">\n";
// global longtable options
os << "<features"
- << write_attribute("rotate", convert<string>(rotate))
+ << write_attribute("rotate", rotate)
<< write_attribute("booktabs", use_booktabs)
<< write_attribute("islongtable", is_long_tabular)
<< write_attribute("firstHeadTopDL", endfirsthead.topDL)
<< write_attribute("lastFootEmpty", endlastfoot.empty);
// longtables cannot be aligned vertically
if (!is_long_tabular) {
- os << write_attribute("tabularvalignment", tabular_valignment);
- os << write_attribute("tabularwidth", tabular_width);
+ os << write_attribute("tabularvalignment", tabular_valignment);
+ os << write_attribute("tabularwidth", tabular_width);
}
if (is_long_tabular)
- os << write_attribute("longtabularalignment",
- longtabular_alignment);
+ os << write_attribute("longtabularalignment", longtabular_alignment);
os << ">\n";
for (col_type c = 0; c < ncols(); ++c) {
os << "<column"
cell_info[r][c].inset->write(os);
os << "\n\\end_inset\n"
<< "</cell>\n";
+ // FIXME This can be removed again once the mystery
+ // crash has been resolved.
+ os << flush;
}
os << "</row>\n";
}
l_getline(is, line);
if (!prefixIs(line, "<lyxtabular ") && !prefixIs(line, "<Tabular ")) {
- LASSERT(false, /**/);
- return;
+ LASSERT(false, return);
}
int version;
if (!getTokenValue(line, "version", version))
return;
- LASSERT(version >= 2, /**/);
+ LATTEST(version >= 2);
int rows_arg;
if (!getTokenValue(line, "rows", rows_arg))
cs.multicolumn = CELL_BEGIN_OF_MULTICOLUMN;
if (column_info[col].alignment != LYX_ALIGN_DECIMAL)
cs.alignment = column_info[col].alignment;
- if (col > 0)
- setRightLine(cell, right_border);
+ setRightLine(cell, right_border);
for (idx_type i = 1; i < number; ++i) {
CellData & cs1 = cellInfo(cell + i);
}
Tabular::idx_type Tabular::setMultiRow(idx_type cell, idx_type number,
- bool const bottom_border)
+ bool const bottom_border,
+ LyXAlignment const halign)
{
idx_type const col = cellColumn(cell);
idx_type const row = cellRow(cell);
// be changed for the whole table row,
// support changing this only for the multirow cell can be done via
// \multirowsetup
- // this feature would be a fileformat change
- // until LyX supports this, use the deault alignment of multirow
- // cells: left
- cs.alignment = LYX_ALIGN_LEFT;
+ if (getPWidth(cell).zero())
+ cs.alignment = halign;
+ else
+ cs.alignment = LYX_ALIGN_LEFT;
// set the bottom line of the last selected cell
setBottomLine(cell, bottom_border);
Tabular::idx_type Tabular::cellIndex(row_type row, col_type column) const
{
- LASSERT(column != npos && column < ncols()
- && row != npos && row < nrows(), /**/);
+ LASSERT(column != npos && column < ncols(), column = 0);
+ LASSERT(row != npos && row < nrows(), row = 0);
return cell_info[row][column].cellno;
}
int Tabular::rowAscent(row_type row) const
{
- LASSERT(row < nrows(), /**/);
+ LASSERT(row < nrows(), row = 0);
return row_info[row].ascent;
}
int Tabular::rowDescent(row_type row) const
{
- LASSERT(row < nrows(), /**/);
+ LASSERT(row < nrows(), row = 0);
return row_info[row].descent;
}
bool Tabular::isPartOfMultiColumn(row_type row, col_type column) const
{
- LASSERT(row < nrows(), /**/);
- LASSERT(column < ncols(), /**/);
+ LASSERT(row < nrows(), return false);
+ LASSERT(column < ncols(), return false);
return cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN;
}
bool Tabular::isPartOfMultiRow(row_type row, col_type column) const
{
- LASSERT(row < nrows(), /**/);
- LASSERT(column < ncols(), /**/);
+ LASSERT(row < nrows(), return false);
+ LASSERT(column < ncols(), return false);
return cell_info[row][column].multirow == CELL_PART_OF_MULTIROW;
}
-void Tabular::TeXTopHLine(otexstream & os, row_type row, string const lang) const
+void Tabular::TeXTopHLine(otexstream & os, row_type row, string const & lang) const
{
// we only output complete row lines and the 1st row here, the rest
// is done in Tabular::TeXBottomHLine(...)
}
-void Tabular::TeXBottomHLine(otexstream & os, row_type row, string const lang) const
+void Tabular::TeXBottomHLine(otexstream & os, row_type row, string const & lang) const
{
// we output bottomlines of row r and the toplines of row r+1
// if the latter do not span the whole tabular
if (!is_long_tabular)
return;
+ // caption handling
+ // output caption which is in no header or footer
+ if (haveLTCaption()) {
+ for (row_type r = 0; r < nrows(); ++r) {
+ if (row_info[r].caption &&
+ !row_info[r].endfirsthead && !row_info[r].endhead &&
+ !row_info[r].endfoot && !row_info[r].endlastfoot)
+ TeXRow(os, r, runparams);
+ }
+ }
// output first header info
if (haveLTFirstHead()) {
if (endfirsthead.topDL)
}
+void InsetTableCell::addToToc(DocIterator const & di, bool output_active) const
+{
+ InsetText::iterateForToc(di, output_active);
+}
+
+
docstring InsetTableCell::xhtml(XHTMLStream & xs, OutputParams const & rp) const
{
if (!isFixedWidth)
{
//lyxerr << "InsetTabular::metrics: " << mi.base.bv << " width: " <<
// mi.base.textwidth << "\n";
- if (!mi.base.bv) {
- LYXERR0("need bv");
- LASSERT(false, /**/);
- }
+ LBUFERR(mi.base.bv);
for (row_type r = 0; r < tabular.nrows(); ++r) {
int maxasc = 0;
// Right
x -= tabular.interColumnSpace(cell);
+ col_type next_cell_col = col + 1;
+ while (next_cell_col < tabular.ncols()
+ && tabular.isMultiColumn(tabular.cellIndex(row, next_cell_col)))
+ next_cell_col++;
drawline = tabular.rightLine(cell)
- || (col + 1 < tabular.ncols()
- && tabular.leftLine(tabular.cellIndex(row, col + 1)));
+ || (next_cell_col < tabular.ncols()
+ && tabular.leftLine(tabular.cellIndex(row, next_cell_col)));
pi.pain.line(x + w, y, x + w, y + h,
drawline ? linecolor : gridcolor,
drawline ? Painter::line_solid : Painter::line_onoffdash);
// In a longtable, tell captions what the current float is
Counters & cnts = buffer().masterBuffer()->params().documentClass().counters();
string const saveflt = cnts.current_float();
- if (tabular.is_long_tabular)
+ if (tabular.is_long_tabular) {
cnts.current_float("table");
+ // in longtables, we only step the counter once
+ cnts.step(from_ascii("table"), utype);
+ cnts.isLongtable(true);
+ }
ParIterator it2 = it;
it2.forwardPos();
buffer().updateBuffer(it2, utype);
//reset afterwards
- if (tabular.is_long_tabular)
+ if (tabular.is_long_tabular) {
cnts.current_float(saveflt);
+ cnts.isLongtable(false);
+ }
}
if (cur.selIsMultiCell()) {
cur.recordUndoInset(DELETE_UNDO);
cutSelection(cur);
- }
- cell(cur.idx())->dispatch(cur, cmd);
+ BufferView * bv = &cur.bv();
+ docstring::const_iterator cit = cmd.argument().begin();
+ docstring::const_iterator const end = cmd.argument().end();
+ for (; cit != end; ++cit)
+ bv->translateAndInsert(*cit, getText(cur.idx()), cur);
+
+ cur.resetAnchor();
+ bv->bookmarkEditPosition();
+ } else
+ cell(cur.idx())->dispatch(cur, cmd);
break;
case LFUN_CHAR_DELETE_BACKWARD:
case LFUN_CLIPBOARD_PASTE:
case LFUN_PRIMARY_SELECTION_PASTE: {
docstring const clip = (act == LFUN_CLIPBOARD_PASTE) ?
- theClipboard().getAsText() :
+ theClipboard().getAsText(Clipboard::PlainTextType) :
theSelection().get();
if (clip.empty())
break;
case LFUN_FONT_SIZE:
case LFUN_FONT_UNDERLINE:
case LFUN_FONT_STRIKEOUT:
- case LFUN_FONT_UULINE:
- case LFUN_FONT_UWAVE:
+ case LFUN_FONT_UNDERUNDERLINE:
+ case LFUN_FONT_UNDERWAVE:
case LFUN_LANGUAGE:
+ case LFUN_PARAGRAPH_PARAMS_APPLY:
+ case LFUN_PARAGRAPH_PARAMS:
case LFUN_WORD_CAPITALIZE:
case LFUN_WORD_UPCASE:
case LFUN_WORD_LOWCASE:
break;
case Tabular::UNSET_LTFIRSTHEAD:
- status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start));
+ status.setEnabled(sel_row_start == sel_row_end);
status.setOnOff(!tabular.getRowOfLTFirstHead(sel_row_start, dummyltt));
break;
break;
case Tabular::UNSET_LTHEAD:
- status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start));
+ status.setEnabled(sel_row_start == sel_row_end);
status.setOnOff(!tabular.getRowOfLTHead(sel_row_start, dummyltt));
break;
break;
case Tabular::UNSET_LTFOOT:
- status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start));
+ status.setEnabled(sel_row_start == sel_row_end);
status.setOnOff(!tabular.getRowOfLTFoot(sel_row_start, dummyltt));
break;
break;
case Tabular::UNSET_LTLASTFOOT:
- status.setEnabled(sel_row_start == sel_row_end && !tabular.ltCaption(sel_row_start));
+ status.setEnabled(sel_row_start == sel_row_end);
status.setOnOff(!tabular.getRowOfLTLastFoot(sel_row_start, dummyltt));
break;
// check whether we are completely in a multirow
if (!tabular.isMultiRow(cur.idx()))
tabular.setMultiRow(cur.idx(), 1,
- tabular.bottomLine(cur.idx()));
+ tabular.bottomLine(cur.idx()),
+ tabular.getAlignment(cur.idx()));
break;
}
// we have a selection so this means we just add all this
row_type const row_start = tabular.cellRow(s_start);
row_type const row_end = tabular.cellRow(cur.selEnd().idx());
cur.idx() = tabular.setMultiRow(s_start, row_end - row_start + 1,
- tabular.bottomLine(cur.selEnd().idx()));
+ tabular.bottomLine(cur.selEnd().idx()),
+ tabular.getAlignment(cur.selEnd().idx()));
cur.pit() = 0;
cur.pos() = 0;
cur.setSelection(false);
tabular.cellInset(r2, c2)->setBuffer(tabular.buffer());
// FIXME: change tracking (MG)
- inset->setChange(Change(buffer().params().trackChanges ?
+ inset->setChange(Change(buffer().params().track_changes ?
Change::INSERTED : Change::UNCHANGED));
cur.pos() = 0;
}
for (col_type c = cs; c <= ce; ++c) {
shared_ptr<InsetTableCell> t
= cell(tabular.cellIndex(r, c));
- if (buffer().params().trackChanges)
+ if (buffer().params().track_changes)
// FIXME: Change tracking (MG)
t->setChange(Change(Change::DELETED));
else
bool InsetTabular::isRightToLeft(Cursor & cur) const
{
- LASSERT(cur.depth() > 1, /**/);
+ // LASSERT: It might be better to abandon this Buffer.
+ LASSERT(cur.depth() > 1, return false);
Paragraph const & parentpar = cur[cur.depth() - 2].paragraph();
pos_type const parentpos = cur[cur.depth() - 2].pos();
return parentpar.getFontSettings(buffer().params(),
Font const font = bv.textMetrics(&inset->text()).
displayFont(0, 0);
inset->setText(buf.substr(op, p - op), font,
- buffer().params().trackChanges);
+ buffer().params().track_changes);
++cols;
++cell;
}
Font const font = bv.textMetrics(&inset->text()).
displayFont(0, 0);
inset->setText(buf.substr(op, p - op), font,
- buffer().params().trackChanges);
+ buffer().params().track_changes);
}
cols = ocol;
++row;
shared_ptr<InsetTableCell> inset = loctab->cellInset(cell);
Font const font = bv.textMetrics(&inset->text()).displayFont(0, 0);
inset->setText(buf.substr(op, len - op), font,
- buffer().params().trackChanges);
+ buffer().params().track_changes);
}
return true;
}