#include "DispatchResult.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
+#include "InsetIterator.h"
#include "InsetList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "Paragraph.h"
#include "ParagraphParameters.h"
#include "ParIterator.h"
+#include "TexRow.h"
+#include "texstream.h"
#include "TextClass.h"
#include "TextMetrics.h"
#include "support/unique_ptr.h"
#include <cstring>
+#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>
}
-DocIterator separatorPos(InsetTableCell * cell, docstring const & align_d)
+DocIterator separatorPos(InsetTableCell const * cell, docstring const & align_d)
{
DocIterator dit = doc_iterator_begin(&(cell->buffer()), cell);
for (; dit; dit.forwardChar())
{
InsetTableCell tail = InsetTableCell(head);
DocIterator const dit = separatorPos(&head, align_d);
- hassep = dit;
+ hassep = (bool)dit;
if (hassep) {
pit_type const psize = head.paragraphs().front().size();
head.paragraphs().front().eraseChars(dit.pos(), psize, 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)
idx_type const i = cellIndex(r, c);
if (columnSpan(i) == 1) {
if (getAlignment(i) == LYX_ALIGN_DECIMAL
- && cell_info[r][c].decimal_width!=0)
+ && cell_info[r][c].decimal_width != 0)
new_width = max(new_width, cellInfo(i).width
+ max_dwidth[c] - cellInfo(i).decimal_width);
else
cur.pop();
}
-}
+} // namespace
void Tabular::setColumnPWidth(Cursor & cur, idx_type cell,
}
+int Tabular::offsetVAlignment() const
+{
+ // for top-alignment the first horizontal table line must be exactly at
+ // the position of the base line of the surrounding text line
+ // for bottom alignment, the same is for the last table line
+ int offset_valign = 0;
+ switch (tabular_valignment) {
+ case Tabular::LYX_VALIGN_BOTTOM:
+ offset_valign = rowAscent(0) - height();
+ break;
+ case Tabular::LYX_VALIGN_MIDDLE:
+ offset_valign = (- height()) / 2 + rowAscent(0);
+ break;
+ case Tabular::LYX_VALIGN_TOP:
+ offset_valign = rowAscent(0);
+ break;
+ }
+ return offset_valign;
+}
+
+
Length const Tabular::getPWidth(idx_type cell) const
{
if (isMultiColumn(cell))
}
-Tabular::CellData & Tabular::cellInfo(idx_type cell) const
+Tabular::CellData const & Tabular::cellInfo(idx_type cell) const
+{
+ return cell_info[cellRow(cell)][cellColumn(cell)];
+}
+
+
+Tabular::CellData & Tabular::cellInfo(idx_type cell)
{
return cell_info[cellRow(cell)][cellColumn(cell)];
}
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)
// we center in multicol when no decimal point
if (column_info[c].alignment == LYX_ALIGN_DECIMAL) {
docstring const align_d = column_info[c].decimal_point;
- DocIterator const dit = separatorPos(cellInset(cell).get(), align_d);
+ DocIterator const dit = separatorPos(cellInset(cell), align_d);
ismulticol |= !dit;
}
OutputParams const & runparams) const
{
idx_type cell = cellIndex(row, 0);
- shared_ptr<InsetTableCell> inset = cellInset(cell);
+ InsetTableCell const * inset = cellInset(cell);
Paragraph const & par = inset->paragraphs().front();
string const lang = par.getParLanguage(buffer().params())->lang();
}
TeXCellPreamble(os, cell, ismulticol, ismultirow);
- shared_ptr<InsetTableCell> inset = cellInset(cell);
+ InsetTableCell const * inset = cellInset(cell);
Paragraph const & par = inset->paragraphs().front();
if (getAlignment(cell) == LYX_ALIGN_DECIMAL) {
// copy cell and split in 2
InsetTableCell head = InsetTableCell(*cellInset(cell));
- head.setBuffer(buffer());
+ head.setBuffer(const_cast<Buffer &>(buffer()));
DocIterator dit = cellInset(cell)->getText(0)->macrocontextPosition();
dit.pop_back();
dit.push_back(CursorSlice(head));
tail.setMacrocontextPositionRecursive(dit);
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.texrow().start(par.id(), 0);
void Tabular::latex(otexstream & os, OutputParams const & runparams) const
{
bool const is_tabular_star = !tabular_width.zero();
- TexRow::RowEntry pos = TexRow::textEntry(runparams.lastid,
- runparams.lastpos);
+ TexRow::RowEntry pos = TexRow::textEntry(runparams.lastid, runparams.lastpos);
//+---------------------------------------------------------------------
//+ first the opening preamble +
if (!TexRow::isNone(pos))
os.texrow().start(pos);
- if (rotate != 0)
+ if (rotate != 0 && !is_long_tabular)
os << "\\begin{turn}{" << convert<string>(rotate) << "}\n";
if (is_long_tabular) {
os << column_info[c].align_special;
} else {
if (!column_info[c].p_width.zero()) {
+ bool decimal = false;
switch (column_info[c].alignment) {
case LYX_ALIGN_LEFT:
os << ">{\\raggedright}";
case LYX_ALIGN_BLOCK:
case LYX_ALIGN_LAYOUT:
case LYX_ALIGN_SPECIAL:
+ break;
case LYX_ALIGN_DECIMAL:
+ os << ">{\\raggedleft}";
+ decimal = true;
break;
}
+ char valign = 'p';
switch (column_info[c].valignment) {
case LYX_VALIGN_TOP:
- os << 'p';
+ // this is the default
break;
case LYX_VALIGN_MIDDLE:
- os << 'm';
+ valign = 'm';
break;
case LYX_VALIGN_BOTTOM:
- os << 'b';
+ valign = 'b';
break;
- }
- os << '{'
- << from_ascii(column_info[c].p_width.asLatexString())
- << '}';
+ }
+ os << valign;
+
+ // Fixed-width cells with alignment at decimal separator
+ // are output as two cells of half the width with the decimal
+ // separator as column sep. This effectively puts the content
+ // centered, which differs from the normal decimal sep alignment
+ // and is not ideal, but we cannot do better ATM (see #9568).
+ // FIXME: Implement proper decimal sep alignment, e.g. via siunitx.
+ if (decimal) {
+ docstring const halffixedwith =
+ from_ascii(Length(column_info[c].p_width.value() / 2,
+ column_info[c].p_width.unit()).asLatexString());
+ os << '{'
+ << halffixedwith
+ << '}'
+ << "@{\\extracolsep{0pt}" << column_info[c].decimal_point << "}"
+ << valign
+ << '{'
+ << halffixedwith
+ << '}';
+ } else
+ os << '{'
+ << from_ascii(column_info[c].p_width.asLatexString())
+ << '}';
} else {
switch (column_info[c].alignment) {
case LYX_ALIGN_LEFT:
os << "\\end{tabular}";
}
- if (rotate != 0)
+ if (rotate != 0 && !is_long_tabular)
os << breakln << "\\end{turn}";
if (!TexRow::isNone(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:
else if (isMultiRow(cell))
attr << " rowspan='" << rowSpan(cell) << "'";
- xs << html::StartTag(celltag, attr.str()) << html::CR();
+ xs << html::StartTag(celltag, attr.str(), true) << html::CR();
ret += cellInset(cell)->xhtml(xs, runparams);
xs << html::EndTag(celltag) << html::CR();
++cell;
}
-shared_ptr<InsetTableCell> Tabular::cellInset(idx_type cell) const
+shared_ptr<InsetTableCell> Tabular::cellInset(idx_type cell)
{
return cell_info[cellRow(cell)][cellColumn(cell)].inset;
}
-shared_ptr<InsetTableCell> Tabular::cellInset(row_type row,
- col_type column) const
+shared_ptr<InsetTableCell> Tabular::cellInset(row_type row, col_type column)
{
return cell_info[row][column].inset;
}
+InsetTableCell const * Tabular::cellInset(idx_type cell) const
+{
+ return cell_info[cellRow(cell)][cellColumn(cell)].inset.get();
+}
+
+
void Tabular::setCellInset(row_type row, col_type column,
- shared_ptr<InsetTableCell> ins) const
+ shared_ptr<InsetTableCell> ins)
{
CellData & cd = cell_info[row][column];
cd.inset = ins;
if (getVAlignment(cell) != LYX_VALIGN_TOP
|| !getPWidth(cell).zero())
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());
}
}
void InsetTableCell::addToToc(DocIterator const & di, bool output_active,
- UpdateType utype) const
+ UpdateType utype, TocBackend & backend) const
{
- InsetText::iterateForToc(di, output_active, utype);
+ InsetText::iterateForToc(di, output_active, utype, backend);
}
InsetTabular::InsetTabular(Buffer * buf, row_type rows,
col_type columns)
: Inset(buf), tabular(buf, max(rows, row_type(1)), max(columns, col_type(1))),
- first_visible_cell_(0), offset_valign_(0), rowselect_(false), colselect_(false)
+ rowselect_(false), colselect_(false)
{
}
InsetTabular::InsetTabular(InsetTabular const & tab)
- : Inset(tab), tabular(tab.tabular)
+ : Inset(tab), tabular(tab.tabular),
+ rowselect_(false), colselect_(false)
{
}
int InsetTabular::rowFromY(Cursor & cur, int y) const
{
// top y coordinate of tabular
- int h = yo(cur.bv()) - tabular.rowAscent(0) + offset_valign_;
+ int h = yo(cur.bv()) - tabular.rowAscent(0) + tabular.offsetVAlignment();
row_type r = 0;
for (; r < tabular.nrows() && y > h; ++r)
h += tabular.rowAscent(r) + tabular.rowDescent(r)
MetricsInfo m = mi;
Length const p_width = tabular.getPWidth(cell);
if (!p_width.zero())
- m.base.textwidth = p_width.inPixels(mi.base);
+ m.base.textwidth = mi.base.inPixels(p_width);
tabular.cellInset(cell)->metrics(m, dim);
if (!p_width.zero())
dim.wid = m.base.textwidth;
maxdes = max(maxdes, dim.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);
}
- // for top-alignment the first horizontal table line must be exactly at
- // the position of the base line of the surrounding text line
- // for bottom alignment, the same is for the last table line
- switch (tabular.tabular_valignment) {
- case Tabular::LYX_VALIGN_BOTTOM:
- offset_valign_ = tabular.rowAscent(0) - tabular.height();
- break;
- case Tabular::LYX_VALIGN_MIDDLE:
- offset_valign_ = (- tabular.height()) / 2 + tabular.rowAscent(0);
- break;
- case Tabular::LYX_VALIGN_TOP:
- offset_valign_ = tabular.rowAscent(0);
- break;
- }
-
tabular.updateColumnWidths();
- dim.asc = tabular.rowAscent(0) - offset_valign_;
+ dim.asc = tabular.rowAscent(0) - tabular.offsetVAlignment();
dim.des = tabular.height() - dim.asc;
dim.wid = tabular.width() + 2 * ADD_TO_TABULAR_WIDTH;
}
bool const original_selection_state = pi.selected;
idx_type idx = 0;
- first_visible_cell_ = Tabular::npos;
- int yy = y + offset_valign_;
+ int yy = y + tabular.offsetVAlignment();
for (row_type r = 0; r < tabular.nrows(); ++r) {
int nx = x;
for (col_type c = 0; c < tabular.ncols(); ++c) {
continue;
}
- if (first_visible_cell_ == Tabular::npos)
- first_visible_cell_ = idx;
-
pi.selected |= isCellSelected(cur, r, c);
int const cx = nx + tabular.textHOffset(idx);
int const cy = yy + tabular.textVOffset(idx);
void InsetTabular::drawBackground(PainterInfo & pi, int x, int y) const
{
x += ADD_TO_TABULAR_WIDTH;
- y += offset_valign_ - tabular.rowAscent(0);
+ y += tabular.offsetVAlignment() - tabular.rowAscent(0);
pi.pain.fillRectangle(x, y, tabular.width(), tabular.height(),
pi.backgroundColor(this));
}
}
int const w = tabular.cellWidth(cell);
int const h = tabular.cellHeight(cell);
- int const yy = y - tabular.rowAscent(r) + offset_valign_;
+ int const yy = y - tabular.rowAscent(r) + tabular.offsetVAlignment();
if (isCellSelected(cur, r, c))
pi.pain.fillRectangle(xx, yy, w, h, Color_selection);
xx += w;
void InsetTabular::addToToc(DocIterator const & cpit, bool output_active,
- UpdateType utype) const
+ UpdateType utype, TocBackend & backend) const
{
DocIterator dit = cpit;
dit.forwardPos();
size_t const end = dit.nargs();
for ( ; dit.idx() < end; dit.top().forwardIdx())
- cell(dit.idx())->addToToc(dit, output_active, utype);
+ cell(dit.idx())->addToToc(dit, output_active, utype, backend);
}
bool InsetTabular::hitSelectColumn(BufferView const & bv, int y) const
{
- int const y0 = yo(bv) - tabular.rowAscent(0) + offset_valign_;
+ int const y0 = yo(bv) - tabular.rowAscent(0) + tabular.offsetVAlignment();
// FIXME: using ADD_TO_TABULAR_WIDTH is not really correct since
// there is no margin added vertically to tabular insets.
// However, it works for now.
cur.screenUpdateFlags(Update::Force | Update::FitCursor);
break;
-// case LFUN_SCREEN_DOWN: {
-// //if (hasSelection())
-// // cur.selection() = false;
-// col_type const col = tabular.cellColumn(cur.idx());
-// int const t = cur.bv().top_y() + cur.bv().height();
-// if (t < yo() + tabular.getHeightOfTabular()) {
-// cur.bv().scrollDocView(t, true);
-// cur.idx() = tabular.cellBelow(first_visible_cell_) + col;
-// } else {
-// cur.idx() = tabular.getFirstCellInRow(tabular.rows() - 1) + col;
-// }
-// cur.par() = 0;
-// cur.pos() = 0;
-// break;
-// }
-//
-// case LFUN_SCREEN_UP: {
-// //if (hasSelection())
-// // cur.selection() = false;
-// col_type const col = tabular.cellColumn(cur.idx());
-// int const t = cur.bv().top_y() + cur.bv().height();
-// if (yo() < 0) {
-// cur.bv().scrollDocView(t, true);
-// if (yo() > 0)
-// cur.idx() = col;
-// else
-// cur.idx() = tabular.cellBelow(first_visible_cell_) + col;
-// } else {
-// cur.idx() = col;
-// }
-// cur.par() = cur.lastpar();
-// cur.pos() = cur.lastpos();
-// break;
-// }
-
case LFUN_LAYOUT_TABULAR:
cur.bv().showDialog("tabular");
break;
case LFUN_FONT_SIZE:
case LFUN_FONT_UNDERLINE:
case LFUN_FONT_STRIKEOUT:
+ case LFUN_FONT_CROSSOUT:
case LFUN_FONT_UNDERUNDERLINE:
case LFUN_FONT_UNDERWAVE:
case LFUN_LANGUAGE:
// 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);
}
status.setEnabled(false);
return true;
}
- // Fall back
+ // fall through
case LFUN_NEWLINE_INSERT: {
if (tabular.getPWidth(cur.idx()).zero()) {
status.setEnabled(false);
void InsetTabular::validate(LaTeXFeatures & features) const
{
tabular.validate(features);
- // FIXME XHTML
- // It'd be better to be able to get this from an InsetLayout, but at present
- // InsetLayouts do not seem really to work for things that aren't InsetTexts.
- if (features.runparams().flavor == OutputParams::HTML)
- features.addCSSSnippet(
- "table { border: 1px solid black; display: inline-block; }\n"
- "td { border: 1px solid black; padding: 0.5ex; }");
+ features.useInsetLayout(getLayout());
}
// y offset correction
y += cellYPos(sl.idx());
y += tabular.textVOffset(sl.idx());
- y += offset_valign_;
+ y += tabular.offsetVAlignment();
// x offset correction
x += cellXPos(sl.idx());
Inset * InsetTabular::editXY(Cursor & cur, int x, int y)
{
//lyxerr << "InsetTabular::editXY: " << this << endl;
- cur.selection(false);
cur.push(*this);
cur.idx() = getNearestCell(cur.bv(), x, y);
return cur.bv().textMetrics(&cell(cur.idx())->text()).editXY(cur, x, y);
cur.recordUndoInset(this);
istringstream is(argument);
+ // limit the size of strings we read to avoid memory problems
+ is >> setw(65636);
string s;
// Safe guard.
size_t safe_guard = 0;
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:
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) {
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;