}
-bool getTokenValue(string const & str, char const * token, Change & change, BufferParams bp)
+bool getTokenValue(string const & str, char const * token, Change & change, BufferParams & bp)
{
// set the change to be Change() as default as this it should be if not
// in the file format.
if (changedata.size() != 3) {
Alert::warning(_("Change tracking data incomplete"),
_("Change tracking information for tabular row/column "
- "is incomplete. I will ignore this.\n"));
+ "is incomplete. I will ignore this."));
return false;
}
BufferParams::AuthorMap const & am = bp.author_map_;
return value.zero() ? string() : write_attribute(name, value.asString());
}
-string const write_attribute(string const & name, Change const & change, BufferParams const bp)
+string const write_attribute(string const & name, Change const & change, BufferParams const & bp)
{
odocstringstream ods;
if (change.inserted())
DocIterator const dit = separatorPos(&head, align_d);
hassep = (bool)dit;
if (hassep) {
- pit_type const psize = head.paragraphs().front().size();
+ pos_type const psize = head.paragraphs().front().size();
head.paragraphs().front().eraseChars(dit.pos(), psize, false);
tail.paragraphs().front().eraseChars(0,
dit.pos() < psize ? dit.pos() + 1 : psize, false);
}
-void Tabular::TeXTopHLine(otexstream & os, row_type row, list<col_type> columns) const
+void Tabular::TeXTopHLine(otexstream & os, row_type row, list<col_type> columns,
+ list<col_type> logical_columns) const
{
// we only output complete row lines and the 1st row here, the rest
// is done in Tabular::TeXBottomHLine(...)
} else if (realfirstrow || have_trims) {
string const cline = use_booktabs ? "\\cmidrule" : "\\cline";
col_type c = 0;
- for (auto & cl : columns) {
+ std::list<col_type>::const_iterator it1 = logical_columns.begin();
+ std::list<col_type>::const_iterator it2 = columns.begin();
+ // We need to iterate over the logical columns here, but take care for
+ // bidi swapping
+ for (; it1 != logical_columns.end() && it2 != columns.end(); ++it1, ++it2) {
+ col_type cl = *it1;
if (cl < c)
continue;
c = cl;
for (col_type j = 0 ; j < c; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
- string const firstcol = convert<string>(c + 1 + offset);
+ // If the two iterators differ, we are in bidi with swapped columns
+ col_type firstcol = (*it1 == *it2) ? c + 1 + offset : columns.size() - c + offset;
while (isPartOfMultiColumn(row, c))
++c;
string trim;
for (col_type j = cstart ; j < c ; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
- col_type const lastcol = c + 1 + offset;
+ col_type lastcol = (*it1 == *it2) ? c + 1 + offset : columns.size() - c + offset;
if (toprtrims.find(c) != toprtrims.end()
&& toprtrims.find(c)->second)
trim += "r";
os << cline;
if (!trim.empty())
os << "(" << trim << ")";
- os << "{" << firstcol << '-' << lastcol << "}";
+ if (firstcol > lastcol)
+ // This can happen with bidi (swapped columns)
+ os << "{" << lastcol << '-' << firstcol << "}";
+ else
+ os << "{" << firstcol << '-' << lastcol << "}";
if (c == columns.size() - 1)
break;
++c;
}
-void Tabular::TeXBottomHLine(otexstream & os, row_type row, list<col_type> columns) const
+void Tabular::TeXBottomHLine(otexstream & os, row_type row, list<col_type> columns,
+ list<col_type> logical_columns) const
{
// we output bottomlines of row r and the toplines of row r+1
// if the latter do not span the whole tabular
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)
+ 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;
} else {
string const cline = use_booktabs ? "\\cmidrule" : "\\cline";
col_type c = 0;
- for (auto & cl : columns) {
+ std::list<col_type>::const_iterator it1 = logical_columns.begin();
+ std::list<col_type>::const_iterator it2 = columns.begin();
+ // We need to iterate over the logical columns here, but take care for
+ // bidi swapping
+ for (; it1 != logical_columns.end() && it2 != columns.end(); ++it1, ++it2) {
+ col_type cl = *it1;
if (cl < c)
continue;
c = cl;
for (col_type j = 0 ; j < c; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
- string const firstcol = convert<string>(c + 1 + offset);
+ // If the two iterators differ, we are in bidi with swapped columns
+ col_type firstcol = (*it1 == *it2) ? c + 1 + offset : columns.size() - c + offset;
while (isPartOfMultiColumn(row, c))
++c;
string trim;
for (col_type j = cstart ; j < c ; ++j)
if (column_info[j].alignment == LYX_ALIGN_DECIMAL)
++offset;
- col_type const lastcol = c + 1 + offset;
+ col_type lastcol = (*it1 == *it2) ? c + 1 + offset : columns.size() - c + offset;
if (bottomrtrims.find(c) != bottomrtrims.end()
&& bottomrtrims.find(c)->second)
trim += "r";
os << cline;
if (!trim.empty())
os << "(" << trim << ")";
- os << "{" << firstcol << '-' << lastcol << "}";
+ if (firstcol > lastcol)
+ // This can happen with bidi (swapped columns)
+ os << "{" << lastcol << '-' << firstcol << "}";
+ else
+ os << "{" << firstcol << '-' << lastcol << "}";
if (c == columns.size() - 1)
break;
++c;
void Tabular::TeXLongtableHeaderFooter(otexstream & os,
OutputParams const & runparams,
- list<col_type> columns) const
+ list<col_type> columns,
+ list<col_type> logical_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, columns);
+ TeXRow(os, r, runparams, columns, logical_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, columns);
+ TeXRow(os, r, runparams, columns, logical_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, columns);
+ TeXRow(os, r, runparams, columns, logical_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, columns);
+ TeXRow(os, r, runparams, columns, logical_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, columns);
+ TeXRow(os, r, runparams, columns, logical_columns);
}
if (endlastfoot.bottomDL)
os << "\\hline\n";
void Tabular::TeXRow(otexstream & os, row_type row,
OutputParams const & runparams,
- list<col_type> columns) const
+ list<col_type> columns, list<col_type> logical_columns) const
{
- idx_type cell = cellIndex(row, 0);
-
//output the top line
- TeXTopHLine(os, row, columns);
+ TeXTopHLine(os, row, columns, logical_columns);
if (row_info[row].top_space_default) {
if (use_booktabs)
if (isPartOfMultiColumn(row, c))
continue;
- cell = cellIndex(row, c);
+ idx_type cell = cellIndex(row, c);
if (isPartOfMultiRow(row, c)
&& column_info[c].alignment != LYX_ALIGN_DECIMAL) {
os << '\n';
//output the bottom line
- TeXBottomHLine(os, row, columns);
+ TeXBottomHLine(os, row, columns, logical_columns);
if (row_info[row].interline_space_default) {
if (use_booktabs)
runparams.local_font->isRightToLeft()
&& runparams.useBidiPackage();
list<col_type> columns;
+ list<col_type> logical_columns;
for (col_type cl = 0; cl < ncols(); ++cl) {
if (!buffer().params().output_changes && column_info[cl].change.deleted())
continue;
columns.push_front(cl);
else
columns.push_back(cl);
+ // for some calculations, we need the logical (non-swapped)
+ // columns also in bidi.
+ logical_columns.push_back(cl);
}
// If we use \cline or \cmidrule, we need to locally de-activate
}
os << "}\n";
- TeXLongtableHeaderFooter(os, runparams, columns);
+ TeXLongtableHeaderFooter(os, runparams, columns, logical_columns);
//+---------------------------------------------------------------------
//+ the single row and columns (cells) +
if (!buffer().params().output_changes && row_info[r].change.deleted())
continue;
if (isValidRow(r)) {
- TeXRow(os, r, runparams, columns);
+ TeXRow(os, r, runparams, columns, logical_columns);
if (is_long_tabular && row_info[r].newpage)
os << "\\newpage\n";
}
}
-docstring Tabular::xhtmlRow(XHTMLStream & xs, row_type row,
+docstring Tabular::xhtmlRow(XMLStream & xs, row_type row,
OutputParams const & runparams, bool header) const
{
docstring ret;
string const celltag = header ? "th" : "td";
idx_type cell = getFirstCellInRow(row);
- xs << html::StartTag("tr");
+ xs << xml::StartTag("tr");
for (col_type c = 0; c < ncols(); ++c) {
if (isPartOfMultiColumn(row, c) || isPartOfMultiRow(row, c))
continue;
else if (isMultiRow(cell))
attr << " rowspan='" << rowSpan(cell) << "'";
- xs << html::StartTag(celltag, attr.str(), true) << html::CR();
+ xs << xml::StartTag(celltag, attr.str(), true) << xml::CR();
ret += cellInset(cell)->xhtml(xs, runparams);
- xs << html::EndTag(celltag) << html::CR();
+ xs << xml::EndTag(celltag) << xml::CR();
++cell;
}
- xs << html::EndTag("tr");
+ xs << xml::EndTag("tr");
return ret;
}
-docstring Tabular::xhtml(XHTMLStream & xs, OutputParams const & runparams) const
+docstring Tabular::xhtml(XMLStream & xs, OutputParams const & runparams) const
{
docstring ret;
align = "right";
break;
}
- xs << html::StartTag("div", "class='longtable' style='text-align: " + align + ";'")
- << html::CR();
+ xs << xml::StartTag("div", "class='longtable' style='text-align: " + align + ";'")
+ << xml::CR();
// The caption flag wins over head/foot
if (haveLTCaption()) {
- xs << html::StartTag("div", "class='longtable-caption' style='text-align: " + align + ";'")
- << html::CR();
+ xs << xml::StartTag("div", "class='longtable-caption' style='text-align: " + align + ";'")
+ << xml::CR();
for (row_type r = 0; r < nrows(); ++r)
if (row_info[r].caption)
ret += xhtmlRow(xs, r, runparams);
- xs << html::EndTag("div") << html::CR();
+ xs << xml::EndTag("div") << xml::CR();
}
}
- xs << html::StartTag("table") << html::CR();
+ xs << xml::StartTag("table") << xml::CR();
// output header info
bool const havefirsthead = haveLTFirstHead(false);
// in XHTML. this test accomplishes that.
bool const havehead = !havefirsthead && haveLTHead(false);
if (havehead || havefirsthead) {
- xs << html::StartTag("thead") << html::CR();
+ xs << xml::StartTag("thead") << xml::CR();
for (row_type r = 0; r < nrows(); ++r) {
if (((havefirsthead && row_info[r].endfirsthead) ||
(havehead && row_info[r].endhead)) &&
ret += xhtmlRow(xs, r, runparams, true);
}
}
- xs << html::EndTag("thead") << html::CR();
+ xs << xml::EndTag("thead") << xml::CR();
}
// output footer info
bool const havelastfoot = haveLTLastFoot(false);
// as before.
bool const havefoot = !havelastfoot && haveLTFoot(false);
if (havefoot || havelastfoot) {
- xs << html::StartTag("tfoot") << html::CR();
+ xs << xml::StartTag("tfoot") << xml::CR();
for (row_type r = 0; r < nrows(); ++r) {
if (((havelastfoot && row_info[r].endlastfoot) ||
(havefoot && row_info[r].endfoot)) &&
ret += xhtmlRow(xs, r, runparams);
}
}
- xs << html::EndTag("tfoot") << html::CR();
+ xs << xml::EndTag("tfoot") << xml::CR();
}
- xs << html::StartTag("tbody") << html::CR();
+ xs << xml::StartTag("tbody") << xml::CR();
for (row_type r = 0; r < nrows(); ++r) {
if (isValidRow(r)) {
ret += xhtmlRow(xs, r, runparams);
}
}
- xs << html::EndTag("tbody")
- << html::CR()
- << html::EndTag("table")
- << html::CR();
+ xs << xml::EndTag("tbody")
+ << xml::CR()
+ << xml::EndTag("table")
+ << xml::CR();
if (is_long_tabular)
- xs << html::EndTag("div") << html::CR();
+ xs << xml::EndTag("div") << xml::CR();
return ret;
}
}
-docstring InsetTableCell::xhtml(XHTMLStream & xs, OutputParams const & rp) const
+docstring InsetTableCell::xhtml(XMLStream & xs, OutputParams const & rp) const
{
if (!isFixedWidth)
return InsetText::insetAsXHTML(xs, rp, InsetText::JustText);
void InsetTableCell::metrics(MetricsInfo & mi, Dimension & dim) const
{
TextMetrics & tm = mi.base.bv->textMetrics(&text());
+ int const horiz_offset = leftOffset(mi.base.bv) + rightOffset(mi.base.bv);
// Hand font through to contained lyxtext:
tm.font_.fontInfo() = mi.base.font;
- mi.base.textwidth -= 2 * TEXT_TO_INSET_OFFSET;
+ mi.base.textwidth -= horiz_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
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;
+ mi.base.textwidth += horiz_offset;
+ dim.asc += topOffset(mi.base.bv);
+ dim.des += bottomOffset(mi.base.bv);
+ dim.wid += horiz_offset;
}
-
/////////////////////////////////////////////////////////////////////
//
// InsetTabular
docstring const align_d = tabular.column_info[c].decimal_point;
dit = separatorPos(&tail, align_d);
- pit_type const psize = tail.paragraphs().front().size();
+ pos_type const psize = tail.paragraphs().front().size();
if (dit) {
tail.paragraphs().front().eraseChars(0,
dit.pos() < psize ? dit.pos() + 1 : psize, false);
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 + TEXT_TO_INSET_OFFSET:
+ // = descent of text in last par + bottomOffset:
int const lastpardes = tm.last().second->descent()
- + TEXT_TO_INSET_OFFSET;
+ + bottomOffset(mi.base.bv);
int offset = 0;
switch (tabular.getVAlignment(cell)) {
case Tabular::LYX_VALIGN_TOP:
bool const original_selection_state = pi.selected;
idx_type idx = 0;
+
+ // Save tabular change status
+ Change tab_change = pi.change;
int yy = y + tabular.offsetVAlignment();
for (row_type r = 0; r < tabular.nrows(); ++r) {
}
pi.selected |= isCellSelected(cur, r, c);
+
+ // Mark deleted rows/columns
+ if (tabular.column_info[c].change.changed())
+ pi.change = tabular.column_info[c].change;
+ else if (tabular.row_info[r].change.changed())
+ pi.change = tabular.row_info[r].change;
+ else
+ pi.change = tab_change;
+
int const cx = nx + tabular.textHOffset(idx);
int const cy = yy + tabular.textVOffset(idx);
// Cache the Inset position.
}
-void InsetTabular::updateBuffer(ParIterator const & it, UpdateType utype)
+void InsetTabular::updateBuffer(ParIterator const & it, UpdateType utype, bool const /*deleted*/)
{
// In a longtable, tell captions what the current float is
Counters & cnts = buffer().masterBuffer()->params().documentClass().counters();
}
-Inset::DisplayType InsetTabular::display() const
+Inset::RowFlags InsetTabular::rowFlags() const
{
if (tabular.is_long_tabular) {
switch (tabular.longtabular_alignment) {
case Tabular::LYX_LONGTABULAR_ALIGN_LEFT:
- return AlignLeft;
+ return Display | AlignLeft;
case Tabular::LYX_LONGTABULAR_ALIGN_CENTER:
- return AlignCenter;
+ return Display;
case Tabular::LYX_LONGTABULAR_ALIGN_RIGHT:
- return AlignRight;
+ return Display | AlignRight;
default:
- return AlignCenter;
+ return Display;
}
} else
return Inline;
}
-docstring InsetTabular::xhtml(XHTMLStream & xs, OutputParams const & rp) const
+docstring InsetTabular::xhtml(XMLStream & xs, OutputParams const & rp) const
{
return tabular.xhtml(xs, rp);
}
paste_tabular.reset(new Tabular(tabular));
for (row_type r = 0; r < rs; ++r)
- paste_tabular->deleteRow(0);
+ paste_tabular->deleteRow(0, true);
row_type const rows = re - rs + 1;
while (paste_tabular->nrows() > rows)
- paste_tabular->deleteRow(rows);
+ paste_tabular->deleteRow(rows, true);
for (col_type c = 0; c < cs; ++c)
- paste_tabular->deleteColumn(0);
+ paste_tabular->deleteColumn(0, true);
col_type const columns = ce - cs + 1;
while (paste_tabular->ncols() > columns)
- paste_tabular->deleteColumn(columns);
+ paste_tabular->deleteColumn(columns, true);
paste_tabular->setBuffer(tabular.buffer());
// FIXME?: why do we need to do this explicitly? (EL)
tabular.cellInset(r2, c2)->setBuffer(tabular.buffer());
- // FIXME: change tracking (MG)
- inset->setChange(Change(buffer().params().track_changes ?
+ if (!lyxrc.ct_markup_copied) {
+ // do not paste deleted text
+ inset->acceptChanges();
+ inset->setChange(Change(buffer().params().track_changes ?
Change::INSERTED : Change::UNCHANGED));
+ }
cur.pos() = 0;
cur.pit() = 0;
}
projects / lyx.git / blobdiff