#include "InsetTabular.h"
+#include "Author.h"
#include "buffer_funcs.h"
#include "Buffer.h"
#include "BufferParams.h"
#include "LyX.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
-#include "OutputParams.h"
#include "xml.h"
#include "output_xhtml.h"
#include "Paragraph.h"
-#include "ParagraphParameters.h"
#include "ParIterator.h"
#include "TexRow.h"
#include "texstream.h"
#include "frontends/Painter.h"
#include "frontends/Selection.h"
+#include "support/Changer.h"
#include "support/convert.h"
#include "support/debug.h"
#include "support/docstream.h"
template <>
-string const write_attribute(string const & name, Tabular::idx_type const & i)
+string const write_attribute(string const & name, idx_type const & i)
{
// we write only true attribute values so we remove a bit of the
// file format bloat for tabulars.
InsetTableCell splitCell(InsetTableCell & head, docstring const & align_d, bool & hassep)
{
- InsetTableCell tail = InsetTableCell(head);
+ InsetTableCell tail = head;
DocIterator const dit = separatorPos(&head, align_d);
- hassep = (bool)dit;
+ hassep = static_cast<bool>(dit);
if (hassep) {
pos_type const psize = head.paragraphs().front().size();
head.paragraphs().front().eraseChars(dit.pos(), psize, false);
if (row + 1 < nrows() &&
cell_info[row][c].multirow == CELL_BEGIN_OF_MULTIROW &&
cell_info[row + 1][c].multirow == CELL_PART_OF_MULTIROW) {
- cell_info[row + 1][c].multirow = CELL_BEGIN_OF_MULTIROW;
+ cell_info[row + 1][c] = cell_info[row][c];
}
}
if (ct)
void Tabular::insertRow(row_type const row, bool copy)
{
- row_info.insert(row_info.begin() + row + 1, RowData(row_info[row]));
+ row_info.insert(row_info.begin() + row + 1, row_info[row]);
cell_info.insert(cell_info.begin() + row + 1,
cell_vector(0, CellData(buffer_)));
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_));
+ copy ? cell_info[row][c] : CellData(buffer_));
if (cell_info[row][c].multirow == CELL_BEGIN_OF_MULTIROW)
cell_info[row + 1][c].multirow = CELL_PART_OF_MULTIROW;
}
}
-void Tabular::moveColumn(col_type col, ColDirection direction)
+void Tabular::moveColumn(col_type col_start, col_type col_end,
+ ColDirection direction)
{
- 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);
- std::swap(cell_info[r][col].right_line, cell_info[r][col + 1].right_line);
-
- idx_type const i = cellIndex(r, col);
- idx_type const j = cellIndex(r, col + 1);
- if (buffer().params().track_changes) {
- cellInfo(i).inset->setChange(Change(Change::INSERTED));
- cellInfo(j).inset->setChange(Change(Change::INSERTED));
+ if (direction == Tabular::LEFT) {
+ for (col_type col = col_start; col <= col_end; ++col) {
+ std::swap(column_info[col - 1], column_info[col]);
+ for (row_type r = 0; r < nrows(); ++r) {
+ std::swap(cell_info[r][col - 1], cell_info[r][col]);
+ std::swap(cell_info[r][col - 1].left_line, cell_info[r][col].left_line);
+ std::swap(cell_info[r][col - 1].right_line, cell_info[r][col].right_line);
+
+ if (buffer().params().track_changes) {
+ idx_type const i = cellIndex(r, col - 1);
+ idx_type const j = cellIndex(r, col);
+ cellInfo(i).inset->setChange(Change(Change::INSERTED));
+ cellInfo(j).inset->setChange(Change(Change::INSERTED));
+ }
+ }
+ updateIndexes();
+ if (col == ncols())
+ break;
+ }
+ } else {
+ for (col_type col = col_end; col >= col_start; --col) {
+ 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);
+ std::swap(cell_info[r][col].right_line, cell_info[r][col + 1].right_line);
+
+ if (buffer().params().track_changes) {
+ idx_type const i = cellIndex(r, col);
+ idx_type const j = cellIndex(r, col + 1);
+ cellInfo(i).inset->setChange(Change(Change::INSERTED));
+ cellInfo(j).inset->setChange(Change(Change::INSERTED));
+ }
+ }
+ updateIndexes();
+ if (col == 0)
+ break;
}
}
- updateIndexes();
}
-void Tabular::moveRow(row_type row, RowDirection direction)
+void Tabular::moveRow(row_type row_start, row_type row_end, RowDirection direction)
{
- 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);
- std::swap(cell_info[row][c].bottom_line, cell_info[row + 1][c].bottom_line);
-
- idx_type const i = cellIndex(row, c);
- idx_type const j = cellIndex(row + 1, c);
- if (buffer().params().track_changes) {
- cellInfo(i).inset->setChange(Change(Change::INSERTED));
- cellInfo(j).inset->setChange(Change(Change::INSERTED));
+ if (direction == Tabular::UP) {
+ for (row_type row = row_start; row <= row_end; ++row) {
+ std::swap(row_info[row - 1], row_info[row]);
+ for (col_type c = 0; c < ncols(); ++c) {
+ std::swap(cell_info[row - 1][c], cell_info[row][c]);
+ std::swap(cell_info[row - 1][c].top_line, cell_info[row][c].top_line);
+ std::swap(cell_info[row - 1][c].bottom_line, cell_info[row][c].bottom_line);
+
+ idx_type const i = cellIndex(row - 1, c);
+ idx_type const j = cellIndex(row, c);
+ if (buffer().params().track_changes) {
+ cellInfo(i).inset->setChange(Change(Change::INSERTED));
+ cellInfo(j).inset->setChange(Change(Change::INSERTED));
+ }
+ }
+ updateIndexes();
+ if (row == nrows())
+ break;
+ }
+ } else {
+ for (row_type row = row_end; row >= row_start; --row) {
+ 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);
+ std::swap(cell_info[row][c].bottom_line, cell_info[row + 1][c].bottom_line);
+
+ idx_type const i = cellIndex(row, c);
+ idx_type const j = cellIndex(row + 1, c);
+ if (buffer().params().track_changes) {
+ cellInfo(i).inset->setChange(Change(Change::INSERTED));
+ cellInfo(j).inset->setChange(Change(Change::INSERTED));
+ }
+ }
+ updateIndexes();
+ if (row == 0)
+ break;
}
}
- updateIndexes();
}
if (col + 1 < ncols() &&
cell_info[r][col].multicolumn == CELL_BEGIN_OF_MULTICOLUMN &&
cell_info[r][col + 1].multicolumn == CELL_PART_OF_MULTICOLUMN) {
- cell_info[r][col + 1].multicolumn = CELL_BEGIN_OF_MULTICOLUMN;
+ cell_info[r][col + 1] = cell_info[r][col];
}
if (!ct)
cell_info[r].erase(cell_info[r].begin() + col);
void Tabular::insertColumn(col_type const col, bool copy)
{
bool const ct = buffer().params().track_changes;
- column_info.insert(column_info.begin() + col + 1, ColumnData(column_info[col]));
+ column_info.insert(column_info.begin() + col + 1, column_info[col]);
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_));
+ copy ? cell_info[r][col] : CellData(buffer_));
if (cell_info[r][col].multicolumn == CELL_BEGIN_OF_MULTICOLUMN)
cell_info[r][col + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
}
}
-Tabular::idx_type Tabular::numberOfCellsInRow(row_type const row) const
+idx_type Tabular::numberOfCellsInRow(row_type const row) const
{
idx_type result = 0;
for (col_type c = 0; c < ncols(); ++c)
if (!tab_width.zero()) {
restwidth = mi.base.inPixels(tab_width);
// Subtract the fixed widths from the table width
- for (auto const w : max_pwidth)
+ for (auto const & w : max_pwidth)
restwidth -= w.second;
}
// Now consider that some variable width columns exceed the vcolwidth
if (vcolwidth > 0) {
bool changed = false;
- for (auto const w : max_width) {
+ for (auto const & w : max_width) {
if (tabularx || w.second > vcolwidth) {
--restcols;
restwidth -= w.second;
namespace {
/**
- * Allow line and paragraph breaks for fixed width multicol/multirow cells
+ * Allow line and paragraph breaks for fixed width multirow cells
* or disallow them, merge cell paragraphs and reset layout to standard
* for variable width multicol cells.
*/
void toggleFixedWidth(Cursor & cur, InsetTableCell * inset,
- bool const fixedWidth, bool const multicol,
- bool const multirow)
+ bool const fixedWidth, bool const multirow)
{
inset->toggleFixedWidth(fixedWidth);
- if (!multirow && (fixedWidth || !multicol))
+ if (!multirow)
return;
- // merge all paragraphs to one
BufferParams const & bp = cur.bv().buffer().params();
- while (inset->paragraphs().size() > 1)
- mergeParagraph(bp, inset->paragraphs(), 0);
-
- // This is relevant for multirows
- if (fixedWidth)
- return;
-
- // remove newlines
- ParagraphList::iterator pit = inset->paragraphs().begin();
- for (; pit != inset->paragraphs().end(); ++pit) {
- for (pos_type j = 0; j != pit->size(); ++j) {
- if (pit->isNewline(j))
- pit->eraseChar(j, bp.track_changes);
- }
- }
-
// reset layout
cur.push(*inset);
// undo information has already been recorded
idx_type const cidx = cellIndex(r, c);
// because of multicolumns
toggleFixedWidth(cur, cellInset(cidx).get(),
- !getPWidth(cidx).zero(), isMultiColumn(cidx),
- isMultiRow(cidx));
+ !getPWidth(cidx).zero(), isMultiRow(cidx));
if (isMultiRow(cidx))
- setAlignment(cidx, LYX_ALIGN_LEFT, false);
+ setAlignment(cidx, column_info[c].alignment,
+ !column_info[c].p_width.zero());
}
// cur can become invalid after paragraphs were merged
cur.fixIfBroken();
cellInfo(cell).p_width = width;
toggleFixedWidth(cur, cellInset(cell).get(), !width.zero(),
- isMultiColumn(cell), isMultiRow(cell));
+ isMultiRow(cell));
// cur can become invalid after paragraphs were merged
cur.fixIfBroken();
return true;
bool Tabular::toggleVarwidth(idx_type cell, bool const varwidth)
{
column_info[cellColumn(cell)].varwidth = varwidth;
+ cellInset(cell).get()->toggleVarWidth(varwidth);
return true;
}
}
-Tabular::idx_type Tabular::getFirstCellInRow(row_type row, bool const ct) const
+idx_type Tabular::getFirstCellInRow(row_type row, bool const ct) const
{
col_type c = 0;
idx_type const numcells = numberOfCellsInRow(row);
}
-Tabular::idx_type Tabular::getLastCellInRow(row_type row, bool const ct) const
+idx_type Tabular::getLastCellInRow(row_type row, bool const ct) const
{
col_type c = ncols() - 1;
// of course we check against 0 so we don't crash. but we have the same
}
-Tabular::row_type Tabular::getFirstRow(bool const ct) const
+row_type Tabular::getFirstRow(bool const ct) const
{
row_type r = 0;
if (!ct)
}
-Tabular::row_type Tabular::getLastRow(bool const ct) const
+row_type Tabular::getLastRow(bool const ct) const
{
row_type r = nrows() - 1;
if (!ct)
}
-Tabular::row_type Tabular::cellRow(idx_type cell) const
+row_type Tabular::cellRow(idx_type cell) const
{
if (cell >= numberofcells)
return nrows() - 1;
}
-Tabular::col_type Tabular::cellColumn(idx_type cell) const
+col_type Tabular::cellColumn(idx_type cell) const
{
if (cell >= numberofcells)
return ncols() - 1;
{
for (row_type r = 0; r < nrows(); ++r) {
idx_type idx = cellIndex(r, c);
- if (getRotateCell(idx) == 0 && useBox(idx) == BOX_VARWIDTH)
+ if (getRotateCell(idx) == 0 && useBox(idx) == BOX_VARWIDTH
+ && getAlignment(idx) == LYX_ALIGN_LEFT
+ && getVAlignment(idx) == LYX_VALIGN_TOP)
return true;
}
return false;
}
-Tabular::idx_type Tabular::setMultiColumn(Cursor & cur, idx_type cell, idx_type number,
+idx_type Tabular::setMultiColumn(Cursor & cur, idx_type cell, idx_type number,
bool const right_border)
{
idx_type const col = cellColumn(cell);
// non-fixed width multicolumns cannot have multiple paragraphs
if (getPWidth(cell).zero()) {
toggleFixedWidth(cur, cellInset(cell).get(),
- !getPWidth(cell).zero(), isMultiColumn(cell),
- isMultiRow(cell));
+ !getPWidth(cell).zero(), isMultiRow(cell));
// cur can become invalid after paragraphs were merged
cur.fixIfBroken();
}
return false;
}
-Tabular::idx_type Tabular::setMultiRow(Cursor & cur, idx_type cell, idx_type number,
+idx_type Tabular::setMultiRow(Cursor & cur, idx_type cell, idx_type number,
bool const bottom_border,
LyXAlignment const halign)
{
if (getPWidth(cell).zero()) {
toggleFixedWidth(cur, cellInset(cell).get(),
!getPWidth(cell).zero(),
- isMultiColumn(cell), isMultiRow(cell));
+ isMultiRow(cell));
// cur can become invalid after paragraphs were merged
cur.fixIfBroken();
}
}
-Tabular::idx_type Tabular::columnSpan(idx_type cell) const
+idx_type Tabular::columnSpan(idx_type cell) const
{
row_type const row = cellRow(cell);
col_type const col = cellColumn(cell);
}
-Tabular::idx_type Tabular::rowSpan(idx_type cell) const
+idx_type Tabular::rowSpan(idx_type cell) const
{
col_type const column = cellColumn(cell);
col_type row = cellRow(cell) + 1;
}
-Tabular::idx_type Tabular::cellAbove(idx_type cell) const
+idx_type Tabular::cellAbove(idx_type cell) const
{
if (cellRow(cell) == 0)
return cell;
}
-Tabular::idx_type Tabular::cellBelow(idx_type cell) const
+idx_type Tabular::cellBelow(idx_type cell) const
{
row_type const nextrow = cellRow(cell) + rowSpan(cell);
if (nextrow < nrows())
}
-Tabular::idx_type Tabular::cellIndex(row_type row, col_type column) const
+idx_type Tabular::cellIndex(row_type row, col_type column) const
{
LASSERT(column != npos && column < ncols(), column = 0);
LASSERT(row != npos && row < nrows(), row = 0);
}
-Tabular::idx_type Tabular::setLTCaption(Cursor & cur, row_type row, bool what)
+idx_type Tabular::setLTCaption(Cursor & cur, row_type row, bool what)
{
idx_type i = getFirstCellInRow(row);
if (what) {
break;
}
- for (col_type j = cstart ; j < c ; ++j)
+ for (col_type j = cstart ; j <= c ; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
col_type lastcol = (*it1 == *it2) ? c + 1 + offset : columns.size() - c + offset;
break;
}
- for (col_type j = cstart ; j < c ; ++j)
+ for (col_type j = cstart ; j <= c ; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
col_type lastcol = (*it1 == *it2) ? c + 1 + offset : columns.size() - c + offset;
<< from_ascii(getPWidth(cell).asLatexString())
<< '}';
} else {
- switch (align) {
- case LYX_ALIGN_LEFT:
- os << 'l';
- break;
- case LYX_ALIGN_RIGHT:
- os << 'r';
- break;
- default:
- os << 'c';
- break;
+ if ((getRotateCell(cell) == 0 && useBox(cell) == BOX_VARWIDTH
+ && align == LYX_ALIGN_LEFT))
+ os << "V{\\linewidth}";
+ else {
+ switch (align) {
+ case LYX_ALIGN_LEFT:
+ os << 'l';
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << 'r';
+ break;
+ default:
+ os << 'c';
+ break;
+ }
}
} // end if else !getPWidth
} // end if else !cellinfo_of_cell
os << "\\multirow{" << rowSpan(cell) << "}{";
if (!getPWidth(cell).zero())
os << from_ascii(getPWidth(cell).asLatexString());
- else
- // we need to set a default value
- os << "*";
+ else {
+ if (column_info[c].varwidth)
+ // this inherits varwidth size
+ os << "=";
+ else
+ // we need to set a default value
+ os << "*";
+ }
os << "}";
if (!getMROffset(cell).zero())
os << "[" << from_ascii(getMROffset(cell).asLatexString()) << "]";
}
os << "]{" << from_ascii(getPWidth(cell).asLatexString())
<< "}\n";
- } else if (getRotateCell(cell) != 0 && getUsebox(cell) == BOX_VARWIDTH) {
- os << "\\begin{varwidth}[";
+ } else if (getUsebox(cell) == BOX_VARWIDTH
+ && (getRotateCell(cell) != 0 || align != LYX_ALIGN_LEFT
+ || valign != LYX_VALIGN_TOP)) {
+ os << "\\begin{cellvarwidth}[";
switch (valign) {
case LYX_VALIGN_TOP:
os << 't';
case LYX_VALIGN_BOTTOM:
os << 'b';
break;
+ }
+ os << "]\n";
+ switch (align) {
+ case LYX_ALIGN_RIGHT:
+ os << "\\raggedleft\n";
+ break;
+ case LYX_ALIGN_CENTER:
+ os << "\\centering\n";
+ break;
+ case LYX_ALIGN_LEFT:
+ //os << "\\narrowragged\n";
+ break;
+ case LYX_ALIGN_BLOCK:
+ case LYX_ALIGN_DECIMAL:
+ case LYX_ALIGN_NONE:
+ case LYX_ALIGN_LAYOUT:
+ case LYX_ALIGN_SPECIAL:
+ break;
+ }
}
- os << "]{\\linewidth}\n";
-}
}
os << '}';
else if (getUsebox(cell) == BOX_MINIPAGE)
os << breakln << "\\end{minipage}";
- else if (getRotateCell(cell) != 0 && getUsebox(cell) == BOX_VARWIDTH)
- os << breakln << "\\end{varwidth}";
+ else if (getUsebox(cell) == BOX_VARWIDTH
+ && (getRotateCell(cell) != 0 || getAlignment(cell) != LYX_ALIGN_LEFT
+ || getVAlignment(cell) != LYX_VALIGN_TOP))
+ os << breakln << "\\end{cellvarwidth}";
if (getRotateCell(cell) != 0)
os << breakln << "\\end{turn}";
if (ismultirow)
} else if (ltCaption(row)) {
// Inside longtable caption rows, we must only output the caption inset
// with its content and omit anything outside of that (see #10791)
- InsetIterator it = inset_iterator_begin(*const_cast<InsetTableCell *>(inset));
- InsetIterator i_end = inset_iterator_end(*const_cast<InsetTableCell *>(inset));
- for (; it != i_end; ++it) {
- if (it->lyxCode() != CAPTION_CODE)
+ InsetTableCell & tc_inset = *const_cast<InsetTableCell *>(inset);
+ for (Inset const & it : tc_inset) {
+ if (it.lyxCode() != CAPTION_CODE)
continue;
- it->latex(os, runparams);
+ it.latex(os, runparams);
break;
}
} else if (!isPartOfMultiRow(row, c)) {
if (!runparams.nice)
os.texrow().start(par.id(), 0);
+ if (isMultiRow(cell) && !LaTeXFeatures::isAvailable("multirow-2021/01/29"))
+ newrp.isNonLong = true;
inset->latex(os, newrp);
}
break;
}
os << 'X';
- } else if (isVTypeColumn(c)) {
- switch (column_info[c].alignment) {
- case LYX_ALIGN_LEFT:
- os << ">{\\raggedright}";
- break;
- case LYX_ALIGN_RIGHT:
- os << ">{\\raggedleft}";
- break;
- case LYX_ALIGN_CENTER:
- os << ">{\\centering}";
- break;
- case LYX_ALIGN_NONE:
- case LYX_ALIGN_BLOCK:
- case LYX_ALIGN_LAYOUT:
- case LYX_ALIGN_SPECIAL:
- case LYX_ALIGN_DECIMAL:
- break;
- }
+ } else if (isVTypeColumn(c))
os << "V{\\linewidth}";
- } else {
+ else {
switch (column_info[c].alignment) {
case LYX_ALIGN_LEFT:
os << 'l';
Length const cwidth = column_info[c].p_width;
if (!cwidth.zero()) {
string const hwidth = cwidth.asHTMLString();
- attr << "style =\"width: " << hwidth << ";\" ";
+ attr << "style=\"width: " << hwidth << ";\" ";
}
attr << "align='";
else if (isMultiRow(cell))
attr << " rowspan='" << rowSpan(cell) << "'";
+ OutputParams rp = runparams;
+ rp.docbook_in_par = false;
+ rp.docbook_force_pars = true;
xs << xml::StartTag(celltag, attr.str(), true);
- cellInset(cell)->docbook(xs, runparams);
+ cellInset(cell)->docbook(xs, rp);
xs << xml::EndTag(celltag);
xs << xml::CR();
++cell;
if (((havefirsthead && row_info[r].endfirsthead) ||
(havehead && row_info[r].endhead)) &&
!row_info[r].caption) {
- docbookRow(xs, r, runparams, true); // TODO: HTML vs CALS
+ docbookRow(xs, r, runparams, true);
}
}
xs << xml::EndTag("thead");
Length const cwidth = column_info[c].p_width;
if (!cwidth.zero()) {
string const hwidth = cwidth.asHTMLString();
- attr << "style =\"width: " << hwidth << ";\" ";
+ attr << "style=\"width: " << hwidth << ";\" ";
}
attr << "align='";
for (idx_type cell = 0; cell < numberofcells; ++cell) {
if (isMultiRow(cell))
features.require("multirow");
- if (getUsebox(cell) == BOX_VARWIDTH)
+ if (getUsebox(cell) == BOX_VARWIDTH) {
features.require("varwidth");
+ features.require("cellvarwidth");
+ }
if (getVAlignment(cell) != LYX_VALIGN_TOP
|| !getPWidth(cell).zero()
|| isVTypeColumn(cellColumn(cell)))
/////////////////////////////////////////////////////////////////////
InsetTableCell::InsetTableCell(Buffer * buf)
- : InsetText(buf, InsetText::PlainLayout), isFixedWidth(false),
+ : InsetText(buf, InsetText::PlainLayout), isFixedWidth(false), isVarwidth(false),
isMultiColumn(false), isMultiRow(false), contentAlign(LYX_ALIGN_CENTER)
{}
-InsetTableCell::InsetTableCell(InsetTableCell const & in) : InsetText(in)
-{
- isFixedWidth = in.isFixedWidth;
- isMultiColumn = in.isMultiColumn;
- isMultiRow = in.isMultiRow;
- contentAlign = in.contentAlign;
-}
-
-bool InsetTableCell::forcePlainLayout(idx_type) const
-{
- return isMultiRow || (isMultiColumn && !isFixedWidth);
-}
-
-
bool InsetTableCell::allowParagraphCustomization(idx_type) const
{
return isFixedWidth;
{
bool enabled = true;
switch (cmd.action()) {
+ case LFUN_INSET_SPLIT:
case LFUN_INSET_DISSOLVE:
enabled = false;
break;
// We tell metrics here not to expand on multiple pars
// This is the difference to InsetText::Metrics
+ Changer changetight = changeVar(mi.tight_insets, true);
if (hasFixedWidth())
- tm.metrics(mi, dim, mi.base.textwidth, false);
+ tm.metrics(mi, dim, mi.base.textwidth);
else
- tm.metrics(mi, dim, 0, false);
+ tm.metrics(mi, dim, 0);
mi.base.textwidth += horiz_offset;
dim.asc += topOffset(mi.base.bv);
dim.des += bottomOffset(mi.base.bv);
bool InsetTabular::allowMultiPar() const
{
- for (Tabular::col_type c = 0; c < tabular.ncols(); ++c) {
- for (Tabular::row_type r = 0; r < tabular.nrows(); ++r) {
+ for (col_type c = 0; c < tabular.ncols(); ++c) {
+ for (row_type r = 0; r < tabular.nrows(); ++r) {
if (tabular.cellInset(r,c)->allowMultiPar())
return true;
}
// determine horizontal offset because of decimal align (if necessary)
int decimal_width = 0;
if (tabular.getAlignment(cell) == LYX_ALIGN_DECIMAL) {
- InsetTableCell tail = InsetTableCell(*tabular.cellInset(cell));
+ InsetTableCell tail = *tabular.cellInset(cell);
tail.setBuffer(tabular.buffer());
// we need to set macrocontext position everywhere
// otherwise we crash with nested insets (e.g. footnotes)
tabular.cell_info[r][c].decimal_hoffset = tm.width() - decimal_width;
tabular.cell_info[r][c].decimal_width = decimal_width;
- // with LYX_VALIGN_BOTTOM the descent is relative to the last par
- // = descent of text in last par + bottomOffset:
- int const lastpardes = tm.last().second->descent()
+ // with LYX_VALIGN_BOTTOM the descent is relative to the last
+ // row of the last par (note that the par might have multile rows!)
+ // = descent of text in last row + bottomOffset:
+ int const lastpardes = tm.last().second->rows().back().descent()
+ bottomOffset(mi.base.bv);
int offset = 0;
switch (tabular.getVAlignment(cell)) {
Color colour = Color_tabularline;
if (tabular.column_info[col].change.changed()
|| tabular.row_info[row].change.changed())
- colour = InsetTableCell(*tabular.cellInset(cell)).paragraphs().front().lookupChange(0).color();
+ colour = tabular.cellInset(cell)->paragraphs().front().lookupChange(0).color();
// Top
bool drawline = tabular.topLine(cell)
}
break;
+ case LFUN_COPY:
+ if (cur.selIsMultiCell())
+ copySelection(cur);
+ else
+ cell(cur.idx())->dispatch(cur, cmd);
+ break;
+
case LFUN_CUT:
if (cur.selIsMultiCell()) {
if (copySelection(cur)) {
cell(cur.idx())->dispatch(cur, cmd);
break;
- case LFUN_COPY:
- if (!cur.selection())
- break;
- if (cur.selIsMultiCell()) {
- cur.finishUndo();
- copySelection(cur);
- } else
- cell(cur.idx())->dispatch(cur, cmd);
- break;
-
case LFUN_CLIPBOARD_PASTE:
case LFUN_PRIMARY_SELECTION_PASTE: {
docstring const clip = (act == LFUN_CLIPBOARD_PASTE) ?
if (insertPlaintextString(cur.bv(), clip, false)) {
// content has been replaced,
// so cursor might be invalid
- cur.pos() = cur.lastpos();
- cur.pit() = cur.lastpit();
+ cur.fixIfBroken();
bvcur.setCursor(cur);
break;
}
break;
}
}
- else if (theClipboard().hasTextContents(Clipboard::LyXTextType)) {
+ else if (!theClipboard().isInternal()
+ && theClipboard().hasTextContents(Clipboard::LyXTextType)) {
// This might be tabular data from another LyX instance. Check!
docstring const clip =
theClipboard().getAsText(Clipboard::PlainTextType);
case Tabular::SET_SPECIAL_MULTICOLUMN:
case Tabular::APPEND_ROW:
case Tabular::APPEND_COLUMN:
- case Tabular::DELETE_ROW:
- case Tabular::DELETE_COLUMN:
case Tabular::COPY_ROW:
case Tabular::COPY_COLUMN:
case Tabular::SET_TOP_SPACE:
status.clear();
return true;
+ case Tabular::DELETE_ROW:
+ status.setEnabled(tabular.nrows() > 1);
+ break;
+ case Tabular::DELETE_COLUMN:
+ status.setEnabled(tabular.ncols() > 1);
+ break;
+
case Tabular::SET_TABULAR_WIDTH:
status.setEnabled(!tabular.rotate
&& tabular.tabular_valignment == Tabular::LYX_VALIGN_MIDDLE);
case Tabular::MOVE_COLUMN_LEFT:
case Tabular::MOVE_ROW_DOWN:
case Tabular::MOVE_ROW_UP: {
- if (cur.selection()) {
- status.message(_("Selections not supported."));
- status.setEnabled(false);
- break;
+ row_type rs, re;
+ col_type cs, ce;
+ if (cur.selIsMultiCell())
+ getSelection(cur, rs, re, cs, ce);
+ else {
+ rs = tabular.cellRow(cur.idx());
+ re = rs;
+ cs = tabular.cellColumn(cur.idx());
+ ce = cs;
}
-
- if ((action == Tabular::MOVE_COLUMN_RIGHT &&
- tabular.ncols() == tabular.cellColumn(cur.idx()) + 1) ||
- (action == Tabular::MOVE_COLUMN_LEFT &&
- tabular.cellColumn(cur.idx()) == 0) ||
- (action == Tabular::MOVE_ROW_DOWN &&
- tabular.nrows() == tabular.cellRow(cur.idx()) + 1) ||
- (action == Tabular::MOVE_ROW_UP &&
- tabular.cellRow(cur.idx()) == 0)) {
+ if ((action == Tabular::MOVE_COLUMN_RIGHT
+ && tabular.ncols() == ce + 1)
+ || (action == Tabular::MOVE_COLUMN_LEFT && cs == 0)
+ || (action == Tabular::MOVE_ROW_DOWN
+ && tabular.nrows() == re + 1)
+ || (action == Tabular::MOVE_ROW_UP && rs == 0)) {
status.setEnabled(false);
break;
}
- if (action == Tabular::MOVE_COLUMN_RIGHT ||
- action == Tabular::MOVE_COLUMN_LEFT) {
- if (tabular.hasMultiColumn(tabular.cellColumn(cur.idx())) ||
- tabular.hasMultiColumn(tabular.cellColumn(cur.idx()) +
- (action == Tabular::MOVE_COLUMN_RIGHT ? 1 : -1))) {
- status.message(_("Multi-column in current or"
- " destination column."));
+ if (action == Tabular::MOVE_COLUMN_RIGHT
+ || action == Tabular::MOVE_COLUMN_LEFT) {
+ bool has_multicol = (action == Tabular::MOVE_COLUMN_RIGHT)
+ ? tabular.hasMultiColumn(ce + 1)
+ : tabular.hasMultiColumn(cs - 1);
+ for (col_type c = cs; c <= ce; ++c) {
+ if (tabular.hasMultiColumn(c)) {
+ has_multicol = true;
+ break;
+ }
+ }
+ if (has_multicol) {
+ status.message(_("Column movement not supported with multi-columns."));
status.setEnabled(false);
break;
}
}
- if (action == Tabular::MOVE_ROW_DOWN ||
- action == Tabular::MOVE_ROW_UP) {
- if (tabular.hasMultiRow(tabular.cellRow(cur.idx())) ||
- tabular.hasMultiRow(tabular.cellRow(cur.idx()) +
- (action == Tabular::MOVE_ROW_DOWN ? 1 : -1))) {
- status.message(_("Multi-row in current or"
- " destination row."));
+ if (action == Tabular::MOVE_ROW_DOWN
+ || action == Tabular::MOVE_ROW_UP) {
+ bool has_multirow = (action == Tabular::MOVE_ROW_DOWN)
+ ? tabular.hasMultiRow(re + 1)
+ : tabular.hasMultiRow(rs - 1);
+ for (row_type r = rs; r <= re; ++r) {
+ if (tabular.hasMultiRow(r)) {
+ has_multirow = true;
+ break;
+ }
+ }
+ if (has_multirow) {
+ status.message(_("Row movement not supported with multi-rows."));
status.setEnabled(false);
break;
}
flag = false;
// fall through
case Tabular::VALIGN_TOP:
- status.setEnabled(!tabular.getPWidth(cur.idx()).zero()
- && !tabular.isMultiRow(cur.idx()));
+ status.setEnabled((!tabular.getPWidth(cur.idx()).zero()
+ || tabular.getUsebox(cur.idx()) == Tabular::BOX_VARWIDTH));
status.setOnOff(
tabular.getVAlignment(cur.idx(), flag) == Tabular::LYX_VALIGN_TOP);
break;
flag = false;
// fall through
case Tabular::VALIGN_BOTTOM:
- status.setEnabled(!tabular.getPWidth(cur.idx()).zero()
- && !tabular.isMultiRow(cur.idx()));
+ status.setEnabled((!tabular.getPWidth(cur.idx()).zero()
+ || tabular.getUsebox(cur.idx()) == Tabular::BOX_VARWIDTH));
status.setOnOff(
tabular.getVAlignment(cur.idx(), flag) == Tabular::LYX_VALIGN_BOTTOM);
break;
flag = false;
// fall through
case Tabular::VALIGN_MIDDLE:
- status.setEnabled(!tabular.getPWidth(cur.idx()).zero()
- && !tabular.isMultiRow(cur.idx()));
+ status.setEnabled((!tabular.getPWidth(cur.idx()).zero()
+ || tabular.getUsebox(cur.idx()) == Tabular::BOX_VARWIDTH));
status.setOnOff(
tabular.getVAlignment(cur.idx(), flag) == Tabular::LYX_VALIGN_MIDDLE);
break;
case Tabular::SET_LONGTABULAR:
case Tabular::TOGGLE_LONGTABULAR:
// setting as longtable is not allowed when table is inside a float
- if (cur.innerInsetOfType(FLOAT_CODE) != 0
- || cur.innerInsetOfType(WRAP_CODE) != 0)
+ if (cur.innerInsetOfType(FLOAT_CODE) != nullptr
+ || cur.innerInsetOfType(WRAP_CODE) != nullptr)
status.setEnabled(false);
else
status.setEnabled(true);
}
// check if there is already a caption
bool have_caption = false;
- InsetTableCell itc = InsetTableCell(*tabular.cellInset(cur.idx()));
+ InsetTableCell itc = *tabular.cellInset(cur.idx());
ParagraphList::const_iterator pit = itc.paragraphs().begin();
ParagraphList::const_iterator pend = itc.paragraphs().end();
for (; pit != pend; ++pit) {
return cell(cur.idx())->getStatus(cur, cmd, status);
}
- // disable in non-fixed-width cells
case LFUN_PARAGRAPH_BREAK:
- // multirow does not allow paragraph breaks
- if (tabular.isMultiRow(cur.idx())) {
- status.setEnabled(false);
- return true;
- }
- // fall through
case LFUN_NEWLINE_INSERT:
- if ((tabular.isMultiColumn(cur.idx()) || tabular.isMultiRow(cur.idx()))
- && tabular.getPWidth(cur.idx()).zero()) {
- status.setEnabled(false);
- return true;
- }
return cell(cur.idx())->getStatus(cur, cmd, status);
case LFUN_NEWPAGE_INSERT:
}
-Inset::RowFlags InsetTabular::rowFlags() const
+int InsetTabular::rowFlags() const
{
- if (tabular.is_long_tabular) {
- switch (tabular.longtabular_alignment) {
- case Tabular::LYX_LONGTABULAR_ALIGN_LEFT:
- return Display | AlignLeft;
- case Tabular::LYX_LONGTABULAR_ALIGN_CENTER:
- return Display;
- case Tabular::LYX_LONGTABULAR_ALIGN_RIGHT:
- return Display | AlignRight;
- default:
- return Display;
- }
- } else
- return Inline;
+ if (tabular.is_long_tabular) {
+ switch (tabular.longtabular_alignment) {
+ case Tabular::LYX_LONGTABULAR_ALIGN_LEFT:
+ return Display | AlignLeft;
+ case Tabular::LYX_LONGTABULAR_ALIGN_CENTER:
+ return Display;
+ case Tabular::LYX_LONGTABULAR_ALIGN_RIGHT:
+ return Display | AlignRight;
+ default:
+ return Display;
+ }
+ } else
+ return Inline;
}
}
-InsetTabular::idx_type InsetTabular::getNearestCell(BufferView & bv, int x, int y) const
+idx_type InsetTabular::getNearestCell(BufferView & bv, int x, int y) const
{
idx_type idx_min = 0;
int dist_min = numeric_limits<int>::max();
break;
case Tabular::MOVE_COLUMN_RIGHT:
- tabular.moveColumn(column, Tabular::RIGHT);
- cur.idx() = tabular.cellIndex(row, column + 1);
+ tabular.moveColumn(sel_col_start, sel_col_end, Tabular::RIGHT);
+ if (cur.selection()) {
+ cur.selection(false);
+ cur.idx() = tabular.cellIndex(sel_row_start, sel_col_start + 1);
+ cur.resetAnchor();
+ cur.idx() = tabular.cellIndex(sel_row_end, sel_col_end + 1);
+ cur.setSelection();
+ } else
+ cur.idx() = tabular.cellIndex(row, column + 1);
break;
case Tabular::MOVE_COLUMN_LEFT:
- tabular.moveColumn(column, Tabular::LEFT);
- cur.idx() = tabular.cellIndex(row, column - 1);
+ tabular.moveColumn(sel_col_start, sel_col_end, Tabular::LEFT);
+ if (cur.selection()) {
+ cur.selection(false);
+ cur.idx() = tabular.cellIndex(sel_row_start, sel_col_start - 1);
+ cur.resetAnchor();
+ cur.idx() = tabular.cellIndex(sel_row_end, sel_col_end - 1);
+ cur.setSelection();
+ } else
+ cur.idx() = tabular.cellIndex(row, column - 1);
break;
case Tabular::MOVE_ROW_DOWN:
- tabular.moveRow(row, Tabular::DOWN);
- cur.idx() = tabular.cellIndex(row + 1, column);
+ tabular.moveRow(sel_row_start, sel_row_end, Tabular::DOWN);
+ if (cur.selection()) {
+ cur.selection(false);
+ cur.idx() = tabular.cellIndex(sel_row_start + 1, sel_col_start);
+ cur.resetAnchor();
+ cur.idx() = tabular.cellIndex(sel_row_end + 1, sel_col_end);
+ cur.setSelection();
+ } else
+ cur.idx() = tabular.cellIndex(row + 1, column);
break;
case Tabular::MOVE_ROW_UP:
- tabular.moveRow(row, Tabular::UP);
- cur.idx() = tabular.cellIndex(row - 1, column);
+ tabular.moveRow(sel_row_start, sel_row_end, Tabular::UP);
+ if (cur.selection()) {
+ cur.selection(false);
+ cur.idx() = tabular.cellIndex(sel_row_start - 1, sel_col_start);
+ cur.resetAnchor();
+ cur.idx() = tabular.cellIndex(sel_row_end - 1, sel_col_end);
+ cur.setSelection();
+ } else
+ cur.idx() = tabular.cellIndex(row - 1, column);
break;
case Tabular::SET_LINE_TOP:
paste_tabular->setBuffer(tabular.buffer());
odocstringstream os;
- OutputParams const runparams(0);
+ OutputParams const runparams(nullptr);
paste_tabular->plaintext(os, runparams, 0, true, '\t', INT_MAX);
// Needed for the "Edit->Paste recent" menu and the system clipboard.
cap::copySelection(cur, os.str());
// FIXME?: why do we need to do this explicitly? (EL)
tabular.cellInset(r2, c2)->setBuffer(tabular.buffer());
- if (!lyxrc.ct_markup_copied) {
- // do not paste deleted text
- inset->acceptChanges();
+ if (lyxrc.ct_markup_copied) {
+ // Only change to inserted if ct is active,
+ // otherwise leave markup as is
+ if (buffer().params().track_changes)
+ inset->setChange(Change(Change::INSERTED));
+ } else
+ // Resolve all markup to inserted or unchanged
inset->setChange(Change(buffer().params().track_changes ?
- Change::INSERTED : Change::UNCHANGED));
- }
+ Change::INSERTED : Change::UNCHANGED));
cur.pos() = 0;
cur.pit() = 0;
}
row_type const row2 = tabular.cellRow(enidx);
for (col_type col = col1; col <= col2; col++)
for (row_type row = row1; row <= row2; row++)
- for (auto par : tabular.cellInset(row, col)->paragraphs())
+ for (auto const & par : tabular.cellInset(row, col)->paragraphs())
retval.push_back(par);
return retval;
}
Text * InsetTabular::getText(int idx) const
{
- return size_t(idx) < nargs() ? cell(idx)->getText(0) : 0;
+ return size_t(idx) < nargs() ? cell(idx)->getText(0) : nullptr;
}
}
-bool InsetTabular::forcePlainLayout(idx_type cell) const
-{
- return tabular.isMultiColumn(cell) && !tabular.getPWidth(cell).zero();
-}
-
-
bool InsetTabular::insertPlaintextString(BufferView & bv, docstring const & buf,
bool usePaste)
{
bool InsetTabular::showCompletionCursor() const
{
- return lyxrc.completion_cursor_text;
+ return lyxrc.completion_cursor_text &&
+ (lyxrc.completion_inline_text || lyxrc.completion_popup_text);
}
CompletionList const * InsetTabular::createCompletionList(Cursor const & cur) const
{
- return completionSupported(cur) ? cur.text()->createCompletionList(cur) : 0;
+ return completionSupported(cur) ? cur.text()->createCompletionList(cur) : nullptr;
}
void InsetTabular::setLayoutForHiddenCells(DocumentClass const & dc)
{
- for (Tabular::col_type c = 0; c < tabular.ncols(); ++c) {
- for (Tabular::row_type r = 0; r < tabular.nrows(); ++r) {
+ for (col_type c = 0; c < tabular.ncols(); ++c) {
+ for (row_type r = 0; r < tabular.nrows(); ++r) {
if (!tabular.isPartOfMultiColumn(r,c) &&
!tabular.isPartOfMultiRow(r,c))
continue;
projects / features.git / blobdiff