#include "DispatchResult.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
+#include "InsetIterator.h"
#include "InsetList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
{ Tabular::MOVE_ROW_UP, "move-row-up", false },
{ Tabular::SET_LINE_TOP, "set-line-top", true },
{ Tabular::SET_LINE_BOTTOM, "set-line-bottom", true },
+ { Tabular::SET_LTRIM_TOP, "set-ltrim-top", true },
+ { Tabular::SET_LTRIM_BOTTOM, "set-ltrim-bottom", true },
+ { Tabular::SET_RTRIM_TOP, "set-rtrim-top", true },
+ { Tabular::SET_RTRIM_BOTTOM, "set-rtrim-bottom", true },
{ Tabular::SET_LINE_LEFT, "set-line-left", true },
{ Tabular::SET_LINE_RIGHT, "set-line-right", true },
{ Tabular::TOGGLE_LINE_TOP, "toggle-line-top", false },
{ Tabular::TOGGLE_LINE_BOTTOM, "toggle-line-bottom", false },
{ Tabular::TOGGLE_LINE_LEFT, "toggle-line-left", false },
{ Tabular::TOGGLE_LINE_RIGHT, "toggle-line-right", false },
+ { Tabular::TOGGLE_LTRIM_TOP, "toggle-ltrim-top", false },
+ { Tabular::TOGGLE_LTRIM_BOTTOM, "toggle-ltrim-bottom", false },
+ { Tabular::TOGGLE_RTRIM_TOP, "toggle-rtrim-top", false },
+ { Tabular::TOGGLE_RTRIM_BOTTOM, "toggle-rtrim-bottom", false },
{ Tabular::ALIGN_LEFT, "align-left", false },
{ Tabular::ALIGN_RIGHT, "align-right", false },
{ Tabular::ALIGN_CENTER, "align-center", false },
{ Tabular::UNSET_MULTIROW, "unset-multirow", false },
{ Tabular::SET_MROFFSET, "set-mroffset", true },
{ Tabular::SET_ALL_LINES, "set-all-lines", false },
+ { Tabular::RESET_FORMAL_DEFAULT, "reset-formal-default", false },
{ Tabular::UNSET_ALL_LINES, "unset-all-lines", false },
{ Tabular::TOGGLE_LONGTABULAR, "toggle-longtabular", false },
{ Tabular::SET_LONGTABULAR, "set-longtabular", false },
{ Tabular::UNSET_LONGTABULAR, "unset-longtabular", false },
{ Tabular::SET_PWIDTH, "set-pwidth", true },
{ Tabular::SET_MPWIDTH, "set-mpwidth", true },
+ { Tabular::TOGGLE_VARWIDTH_COLUMN, "toggle-varwidth-column", true },
{ Tabular::SET_ROTATE_TABULAR, "set-rotate-tabular", true },
{ Tabular::UNSET_ROTATE_TABULAR, "unset-rotate-tabular", true },
{ Tabular::TOGGLE_ROTATE_TABULAR, "toggle-rotate-tabular", true },
{ Tabular::LONGTABULAR_ALIGN_RIGHT, "longtabular-align-right", false },
{ Tabular::SET_DECIMAL_POINT, "set-decimal-point", true },
{ Tabular::SET_TABULAR_WIDTH, "set-tabular-width", true },
+ { Tabular::SET_INNER_LINES, "set-inner-lines", false },
{ Tabular::LAST_ACTION, "", false }
};
return "parbox";
case Tabular::BOX_MINIPAGE:
return "minipage";
+ case Tabular::BOX_VARWIDTH:
+ return "varwidth";
}
return string();
}
num = Tabular::BOX_PARBOX;
else if (str == "minipage")
num = Tabular::BOX_MINIPAGE;
+ else if (str == "varwidth")
+ num = Tabular::BOX_VARWIDTH;
else
return false;
return true;
bottom_line(false),
left_line(false),
right_line(false),
+ top_line_rtrimmed(false),
+ top_line_ltrimmed(false),
+ bottom_line_rtrimmed(false),
+ bottom_line_ltrimmed(false),
usebox(BOX_NONE),
rotate(0),
inset(new InsetTableCell(buf))
bottom_line(cs.bottom_line),
left_line(cs.left_line),
right_line(cs.right_line),
+ top_line_rtrimmed(cs.top_line_rtrimmed),
+ top_line_ltrimmed(cs.top_line_ltrimmed),
+ bottom_line_rtrimmed(cs.bottom_line_rtrimmed),
+ bottom_line_ltrimmed(cs.bottom_line_ltrimmed),
usebox(cs.usebox),
rotate(cs.rotate),
align_special(cs.align_special),
bottom_line = cs.bottom_line;
left_line = cs.left_line;
right_line = cs.right_line;
+ top_line_rtrimmed = cs.top_line_rtrimmed;
+ top_line_ltrimmed = cs.top_line_ltrimmed;
+ bottom_line_rtrimmed = cs.bottom_line_rtrimmed;
+ bottom_line_rtrimmed = cs.bottom_line_rtrimmed;
usebox = cs.usebox;
rotate = cs.rotate;
align_special = cs.align_special;
Tabular::ColumnData::ColumnData()
: alignment(LYX_ALIGN_CENTER),
valignment(LYX_VALIGN_TOP),
- width(0)
+ width(0),
+ varwidth(false)
{
}
setBottomLine(i, bottomLine(j));
setTopLine(i, topLine(j));
setLeftLine(i, leftLine(j));
+ setRightLine(i, rightLine(j));
if (rightLine(i) && rightLine(j)) {
- setRightLine(i, true);
setRightLine(j, false);
}
if (buffer().params().track_changes)
// reset column and row of cells and update their width and alignment
for (row_type row = 0; row < nrows(); ++row)
for (col_type column = 0; column < ncols(); ++column) {
- if (isPartOfMultiColumn(row, column))
+ if (isPartOfMultiColumn(row, column)) {
+ cell_info[row][column].inset->toggleMultiCol(true);
continue;
+ }
+ cell_info[row][column].inset->toggleMultiCol(false);
// columnofcell needs to be called before setting width and aligment
// multirow cells inherit the width from the column width
if (!isPartOfMultiRow(row, column)) {
rowofcell[i] = row;
}
setFixedWidth(row, column);
- if (isPartOfMultiRow(row, column))
+ if (isPartOfMultiRow(row, column)) {
+ cell_info[row][column].inset->toggleMultiRow(true);
continue;
+ }
+ cell_info[row][column].inset->toggleMultiRow(false);
cell_info[row][column].inset->setContentAlignment(
getAlignment(cellIndex(row, column)));
++i;
}
-bool Tabular::leftLine(idx_type cell) const
+bool Tabular::leftLine(idx_type cell, bool const ignore_bt) const
{
- if (use_booktabs)
+ if (use_booktabs && !ignore_bt)
return false;
return cellInfo(cell).left_line;
}
-bool Tabular::rightLine(idx_type cell) const
+bool Tabular::rightLine(idx_type cell, bool const ignore_bt) const
{
- if (use_booktabs)
+ if (use_booktabs && !ignore_bt)
return false;
return cellInfo(cell).right_line;
}
+pair<bool, bool> Tabular::topLineTrim(idx_type const cell) const
+{
+ if (!use_booktabs)
+ return make_pair(false, false);
+ return make_pair(cellInfo(cell).top_line_ltrimmed,
+ cellInfo(cell).top_line_rtrimmed);
+}
+
+
+pair<bool, bool> Tabular::bottomLineTrim(idx_type const cell) const
+{
+ if (!use_booktabs)
+ return make_pair(false, false);
+ return make_pair(cellInfo(cell).bottom_line_ltrimmed,
+ cellInfo(cell).bottom_line_rtrimmed);
+}
+
+
int Tabular::interRowSpace(row_type row) const
{
if (!row || row >= nrows())
}
-bool Tabular::updateColumnWidths()
+bool Tabular::updateColumnWidths(MetricsInfo & mi)
{
vector<int> max_dwidth(ncols(), 0);
+ // collect max. fixed width of column
+ map<col_type, int> max_pwidth;
+ // collect max. variable width of column
+ map<col_type, int> max_width;
+
for(col_type c = 0; c < ncols(); ++c)
for(row_type r = 0; r < nrows(); ++r) {
idx_type const i = cellIndex(r, c);
if (getAlignment(i) == LYX_ALIGN_DECIMAL)
max_dwidth[c] = max(max_dwidth[c], cell_info[r][c].decimal_width);
+ if (!getPWidth(i).zero())
+ max_pwidth[c] = max(max_pwidth[c], cell_info[r][c].width);
+ else if (!column_info[c].varwidth)
+ max_width[c] = max(max_width[c], cell_info[r][c].width);
+ }
+
+ // If we have a fixed tabular width, we take this into account
+ Length tab_width = tabular_width;
+ bool const tabularx = hasVarwidthColumn();
+ if (tabularx && tab_width.zero())
+ // If no tabular width is specified with X columns,
+ // we use 100% colwidth
+ tab_width = Length(100, Length::PCW);
+ int restwidth = -1;
+ if (!tab_width.zero()) {
+ restwidth = mi.base.inPixels(tab_width);
+ // Substract the fixed widths from the table width
+ for (auto const w : max_pwidth)
+ restwidth -= w.second;
+ }
+
+ // If we have a fixed width, distribute the available table width
+ // (minus the fixed widths) to the variable-width columns
+ int vcolwidth = -1;
+ int restcols = ncols() - max_pwidth.size();
+ if (restwidth > 0)
+ vcolwidth = restwidth / restcols;
+
+ // Now consider that some variable width columns exceed the vcolwidth
+ if (vcolwidth > 0) {
+ bool changed = false;
+ for (auto const w : max_width) {
+ if (tabularx || w.second > vcolwidth) {
+ --restcols;
+ restwidth -= w.second;
+ changed = true;
+ }
}
+ if (changed && restwidth > 0)
+ vcolwidth = restwidth / restcols;
+ }
bool update = false;
// for each col get max of single col cells
&& cell_info[r][c].decimal_width != 0)
new_width = max(new_width, cellInfo(i).width
+ max_dwidth[c] - cellInfo(i).decimal_width);
- else
+ else if (getPWidth(i).zero() && vcolwidth > 0) {
+ if (tabularx && !column_info[c].varwidth)
+ new_width = max(new_width, cellInfo(i).width);
+ else if (tabularx)
+ new_width = vcolwidth;
+ else
+ new_width = max(vcolwidth, max(new_width, cellInfo(i).width));
+ } else
new_width = max(new_width, cellInfo(i).width);
}
}
if (column_info[c].width != new_width) {
column_info[c].width = new_width;
- update = true;
+ // Do not trigger update when no space is left for variable
+ // columns, as this will loop
+ update = tab_width.zero() || restwidth > 0;
}
}
// update col widths to fit merged cells
if (cellInfo(i).width > old_width) {
column_info[c + span - 1].width += cellInfo(i).width - old_width;
- update = true;
+ // Do not trigger update when no space is left for variable
+ // columns, as this will loop
+ update = tab_width.zero() || restwidth > 0;
}
}
namespace {
/**
- * Allow line and paragraph breaks for fixed width cells or disallow them,
- * merge cell paragraphs and reset layout to standard for variable width
- * cells.
+ * Allow line and paragraph breaks for fixed width multicol/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 fixedWidth)
+void toggleFixedWidth(Cursor & cur, InsetTableCell * inset,
+ bool const fixedWidth, bool const multicol,
+ bool const multirow)
{
inset->toggleFixedWidth(fixedWidth);
- if (fixedWidth)
+ if (!multirow && (fixedWidth || !multicol))
return;
// merge all paragraphs to one
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
cur.pop();
}
-}
+} // namespace
void Tabular::setColumnPWidth(Cursor & cur, idx_type cell,
if (column_info[c].p_width.zero())
column_info[c].valignment = LYX_VALIGN_TOP;
for (row_type r = 0; r < nrows(); ++r) {
- idx_type const cell = cellIndex(r, c);
+ idx_type const cidx = cellIndex(r, c);
// because of multicolumns
- toggleFixedWidth(cur, cellInset(cell).get(),
- !getPWidth(cell).zero());
- if (isMultiRow(cell))
- setAlignment(cell, LYX_ALIGN_LEFT, false);
+ toggleFixedWidth(cur, cellInset(cidx).get(),
+ !getPWidth(cidx).zero(), isMultiColumn(cidx),
+ isMultiRow(cidx));
+ if (isMultiRow(cidx))
+ setAlignment(cidx, LYX_ALIGN_LEFT, false);
}
- // cur paragraph can become invalid after paragraphs were merged
- if (cur.pit() > cur.lastpit())
- cur.pit() = cur.lastpit();
- // cur position can become invalid after newlines were removed
- if (cur.pos() > cur.lastpos())
- cur.pos() = cur.lastpos();
+ // cur can become invalid after paragraphs were merged
+ cur.fixIfBroken();
}
return false;
cellInfo(cell).p_width = width;
- toggleFixedWidth(cur, cellInset(cell).get(), !width.zero());
- // cur paragraph can become invalid after paragraphs were merged
- if (cur.pit() > cur.lastpit())
- cur.pit() = cur.lastpit();
- // cur position can become invalid after newlines were removed
- if (cur.pos() > cur.lastpos())
- cur.pos() = cur.lastpos();
+ toggleFixedWidth(cur, cellInset(cell).get(), !width.zero(),
+ isMultiColumn(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;
return true;
}
}
+void Tabular::setTopLineLTrim(idx_type i, bool val)
+{
+ cellInfo(i).top_line_ltrimmed = val;
+}
+
+
+void Tabular::setTopLineRTrim(idx_type i, bool val)
+{
+ cellInfo(i).top_line_rtrimmed = val;
+}
+
+
+void Tabular::setBottomLineLTrim(idx_type i, bool val)
+{
+ cellInfo(i).bottom_line_ltrimmed = val;
+}
+
+
+void Tabular::setBottomLineRTrim(idx_type i, bool val)
+{
+ cellInfo(i).bottom_line_rtrimmed = val;
+}
+
+
+void Tabular::setTopLineTrim(idx_type i, pair<bool, bool> trim)
+{
+ setTopLineLTrim(i, trim.first);
+ setTopLineRTrim(i, trim.second);
+}
+
+void Tabular::setBottomLineTrim(idx_type i, pair<bool, bool> trim)
+{
+ setBottomLineLTrim(i, trim.first);
+ setBottomLineRTrim(i, trim.second);
+}
+
void Tabular::setLeftLine(idx_type cell, bool line)
{
cellInfo(cell).left_line = line;
<< write_attribute("lastFootBottomDL", endlastfoot.bottomDL)
<< write_attribute("lastFootEmpty", endlastfoot.empty);
// longtables cannot be aligned vertically
- if (!is_long_tabular) {
+ if (!is_long_tabular)
os << write_attribute("tabularvalignment", tabular_valignment);
- os << write_attribute("tabularwidth", tabular_width);
- }
+ os << write_attribute("tabularwidth", tabular_width);
if (is_long_tabular)
os << write_attribute("longtabularalignment", longtabular_alignment);
os << ">\n";
os << write_attribute("decimal_point", column_info[c].decimal_point);
os << write_attribute("valignment", column_info[c].valignment)
<< write_attribute("width", column_info[c].p_width.asString())
+ << write_attribute("varwidth", column_info[c].varwidth)
<< write_attribute("special", column_info[c].align_special)
<< ">\n";
}
<< write_attribute("alignment", cell_info[r][c].alignment)
<< write_attribute("valignment", cell_info[r][c].valignment)
<< write_attribute("topline", cell_info[r][c].top_line)
+ << write_attribute("toplineltrim", cell_info[r][c].top_line_ltrimmed)
+ << write_attribute("toplinertrim", cell_info[r][c].top_line_rtrimmed)
<< write_attribute("bottomline", cell_info[r][c].bottom_line)
+ << write_attribute("bottomlineltrim", cell_info[r][c].bottom_line_ltrimmed)
+ << write_attribute("bottomlinertrim", cell_info[r][c].bottom_line_rtrimmed)
<< write_attribute("leftline", cell_info[r][c].left_line)
<< write_attribute("rightline", cell_info[r][c].right_line)
<< write_attribute("rotate", cell_info[r][c].rotate)
getTokenValue(line, "valignment", column_info[c].valignment);
getTokenValue(line, "width", column_info[c].p_width);
getTokenValue(line, "special", column_info[c].align_special);
+ getTokenValue(line, "varwidth", column_info[c].varwidth);
}
for (row_type i = 0; i < nrows(); ++i) {
getTokenValue(line, "alignment", cell_info[i][j].alignment);
getTokenValue(line, "valignment", cell_info[i][j].valignment);
getTokenValue(line, "topline", cell_info[i][j].top_line);
+ getTokenValue(line, "toplineltrim", cell_info[i][j].top_line_ltrimmed);
+ getTokenValue(line, "toplinertrim", cell_info[i][j].top_line_rtrimmed);
getTokenValue(line, "bottomline", cell_info[i][j].bottom_line);
+ getTokenValue(line, "bottomlineltrim", cell_info[i][j].bottom_line_ltrimmed);
+ getTokenValue(line, "bottomlinertrim", cell_info[i][j].bottom_line_rtrimmed);
getTokenValue(line, "leftline", cell_info[i][j].left_line);
getTokenValue(line, "rightline", cell_info[i][j].right_line);
getTokenValue(line, "rotate", cell_info[i][j].rotate);
}
+bool Tabular::hasVarwidthColumn() const
+{
+ for (col_type c = 0; c < ncols(); ++c) {
+ if (column_info[c].varwidth)
+ return true;
+ }
+ return false;
+}
+
+
+bool Tabular::isVTypeColumn(col_type c) const
+{
+ for (row_type r = 0; r < nrows(); ++r) {
+ idx_type idx = cellIndex(r, c);
+ if (getRotateCell(idx) == 0 && useBox(idx) == BOX_VARWIDTH)
+ return true;
+ }
+ return false;
+}
+
+
Tabular::CellData const & Tabular::cellInfo(idx_type cell) const
{
return cell_info[cellRow(cell)][cellColumn(cell)];
}
-Tabular::idx_type Tabular::setMultiColumn(idx_type cell, idx_type number,
+Tabular::idx_type Tabular::setMultiColumn(Cursor & cur, idx_type cell, idx_type number,
bool const right_border)
{
idx_type const col = cellColumn(cell);
if (column_info[col].alignment != LYX_ALIGN_DECIMAL)
cs.alignment = column_info[col].alignment;
setRightLine(cell, right_border);
+ // non-fixed width multicolumns cannot have multiple paragraphs
+ if (getPWidth(cell).zero()) {
+ toggleFixedWidth(cur, cellInset(cell).get(),
+ !getPWidth(cell).zero(), isMultiColumn(cell),
+ isMultiRow(cell));
+ // cur can become invalid after paragraphs were merged
+ cur.fixIfBroken();
+ }
idx_type lastcell = cellIndex(row, col + number - 1);
for (idx_type i = 1; i < lastcell - cell + 1; ++i) {
return false;
}
-Tabular::idx_type Tabular::setMultiRow(idx_type cell, idx_type number,
+Tabular::idx_type Tabular::setMultiRow(Cursor & cur, idx_type cell, idx_type number,
bool const bottom_border,
LyXAlignment const halign)
{
else
cs.alignment = LYX_ALIGN_LEFT;
+ // Multirows cannot have multiple paragraphs
+ if (getPWidth(cell).zero()) {
+ toggleFixedWidth(cur, cellInset(cell).get(),
+ !getPWidth(cell).zero(),
+ isMultiColumn(cell), isMultiRow(cell));
+ // cur can become invalid after paragraphs were merged
+ cur.fixIfBroken();
+ }
+
// set the bottom line of the last selected cell
setBottomLine(cell, bottom_border);
bool Tabular::needRotating() const
{
- if (rotate)
+ if (rotate && !is_long_tabular)
return true;
for (row_type r = 0; r < nrows(); ++r)
for (col_type c = 0; c < ncols(); ++c)
}
-// FIXME: Remove this routine because we cannot insert \parboxes when the user
-// adds line breaks, see bug 4886.
Tabular::BoxType Tabular::getUsebox(idx_type cell) const
{
- if ((!column_info[cellColumn(cell)].p_width.zero() && !isMultiColumn(cell)) ||
- (isMultiColumn(cell) && !cellInfo(cell).p_width.zero()))
+ if (getRotateCell(cell) == 0
+ && ((!column_info[cellColumn(cell)].p_width.zero() && !isMultiColumn(cell)) ||
+ (isMultiColumn(cell) && !cellInfo(cell).p_width.zero())))
return BOX_NONE;
if (cellInfo(cell).usebox > 1)
return cellInfo(cell).usebox;
- return useParbox(cell);
+ return useBox(cell);
}
}
-Tabular::idx_type Tabular::setLTCaption(row_type row, bool what)
+Tabular::idx_type Tabular::setLTCaption(Cursor & cur, row_type row, bool what)
{
idx_type i = getFirstCellInRow(row);
if (what) {
- setMultiColumn(i, numberOfCellsInRow(row), false);
+ setMultiColumn(cur, i, numberOfCellsInRow(row), false);
setTopLine(i, false);
setBottomLine(i, false);
setLeftLine(i, false);
}
-void Tabular::TeXTopHLine(otexstream & os, row_type row, string const & lang) const
+void Tabular::TeXTopHLine(otexstream & os, row_type row, string const & lang,
+ list<col_type> columns) const
{
// we only output complete row lines and the 1st row here, the rest
// is done in Tabular::TeXBottomHLine(...)
// get for each column the topline (if any)
- vector<bool> topline;
+ map<col_type, bool> topline, topltrims, toprtrims;
col_type nset = 0;
- for (col_type c = 0; c < ncols(); ++c) {
- topline.push_back(topLine(cellIndex(row, c)));
+ bool have_trims = false;
+ for (auto const & c : columns) {
+ topline[c] = topLine(cellIndex(row, c));
+ topltrims[c] = topLineTrim(cellIndex(row, c)).first;
+ toprtrims[c] = topLineTrim(cellIndex(row, c)).second;
// If cell is part of a multirow and not the first cell of the
// multirow, no line must be drawn.
if (row != 0)
if (isMultiRow(cellIndex(row, c))
- && cell_info[row][c].multirow != CELL_BEGIN_OF_MULTIROW)
+ && cell_info[row][c].multirow != CELL_BEGIN_OF_MULTIROW) {
topline[c] = false;
- if (topline[c])
+ topltrims[c] = false;
+ toprtrims[c] = false;
+ }
+ // copy trimming to multicolumn parts
+ if (isPartOfMultiColumn(row, c)) {
+ topltrims[c] = topltrims[c-1];
+ toprtrims[c] = toprtrims[c-1];
+ }
+ if (topline.find(c) != topline.end() && topline.find(c)->second)
++nset;
+ if ((topltrims.find(c) != topltrims.end() && topltrims.find(c)->second)
+ || (toprtrims.find(c) != toprtrims.end() && toprtrims.find(c)->second))
+ have_trims = true;
}
// do nothing if empty first row, or incomplete row line after
if ((row == 0 && nset == 0) || (row > 0 && nset != ncols()))
return;
+ // Is this the actual first row (excluding longtable caption row)?
+ bool const realfirstrow = (row == 0
+ || (is_long_tabular && row == 1 && ltCaption(0)));
+
// only output complete row lines and the 1st row's clines
- if (nset == ncols()) {
+ if (nset == ncols() && !have_trims) {
if (use_booktabs) {
- os << (row == 0 ? "\\toprule " : "\\midrule ");
+ os << (realfirstrow ? "\\toprule " : "\\midrule ");
} else {
os << "\\hline ";
}
- } else if (row == 0) {
- for (col_type c = 0; c < ncols(); ++c) {
- if (topline[c]) {
+ } else if (realfirstrow || have_trims) {
+ string const cline = use_booktabs ? "\\cmidrule" : "\\cline";
+ for (auto & c : columns) {
+ if (topline.find(c)->second) {
col_type offset = 0;
for (col_type j = 0 ; j < c; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
-
- //babel makes the "-" character an active one, so we have to suppress this here
- //see http://groups.google.com/group/comp.text.tex/browse_thread/thread/af769424a4a0f289#
- if (lang == "slovak" || lang == "czech")
- os << "\\expandafter" << (use_booktabs ? "\\cmidrule" : "\\cline")
- << "\\expandafter{\\expandafter" << c + 1 + offset << "\\string-";
- else
- os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << c + 1 + offset << '-';
-
+ while (isPartOfMultiColumn(row, c))
+ ++c;
+ string trim;
+ if (topltrims.find(c) != topltrims.end()
+ && topltrims.find(c)->second)
+ trim = "l";
+ string const firstcol = convert<string>(c + 1 + offset);
col_type cstart = c;
- for ( ; c < ncols() && topline[c]; ++c) {}
+ for ( ; c < ncols() - 1 && topline.find(c)->second ; ++c) {
+ if (isMultiColumn(cellIndex(row, c))
+ && c < ncols() - 1 && isPartOfMultiColumn(row, c + 1))
+ continue;
+ if (c > cstart && topltrims.find(c) != topltrims.end()
+ && topltrims.find(c)->second) {
+ if (!isPartOfMultiColumn(row, c))
+ --c;
+ break;
+ } else if (toprtrims.find(c) != toprtrims.end()
+ && toprtrims.find(c)->second)
+ break;
+ }
for (col_type j = cstart ; j < c ; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
+ col_type const lastcol = c + 1 + offset;
+ if (toprtrims.find(c) != toprtrims.end()
+ && toprtrims.find(c)->second)
+ trim += "r";
- os << c + offset << "} ";
+ //babel makes the "-" character an active one, so we have to suppress this here
+ //see http://groups.google.com/group/comp.text.tex/browse_thread/thread/af769424a4a0f289#
+ if (lang == "slovak" || lang == "czech") {
+ os << "\\expandafter" << cline;
+ if (!trim.empty())
+ os << "(" << trim << ")";
+ os << "\\expandafter{\\expandafter" << firstcol << "\\string-";
+ } else {
+ os << cline;
+ if (!trim.empty())
+ os << "(" << trim << ")";
+ os << "{" << firstcol << '-';
+ }
+ os << lastcol << "}";
+ if (c == ncols() - 1)
+ break;
}
}
}
}
-void Tabular::TeXBottomHLine(otexstream & os, row_type row, string const & lang) const
+void Tabular::TeXBottomHLine(otexstream & os, row_type row, string const & lang,
+ list<col_type> columns) const
{
// we output bottomlines of row r and the toplines of row r+1
// if the latter do not span the whole tabular
// get the bottomlines of row r, and toplines in next row
bool lastrow = row == nrows() - 1;
- vector<bool> bottomline, topline;
+ map<col_type, bool> bottomline, topline, topltrims, toprtrims, bottomltrims, bottomrtrims;
bool nextrowset = true;
- for (col_type c = 0; c < ncols(); ++c) {
- bottomline.push_back(bottomLine(cellIndex(row, c)));
- topline.push_back(!lastrow && topLine(cellIndex(row + 1, c)));
+ for (auto const & c : columns) {
+ idx_type const idx = cellIndex(row, c);
+ bottomline[c] = bottomLine(cellIndex(row, c));
+ bottomltrims[c] = bottomLineTrim(idx).first;
+ bottomrtrims[c] = bottomLineTrim(idx).second;
+ topline[c] = !lastrow && topLine(cellIndex(row + 1, c));
+ topltrims[c] = !lastrow && topLineTrim(cellIndex(row + 1, c)).first;
+ toprtrims[c] = !lastrow && topLineTrim(cellIndex(row + 1, c)).second;
// If cell is part of a multirow and not the last cell of the
// multirow, no line must be drawn.
if (!lastrow)
&& cell_info[row + 1][c].multirow != CELL_BEGIN_OF_MULTIROW) {
bottomline[c] = false;
topline[c] = false;
- }
- nextrowset &= topline[c];
+ bottomltrims[c] = false;
+ bottomrtrims[c] = false;
+ topltrims[c] = false;
+ toprtrims[c] = false;
+ }
+ // copy trimming in multicolumn parts
+ if (isPartOfMultiColumn(row, c)) {
+ topltrims[c] = topltrims[c-1];
+ toprtrims[c] = toprtrims[c-1];
+ bottomltrims[c] = bottomltrims[c-1];
+ bottomrtrims[c] = bottomrtrims[c-1];
+ }
+
+ nextrowset &= topline.find(c) != topline.end() && topline.find(c)->second;
}
// combine this row's bottom lines and next row's toplines if necessary
col_type nset = 0;
- for (col_type c = 0; c < ncols(); ++c) {
+ bool have_trims = false;
+ for (auto const & c : columns) {
if (!nextrowset)
- bottomline[c] = bottomline[c] || topline[c];
- if (bottomline[c])
+ bottomline[c] = bottomline.find(c)->second || topline.find(c)->second;
+ bottomltrims[c] = (bottomltrims.find(c) != bottomltrims.end() && bottomltrims.find(c)->second)
+ || (topltrims.find(c) != topltrims.end() && topltrims.find(c)->second);
+ bottomrtrims[c] =(bottomrtrims.find(c) != bottomrtrims.end() && bottomrtrims.find(c)->second)
+ || (toprtrims.find(c) != toprtrims.end() && toprtrims.find(c)->second);
+ if (bottomline.find(c)->second)
++nset;
+ if ((bottomltrims.find(c) != bottomltrims.end() && bottomltrims.find(c)->second)
+ || (bottomrtrims.find(c) != bottomrtrims.end() && bottomrtrims.find(c)->second))
+ have_trims = true;
}
// do nothing if empty, OR incomplete row line with a topline in next row
if (nset == 0 || (nextrowset && nset != ncols()))
return;
- if (nset == ncols()) {
+ if (nset == ncols() && !have_trims) {
if (use_booktabs)
os << (lastrow ? "\\bottomrule" : "\\midrule");
else
os << "\\hline ";
} else {
- for (col_type c = 0; c < ncols(); ++c) {
- if (bottomline[c]) {
+ string const cline = use_booktabs ? "\\cmidrule" : "\\cline";
+ for (auto & c : columns) {
+ if (bottomline.find(c)->second) {
col_type offset = 0;
for (col_type j = 0 ; j < c; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
-
- //babel makes the "-" character an active one, so we have to suppress this here
- //see http://groups.google.com/group/comp.text.tex/browse_thread/thread/af769424a4a0f289#
- if (lang == "slovak" || lang == "czech")
- os << "\\expandafter" << (use_booktabs ? "\\cmidrule" : "\\cline")
- << "\\expandafter{\\expandafter" << c + 1 + offset << "\\string-";
- else
- os << (use_booktabs ? "\\cmidrule{" : "\\cline{") << c + 1 + offset << '-';
-
+ while (isPartOfMultiColumn(row, c))
+ ++c;
+ string trim;
+ if (bottomltrims.find(c) != bottomltrims.end()
+ && bottomltrims.find(c)->second)
+ trim = "l";
+ string const firstcol = convert<string>(c + 1 + offset);
col_type cstart = c;
- for ( ; c < ncols() && bottomline[c]; ++c) {}
+ for ( ; c < ncols() - 1 && bottomline.find(c)->second ; ++c) {
+ if (isMultiColumn(cellIndex(row, c))
+ && c < ncols() - 1
+ && isPartOfMultiColumn(row, c + 1))
+ continue;
+ if (c > cstart && bottomltrims.find(c) != bottomltrims.end()
+ && bottomltrims.find(c)->second) {
+ if (!isPartOfMultiColumn(row, c))
+ --c;
+ break;
+ } else if (bottomrtrims.find(c) != bottomrtrims.end()
+ && bottomrtrims.find(c)->second)
+ break;
+ }
for (col_type j = cstart ; j < c ; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
+ col_type const lastcol = c + 1 + offset;
+ if (bottomrtrims.find(c) != bottomrtrims.end()
+ && bottomrtrims.find(c)->second)
+ trim += "r";
- os << c + offset << "} ";
+ //babel makes the "-" character an active one, so we have to suppress this here
+ //see http://groups.google.com/group/comp.text.tex/browse_thread/thread/af769424a4a0f289#
+ if (lang == "slovak" || lang == "czech") {
+ os << "\\expandafter" << cline;
+ if (!trim.empty())
+ os << "(" << trim << ")";
+ os << "\\expandafter{\\expandafter" << firstcol << "\\string-";
+ } else {
+ os << cline;
+ if (!trim.empty())
+ os << "(" << trim << ")";
+ os << "{" << firstcol << '-';
+ }
+ os << lastcol << "}";
+ if (c == ncols() - 1)
+ break;
}
}
}
void Tabular::TeXCellPreamble(otexstream & os, idx_type cell,
- bool & ismulticol, bool & ismultirow) const
+ bool & ismulticol, bool & ismultirow,
+ bool const bidi) const
{
row_type const r = cellRow(cell);
if (is_long_tabular && row_info[r].caption)
LyXAlignment align = getAlignment(cell, !isMultiColumn(cell));
// figure out how to set the lines
// we always set double lines to the right of the cell
+ // or left in bidi RTL, respectively.
col_type const c = cellColumn(cell);
col_type const nextcol = c + columnSpan(cell);
+ bool const decimal = column_info[c].alignment == LYX_ALIGN_DECIMAL;
bool colright = columnRightLine(c);
bool colleft = columnLeftLine(c);
bool nextcolleft = nextcol < ncols() && columnLeftLine(nextcol);
bool coldouble = colright && nextcolleft;
bool celldouble = rightLine(cell) && nextcellleft;
- ismulticol = isMultiColumn(cell)
- || (c == 0 && colleft != leftLine(cell))
- || ((colright || nextcolleft) && !rightLine(cell) && !nextcellleft)
- || (!colright && !nextcolleft && (rightLine(cell) || nextcellleft))
- || (coldouble != celldouble);
+ ismulticol = (isMultiColumn(cell)
+ || (c == 0 && colleft != leftLine(cell))
+ || ((colright || nextcolleft) && !rightLine(cell) && !nextcellleft)
+ || (!colright && !nextcolleft && (rightLine(cell) || nextcellleft))
+ || (coldouble != celldouble))
+ && !decimal;
// we center in multicol when no decimal point
- if (column_info[c].alignment == LYX_ALIGN_DECIMAL) {
+ if (decimal) {
docstring const align_d = column_info[c].decimal_point;
DocIterator const dit = separatorPos(cellInset(cell), align_d);
- ismulticol |= !dit;
+ bool const nosep = !dit;
+ ismulticol |= nosep;
+ celldouble &= nosep;
}
// up counter by 1 for each decimally aligned col since they use 2 latex cols
int latexcolspan = columnSpan(cell);
- for(col_type col = c; col < c + columnSpan(cell); ++col)
+ for (col_type col = c; col < c + columnSpan(cell); ++col)
if (column_info[col].alignment == LYX_ALIGN_DECIMAL)
++latexcolspan;
if (ismulticol) {
os << "\\multicolumn{" << latexcolspan << "}{";
- if (c ==0 && leftLine(cell))
+ if (((bidi && c == getLastCellInRow(cellRow(0)) && rightLine(cell))
+ || (!bidi && c == 0 && leftLine(cell))))
+ os << '|';
+ if (bidi && celldouble)
+ // add extra vertical line if we want a double one
os << '|';
if (!cellInfo(cell).align_special.empty()) {
os << cellInfo(cell).align_special;
}
} // end if else !getPWidth
} // end if else !cellinfo_of_cell
- if (rightLine(cell) || nextcellleft)
+ if ((bidi && leftLine(cell)) || (!bidi && rightLine(cell)) || nextcellleft)
os << '|';
- if (celldouble)
+ if (!bidi && celldouble)
// add extra vertical line if we want a double one
os << '|';
os << "}{";
}
os << "]{" << from_ascii(getPWidth(cell).asLatexString())
<< "}\n";
+ } else if (getRotateCell(cell) != 0 && getUsebox(cell) == BOX_VARWIDTH) {
+ os << "\\begin{varwidth}[";
+ switch (valign) {
+ case LYX_VALIGN_TOP:
+ os << 't';
+ break;
+ case LYX_VALIGN_MIDDLE:
+ os << 'm';
+ break;
+ case LYX_VALIGN_BOTTOM:
+ os << 'b';
+ 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}";
if (getRotateCell(cell) != 0)
os << breakln << "\\end{turn}";
if (ismultirow)
void Tabular::TeXLongtableHeaderFooter(otexstream & os,
- OutputParams const & runparams) const
+ OutputParams const & runparams,
+ list<col_type> columns) const
{
if (!is_long_tabular)
return;
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);
+ TeXRow(os, r, runparams, columns);
}
}
// output first header info
os << "\\hline\n";
for (row_type r = 0; r < nrows(); ++r) {
if (row_info[r].endfirsthead)
- TeXRow(os, r, runparams);
+ TeXRow(os, r, runparams, columns);
}
if (endfirsthead.bottomDL)
os << "\\hline\n";
os << "\\hline\n";
for (row_type r = 0; r < nrows(); ++r) {
if (row_info[r].endhead)
- TeXRow(os, r, runparams);
+ TeXRow(os, r, runparams, columns);
}
if (endhead.bottomDL)
os << "\\hline\n";
os << "\\hline\n";
for (row_type r = 0; r < nrows(); ++r) {
if (row_info[r].endfoot)
- TeXRow(os, r, runparams);
+ TeXRow(os, r, runparams, columns);
}
if (endfoot.bottomDL)
os << "\\hline\n";
os << "\\hline\n";
for (row_type r = 0; r < nrows(); ++r) {
if (row_info[r].endlastfoot)
- TeXRow(os, r, runparams);
+ TeXRow(os, r, runparams, columns);
}
if (endlastfoot.bottomDL)
os << "\\hline\n";
void Tabular::TeXRow(otexstream & os, row_type row,
- OutputParams const & runparams) const
+ OutputParams const & runparams,
+ list<col_type> columns) const
{
idx_type cell = cellIndex(row, 0);
- InsetTableCell const * inset = cellInset(cell);
- Paragraph const & par = inset->paragraphs().front();
- string const lang = par.getParLanguage(buffer().params())->lang();
+ InsetTableCell const * cinset = cellInset(cell);
+ Paragraph const & cpar = cinset->paragraphs().front();
+ string const clang = cpar.getParLanguage(buffer().params())->lang();
//output the top line
- TeXTopHLine(os, row, lang);
+ TeXTopHLine(os, row, clang, columns);
if (row_info[row].top_space_default) {
if (use_booktabs)
}
bool ismulticol = false;
bool ismultirow = false;
- for (col_type c = 0; c < ncols(); ++c) {
+
+ // The bidi package (loaded by polyglossia) reverses RTL table columns
+ bool const bidi_rtl =
+ runparams.local_font->isRightToLeft()
+ && runparams.use_polyglossia;
+ idx_type lastcell =
+ bidi_rtl ? getFirstCellInRow(row) : getLastCellInRow(row);
+
+ for (auto const & c : columns) {
if (isPartOfMultiColumn(row, c))
continue;
if (isPartOfMultiRow(row, c)
&& column_info[c].alignment != LYX_ALIGN_DECIMAL) {
- if (cell != getLastCellInRow(row))
+ if (cell != lastcell)
os << " & ";
continue;
}
- TeXCellPreamble(os, cell, ismulticol, ismultirow);
+ TeXCellPreamble(os, cell, ismulticol, ismultirow, bidi_rtl);
InsetTableCell const * inset = cellInset(cell);
Paragraph const & par = inset->paragraphs().front();
head.setMacrocontextPositionRecursive(dit);
bool hassep = false;
InsetTableCell tail = splitCell(head, column_info[c].decimal_point, hassep);
- head.latex(os, newrp);
if (hassep) {
- os << '&';
tail.setBuffer(head.buffer());
dit.pop_back();
dit.push_back(CursorSlice(tail));
tail.setMacrocontextPositionRecursive(dit);
- tail.latex(os, newrp);
+ }
+ if (bidi_rtl) {
+ if (hassep) {
+ tail.latex(os, newrp);
+ os << '&';
+ }
+ head.latex(os, newrp);
+ } else {
+ head.latex(os, newrp);
+ if (hassep) {
+ os << '&';
+ tail.latex(os, newrp);
+ }
+ }
+ } 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)
+ continue;
+ it->latex(os, runparams);
+ break;
}
} else if (!isPartOfMultiRow(row, c)) {
if (!runparams.nice)
os << '}';
TeXCellPostamble(os, cell, ismulticol, ismultirow);
- if (cell != getLastCellInRow(row)) { // not last cell in row
+ if (cell != lastcell) { // not last cell in row
if (runparams.nice)
os << " & ";
else
os << '\n';
//output the bottom line
- TeXBottomHLine(os, row, lang);
+ TeXBottomHLine(os, row, clang, columns);
if (row_info[row].interline_space_default) {
if (use_booktabs)
void Tabular::latex(otexstream & os, OutputParams const & runparams) const
{
- bool const is_tabular_star = !tabular_width.zero();
+ bool const is_tabular_star = !is_long_tabular && !tabular_width.zero()
+ && !hasVarwidthColumn();
+ bool const is_xltabular = is_long_tabular
+ && (hasVarwidthColumn() || !tabular_width.zero());
TexRow::RowEntry pos = TexRow::textEntry(runparams.lastid, runparams.lastpos);
//+---------------------------------------------------------------------
if (!TexRow::isNone(pos))
os.texrow().start(pos);
- if (rotate != 0)
- os << "\\begin{turn}{" << convert<string>(rotate) << "}\n";
+ if (rotate != 0) {
+ if (is_long_tabular)
+ os << "\\begin{landscape}\n";
+ else
+ os << "\\begin{turn}{" << convert<string>(rotate) << "}\n";
+ }
if (is_long_tabular) {
- os << "\\begin{longtable}";
+ if (is_xltabular)
+ os << "\\begin{xltabular}";
+ else
+ os << "\\begin{longtable}";
switch (longtabular_alignment) {
case LYX_LONGTABULAR_ALIGN_LEFT:
os << "[l]";
break;
case LYX_LONGTABULAR_ALIGN_CENTER:
+ os << "[c]";
break;
case LYX_LONGTABULAR_ALIGN_RIGHT:
os << "[r]";
break;
}
+ if (is_xltabular) {
+ if (tabular_width.zero())
+ os << "{" << from_ascii("\\columnwidth") << "}";
+ else
+ os << "{" << from_ascii(tabular_width.asLatexString()) << "}";
+ }
} else {
if (is_tabular_star)
os << "\\begin{tabular*}{" << from_ascii(tabular_width.asLatexString()) << "}";
- else
+ else if (hasVarwidthColumn()) {
+ os << "\\begin{tabularx}{";
+ if (tabular_width.zero())
+ os << from_ascii("\\columnwidth") << "}";
+ else
+ os << from_ascii(tabular_width.asLatexString()) << "}";
+ } else
os << "\\begin{tabular}";
switch (tabular_valignment) {
case LYX_VALIGN_TOP:
if (is_tabular_star)
os << "@{\\extracolsep{\\fill}}";
- for (col_type c = 0; c < ncols(); ++c) {
- if (columnLeftLine(c))
+ // The bidi package (loaded by polyglossia) swaps the column
+ // order for RTL (#9686). Thus we use this list.
+ bool const bidi_rtl =
+ runparams.local_font->isRightToLeft()
+ && runparams.use_polyglossia;
+ list<col_type> columns;
+ for (col_type cl = 0; cl < ncols(); ++cl) {
+ if (bidi_rtl)
+ columns.push_front(cl);
+ else
+ columns.push_back(cl);
+ }
+
+ for (auto const & c : columns) {
+ if ((bidi_rtl && columnRightLine(c)) || (!bidi_rtl && columnLeftLine(c)))
os << '|';
if (!column_info[c].align_special.empty()) {
os << column_info[c].align_special;
case LYX_ALIGN_LAYOUT:
case LYX_ALIGN_SPECIAL:
break;
- case LYX_ALIGN_DECIMAL:
- os << ">{\\raggedleft}";
+ case LYX_ALIGN_DECIMAL: {
+ if (bidi_rtl)
+ os << ">{\\raggedright}";
+ else
+ os << ">{\\raggedleft}";
decimal = true;
break;
}
+ }
char valign = 'p';
switch (column_info[c].valignment) {
os << '{'
<< from_ascii(column_info[c].p_width.asLatexString())
<< '}';
+ } else if (column_info[c].varwidth) {
+ switch (column_info[c].alignment) {
+ case LYX_ALIGN_LEFT:
+ os << ">{\\raggedright\\arraybackslash}";
+ break;
+ case LYX_ALIGN_RIGHT:
+ os << ">{\\raggedleft\\arraybackslash}";
+ break;
+ case LYX_ALIGN_CENTER:
+ os << ">{\\centering\\arraybackslash}";
+ break;
+ case LYX_ALIGN_NONE:
+ case LYX_ALIGN_BLOCK:
+ case LYX_ALIGN_LAYOUT:
+ case LYX_ALIGN_SPECIAL:
+ case LYX_ALIGN_DECIMAL:
+ 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;
+ }
+ os << "V{\\linewidth}";
} else {
switch (column_info[c].alignment) {
case LYX_ALIGN_LEFT:
}
} // end if else !column_info[i].p_width
} // end if else !column_info[i].align_special
- if (columnRightLine(c))
+ if ((bidi_rtl && columnLeftLine(c)) || (!bidi_rtl && columnRightLine(c)))
os << '|';
}
os << "}\n";
- TeXLongtableHeaderFooter(os, runparams);
+ TeXLongtableHeaderFooter(os, runparams, columns);
//+---------------------------------------------------------------------
//+ the single row and columns (cells) +
for (row_type r = 0; r < nrows(); ++r) {
if (isValidRow(r)) {
- TeXRow(os, r, runparams);
+ TeXRow(os, r, runparams, columns);
if (is_long_tabular && row_info[r].newpage)
os << "\\newpage\n";
}
//+ the closing of the tabular +
//+---------------------------------------------------------------------
- if (is_long_tabular)
- os << "\\end{longtable}";
- else {
+ if (is_long_tabular) {
+ if (is_xltabular)
+ os << "\\end{xltabular}";
+ else
+ os << "\\end{longtable}";
+ } else {
if (is_tabular_star)
os << "\\end{tabular*}";
+ else if (hasVarwidthColumn())
+ os << "\\end{tabularx}";
else
os << "\\end{tabular}";
}
- if (rotate != 0)
- os << breakln << "\\end{turn}";
+ if (rotate != 0) {
+ if (is_long_tabular)
+ os << breakln << "\\end{landscape}";
+ else
+ os << breakln << "\\end{turn}";
+ }
if (!TexRow::isNone(pos))
os.texrow().start(pos);
continue;
stringstream attr;
-
+
Length const cwidth = column_info[c].p_width;
if (!cwidth.zero()) {
string const hwidth = cwidth.asHTMLString();
attr << "style =\"width: " << hwidth << ";\" ";
}
-
+
attr << "align='";
switch (getAlignment(cell)) {
case LYX_ALIGN_LEFT:
features.require("NeedTabularnewline");
if (use_booktabs)
features.require("booktabs");
- if (is_long_tabular)
- features.require("longtable");
+ if (is_long_tabular && !hasVarwidthColumn()) {
+ if (tabular_width.zero())
+ features.require("longtable");
+ else
+ features.require("xltabular");
+ }
+ if (rotate && is_long_tabular)
+ features.require("lscape");
if (needRotating())
features.require("rotating");
+ if (hasVarwidthColumn()) {
+ if (is_long_tabular)
+ features.require("xltabular");
+ else
+ features.require("tabularx");
+ }
for (idx_type cell = 0; cell < numberofcells; ++cell) {
if (isMultiRow(cell))
features.require("multirow");
+ if (getUsebox(cell) == BOX_VARWIDTH)
+ features.require("varwidth");
if (getVAlignment(cell) != LYX_VALIGN_TOP
- || !getPWidth(cell).zero())
+ || !getPWidth(cell).zero()
+ || isVTypeColumn(cellColumn(cell)))
features.require("array");
+ // Tell footnote that we need a savenote
+ // environment in non-long tables or
+ // longtable headers/footers
+ else if (!is_long_tabular && !features.inFloat())
+ features.saveNoteEnv("tabular");
+ else if (!isValidRow(cellRow(cell)))
+ features.saveNoteEnv("longtable");
+
cellInset(cell)->validate(features);
+ features.saveNoteEnv(string());
}
}
-Tabular::BoxType Tabular::useParbox(idx_type cell) const
+Tabular::BoxType Tabular::useBox(idx_type cell) const
{
ParagraphList const & parlist = cellInset(cell)->paragraphs();
+ if (parlist.size() > 1)
+ return BOX_VARWIDTH;
+
ParagraphList::const_iterator cit = parlist.begin();
ParagraphList::const_iterator end = parlist.end();
for (; cit != end; ++cit)
for (int i = 0; i < cit->size(); ++i)
- if (cit->isNewline(i))
- return BOX_PARBOX;
+ if (cit->isNewline(i) || cit->layout().isEnvironment())
+ return BOX_VARWIDTH;
return BOX_NONE;
}
InsetTableCell::InsetTableCell(Buffer * buf)
: InsetText(buf, InsetText::PlainLayout), isFixedWidth(false),
- contentAlign(LYX_ALIGN_CENTER)
+ isMultiColumn(false), isMultiRow(false), contentAlign(LYX_ALIGN_CENTER)
{}
bool InsetTableCell::forcePlainLayout(idx_type) const
{
- return !isFixedWidth;
+ return isMultiRow || (isMultiColumn && !isFixedWidth);
}
}
+void InsetTableCell::metrics(MetricsInfo & mi, Dimension & dim) const
+{
+ TextMetrics & tm = mi.base.bv->textMetrics(&text());
+
+ // Hand font through to contained lyxtext:
+ tm.font_.fontInfo() = mi.base.font;
+ mi.base.textwidth -= 2 * TEXT_TO_INSET_OFFSET;
+
+ // This can happen when a layout has a left and right margin,
+ // and the view is made very narrow. We can't do better than
+ // to draw it partly out of view (bug 5890).
+ if (mi.base.textwidth < 1)
+ mi.base.textwidth = 1;
+
+ // We tell metrics here not to expand on multiple pars
+ // This is the difference to InsetText::Metrics
+ if (hasFixedWidth())
+ tm.metrics(mi, dim, mi.base.textwidth, false);
+ else
+ tm.metrics(mi, dim, 0, false);
+ mi.base.textwidth += 2 * TEXT_TO_INSET_OFFSET;
+ dim.asc += TEXT_TO_INSET_OFFSET;
+ dim.des += TEXT_TO_INSET_OFFSET;
+ dim.wid += 2 * TEXT_TO_INSET_OFFSET;
+}
+
+
/////////////////////////////////////////////////////////////////////
//
// multicolumn or multirow cell, but not first one
continue;
idx_type const cell = tabular.cellIndex(r, c);
- Dimension dim;
+ Dimension dim0;
MetricsInfo m = mi;
Length const p_width = tabular.getPWidth(cell);
if (!p_width.zero())
- m.base.textwidth = p_width.inPixels(mi.base);
- tabular.cellInset(cell)->metrics(m, dim);
- if (!p_width.zero())
- dim.wid = m.base.textwidth;
- tabular.cellInfo(cell).width = dim.wid + 2 * WIDTH_OF_LINE
+ m.base.textwidth = mi.base.inPixels(p_width);
+ else if (tabular.column_info[c].varwidth)
+ m.base.textwidth = tabular.column_info[c].width;
+ tabular.cellInset(cell)->metrics(m, dim0);
+ if (!p_width.zero() || tabular.column_info[c].varwidth)
+ dim0.wid = m.base.textwidth;
+ tabular.cellInfo(cell).width = dim0.wid + 2 * WIDTH_OF_LINE
+ tabular.interColumnSpace(cell);
// FIXME(?): do we need a second metrics call?
case Tabular::LYX_VALIGN_TOP:
break;
case Tabular::LYX_VALIGN_MIDDLE:
- offset = -(dim.des - lastpardes)/2;
+ offset = -(dim0.des - lastpardes)/2;
break;
case Tabular::LYX_VALIGN_BOTTOM:
- offset = -(dim.des - lastpardes);
+ offset = -(dim0.des - lastpardes);
break;
}
tabular.cell_info[r][c].voffset = offset;
- maxasc = max(maxasc, dim.asc - offset);
- maxdes = max(maxdes, dim.des + offset);
+ maxasc = max(maxasc, dim0.asc - offset);
+ maxdes = max(maxdes, dim0.des + offset);
}
int const top_space = tabular.row_info[r].top_space_default ?
- default_line_space :
- tabular.row_info[r].top_space.inPixels(mi.base);
+ default_line_space :
+ mi.base.inPixels(tabular.row_info[r].top_space);
tabular.setRowAscent(r, maxasc + ADD_TO_HEIGHT + top_space);
int const bottom_space = tabular.row_info[r].bottom_space_default ?
- default_line_space :
- tabular.row_info[r].bottom_space.inPixels(mi.base);
+ default_line_space :
+ mi.base.inPixels(tabular.row_info[r].bottom_space);
tabular.setRowDescent(r, maxdes + ADD_TO_HEIGHT + bottom_space);
}
- tabular.updateColumnWidths();
+ // We need to recalculate the metrics after column width calculation
+ // with xtabular (possibly multiple times, so the call is recursive).
+ if (tabular.updateColumnWidths(mi) && tabular.hasVarwidthColumn())
+ metrics(mi, dim);
dim.asc = tabular.rowAscent(0) - tabular.offsetVAlignment();
dim.des = tabular.height() - dim.asc;
dim.wid = tabular.width() + 2 * ADD_TO_TABULAR_WIDTH;
}
-bool InsetTabular::isCellSelected(Cursor & cur, row_type row, col_type col)
- const
+bool InsetTabular::isCellSelected(Cursor & cur, row_type row, col_type col) const
{
if (&cur.inset() == this && cur.selection()) {
if (cur.selIsMultiCell()) {
}
+namespace {
+
+void tabline(PainterInfo const & pi, int x1, int y1, int x2, int y2, int lt, int rt,
+ bool drawline, bool heavy = false)
+{
+ ColorCode const col = drawline ? Color_tabularline : Color_tabularonoffline;
+ if (drawline && lt > 0)
+ pi.pain.line(x1, y1, x1 + lt, y2, pi.textColor(Color_tabularonoffline),
+ Painter::line_onoffdash,
+ Painter::thin_line);
+ pi.pain.line(x1 + lt, y1, x2 - rt, y2, pi.textColor(col),
+ drawline ? Painter::line_solid : Painter::line_onoffdash,
+ (heavy ? 2 : 1) * Painter::thin_line);
+ if (drawline && rt > 0)
+ pi.pain.line(x2 - rt, y1, x2, y2, pi.textColor(Color_tabularonoffline),
+ Painter::line_onoffdash,
+ Painter::thin_line);
+}
+
+}
+
+
void InsetTabular::drawCellLines(PainterInfo & pi, int x, int y,
row_type row, idx_type cell) const
{
y -= tabular.rowAscent(row);
int const w = tabular.cellWidth(cell);
int const h = tabular.cellHeight(cell);
- Color const linecolor = pi.textColor(Color_tabularline);
- Color const gridcolor = pi.textColor(Color_tabularonoffline);
+ int lt = 0;
+ int rt = 0;
+
+ col_type const col = tabular.cellColumn(cell);
// Top
bool drawline = tabular.topLine(cell)
|| (row > 0 && tabular.bottomLine(tabular.cellAbove(cell)));
- pi.pain.line(x, y, x + w, y,
- drawline ? linecolor : gridcolor,
- drawline ? Painter::line_solid : Painter::line_onoffdash);
+ bool heavy = tabular.use_booktabs
+ && (row == 0 || (tabular.is_long_tabular && row == 1 && tabular.ltCaption(0)))
+ && tabular.rowTopLine(row);
+ if (tabular.topLineTrim(cell).first
+ || (row > 0 && tabular.bottomLineTrim(tabular.cellIndex(row - 1, col)).first))
+ lt = 10;
+ if (tabular.topLineTrim(cell).second
+ || (row > 0 && tabular.bottomLineTrim(tabular.cellIndex(row - 1, col)).second))
+ rt = 10;
+ tabline(pi, x, y, x + w, y, lt, rt, drawline, heavy);
// Bottom
+ lt = rt = 0;
drawline = tabular.bottomLine(cell);
- pi.pain.line(x, y + h, x + w, y + h,
- drawline ? linecolor : gridcolor,
- drawline ? Painter::line_solid : Painter::line_onoffdash);
+ row_type const lastrow = tabular.nrows() - 1;
+ // Consider multi-rows
+ row_type r = row;
+ while (r < lastrow && tabular.isMultiRow(tabular.cellIndex(r, col))
+ && tabular.isPartOfMultiRow(r + 1, col))
+ r++;
+ heavy = tabular.use_booktabs
+ && ((row == lastrow && tabular.rowBottomLine(row))
+ || (r == lastrow && tabular.rowBottomLine(r)));
+ if (tabular.bottomLineTrim(cell).first)
+ lt = 10;
+ if (tabular.bottomLineTrim(cell).second)
+ rt = 10;
+ tabline(pi, x, y + h, x + w, y + h, lt, rt, drawline, heavy);
// Left
- col_type const col = tabular.cellColumn(cell);
drawline = tabular.leftLine(cell)
|| (col > 0 && tabular.rightLine(tabular.cellIndex(row, col - 1)));
- pi.pain.line(x, y, x, y + h,
- drawline ? linecolor : gridcolor,
- drawline ? Painter::line_solid : Painter::line_onoffdash);
+ tabline(pi, x, y, x, y + h, 0, 0, drawline);
// Right
x -= tabular.interColumnSpace(cell);
drawline = tabular.rightLine(cell)
|| (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);
+ tabline(pi, x + w, y, x + w, y + h, 0, 0, drawline);
}
case LFUN_PASTE:
if (!tabularStackDirty()) {
+ // Check if we have plain text or HTML with rows/columns.
+ // and if so, pass over to LFUN_CLIPBOARD_PASTE
+ if (theClipboard().hasTextContents(Clipboard::AnyTextType)
+ && !theClipboard().hasTextContents(Clipboard::LyXTextType)) {
+ docstring const clip =
+ theClipboard().getAsText(Clipboard::AnyTextType);
+ if (clip.find_first_of(from_ascii("\t\n")) != docstring::npos) {
+ FuncRequest ncmd = FuncRequest(LFUN_CLIPBOARD_PASTE, cmd.argument());
+ doDispatch(cur, ncmd);
+ break;
+ }
+ }
if (!cur.selIsMultiCell())
cell(cur.idx())->dispatch(cur, cmd);
break;
switch (action) {
case Tabular::SET_PWIDTH:
case Tabular::SET_MPWIDTH:
+ case Tabular::TOGGLE_VARWIDTH_COLUMN:
case Tabular::SET_SPECIAL_COLUMN:
case Tabular::SET_SPECIAL_MULTICOLUMN:
case Tabular::APPEND_ROW:
return true;
case Tabular::SET_TABULAR_WIDTH:
- status.setEnabled(!tabular.rotate && !tabular.is_long_tabular
+ status.setEnabled(!tabular.rotate
&& tabular.tabular_valignment == Tabular::LYX_VALIGN_MIDDLE);
break;
case Tabular::SET_ALL_LINES:
case Tabular::UNSET_ALL_LINES:
+ case Tabular::SET_INNER_LINES:
case Tabular::SET_BORDER_LINES:
status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
break;
+ case Tabular::RESET_FORMAL_DEFAULT:
+ status.setEnabled(tabular.use_booktabs);
+ break;
+
case Tabular::SET_LINE_TOP:
case Tabular::SET_LINE_BOTTOM:
status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
&& !tabular.ltCaption(tabular.cellRow(cur.idx())));
break;
+ case Tabular::SET_LTRIM_TOP:
+ case Tabular::SET_RTRIM_TOP:
+ status.setEnabled(tabular.use_booktabs
+ && tabular.cellRow(cur.idx()) != 0
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
+ break;
+
+ case Tabular::SET_LTRIM_BOTTOM:
+ case Tabular::SET_RTRIM_BOTTOM:
+ status.setEnabled(tabular.use_booktabs
+ && tabular.cellRow(cur.idx()) != tabular.nrows() - 1
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
+ break;
+
case Tabular::TOGGLE_LINE_TOP:
status.setEnabled(!tabular.ltCaption(tabular.cellRow(cur.idx())));
status.setOnOff(tabular.topLine(cur.idx()));
status.setOnOff(tabular.rightLine(cur.idx()));
break;
+ case Tabular::TOGGLE_LTRIM_TOP:
+ status.setEnabled(tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setOnOff(tabular.topLineTrim(cur.idx()).first);
+ break;
+
+ case Tabular::TOGGLE_RTRIM_TOP:
+ status.setEnabled(tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setOnOff(tabular.topLineTrim(cur.idx()).second);
+ break;
+
+ case Tabular::TOGGLE_LTRIM_BOTTOM:
+ status.setEnabled(tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setOnOff(tabular.bottomLineTrim(cur.idx()).first);
+ break;
+
+ case Tabular::TOGGLE_RTRIM_BOTTOM:
+ status.setEnabled(tabular.use_booktabs
+ && !tabular.ltCaption(tabular.cellRow(cur.idx())));
+ status.setOnOff(tabular.bottomLineTrim(cur.idx()).second);
+ break;
+
// multirow cells only inherit the alignment of the column if the column has
// no width, otherwise they are left-aligned
// therefore allow always left but right and center only if there is no width
case Tabular::M_ALIGN_LEFT:
flag = false;
+ // fall through
case Tabular::ALIGN_LEFT:
status.setOnOff(tabular.getAlignment(cur.idx(), flag) == LYX_ALIGN_LEFT);
break;
case Tabular::M_ALIGN_RIGHT:
flag = false;
+ // fall through
case Tabular::ALIGN_RIGHT:
status.setEnabled(!(tabular.isMultiRow(cur.idx())
&& !tabular.getPWidth(cur.idx()).zero()));
case Tabular::M_ALIGN_CENTER:
flag = false;
+ // fall through
case Tabular::ALIGN_CENTER:
status.setEnabled(!(tabular.isMultiRow(cur.idx())
&& !tabular.getPWidth(cur.idx()).zero()));
case Tabular::M_VALIGN_TOP:
flag = false;
+ // fall through
case Tabular::VALIGN_TOP:
status.setEnabled(!tabular.getPWidth(cur.idx()).zero()
&& !tabular.isMultiRow(cur.idx()));
case Tabular::M_VALIGN_BOTTOM:
flag = false;
+ // fall through
case Tabular::VALIGN_BOTTOM:
status.setEnabled(!tabular.getPWidth(cur.idx()).zero()
&& !tabular.isMultiRow(cur.idx()));
case Tabular::M_VALIGN_MIDDLE:
flag = false;
+ // fall through
case Tabular::VALIGN_MIDDLE:
status.setEnabled(!tabular.getPWidth(cur.idx()).zero()
&& !tabular.isMultiRow(cur.idx()));
if (&cur.inset() != this)
break;
string action = cmd.getArg(0);
- string arg = cmd.getLongArg(1);
+ string arg = cmd.getLongArg(1);
return getFeatureStatus(cur, action, arg, status);
}
// disable these with multiple cells selected
case LFUN_INSET_INSERT:
case LFUN_TABULAR_INSERT:
+ case LFUN_TABULAR_STYLE_INSERT:
case LFUN_FLEX_INSERT:
case LFUN_FLOAT_INSERT:
case LFUN_FLOAT_WIDE_INSERT:
status.setEnabled(false);
return true;
}
- // Fall back
- case LFUN_NEWLINE_INSERT: {
- if (tabular.getPWidth(cur.idx()).zero()) {
+ // 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;
- } else
- return cell(cur.idx())->getStatus(cur, cmd, status);
- }
+ }
+ return cell(cur.idx())->getStatus(cur, cmd, status);
case LFUN_NEWPAGE_INSERT:
status.setEnabled(false);
row_type sel_row_start;
row_type sel_row_end;
bool setLines = false;
+ bool setLinesInnerOnly = false;
LyXAlignment setAlign = LYX_ALIGN_LEFT;
Tabular::VAlignment setVAlign = Tabular::LYX_VALIGN_TOP;
case Tabular::SET_PWIDTH: {
Length const len(value);
- tabular.setColumnPWidth(cur, cur.idx(), len);
- if (len.zero()
- && tabular.getAlignment(cur.idx(), true) == LYX_ALIGN_BLOCK)
- tabularFeatures(cur, Tabular::ALIGN_CENTER, string());
+ for (col_type c = sel_col_start; c <= sel_col_end; ++c) {
+ tabular.setColumnPWidth(cur, tabular.cellIndex(row, c), len);
+ if (len.zero()
+ && tabular.getAlignment(tabular.cellIndex(row, c), true) == LYX_ALIGN_BLOCK)
+ tabularFeatures(cur, Tabular::ALIGN_CENTER, string());
+ }
break;
}
tabular.setMColumnPWidth(cur, cur.idx(), Length(value));
break;
+ case Tabular::TOGGLE_VARWIDTH_COLUMN: {
+ bool const varwidth = value == "on";
+ for (col_type c = sel_col_start; c <= sel_col_end; ++c)
+ tabular.toggleVarwidth(tabular.cellIndex(row, c), varwidth);
+ break;
+ }
+
case Tabular::SET_MROFFSET:
tabular.setMROffset(cur, cur.idx(), Length(value));
break;
case Tabular::DELETE_ROW:
if (sel_row_end == tabular.nrows() - 1 && sel_row_start != 0) {
- for (col_type c = 0; c < tabular.ncols(); c++)
+ for (col_type c = 0; c < tabular.ncols(); c++) {
tabular.setBottomLine(tabular.cellIndex(sel_row_start - 1, c),
tabular.bottomLine(tabular.cellIndex(sel_row_end, c)));
+ tabular.setBottomLineTrim(tabular.cellIndex(sel_row_start - 1, c),
+ tabular.bottomLineTrim(tabular.cellIndex(sel_row_end, c)));
+ }
}
for (row_type r = sel_row_start; r <= sel_row_end; ++r)
break;
}
+ case Tabular::SET_LTRIM_TOP:
+ case Tabular::TOGGLE_LTRIM_TOP: {
+ bool l = (feature == Tabular::SET_LTRIM_TOP)
+ ? (value == "true") : !tabular.topLineTrim(cur.idx()).first;
+ for (row_type r = sel_row_start; r <= sel_row_end; ++r)
+ for (col_type c = sel_col_start; c <= sel_col_end; ++c)
+ tabular.setTopLineLTrim(tabular.cellIndex(r, c), l);
+ break;
+ }
+
+ case Tabular::SET_RTRIM_TOP:
+ case Tabular::TOGGLE_RTRIM_TOP: {
+ bool l = (feature == Tabular::SET_RTRIM_TOP)
+ ? (value == "true") : !tabular.topLineTrim(cur.idx()).second;
+ for (row_type r = sel_row_start; r <= sel_row_end; ++r)
+ for (col_type c = sel_col_start; c <= sel_col_end; ++c)
+ tabular.setTopLineRTrim(tabular.cellIndex(r, c), l);
+ break;
+ }
+
+ case Tabular::SET_LTRIM_BOTTOM:
+ case Tabular::TOGGLE_LTRIM_BOTTOM: {
+ bool l = (feature == Tabular::SET_LTRIM_BOTTOM)
+ ? (value == "true") : !tabular.bottomLineTrim(cur.idx()).first;
+ for (row_type r = sel_row_start; r <= sel_row_end; ++r)
+ for (col_type c = sel_col_start; c <= sel_col_end; ++c)
+ tabular.setBottomLineLTrim(tabular.cellIndex(r, c), l);
+ break;
+ }
+
+ case Tabular::SET_RTRIM_BOTTOM:
+ case Tabular::TOGGLE_RTRIM_BOTTOM: {
+ bool l = (feature == Tabular::SET_RTRIM_BOTTOM)
+ ? (value == "true") : !tabular.bottomLineTrim(cur.idx()).second;
+ for (row_type r = sel_row_start; r <= sel_row_end; ++r)
+ for (col_type c = sel_col_start; c <= sel_col_end; ++c)
+ tabular.setBottomLineRTrim(tabular.cellIndex(r, c), l);
+ break;
+ }
+
case Tabular::SET_LINE_LEFT:
case Tabular::TOGGLE_LINE_LEFT: {
bool lineSet = (feature == Tabular::SET_LINE_LEFT)
case Tabular::M_VALIGN_BOTTOM:
case Tabular::M_VALIGN_MIDDLE:
flag = false;
+ // fall through
case Tabular::VALIGN_TOP:
case Tabular::VALIGN_BOTTOM:
case Tabular::VALIGN_MIDDLE:
// just multicol for one single cell
// check whether we are completely in a multicol
if (!tabular.isMultiColumn(cur.idx()))
- tabular.setMultiColumn(cur.idx(), 1,
+ tabular.setMultiColumn(cur, cur.idx(), 1,
tabular.rightLine(cur.idx()));
break;
}
idx_type const s_start = cur.selBegin().idx();
row_type const col_start = tabular.cellColumn(s_start);
row_type const col_end = tabular.cellColumn(cur.selEnd().idx());
- cur.idx() = tabular.setMultiColumn(s_start, col_end - col_start + 1,
+ cur.idx() = tabular.setMultiColumn(cur, s_start, col_end - col_start + 1,
tabular.rightLine(cur.selEnd().idx()));
cur.pit() = 0;
cur.pos() = 0;
// just multirow for one single cell
// check whether we are completely in a multirow
if (!tabular.isMultiRow(cur.idx()))
- tabular.setMultiRow(cur.idx(), 1,
+ tabular.setMultiRow(cur, cur.idx(), 1,
tabular.bottomLine(cur.idx()),
tabular.getAlignment(cur.idx()));
break;
idx_type const s_start = cur.selBegin().idx();
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,
+ cur.idx() = tabular.setMultiRow(cur, s_start, row_end - row_start + 1,
tabular.bottomLine(cur.selEnd().idx()),
tabular.getAlignment(cur.selEnd().idx()));
cur.pit() = 0;
break;
}
+ case Tabular::SET_INNER_LINES:
+ setLinesInnerOnly = true;
+ // fall through
case Tabular::SET_ALL_LINES:
setLines = true;
+ // fall through
case Tabular::UNSET_ALL_LINES:
for (row_type r = sel_row_start; r <= sel_row_end; ++r)
for (col_type c = sel_col_start; c <= sel_col_end; ++c) {
idx_type const cell = tabular.cellIndex(r, c);
- tabular.setTopLine(cell, setLines);
- tabular.setBottomLine(cell, setLines);
- tabular.setRightLine(cell, setLines);
- tabular.setLeftLine(cell, setLines);
+ if (!setLinesInnerOnly || r != sel_row_start)
+ tabular.setTopLine(cell, setLines);
+ if ((!setLinesInnerOnly || r != sel_row_end)
+ && (!setLines || r == sel_row_end))
+ tabular.setBottomLine(cell, setLines);
+ if ((!setLinesInnerOnly || c != sel_col_end)
+ && (!setLines || c == sel_col_end))
+ tabular.setRightLine(cell, setLines);
+ if ((!setLinesInnerOnly || c != sel_col_start))
+ tabular.setLeftLine(cell, setLines);
+ }
+ break;
+
+ case Tabular::RESET_FORMAL_DEFAULT:
+ for (row_type r = 0; r < tabular.nrows(); ++r) {
+ bool const head_or_foot = r == 0 || r == tabular.nrows() - 1;
+ for (col_type c = 0; c < tabular.ncols(); ++c) {
+ idx_type const cell = tabular.cellIndex(r, c);
+ tabular.setTopLine(cell, head_or_foot);
+ tabular.setBottomLine(cell, head_or_foot);
}
+ }
break;
case Tabular::SET_BORDER_LINES:
tabular.longtabular_alignment = Tabular::LYX_LONGTABULAR_ALIGN_RIGHT;
break;
-
-
case Tabular::SET_ROTATE_CELL:
for (row_type r = sel_row_start; r <= sel_row_end; ++r)
for (col_type c = sel_col_start; c <= sel_col_end; ++c)
case Tabular::UNSET_LTFIRSTHEAD:
flag = false;
+ // fall through
case Tabular::SET_LTFIRSTHEAD:
tabular.getRowOfLTFirstHead(row, ltt);
checkLongtableSpecial(ltt, value, flag);
case Tabular::UNSET_LTHEAD:
flag = false;
+ // fall through
case Tabular::SET_LTHEAD:
tabular.getRowOfLTHead(row, ltt);
checkLongtableSpecial(ltt, value, flag);
case Tabular::UNSET_LTFOOT:
flag = false;
+ // fall through
case Tabular::SET_LTFOOT:
tabular.getRowOfLTFoot(row, ltt);
checkLongtableSpecial(ltt, value, flag);
case Tabular::UNSET_LTLASTFOOT:
flag = false;
+ // fall through
case Tabular::SET_LTLASTFOOT:
tabular.getRowOfLTLastFoot(row, ltt);
checkLongtableSpecial(ltt, value, flag);
case Tabular::UNSET_LTNEWPAGE:
flag = false;
+ // fall through
case Tabular::SET_LTNEWPAGE:
tabular.setLTNewPage(row, flag);
break;
case Tabular::SET_LTCAPTION: {
if (tabular.ltCaption(row))
break;
- cur.idx() = tabular.setLTCaption(row, true);
+ cur.idx() = tabular.setLTCaption(cur, row, true);
cur.pit() = 0;
cur.pos() = 0;
cur.selection(false);
case Tabular::UNSET_LTCAPTION: {
if (!tabular.ltCaption(row))
break;
- cur.idx() = tabular.setLTCaption(row, false);
+ cur.idx() = tabular.setLTCaption(cur, row, false);
cur.pit() = 0;
cur.pos() = 0;
cur.selection(false);
inset->setChange(Change(buffer().params().track_changes ?
Change::INSERTED : Change::UNCHANGED));
cur.pos() = 0;
+ cur.pit() = 0;
}
}
return true;
bool InsetTabular::forcePlainLayout(idx_type cell) const
{
- return !tabular.getPWidth(cell).zero();
+ return tabular.isMultiColumn(cell) && !tabular.getPWidth(cell).zero();
}
}
size_t op = 0;
- idx_type const cells = loctab->numberofcells;
+ idx_type cells = loctab->numberofcells;
p = 0;
cols = ocol;
rows = loctab->nrows();
- col_type const columns = loctab->ncols();
+ col_type columns = loctab->ncols();
- while (cell < cells && p < len && row < rows &&
+ while (p < len &&
(p = buf.find_first_of(from_ascii("\t\n"), p)) != docstring::npos)
{
if (p >= len)
break;
switch (buf[p]) {
case '\t':
- // we can only set this if we are not too far right
+ // append column if necessary
+ if (cols == columns) {
+ loctab->appendColumn(cols - 1);
+ columns = loctab->ncols();
+ cells = loctab->numberofcells;
+ ++cell;
+ }
if (cols < columns) {
shared_ptr<InsetTableCell> inset = loctab->cellInset(cell);
Font const font = bv.textMetrics(&inset->text()).
}
cols = ocol;
++row;
+ // append row if necessary
+ if (row == rows && p < len - 1) {
+ loctab->appendRow(row - 1);
+ rows = loctab->nrows();
+ cells = loctab->numberofcells;
+ }
if (row < rows)
cell = loctab->cellIndex(row, cols);
break;