* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author Jürgen Vigna
* \author Lars Gullik Bjønnes
* \author Matthias Ettrich
* \author José Matos
#include "Buffer.h"
#include "BufferParams.h"
#include "BufferView.h"
-#include "Color.h"
#include "CoordCache.h"
#include "Counters.h"
#include "Cursor.h"
#include "CutAndPaste.h"
-#include "debug.h"
#include "DispatchResult.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
-#include "gettext.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "Lexer.h"
+#include "LyXFunc.h"
+#include "LyXRC.h"
#include "MetricsInfo.h"
#include "OutputParams.h"
#include "paragraph_funcs.h"
#include "Paragraph.h"
#include "ParagraphParameters.h"
#include "ParIterator.h"
+#include "TextClass.h"
#include "TextMetrics.h"
-#include "Undo.h"
-
-#include "support/convert.h"
-#include "support/lstrings.h"
#include "frontends/alert.h"
#include "frontends/Clipboard.h"
#include "frontends/Painter.h"
#include "frontends/Selection.h"
+
+#include "support/convert.h"
+#include "support/debug.h"
+#include "support/docstream.h"
+#include "support/FileName.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
+
+#include <boost/scoped_ptr.hpp>
+
#include <sstream>
#include <iostream>
#include <limits>
+#include <cstring>
-using std::abs;
-using std::endl;
-using std::getline;
-using std::istream;
-using std::istringstream;
-using std::max;
-using std::ostream;
-using std::ostringstream;
-using std::string;
-using std::swap;
-using std::vector;
-
-#ifndef CXX_GLOBAL_CSTD
-using std::strlen;
-#endif
+using namespace std;
+using namespace lyx::support;
using boost::shared_ptr;
using boost::dynamic_pointer_cast;
namespace lyx {
-using support::prefixIs;
-using support::ltrim;
-using support::rtrim;
-using support::suffixIs;
-
using cap::dirtyTabularStack;
using cap::tabularStackDirty;
namespace {
-int const ADD_TO_HEIGHT = 2;
-int const ADD_TO_TABULAR_WIDTH = 2;
-int const default_line_space = 10;
-int const WIDTH_OF_LINE = 5;
+int const ADD_TO_HEIGHT = 2; // in cell
+int const ADD_TO_TABULAR_WIDTH = 6; // horiz space before and after the table
+int const default_line_space = 10; // ?
+int const WIDTH_OF_LINE = 5; // space between double lines
///
{ Tabular::VALIGN_TOP, "valign-top" },
{ Tabular::VALIGN_BOTTOM, "valign-bottom" },
{ Tabular::VALIGN_MIDDLE, "valign-middle" },
- { Tabular::M_TOGGLE_LINE_TOP, "m-toggle-line-top" },
- { Tabular::M_TOGGLE_LINE_BOTTOM, "m-toggle-line-bottom" },
- { Tabular::M_TOGGLE_LINE_LEFT, "m-toggle-line-left" },
- { Tabular::M_TOGGLE_LINE_RIGHT, "m-toggle-line-right" },
{ Tabular::M_ALIGN_LEFT, "m-align-left" },
{ Tabular::M_ALIGN_RIGHT, "m-align-right" },
{ Tabular::M_ALIGN_CENTER, "m-align-center" },
{ Tabular::SET_TOP_SPACE, "set-top-space" },
{ Tabular::SET_BOTTOM_SPACE, "set-bottom-space" },
{ Tabular::SET_INTERLINE_SPACE, "set-interline-space" },
+ { Tabular::SET_BORDER_LINES, "set-border-lines" },
{ Tabular::LAST_ACTION, "" }
};
-class FeatureEqual : public std::unary_function<TabularFeature, bool> {
+class FeatureEqual : public unary_function<TabularFeature, bool> {
public:
FeatureEqual(Tabular::Feature feature)
: feature_(feature) {}
{
ret.erase();
size_t token_length = strlen(token);
- string::size_type pos = str.find(token);
+ size_t pos = str.find(token);
if (pos == string::npos || pos + token_length + 1 >= str.length()
|| str[pos + token_length] != '=')
{
TabularFeature * end = tabularFeature +
sizeof(tabularFeature) / sizeof(TabularFeature);
- TabularFeature * it = std::find_if(tabularFeature, end,
+ TabularFeature * it = find_if(tabularFeature, end,
FeatureEqual(feature));
return (it == end) ? string() : it->feature;
}
/////////////////////////////////////////////////////////////////////
-Tabular::cellstruct::cellstruct(BufferParams const & bp)
+Tabular::CellData::CellData(Buffer const & buf, Tabular const & table)
: cellno(0),
width(0),
multicolumn(Tabular::CELL_NORMAL),
alignment(LYX_ALIGN_CENTER),
valignment(LYX_VALIGN_TOP),
- top_line(true),
+ top_line(false),
bottom_line(false),
- left_line(true),
+ left_line(false),
right_line(false),
usebox(BOX_NONE),
rotate(false),
- inset(new InsetText(bp))
-{}
+ inset(new InsetTableCell(buf, this, &table))
+{
+ inset->setBuffer(const_cast<Buffer &>(buf));
+ inset->paragraphs().back().setLayout(buf.params().documentClass().emptyLayout());
+}
-Tabular::cellstruct::cellstruct(cellstruct const & cs)
+Tabular::CellData::CellData(CellData const & cs)
: cellno(cs.cellno),
width(cs.width),
multicolumn(cs.multicolumn),
rotate(cs.rotate),
align_special(cs.align_special),
p_width(cs.p_width),
- inset(dynamic_cast<InsetText*>(cs.inset->clone()))
-{}
+ inset(dynamic_cast<InsetTableCell *>(cs.inset->clone()))
+{
+ inset->setCellData(this);
+}
-Tabular::cellstruct & Tabular::cellstruct::operator=(cellstruct cs)
+Tabular::CellData & Tabular::CellData::operator=(CellData cs)
{
swap(cs);
return *this;
}
-void Tabular::cellstruct::swap(cellstruct & rhs)
+void Tabular::CellData::swap(CellData & rhs)
{
std::swap(cellno, rhs.cellno);
std::swap(width, rhs.width);
}
-Tabular::rowstruct::rowstruct()
+Tabular::RowData::RowData()
: ascent(0),
descent(0),
- top_line(true),
- bottom_line(false),
top_space_default(false),
bottom_space_default(false),
interline_space_default(false),
{}
-Tabular::columnstruct::columnstruct()
+Tabular::ColumnData::ColumnData()
: alignment(LYX_ALIGN_CENTER),
valignment(LYX_VALIGN_TOP),
- left_line(true),
- right_line(false),
width(0)
{
}
}
-Tabular::Tabular(BufferParams const & bp, row_type rows_arg,
- col_type columns_arg)
+Tabular::Tabular(Buffer const & buffer, row_type rows_arg, col_type columns_arg)
{
- init(bp, rows_arg, columns_arg);
+ init(buffer, rows_arg, columns_arg);
}
// activates all lines and sets all widths to 0
-void Tabular::init(BufferParams const & bp, row_type rows_arg,
+void Tabular::init(Buffer const & buf, row_type rows_arg,
col_type columns_arg)
{
+ buffer_ = &buf;
row_info = row_vector(rows_arg);
column_info = column_vector(columns_arg);
- cell_info = cell_vvector(rows_arg, cell_vector(columns_arg, cellstruct(bp)));
+ cell_info = cell_vvector(rows_arg, cell_vector(columns_arg, CellData(buf, *this)));
row_info.reserve(10);
column_info.reserve(10);
cell_info.reserve(100);
fixCellNums();
- for (row_type i = 0; i < rows_arg; ++i)
- cell_info[i].back().right_line = true;
- row_info.back().bottom_line = true;
- row_info.front().bottom_line = true;
- column_info.back().right_line = true;
is_long_tabular = false;
rotate = false;
use_booktabs = false;
+ // set silly default lines
+ for (row_type i = 0; i < rowCount(); ++i)
+ for (col_type j = 0; j < columnCount(); ++j) {
+ cell_info[i][j].top_line = true;
+ cell_info[i][j].left_line = true;
+ cell_info[i][j].bottom_line = i == 0 || i == rowCount() - 1;
+ cell_info[i][j].right_line = j == columnCount() - 1;
+ }
}
void Tabular::fixCellNums()
{
idx_type cellno = 0;
- for (row_type i = 0; i < rowCount(); ++i) {
- for (col_type j = 0; j < columnCount(); ++j) {
- // When debugging it can be nice to set
- // this to true.
- cell_info[i][j].inset->setDrawFrame(false);
+ for (row_type i = 0; i < rowCount(); ++i)
+ for (col_type j = 0; j < columnCount(); ++j)
cell_info[i][j].cellno = cellno++;
- }
- cell_info[i].back().right_line = true;
- }
updateIndexes();
}
-void Tabular::appendRow(BufferParams const & bp, idx_type const cell)
+void Tabular::appendRow(idx_type const cell)
{
+ BufferParams const & bp = buffer().params();
row_type const row = cellRow(cell);
row_vector::iterator rit = row_info.begin() + row;
- row_info.insert(rit, rowstruct());
+ row_info.insert(rit, RowData());
// now set the values of the row before
row_info[row] = row_info[row + 1];
for (row_type i = 0; i < nrows - 1; ++i)
swap(cell_info[i], old[i]);
- cell_info = cell_vvector(nrows, cell_vector(ncols, cellstruct(bp)));
+ cell_info = cell_vvector(nrows, cell_vector(ncols, CellData(buffer(), *this)));
for (row_type i = 0; i <= row; ++i)
swap(cell_info[i], old[i]);
}
-void Tabular::copyRow(BufferParams const & bp, row_type const row)
+void Tabular::copyRow(row_type const row)
{
row_info.insert(row_info.begin() + row, row_info[row]);
cell_info.insert(cell_info.begin() + row, cell_info[row]);
- if (bp.trackChanges)
+ if (buffer().params().trackChanges)
for (col_type j = 0; j < columnCount(); ++j)
cell_info[row + 1][j].inset->setChange(Change(Change::INSERTED));
}
-void Tabular::appendColumn(BufferParams const & bp, idx_type const cell)
+void Tabular::appendColumn(idx_type const cell)
{
col_type const column = cellColumn(cell);
- col_type const ncols = columnCount();
column_vector::iterator cit = column_info.begin() + column + 1;
- column_info.insert(cit, columnstruct());
+ column_info.insert(cit, ColumnData());
+ col_type const ncols = columnCount();
// set the column values of the column before
column_info[column + 1] = column_info[column];
for (row_type i = 0; i < rowCount(); ++i) {
- cell_info[i].insert(cell_info[i].begin() + column + 1, cellstruct(bp));
-
- // care about multicolumns
- if (cell_info[i][column + 1].multicolumn == CELL_BEGIN_OF_MULTICOLUMN)
- cell_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
-
- if (column + 2 >= ncols
- || cell_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN)
- cell_info[i][column + 1].multicolumn = Tabular::CELL_NORMAL;
+ cell_info[i].insert(cell_info[i].begin() + column + 1, CellData(buffer(), *this));
+ col_type c = column + 2;
+ while (c < ncols
+ && cell_info[i][c].multicolumn == CELL_PART_OF_MULTICOLUMN) {
+ cell_info[i][c].multicolumn = CELL_NORMAL;
+ ++c;
+ }
}
//++column;
for (row_type i = 0; i < rowCount(); ++i) {
cell_info[i][column + 1].inset->clear();
- if (bp.trackChanges)
+ if (buffer().params().trackChanges)
cell_info[i][column + 1].inset->setChange(Change(Change::INSERTED));
}
fixCellNums();
}
-void Tabular::copyColumn(BufferParams const & bp, col_type const column)
+void Tabular::copyColumn(col_type const column)
{
+ BufferParams const & bp = buffer().params();
column_info.insert(column_info.begin() + column, column_info[column]);
for (row_type i = 0; i < rowCount(); ++i)
for (row_type row = 0; row < rowCount(); ++row) {
for (col_type column = 0; column < columnCount(); ++column) {
if (cell_info[row][column].multicolumn
- != Tabular::CELL_PART_OF_MULTICOLUMN)
+ != CELL_PART_OF_MULTICOLUMN)
++numberofcells;
BOOST_ASSERT(numberofcells != 0);
cell_info[row][column].cellno =
do {
++column;
} while (column < columnCount() &&
- cell_info[row][column].multicolumn
- == Tabular::CELL_PART_OF_MULTICOLUMN);
+ cell_info[row][column].multicolumn
+ == Tabular::CELL_PART_OF_MULTICOLUMN);
if (column == columnCount()) {
column = 0;
}
-bool Tabular::topLine(idx_type const cell, bool const wholerow) const
+bool Tabular::topLine(idx_type const cell) const
{
- if (!wholerow && isMultiColumn(cell) &&
- !(use_booktabs && cellRow(cell) == 0))
- return cellinfo_of_cell(cell).top_line;
- return row_info[cellRow(cell)].top_line;
+ return cellinfo_of_cell(cell).top_line;
}
-bool Tabular::bottomLine(idx_type const cell, bool wholerow) const
+bool Tabular::bottomLine(idx_type const cell) const
{
- if (!wholerow && isMultiColumn(cell) &&
- !(use_booktabs && isLastRow(cell)))
- return cellinfo_of_cell(cell).bottom_line;
- return row_info[cellRow(cell)].bottom_line;
+ return cellinfo_of_cell(cell).bottom_line;
}
-bool Tabular::leftLine(idx_type cell, bool wholecolumn) const
+bool Tabular::leftLine(idx_type cell) const
{
if (use_booktabs)
return false;
- if (!wholecolumn && isMultiColumn(cell) &&
- (isFirstCellInRow(cell) || isMultiColumn(cell-1)))
- return cellinfo_of_cell(cell).left_line;
- return column_info[cellColumn(cell)].left_line;
+ return cellinfo_of_cell(cell).left_line;
}
-bool Tabular::rightLine(idx_type cell, bool wholecolumn) const
+bool Tabular::rightLine(idx_type cell) const
{
if (use_booktabs)
return false;
- if (!wholecolumn && isMultiColumn(cell) &&
- (isLastCellInRow(cell) || isMultiColumn(cell + 1)))
- return cellinfo_of_cell(cell).right_line;
- return column_info[cellRightColumn(cell)].right_line;
+ return cellinfo_of_cell(cell).right_line;
}
bool Tabular::topAlreadyDrawn(idx_type cell) const
{
row_type row = cellRow(cell);
- if (row > 0 && !getAdditionalHeight(row)) {
- col_type column = cellColumn(cell);
- --row;
- while (column
- && cell_info[row][column].multicolumn
- == Tabular::CELL_PART_OF_MULTICOLUMN)
- --column;
- if (cell_info[row][column].multicolumn == Tabular::CELL_NORMAL)
- return row_info[row].bottom_line;
- else
- return cell_info[row][column].bottom_line;
- }
- return false;
+ if (row == 0)
+ return false;
+ idx_type i = cellIndex(row - 1, cellColumn(cell));
+ return !rowBottomLine(row - 1) && bottomLine(i);
}
bool Tabular::leftAlreadyDrawn(idx_type cell) const
{
- col_type column = cellColumn(cell);
- if (column > 0) {
- row_type row = cellRow(cell);
- while (--column &&
- (cell_info[row][column].multicolumn ==
- Tabular::CELL_PART_OF_MULTICOLUMN)) { }
- if (getAdditionalWidth(cell_info[row][column].cellno))
- return false;
- return rightLine(cell_info[row][column].cellno);
- }
- return false;
+ col_type col = cellColumn(cell);
+ if (col == 0)
+ return false;
+ idx_type i = cellIndex(cellRow(cell), col - 1);
+ return !columnRightLine(col - 1) && rightLine(i);
}
if (!row || row >= rowCount())
return 0;
- bool top = true;
- bool bottom = true;
-
- for (col_type column = 0; column < columnCount() && bottom; ++column) {
- switch (cell_info[row - 1][column].multicolumn) {
- case Tabular::CELL_BEGIN_OF_MULTICOLUMN:
- bottom = cell_info[row - 1][column].bottom_line;
- break;
- case Tabular::CELL_NORMAL:
- bottom = row_info[row - 1].bottom_line;
- }
- }
- for (col_type column = 0; column < columnCount() && top; ++column) {
- switch (cell_info[row][column].multicolumn) {
- case Tabular::CELL_BEGIN_OF_MULTICOLUMN:
- top = cell_info[row][column].top_line;
- break;
- case Tabular::CELL_NORMAL:
- top = row_info[row].top_line;
- }
- }
int const interline_space = row_info[row - 1].interline_space_default ?
default_line_space :
row_info[row - 1].interline_space.inPixels(width());
- if (top && bottom)
+ if (rowTopLine(row) && rowBottomLine(row - 1))
return interline_space + WIDTH_OF_LINE;
return interline_space;
}
{
// internally already set in setCellWidth
// used to get it back in text.cpp
- col_type const col = cellRightColumn(cell);
- row_type const row = cellRow(cell);
- if (col < columnCount() - 1 && rightLine(cell) &&
- leftLine(cell_info[row][col+1].cellno)) // column_info[col+1].left_line)
- {
+ col_type c = cellColumn(cell);
+ if (c < columnCount() - 1
+ && columnRightLine(c) && columnLeftLine(c + 1)
+ && cellinfo_of_cell(cell).multicolumn == CELL_NORMAL)
return WIDTH_OF_LINE;
- }
return 0;
}
void Tabular::setCellWidth(idx_type cell, int new_width)
{
row_type const row = cellRow(cell);
- col_type const column1 = cellColumn(cell);
+ col_type const col = cellColumn(cell);
bool tmp = false;
int width = 0;
int add_width = 0;
- if (rightLine(cell_info[row][column1].cellno, true) &&
- column1 < columnCount() - 1 &&
- leftLine(cell_info[row][column1+1].cellno, true))
- {
+ if (col < columnCount() - 1 && columnRightLine(col) &&
+ columnLeftLine(col + 1)) {
add_width = WIDTH_OF_LINE;
}
tmp = setWidthOfMulticolCell(cell, new_width);
} else {
width = new_width + 2 * WIDTH_OF_LINE + add_width;
- cell_info[row][column1].width = width;
- tmp = calculate_width_of_column_NMC(column1);
+ cell_info[row][col].width = width;
+ tmp = calculate_width_of_column_NMC(col);
if (tmp)
- recalculateMulticolumnsOfColumn(column1);
+ recalculateMulticolumnsOfColumn(col);
}
if (tmp) {
for (col_type i = 0; i < columnCount(); ++i)
* merge cell paragraphs and reset layout to standard for variable width
* cells.
*/
-void toggleFixedWidth(Cursor & cur, InsetText * inset, bool fixedWidth)
+void toggleFixedWidth(Cursor & cur, InsetTableCell * inset, bool fixedWidth)
{
inset->setAutoBreakRows(fixedWidth);
if (fixedWidth)
cur.push(*inset);
// undo information has already been recorded
inset->getText(0)->setLayout(cur.bv().buffer(), 0, cur.lastpit() + 1,
- bp.getTextClass().defaultLayoutName());
+ bp.documentClass().emptyLayoutName());
cur.pop();
}
}
-void Tabular::setTopLine(idx_type cell, bool line, bool wholerow)
+void Tabular::setTopLine(idx_type i, bool line)
{
- row_type const row = cellRow(cell);
- if (wholerow || !isMultiColumn(cell))
- row_info[row].top_line = line;
- else
- cellinfo_of_cell(cell).top_line = line;
+ cellinfo_of_cell(i).top_line = line;
}
-void Tabular::setBottomLine(idx_type cell, bool line, bool wholerow)
+void Tabular::setBottomLine(idx_type i, bool line)
{
- if (wholerow || !isMultiColumn(cell))
- row_info[cellRow(cell)].bottom_line = line;
- else
- cellinfo_of_cell(cell).bottom_line = line;
+ cellinfo_of_cell(i).bottom_line = line;
}
-void Tabular::setLeftLine(idx_type cell, bool line, bool wholecolumn)
+void Tabular::setLeftLine(idx_type cell, bool line)
{
- if (wholecolumn || !isMultiColumn(cell))
- column_info[cellColumn(cell)].left_line = line;
- else
- cellinfo_of_cell(cell).left_line = line;
+ cellinfo_of_cell(cell).left_line = line;
}
-void Tabular::setRightLine(idx_type cell, bool line, bool wholecolumn)
+void Tabular::setRightLine(idx_type cell, bool line)
{
- if (wholecolumn || !isMultiColumn(cell))
- column_info[cellRightColumn(cell)].right_line = line;
- else
- cellinfo_of_cell(cell).right_line = line;
+ cellinfo_of_cell(cell).right_line = line;
+}
+
+bool Tabular::rowTopLine(row_type r) const
+{
+ idx_type i0 = getFirstCellInRow(r);
+ idx_type i1 = getLastCellInRow(r);
+ bool all_rows_set = true;
+ for (idx_type j = i0; all_rows_set && j <= i1; ++j)
+ all_rows_set = cellinfo_of_cell(j).top_line;
+ return all_rows_set;
+}
+
+
+bool Tabular::rowBottomLine(row_type r) const
+{
+ idx_type i0 = getFirstCellInRow(r);
+ idx_type i1 = getLastCellInRow(r);
+ bool all_rows_set = true;
+ for (idx_type j = i0; all_rows_set && j <= i1; ++j)
+ all_rows_set = cellinfo_of_cell(j).bottom_line;
+ return all_rows_set;
+}
+
+
+bool Tabular::columnLeftLine(col_type c) const
+{
+ bool all_cols_set = true;
+ row_type nrows = rowCount();
+ for (row_type r = 0; all_cols_set && r < nrows; ++r) {
+ idx_type i = cellIndex(r, c);
+ if (columnSpan(i) == 1)
+ all_cols_set = cellinfo_of_cell(i).left_line;
+ }
+ return all_cols_set;
+}
+
+
+bool Tabular::columnRightLine(col_type c) const
+{
+ bool all_cols_set = true;
+ row_type nrows = rowCount();
+ for (row_type r = 0; all_cols_set && r < nrows; ++r) {
+ idx_type i = cellIndex(r, c);
+ if (c == cellColumn(i) + columnSpan(i) - 1)
+ all_cols_set = cellinfo_of_cell(i).right_line;
+ }
+ return all_cols_set;
}
row_type const row = cellRow(cell);
col_type column = cellColumn(cell);
while (column < columnCount() - 1 &&
- cell_info[row][column + 1].multicolumn == Tabular::CELL_PART_OF_MULTICOLUMN)
+ cell_info[row][column + 1].multicolumn == CELL_PART_OF_MULTICOLUMN)
++column;
return column;
}
-void Tabular::write(Buffer const & buf, ostream & os) const
+void Tabular::write(ostream & os) const
{
// header line
os << "<lyxtabular"
os << "<column"
<< write_attribute("alignment", column_info[j].alignment)
<< write_attribute("valignment", column_info[j].valignment)
- << write_attribute("leftline", column_info[j].left_line)
- << write_attribute("rightline", column_info[j].right_line)
<< write_attribute("width", column_info[j].p_width.asString())
<< write_attribute("special", column_info[j].align_special)
<< ">\n";
}
for (row_type i = 0; i < rowCount(); ++i) {
- os << "<row"
- << write_attribute("topline", row_info[i].top_line)
- << write_attribute("bottomline", row_info[i].bottom_line);
static const string def("default");
+ os << "<row";
if (row_info[i].top_space_default)
os << write_attribute("topspace", def);
else
<< write_attribute("special", cell_info[i][j].align_special)
<< ">\n";
os << "\\begin_inset ";
- cell_info[i][j].inset->write(buf, os);
+ cell_info[i][j].inset->write(os);
os << "\n\\end_inset\n"
<< "</cell>\n";
}
}
-void Tabular::read(Buffer const & buf, Lexer & lex)
+void Tabular::read(Lexer & lex)
{
string line;
istream & is = lex.getStream();
l_getline(is, line);
- if (!prefixIs(line, "<lyxtabular ")
- && !prefixIs(line, "<Tabular ")) {
+ if (!prefixIs(line, "<lyxtabular ") && !prefixIs(line, "<Tabular ")) {
BOOST_ASSERT(false);
return;
}
int columns_arg;
if (!getTokenValue(line, "columns", columns_arg))
return;
- init(buf.params(), rows_arg, columns_arg);
+ init(buffer(), rows_arg, columns_arg);
l_getline(is, line);
if (!prefixIs(line, "<features")) {
lyxerr << "Wrong tabular format (expected <features ...> got"
}
getTokenValue(line, "alignment", column_info[j].alignment);
getTokenValue(line, "valignment", column_info[j].valignment);
- getTokenValue(line, "leftline", column_info[j].left_line);
- getTokenValue(line, "rightline", column_info[j].right_line);
getTokenValue(line, "width", column_info[j].p_width);
getTokenValue(line, "special", column_info[j].align_special);
}
<< line << ')' << endl;
return;
}
- getTokenValue(line, "topline", row_info[i].top_line);
- getTokenValue(line, "bottomline", row_info[i].bottom_line);
getTokenValue(line, "topspace", row_info[i].top_space,
row_info[i].top_space_default);
getTokenValue(line, "bottomspace", row_info[i].bottom_space,
getTokenValue(line, "special", cell_info[i][j].align_special);
l_getline(is, line);
if (prefixIs(line, "\\begin_inset")) {
- cell_info[i][j].inset->read(buf, lex);
+ cell_info[i][j].inset->read(lex);
l_getline(is, line);
}
if (!prefixIs(line, "</cell>")) {
bool Tabular::isMultiColumn(idx_type cell) const
{
- return cellinfo_of_cell(cell).multicolumn != Tabular::CELL_NORMAL;
+ return cellinfo_of_cell(cell).multicolumn != CELL_NORMAL;
}
bool Tabular::isMultiColumnReal(idx_type cell) const
{
return cellColumn(cell) != cellRightColumn(cell) &&
- cellinfo_of_cell(cell).multicolumn != Tabular::CELL_NORMAL;
+ cellinfo_of_cell(cell).multicolumn != CELL_NORMAL;
}
-Tabular::cellstruct & Tabular::cellinfo_of_cell(idx_type cell) const
+Tabular::CellData & Tabular::cellinfo_of_cell(idx_type cell) const
{
return cell_info[cellRow(cell)][cellColumn(cell)];
}
-void Tabular::setMultiColumn(Buffer * buffer, idx_type cell,
- idx_type number)
+void Tabular::setMultiColumn(idx_type cell, idx_type number)
{
- cellstruct & cs = cellinfo_of_cell(cell);
+ CellData & cs = cellinfo_of_cell(cell);
cs.multicolumn = CELL_BEGIN_OF_MULTICOLUMN;
cs.alignment = column_info[cellColumn(cell)].alignment;
- cs.top_line = row_info[cellRow(cell)].top_line;
- cs.bottom_line = row_info[cellRow(cell)].bottom_line;
- cs.left_line = column_info[cellColumn(cell)].left_line;
- cs.right_line = column_info[cellColumn(cell+number-1)].right_line;
for (idx_type i = 1; i < number; ++i) {
- cellstruct & cs1 = cellinfo_of_cell(cell + i);
+ CellData & cs1 = cellinfo_of_cell(cell + i);
cs1.multicolumn = CELL_PART_OF_MULTICOLUMN;
- cs.inset->appendParagraphs(buffer, cs1.inset->paragraphs());
+ cs.inset->appendParagraphs(cs1.inset->paragraphs());
cs1.inset->clear();
}
+ setRightLine(cell, rightLine(cell + number - 1));
updateIndexes();
}
-Tabular::idx_type Tabular::cells_in_multicolumn(idx_type cell) const
+Tabular::idx_type Tabular::columnSpan(idx_type cell) const
{
row_type const row = cellRow(cell);
col_type column = cellColumn(cell);
}
-Tabular::idx_type Tabular::getLastCellAbove(idx_type cell) const
-{
- if (cellRow(cell) == 0)
- return cell;
- if (!isMultiColumn(cell))
- return getCellAbove(cell);
- return cell_info[cellRow(cell) - 1][cellRightColumn(cell)].cellno;
-}
-
-
-Tabular::idx_type Tabular::getLastCellBelow(idx_type cell) const
-{
- if (cellRow(cell) + 1 >= rowCount())
- return cell;
- if (!isMultiColumn(cell))
- return getCellBelow(cell);
- return cell_info[cellRow(cell) + 1][cellRightColumn(cell)].cellno;
-}
-
-
Tabular::idx_type Tabular::cellIndex(row_type row,
col_type column) const
{
++tmp;
}
if (use_booktabs && row == 0) {
- os << "\\toprule ";
+ if (topLine(fcell))
+ os << "\\toprule ";
} else if (tmp == n - fcell) {
os << (use_booktabs ? "\\midrule " : "\\hline ");
} else if (tmp) {
++tmp;
}
if (use_booktabs && row == rowCount() - 1) {
- os << "\\bottomrule";
+ if (bottomLine(fcell))
+ os << "\\bottomrule";
} else if (tmp == n - fcell) {
os << (use_booktabs ? "\\midrule" : "\\hline");
} else if (tmp) {
os << "\\begin{sideways}\n";
++ret;
}
- if (isMultiColumn(cell)) {
- os << "\\multicolumn{" << cells_in_multicolumn(cell) << "}{";
- if (leftLine(cell) &&
- (isFirstCellInRow(cell) ||
- (!isMultiColumn(cell - 1) && !leftLine(cell, true) &&
- !rightLine(cell - 1, true))))
+ Tabular::VAlignment valign = getVAlignment(cell, !isMultiColumn(cell));
+ LyXAlignment align = getAlignment(cell, !isMultiColumn(cell));
+ col_type c = cellColumn(cell);
+ if (isMultiColumn(cell)
+ || (leftLine(cell) && !columnLeftLine(c))
+ || (rightLine(cell) && !columnRightLine(c))) {
+ os << "\\multicolumn{" << columnSpan(cell) << "}{";
+ if (leftLine(cell))
os << '|';
if (!cellinfo_of_cell(cell).align_special.empty()) {
os << cellinfo_of_cell(cell).align_special;
} else {
if (!getPWidth(cell).zero()) {
- switch (getVAlignment(cell)) {
+ switch (valign) {
case LYX_VALIGN_TOP:
os << 'p';
break;
<< from_ascii(getPWidth(cell).asLatexString())
<< '}';
} else {
- switch (getAlignment(cell)) {
+ switch (align) {
case LYX_ALIGN_LEFT:
os << 'l';
break;
} // end if else !cellinfo_of_cell
if (rightLine(cell))
os << '|';
- if (((cell + 1) < cellCount()) && !isFirstCellInRow(cell+1) &&
- leftLine(cell+1))
- os << '|';
os << "}{";
}
if (getUsebox(cell) == BOX_PARBOX) {
os << "\\parbox[";
- switch (getVAlignment(cell)) {
+ switch (valign) {
case LYX_VALIGN_TOP:
os << 't';
break;
<< "}{";
} else if (getUsebox(cell) == BOX_MINIPAGE) {
os << "\\begin{minipage}[";
- switch (getVAlignment(cell)) {
+ switch (valign) {
case LYX_VALIGN_TOP:
os << 't';
break;
os << "%\n\\end{minipage}";
ret += 2;
}
- if (isMultiColumn(cell)) {
+ col_type c = cellColumn(cell);
+ if (isMultiColumn(cell)
+ || (leftLine(cell) && !columnLeftLine(c))
+ || (rightLine(cell) && !columnRightLine(c))) {
os << '}';
}
if (getRotateCell(cell)) {
}
-int Tabular::TeXLongtableHeaderFooter(odocstream & os, Buffer const & buf,
+int Tabular::TeXLongtableHeaderFooter(odocstream & os,
OutputParams const & runparams) const
{
if (!is_long_tabular)
}
for (row_type i = 0; i < rowCount(); ++i) {
if (row_info[i].endhead) {
- ret += TeXRow(os, i, buf, runparams);
+ ret += TeXRow(os, i, runparams);
}
}
if (endhead.bottomDL) {
}
for (row_type i = 0; i < rowCount(); ++i) {
if (row_info[i].endfirsthead) {
- ret += TeXRow(os, i, buf, runparams);
+ ret += TeXRow(os, i, runparams);
}
}
if (endfirsthead.bottomDL) {
}
for (row_type i = 0; i < rowCount(); ++i) {
if (row_info[i].endfoot) {
- ret += TeXRow(os, i, buf, runparams);
+ ret += TeXRow(os, i, runparams);
}
}
if (endfoot.bottomDL) {
}
for (row_type i = 0; i < rowCount(); ++i) {
if (row_info[i].endlastfoot) {
- ret += TeXRow(os, i, buf, runparams);
+ ret += TeXRow(os, i, runparams);
}
}
if (endlastfoot.bottomDL) {
}
-int Tabular::TeXRow(odocstream & os, row_type i, Buffer const & buf,
+int Tabular::TeXRow(odocstream & os, row_type i,
OutputParams const & runparams) const
{
idx_type cell = cellIndex(i, 0);
if (isPartOfMultiColumn(i, j))
continue;
ret += TeXCellPreamble(os, cell);
- shared_ptr<InsetText> inset = getCellInset(cell);
+ shared_ptr<InsetTableCell> inset = getCellInset(cell);
Paragraph const & par = inset->paragraphs().front();
- bool rtl = par.isRTL(buf.params())
+ bool rtl = par.isRTL(buffer().params())
&& !par.empty()
&& getPWidth(cell).zero();
if (rtl) {
- if (par.getParLanguage(buf.params())->lang() ==
+ if (par.getParLanguage(buffer().params())->lang() ==
"farsi")
os << "\\textFR{";
- else if (par.getParLanguage(buf.params())->lang() == "arabic_arabi")
+ else if (par.getParLanguage(buffer().params())->lang() == "arabic_arabi")
os << "\\textAR{";
// currently, remaning RTL languages are arabic_arabtex and hebrew
else
os << "\\R{";
}
- ret += inset->latex(buf, os, runparams);
+ ret += inset->latex(os, runparams);
if (rtl)
os << '}';
}
-int Tabular::latex(Buffer const & buf, odocstream & os,
- OutputParams const & runparams) const
+int Tabular::latex(odocstream & os, OutputParams const & runparams) const
{
int ret = 0;
os << "\\begin{longtable}{";
else
os << "\\begin{tabular}{";
+
for (col_type i = 0; i < columnCount(); ++i) {
- if (!use_booktabs && column_info[i].left_line)
+ if (!use_booktabs && columnLeftLine(i))
os << '|';
if (!column_info[i].align_special.empty()) {
os << column_info[i].align_special;
}
} // end if else !column_info[i].p_width
} // end if else !column_info[i].align_special
- if (!use_booktabs && column_info[i].right_line)
+ if (!use_booktabs && columnRightLine(i))
os << '|';
}
os << "}\n";
++ret;
- ret += TeXLongtableHeaderFooter(os, buf, runparams);
+ ret += TeXLongtableHeaderFooter(os, runparams);
//+---------------------------------------------------------------------
//+ the single row and columns (cells) +
for (row_type i = 0; i < rowCount(); ++i) {
if (isValidRow(i)) {
- ret += TeXRow(os, i, buf, runparams);
+ ret += TeXRow(os, i, runparams);
if (is_long_tabular && row_info[i].newpage) {
os << "\\newpage\n";
++ret;
}
-int Tabular::docbookRow(Buffer const & buf, odocstream & os, row_type row,
+int Tabular::docbookRow(odocstream & os, row_type row,
OutputParams const & runparams) const
{
int ret = 0;
if (isMultiColumn(cell)) {
os << " namest=\"col" << j << "\" ";
- os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< '"';
+ os << "nameend=\"col" << j + columnSpan(cell) - 1<< '"';
}
os << '>';
- ret += getCellInset(cell)->docbook(buf, os, runparams);
+ ret += getCellInset(cell)->docbook(os, runparams);
os << "</entry>\n";
++cell;
}
}
-int Tabular::docbook(Buffer const & buf, odocstream & os,
- OutputParams const & runparams) const
+int Tabular::docbook(odocstream & os, OutputParams const & runparams) const
{
int ret = 0;
++ret;
for (row_type i = 0; i < rowCount(); ++i) {
if (row_info[i].endhead || row_info[i].endfirsthead) {
- ret += docbookRow(buf, os, i, runparams);
+ ret += docbookRow(os, i, runparams);
}
}
os << "</thead>\n";
++ret;
for (row_type i = 0; i < rowCount(); ++i) {
if (row_info[i].endfoot || row_info[i].endlastfoot) {
- ret += docbookRow(buf, os, i, runparams);
+ ret += docbookRow(os, i, runparams);
}
}
os << "</tfoot>\n";
++ret;
for (row_type i = 0; i < rowCount(); ++i) {
if (isValidRow(i)) {
- ret += docbookRow(buf, os, i, runparams);
+ ret += docbookRow(os, i, runparams);
}
}
os << "</tbody>\n";
}
-void Tabular::plaintextPrintCell(Buffer const & buf, odocstream & os,
+void Tabular::plaintextPrintCell(odocstream & os,
OutputParams const & runparams,
idx_type cell, row_type row, col_type column,
vector<unsigned int> const & clen,
bool onlydata) const
{
odocstringstream sstr;
- getCellInset(cell)->plaintext(buf, sstr, runparams);
+ getCellInset(cell)->plaintext(sstr, runparams);
if (onlydata) {
os << sstr.str();
}
-void Tabular::plaintext(Buffer const & buf, odocstream & os,
+void Tabular::plaintext(odocstream & os,
OutputParams const & runparams, int const depth,
- bool onlydata, unsigned char delim) const
+ bool onlydata, char_type delim) const
{
// first calculate the width of the single columns
vector<unsigned int> clen(columnCount());
if (isMultiColumnReal(cell))
continue;
odocstringstream sstr;
- getCellInset(cell)->plaintext(buf, sstr, runparams);
+ getCellInset(cell)->plaintext(sstr, runparams);
if (clen[j] < sstr.str().length())
clen[j] = sstr.str().length();
}
if (!isMultiColumnReal(cell) || isPartOfMultiColumn(i, j))
continue;
odocstringstream sstr;
- getCellInset(cell)->plaintext(buf, sstr, runparams);
+ getCellInset(cell)->plaintext(sstr, runparams);
int len = int(sstr.str().length());
- idx_type const n = cells_in_multicolumn(cell);
+ idx_type const n = columnSpan(cell);
for (col_type k = j; len > 0 && k < j + n - 1; ++k)
len -= clen[k];
if (len > int(clen[j + n - 1]))
if (isPartOfMultiColumn(i, j))
continue;
if (onlydata && j > 0)
- os << delim;
- plaintextPrintCell(buf, os, runparams,
- cell, i, j, clen, onlydata);
+ // we don't use operator<< for single UCS4 character.
+ // see explanation in docstream.h
+ os.put(delim);
+ plaintextPrintCell(os, runparams, cell, i, j, clen, onlydata);
++cell;
}
os << endl;
}
-shared_ptr<InsetText> Tabular::getCellInset(idx_type cell) const
+shared_ptr<InsetTableCell> Tabular::getCellInset(idx_type cell) const
{
return cell_info[cellRow(cell)][cellColumn(cell)].inset;
}
-shared_ptr<InsetText> Tabular::getCellInset(row_type row,
+shared_ptr<InsetTableCell> Tabular::getCellInset(row_type row,
col_type column) const
{
return cell_info[row][column].inset;
void Tabular::setCellInset(row_type row, col_type column,
- shared_ptr<InsetText> ins) const
+ shared_ptr<InsetTableCell> ins) const
{
- cell_info[row][column].inset = ins;
+ CellData & cd = cell_info[row][column];
+ cd.inset = ins;
+ // reset the InsetTableCell's pointers
+ ins->setCellData(&cd);
+ ins->setTabular(this);
}
for (idx_type cell = 0, n = cellCount(); cell < n; ++cell)
if (getCellInset(cell).get() == inset) {
- LYXERR(Debug::INSETTEXT) << "Tabular::getCellFromInset: "
- << "cell=" << cell << endl;
+ LYXERR(Debug::INSETTEXT, "Tabular::getCellFromInset: "
+ << "cell=" << cell);
return cell;
}
/////////////////////////////////////////////////////////////////////
//
-// InsetTabular
+// InsetTableCell
//
/////////////////////////////////////////////////////////////////////
-InsetTabular::InsetTabular(Buffer const & buf, row_type rows,
- col_type columns)
- : tabular(buf.params(), max(rows, row_type(1)),
- max(columns, col_type(1))), buffer_(&buf), scx_(0)
+InsetTableCell::InsetTableCell(Buffer const & buf,
+ Tabular::CellData const * cell, Tabular const * table)
+ : InsetText(buf), cell_data_(cell), table_(table)
{}
-InsetTabular::InsetTabular(InsetTabular const & tab)
- : Inset(tab), tabular(tab.tabular),
- buffer_(tab.buffer_), scx_(0)
-{}
+bool InsetTableCell::forceEmptyLayout(idx_type) const
+{
+ BOOST_ASSERT(table_);
+ BOOST_ASSERT(cell_data_);
+ return table_->getPWidth(cell_data_->cellno).zero();
+}
+bool InsetTableCell::allowParagraphCustomization(idx_type) const
+{
+ BOOST_ASSERT(table_);
+ BOOST_ASSERT(cell_data_);
+ return !table_->getPWidth(cell_data_->cellno).zero();
+}
-InsetTabular::~InsetTabular()
+bool InsetTableCell::getStatus(Cursor & cur, FuncRequest const & cmd,
+ FuncStatus & status) const
{
- InsetTabularMailer(*this).hideDialog();
+ bool enabled;
+ switch (cmd.action) {
+ case LFUN_LAYOUT:
+ enabled = !forceEmptyLayout();
+ break;
+ case LFUN_LAYOUT_PARAGRAPH:
+ enabled = allowParagraphCustomization();
+ break;
+ default:
+ return InsetText::getStatus(cur, cmd, status);
+ }
+ status.enabled(enabled);
+ return true;
+}
+
+/////////////////////////////////////////////////////////////////////
+//
+// InsetTabular
+//
+/////////////////////////////////////////////////////////////////////
+
+InsetTabular::InsetTabular(Buffer const & buf, row_type rows,
+ col_type columns)
+ : tabular(buf, max(rows, row_type(1)), max(columns, col_type(1))), scx_(0)
+{
+ setBuffer(const_cast<Buffer &>(buf)); // FIXME: remove later
}
-Inset * InsetTabular::clone() const
+InsetTabular::InsetTabular(InsetTabular const & tab)
+ : Inset(tab), tabular(tab.tabular), scx_(0)
{
- return new InsetTabular(*this);
+ setBuffer(const_cast<Buffer &>(tab.buffer())); // FIXME: remove later
}
-Buffer const & InsetTabular::buffer() const
+InsetTabular::~InsetTabular()
{
- return *buffer_;
+ InsetTabularMailer(*this).hideDialog();
}
-void InsetTabular::buffer(Buffer const * b)
+bool InsetTabular::insetAllowed(InsetCode code) const
{
- buffer_ = b;
+ if (code == MATHMACRO_CODE)
+ return false;
+
+ return true;
}
-void InsetTabular::write(Buffer const & buf, ostream & os) const
+void InsetTabular::write(ostream & os) const
{
os << "Tabular" << endl;
- tabular.write(buf, os);
+ tabular.write(os);
}
-void InsetTabular::read(Buffer const & buf, Lexer & lex)
+void InsetTabular::read(Lexer & lex)
{
bool const old_format = (lex.getString() == "\\LyXTable");
- tabular.read(buf, lex);
+ tabular.read(lex);
if (old_format)
return;
}
+int InsetTabular::rowFromY(Cursor & cur, int y) const
+{
+ // top y coordinate of tabular
+ int h = yo(cur.bv()) - tabular.rowAscent(0);
+ size_t nrows = tabular.rowCount();
+ row_type r = 0;
+ for (;r < nrows && y > h; ++r) {
+ h += tabular.rowAscent(r);
+ h += tabular.rowDescent(r);
+ h += tabular.getAdditionalHeight(r);
+ }
+ return r - 1;
+}
+
+
+int InsetTabular::columnFromX(Cursor & cur, int x) const
+{
+ // left x coordinate of tabular
+ int w = xo(cur.bv()) + ADD_TO_TABULAR_WIDTH;
+ size_t ncols = tabular.columnCount();
+ col_type c = 0;
+ for (;c < ncols && x > w; ++c) {
+ w += tabular.columnWidth(c);
+ }
+ return c - 1;
+}
+
+
void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const
{
//lyxerr << "InsetTabular::metrics: " << mi.base.bv << " width: " <<
MetricsInfo m = mi;
Length p_width;
if (tabular.cell_info[i][j].multicolumn ==
- Tabular::CELL_BEGIN_OF_MULTICOLUMN)
+ Tabular::CELL_BEGIN_OF_MULTICOLUMN)
p_width = tabular.cellinfo_of_cell(cell).p_width;
else
p_width = tabular.column_info[j].p_width;
x += scx_;
x += ADD_TO_TABULAR_WIDTH;
+ bool const original_drawing_state = pi.pain.isDrawingEnabled();
+
idx_type idx = 0;
first_visible_cell = Tabular::npos;
for (row_type i = 0; i < tabular.rowCount(); ++i) {
pi.pain.setDrawingEnabled(false);
cell(idx)->draw(pi, cx, y);
drawCellLines(pi.pain, nx, y, i, idx, pi.erased_);
- pi.pain.setDrawingEnabled(true);
+ pi.pain.setDrawingEnabled(original_drawing_state);
} else {
cell(idx)->draw(pi, cx, y);
drawCellLines(pi.pain, nx, y, i, idx, pi.erased_);
if (!cur.selection())
return;
- if (!ptr_cmp(&cur.inset(), this))
+ if (&cur.inset() != this)
return;
//resetPos(cur);
int const w = tabular.columnWidth(cell);
if (i >= cs && i <= ce && j >= rs && j <= re)
pi.pain.fillRectangle(xx, y, w, h,
- Color::selection);
+ Color_selection);
xx += w;
}
y += h;
{
int x2 = x + tabular.columnWidth(cell);
bool on_off = false;
- Color::color col = Color::tabularline;
- Color::color onoffcol = Color::tabularonoffline;
+ ColorCode col = Color_tabularline;
+ ColorCode onoffcol = Color_tabularonoffline;
if (erased) {
- col = Color::deletedtext;
- onoffcol = Color::deletedtext;
+ col = Color_deletedtext;
+ onoffcol = Color_deletedtext;
}
if (!tabular.topAlreadyDrawn(cell)) {
}
-docstring const InsetTabular::editMessage() const
+docstring InsetTabular::editMessage() const
{
return _("Opened table");
}
-void InsetTabular::edit(Cursor & cur, bool left)
+void InsetTabular::edit(Cursor & cur, bool front, EntryDirection)
{
//lyxerr << "InsetTabular::edit: " << this << endl;
- finishUndo();
+ cur.finishUndo();
cur.selection() = false;
cur.push(*this);
- if (left) {
+ if (front) {
if (isRightToLeft(cur))
cur.idx() = tabular.getLastCellInRow(0);
else
}
-void InsetTabular::updateLabels(Buffer const & buf, ParIterator const & it)
+void InsetTabular::updateLabels(ParIterator const & it)
{
// In a longtable, tell captions what the current float is
- Counters & cnts = buf.params().getTextClass().counters();
+ Counters & cnts = buffer().params().documentClass().counters();
string const saveflt = cnts.current_float();
if (tabular.isLongTabular())
cnts.current_float("table");
it2.forwardPos();
size_t const end = it2.nargs();
for ( ; it2.idx() < end; it2.top().forwardIdx())
- lyx::updateLabels(buf, it2);
+ lyx::updateLabels(buffer(), it2);
//reset afterwards
if (tabular.isLongTabular())
void InsetTabular::doDispatch(Cursor & cur, FuncRequest & cmd)
{
- LYXERR(Debug::DEBUG) << "# InsetTabular::doDispatch: cmd: " << cmd
- << "\n cur:" << cur << endl;
+ LYXERR(Debug::DEBUG, "# InsetTabular::doDispatch: cmd: " << cmd
+ << "\n cur:" << cur);
CursorSlice sl = cur.top();
Cursor & bvcur = cur.bv().cursor();
switch (cmd.action) {
- case LFUN_MOUSE_PRESS:
+ case LFUN_MOUSE_PRESS: {
//lyxerr << "# InsetTabular::MousePress\n" << cur.bv().cursor() << endl;
+ // select row
+ if (cmd.x < xo(cur.bv()) + ADD_TO_TABULAR_WIDTH
+ || cmd.x > xo(cur.bv()) + tabular.width()) {
+ row_type r = rowFromY(cur, cmd.y);
+ cur.idx() = tabular.getFirstCellInRow(r);
+ cur.pos() = 0;
+ cur.resetAnchor();
+ cur.idx() = tabular.getLastCellInRow(r);
+ cur.pos() = cur.lastpos();
+ cur.selection() = true;
+ bvcur = cur;
+ break;
+ }
+ // select column
+ int const y0 = yo(cur.bv()) - tabular.rowAscent(0);
+ if (cmd.y < y0 + ADD_TO_TABULAR_WIDTH
+ || cmd.y > y0 + tabular.height()) {
+ col_type c = columnFromX(cur, cmd.x);
+ cur.idx() = tabular.cellIndex(0, c);
+ cur.pos() = 0;
+ cur.resetAnchor();
+ cur.idx() = tabular.cellIndex(tabular.rowCount() - 1, c);
+ cur.pos() = cur.lastpos();
+ cur.selection() = true;
+ bvcur = cur;
+ break;
+ }
// do not reset cursor/selection if we have selected
// some cells (bug 2715).
if (cmd.button() == mouse_button::button3
&& tablemode(bvcur))
;
else
- // Let InsetText do it
+ // Let InsetTableCell do it
cell(cur.idx())->dispatch(cur, cmd);
break;
+ }
case LFUN_MOUSE_MOTION:
//lyxerr << "# InsetTabular::MouseMotion\n" << bvcur << endl;
if (cmd.button() == mouse_button::button1) {
// only accept motions to places not deeper nested than the real anchor
- if (bvcur.anchor_.hasPart(cur)) {
- // only update if selection changes
- if (bvcur.idx() == cur.idx() &&
- !(bvcur.anchor_.idx() == cur.idx() && bvcur.pos() != cur.pos()))
- cur.noUpdate();
- setCursorFromCoordinates(cur, cmd.x, cmd.y);
+ if (!bvcur.anchor_.hasPart(cur)) {
+ cur.undispatched();
+ break;
+ }
+ // select (additional) row
+ if (cmd.x < xo(cur.bv()) + ADD_TO_TABULAR_WIDTH
+ || cmd.x > xo(cur.bv()) + tabular.width()) {
+ row_type r = rowFromY(cur, cmd.y);
+ cur.idx() = tabular.getLastCellInRow(r);
bvcur.setCursor(cur);
bvcur.selection() = true;
- } else
- cur.undispatched();
+ break;
+ }
+ // select (additional) column
+ int const y0 = yo(cur.bv()) - tabular.rowAscent(0);
+ if (cmd.y < y0 + ADD_TO_TABULAR_WIDTH
+ || cmd.y > y0 + tabular.height()) {
+ col_type c = columnFromX(cur, cmd.x);
+ cur.idx() = tabular.cellIndex(tabular.rowCount() - 1, c);
+ bvcur.setCursor(cur);
+ bvcur.selection() = true;
+ break;
+ }
+ // only update if selection changes
+ if (bvcur.idx() == cur.idx() &&
+ !(bvcur.anchor_.idx() == cur.idx() && bvcur.pos() != cur.pos()))
+ cur.noUpdate();
+ setCursorFromCoordinates(cur, cmd.x, cmd.y);
+ bvcur.setCursor(cur);
+ bvcur.selection() = true;
}
break;
moveNextCell(cur);
cur.selection() = false;
break;
-
case LFUN_CHAR_FORWARD_SELECT:
case LFUN_CHAR_FORWARD:
cell(cur.idx())->dispatch(cur, cmd);
if (!cur.result().dispatched()) {
- isRightToLeft(cur) ? movePrevCell(cur) : moveNextCell(cur);
+ moveNextCell(cur);
if (sl == cur.top())
- cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_FORWARD);
else
cur.dispatched();
}
case LFUN_CHAR_BACKWARD:
cell(cur.idx())->dispatch(cur, cmd);
if (!cur.result().dispatched()) {
- isRightToLeft(cur) ? moveNextCell(cur) : movePrevCell(cur);
+ movePrevCell(cur);
if (sl == cur.top())
- cmd = FuncRequest(LFUN_FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
else
cur.dispatched();
}
break;
+ case LFUN_CHAR_RIGHT_SELECT:
+ case LFUN_CHAR_RIGHT:
+ //FIXME: for visual cursor, really move right
+ if (isRightToLeft(cur))
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_RIGHT_SELECT ?
+ LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD));
+ else
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_RIGHT_SELECT ?
+ LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD));
+ break;
+
+ case LFUN_CHAR_LEFT_SELECT:
+ case LFUN_CHAR_LEFT:
+ //FIXME: for visual cursor, really move left
+ if (isRightToLeft(cur))
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_LEFT_SELECT ?
+ LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD));
+ else
+ lyx::dispatch(FuncRequest(
+ cmd.action == LFUN_CHAR_LEFT_SELECT ?
+ LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD));
+ break;
+
case LFUN_DOWN_SELECT:
case LFUN_DOWN:
cell(cur.idx())->dispatch(cur, cmd);
cur.pos() = tm.x2pos(cur.pit(), 0, cur.targetX());
}
if (sl == cur.top()) {
- // we trick it to go to the RIGHT after leaving the
+ // we trick it to go to forward after leaving the
// tabular.
- cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+ cmd = FuncRequest(LFUN_FINISHED_FORWARD);
cur.undispatched();
}
break;
case LFUN_FILE_INSERT_PLAINTEXT_PARA:
case LFUN_FILE_INSERT_PLAINTEXT: {
// FIXME UNICODE
- docstring const tmpstr = cur.bv().contentsOfPlaintextFile(to_utf8(cmd.argument()), false);
- if (!tmpstr.empty() && !insertPlaintextString(cur.bv(), tmpstr, false))
+ docstring const tmpstr = cur.bv().contentsOfPlaintextFile(
+ FileName(to_utf8(cmd.argument())));
+ if (tmpstr.empty())
+ break;
+ cur.recordUndoInset(INSERT_UNDO);
+ if (insertPlaintextString(cur.bv(), tmpstr, false)) {
+ // content has been replaced,
+ // so cursor might be invalid
+ cur.pos() = cur.lastpos();
+ cur.pit() = cur.lastpit();
+ bvcur.setCursor(cur);
+ } else
cur.undispatched();
break;
}
case LFUN_CUT:
if (tablemode(cur)) {
if (copySelection(cur)) {
- recordUndoInset(cur, Undo::DELETE);
+ cur.recordUndoInset(DELETE_UNDO);
cutSelection(cur);
}
}
case LFUN_CHAR_DELETE_BACKWARD:
case LFUN_CHAR_DELETE_FORWARD:
if (tablemode(cur)) {
- recordUndoInset(cur, Undo::DELETE);
+ cur.recordUndoInset(DELETE_UNDO);
cutSelection(cur);
}
else
if (!cur.selection())
break;
if (tablemode(cur)) {
- finishUndo();
+ cur.finishUndo();
copySelection(cur);
} else
cell(cur.idx())->dispatch(cur, cmd);
// pass to InsertPlaintextString, but
// only if we have multi-cell content
if (clip.find_first_of(from_ascii("\t\n")) != docstring::npos) {
+ cur.recordUndoInset(INSERT_UNDO);
if (insertPlaintextString(cur.bv(), clip, false)) {
// content has been replaced,
// so cursor might be invalid
cur.pos() = cur.lastpos();
+ cur.pit() = cur.lastpit();
bvcur.setCursor(cur);
break;
}
}
case LFUN_PASTE:
- if (tabularStackDirty() && theClipboard().isInternal()) {
- recordUndoInset(cur, Undo::INSERT);
+ if (tabularStackDirty() && theClipboard().isInternal() ||
+ !theClipboard().hasInternal() && theClipboard().hasLyXContents()) {
+ cur.recordUndoInset(INSERT_UNDO);
pasteClipboard(cur);
break;
}
case Tabular::SET_TOP_SPACE:
case Tabular::SET_BOTTOM_SPACE:
case Tabular::SET_INTERLINE_SPACE:
+ case Tabular::SET_BORDER_LINES:
status.clear();
return true;
status.setOnOff(tabular.isMultiColumn(cur.idx()));
break;
- case Tabular::M_TOGGLE_LINE_TOP:
- flag = false;
case Tabular::TOGGLE_LINE_TOP:
- status.setOnOff(tabular.topLine(cur.idx(), flag));
+ status.setOnOff(tabular.topLine(cur.idx()));
break;
- case Tabular::M_TOGGLE_LINE_BOTTOM:
- flag = false;
case Tabular::TOGGLE_LINE_BOTTOM:
- status.setOnOff(tabular.bottomLine(cur.idx(), flag));
+ status.setOnOff(tabular.bottomLine(cur.idx()));
break;
- case Tabular::M_TOGGLE_LINE_LEFT:
- flag = false;
case Tabular::TOGGLE_LINE_LEFT:
- status.setOnOff(tabular.leftLine(cur.idx(), flag));
+ status.setOnOff(tabular.leftLine(cur.idx()));
break;
- case Tabular::M_TOGGLE_LINE_RIGHT:
- flag = false;
case Tabular::TOGGLE_LINE_RIGHT:
- status.setOnOff(tabular.rightLine(cur.idx(), flag));
+ status.setOnOff(tabular.rightLine(cur.idx()));
break;
case Tabular::M_ALIGN_LEFT:
}
// disable in non-fixed-width cells
- case LFUN_BREAK_LINE:
+ case LFUN_NEW_LINE:
case LFUN_BREAK_PARAGRAPH:
case LFUN_BREAK_PARAGRAPH_SKIP: {
if (tabular.getPWidth(cur.idx()).zero()) {
return cell(cur.idx())->getStatus(cur, cmd, status);
case LFUN_INSET_MODIFY:
- if (translate(cmd.getArg(0)) == TABULAR_CODE) {
+ if (insetCode(cmd.getArg(0)) == TABULAR_CODE) {
status.enabled(true);
return true;
}
}
-int InsetTabular::latex(Buffer const & buf, odocstream & os,
- OutputParams const & runparams) const
+int InsetTabular::latex(odocstream & os, OutputParams const & runparams) const
{
- return tabular.latex(buf, os, runparams);
+ return tabular.latex(os, runparams);
}
-int InsetTabular::plaintext(Buffer const & buf, odocstream & os,
- OutputParams const & runparams) const
+int InsetTabular::plaintext(odocstream & os, OutputParams const & runparams) const
{
os << '\n'; // output table on a new line
int const dp = runparams.linelen > 0 ? runparams.depth : 0;
- tabular.plaintext(buf, os, runparams, dp, false, 0);
+ tabular.plaintext(os, runparams, dp, false, 0);
return PLAINTEXT_NEWLINE;
}
-int InsetTabular::docbook(Buffer const & buf, odocstream & os,
- OutputParams const & runparams) const
+int InsetTabular::docbook(odocstream & os, OutputParams const & runparams) const
{
int ret = 0;
Inset * master = 0;
os << "<informaltable>";
++ret;
}
- ret += tabular.docbook(buf, os, runparams);
+ ret += tabular.docbook(os, runparams);
if (!master) {
os << "</informaltable>";
++ret;
}
-shared_ptr<InsetText const> InsetTabular::cell(idx_type idx) const
+shared_ptr<InsetTableCell const> InsetTabular::cell(idx_type idx) const
{
return tabular.getCellInset(idx);
}
-shared_ptr<InsetText> InsetTabular::cell(idx_type idx)
+shared_ptr<InsetTableCell> InsetTabular::cell(idx_type idx)
{
return tabular.getCellInset(idx);
}
InsetTabular::idx_type InsetTabular::getNearestCell(BufferView & bv, int x, int y) const
{
idx_type idx_min = 0;
- int dist_min = std::numeric_limits<int>::max();
+ int dist_min = numeric_limits<int>::max();
for (idx_type i = 0, n = nargs(); i != n; ++i) {
if (bv.coordCache().getInsets().has(tabular.getCellInset(i).get())) {
int const d = dist(bv, i, x, y);
void InsetTabular::tabularFeatures(Cursor & cur,
Tabular::Feature feature, string const & value)
{
- BufferView & bv = cur.bv();
col_type sel_col_start;
col_type sel_col_end;
row_type sel_row_start;
break;
}
- recordUndoInset(cur, Undo::ATOMIC);
+ cur.recordUndoInset(ATOMIC_UNDO);
getSelection(cur, sel_row_start, sel_row_end, sel_col_start, sel_col_end);
row_type const row = tabular.cellRow(cur.idx());
case Tabular::APPEND_ROW:
// append the row into the tabular
- tabular.appendRow(bv.buffer().params(), cur.idx());
+ tabular.appendRow(cur.idx());
break;
case Tabular::APPEND_COLUMN:
// append the column into the tabular
- tabular.appendColumn(bv.buffer().params(), cur.idx());
+ tabular.appendColumn(cur.idx());
cur.idx() = tabular.cellIndex(row, column);
break;
break;
case Tabular::COPY_ROW:
- tabular.copyRow(bv.buffer().params(), row);
+ tabular.copyRow(row);
break;
case Tabular::COPY_COLUMN:
- tabular.copyColumn(bv.buffer().params(), column);
+ tabular.copyColumn(column);
cur.idx() = tabular.cellIndex(row, column);
break;
- case Tabular::M_TOGGLE_LINE_TOP:
- flag = false;
case Tabular::TOGGLE_LINE_TOP: {
- bool lineSet = !tabular.topLine(cur.idx(), flag);
+ bool lineSet = !tabular.topLine(cur.idx());
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setTopLine(
- tabular.cellIndex(i, j),
- lineSet, flag);
+ tabular.setTopLine(tabular.cellIndex(i, j), lineSet);
break;
}
- case Tabular::M_TOGGLE_LINE_BOTTOM:
- flag = false;
case Tabular::TOGGLE_LINE_BOTTOM: {
- bool lineSet = !tabular.bottomLine(cur.idx(), flag);
+ bool lineSet = !tabular.bottomLine(cur.idx());
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setBottomLine(
- tabular.cellIndex(i, j),
- lineSet,
- flag);
+ tabular.setBottomLine(tabular.cellIndex(i, j), lineSet);
break;
}
- case Tabular::M_TOGGLE_LINE_LEFT:
- flag = false;
case Tabular::TOGGLE_LINE_LEFT: {
- bool lineSet = !tabular.leftLine(cur.idx(), flag);
+ bool lineSet = !tabular.leftLine(cur.idx());
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setLeftLine(
- tabular.cellIndex(i,j),
- lineSet,
- flag);
+ tabular.setLeftLine(tabular.cellIndex(i, j), lineSet);
break;
}
- case Tabular::M_TOGGLE_LINE_RIGHT:
- flag = false;
case Tabular::TOGGLE_LINE_RIGHT: {
- bool lineSet = !tabular.rightLine(cur.idx(), flag);
+ bool lineSet = !tabular.rightLine(cur.idx());
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setRightLine(
- tabular.cellIndex(i,j),
- lineSet,
- flag);
+ tabular.setRightLine(tabular.cellIndex(i, j), lineSet);
break;
}
case Tabular::ALIGN_BLOCK:
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setAlignment(
- tabular.cellIndex(i, j),
- setAlign,
- flag);
+ tabular.setAlignment(tabular.cellIndex(i, j), setAlign, flag);
break;
case Tabular::M_VALIGN_TOP:
case Tabular::VALIGN_MIDDLE:
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setVAlignment(
- tabular.cellIndex(i, j),
- setVAlign, flag);
+ tabular.setVAlignment(tabular.cellIndex(i, j), setVAlign, flag);
break;
case Tabular::MULTICOLUMN: {
if (tabular.isMultiColumn(cur.idx()))
tabular.unsetMultiColumn(cur.idx());
else
- tabular.setMultiColumn(&bv.buffer(), cur.idx(), 1);
+ tabular.setMultiColumn(cur.idx(), 1);
break;
}
// we have a selection so this means we just add all this
// cells to form a multicolumn cell
idx_type const s_start = cur.selBegin().idx();
idx_type const s_end = cur.selEnd().idx();
- tabular.setMultiColumn(&bv.buffer(), s_start, s_end - s_start + 1);
+ tabular.setMultiColumn(s_start, s_end - s_start + 1);
cur.idx() = s_start;
cur.pit() = 0;
cur.pos() = 0;
tabular.cellIndex(i,j), setLines);
break;
+ case Tabular::SET_BORDER_LINES:
+ for (row_type i = sel_row_start; i <= sel_row_end; ++i) {
+ tabular.setLeftLine(tabular.cellIndex(i, sel_col_start), true);
+ tabular.setRightLine(tabular.cellIndex(i, sel_col_end), true);
+ }
+ for (col_type j = sel_col_start; j <= sel_col_end; ++j) {
+ tabular.setTopLine(tabular.cellIndex(sel_row_start, j), true);
+ tabular.setBottomLine(tabular.cellIndex(sel_row_end, j), true);
+ }
+ break;
+
case Tabular::SET_LONGTABULAR:
tabular.setLongTabular(true);
break;
case Tabular::UNSET_ROTATE_CELL:
for (row_type i = sel_row_start; i <= sel_row_end; ++i)
for (col_type j = sel_col_start; j <= sel_col_end; ++j)
- tabular.setRotateCell(
- tabular.cellIndex(i, j), false);
+ tabular.setRotateCell(tabular.cellIndex(i, j), false);
break;
case Tabular::TOGGLE_ROTATE_CELL:
while (paste_tabular->rowCount() > rows)
paste_tabular->deleteRow(rows);
- paste_tabular->setTopLine(0, true, true);
- paste_tabular->setBottomLine(paste_tabular->getFirstCellInRow(rows - 1),
- true, true);
-
for (col_type i = 0; i < cs; ++i)
paste_tabular->deleteColumn(0);
while (paste_tabular->columnCount() > columns)
paste_tabular->deleteColumn(columns);
- paste_tabular->setLeftLine(0, true, true);
- paste_tabular->setRightLine(paste_tabular->getLastCellInRow(0),
- true, true);
+ // We clear all the InsetTableCell pointers, since they
+ // might now become invalid and there is no point in having
+ // them point to temporary things in paste_tabular.
+ for (row_type i = 0; i < paste_tabular->rowCount(); ++i)
+ for (col_type j = 0; j < paste_tabular->columnCount(); ++j) {
+ paste_tabular->getCellInset(i,j)->setCellData(0);
+ paste_tabular->getCellInset(i,j)->setTabular(0);
+ }
odocstringstream os;
OutputParams const runparams(0);
- paste_tabular->plaintext(cur.buffer(), os, runparams, 0, true, '\t');
+ paste_tabular->plaintext(os, runparams, 0, true, '\t');
// Needed for the "Edit->Paste recent" menu and the system clipboard.
cap::copySelection(cur, os.str());
--c1;
continue;
}
- shared_ptr<InsetText> inset(
- new InsetText(*paste_tabular->getCellInset(r1, c1)));
+ shared_ptr<InsetTableCell> inset(
+ new InsetTableCell(*paste_tabular->getCellInset(r1, c1)));
+ // note that setCellInset will call InsetTableCell::setCellData()
+ // and InsetTableCell::setTabular()
tabular.setCellInset(r2, c2, inset);
// FIXME: change tracking (MG)
inset->setChange(Change(cur.buffer().params().trackChanges ?
getSelection(cur, rs, re, cs, ce);
for (row_type i = rs; i <= re; ++i) {
for (col_type j = cs; j <= ce; ++j) {
- shared_ptr<InsetText> t
+ shared_ptr<InsetTableCell> t
= cell(tabular.cellIndex(i, j));
if (cur.buffer().params().trackChanges)
// FIXME: Change tracking (MG)
}
-bool InsetTabular::forceDefaultParagraphs(idx_type cell) const
+bool InsetTabular::allowParagraphCustomization(idx_type cell) const
{
return tabular.getPWidth(cell).zero();
}
+bool InsetTabular::forceEmptyLayout(idx_type cell) const
+{
+ return !tabular.getPWidth(cell).zero();
+}
+
+
bool InsetTabular::insertPlaintextString(BufferView & bv, docstring const & buf,
bool usePaste)
{
if (buf.length() <= 0)
return true;
- Buffer const & buffer = bv.buffer();
-
col_type cols = 1;
row_type rows = 1;
col_type maxCols = 1;
- docstring::size_type const len = buf.length();
- docstring::size_type p = 0;
+ size_t const len = buf.length();
+ size_t p = 0;
while (p < len &&
(p = buf.find_first_of(from_ascii("\t\n"), p)) != docstring::npos) {
col_type ocol = 0;
row_type row = 0;
if (usePaste) {
- paste_tabular.reset(
- new Tabular(buffer.params(), rows, maxCols));
+ paste_tabular.reset(new Tabular(buffer(), rows, maxCols));
loctab = paste_tabular.get();
cols = 0;
dirtyTabularStack(true);
row = tabular.cellRow(cell);
}
- docstring::size_type op = 0;
+ size_t op = 0;
idx_type const cells = loctab->cellCount();
p = 0;
cols = ocol;
case '\t':
// we can only set this if we are not too far right
if (cols < columns) {
- shared_ptr<InsetText> inset = loctab->getCellInset(cell);
+ shared_ptr<InsetTableCell> inset = loctab->getCellInset(cell);
Font const font = bv.textMetrics(&inset->text_).
- getDisplayFont(0, 0);
+ displayFont(0, 0);
inset->setText(buf.substr(op, p - op), font,
- buffer.params().trackChanges);
+ buffer().params().trackChanges);
++cols;
++cell;
}
case '\n':
// we can only set this if we are not too far right
if (cols < columns) {
- shared_ptr<InsetText> inset = tabular.getCellInset(cell);
+ shared_ptr<InsetTableCell> inset = tabular.getCellInset(cell);
Font const font = bv.textMetrics(&inset->text_).
- getDisplayFont(0, 0);
+ displayFont(0, 0);
inset->setText(buf.substr(op, p - op), font,
- buffer.params().trackChanges);
+ buffer().params().trackChanges);
}
cols = ocol;
++row;
}
// check for the last cell if there is no trailing '\n'
if (cell < cells && op < len) {
- shared_ptr<InsetText> inset = loctab->getCellInset(cell);
- Font const font = bv.textMetrics(&inset->text_).getDisplayFont(0, 0);
+ shared_ptr<InsetTableCell> inset = loctab->getCellInset(cell);
+ Font const font = bv.textMetrics(&inset->text_).displayFont(0, 0);
inset->setText(buf.substr(op, len - op), font,
- buffer.params().trackChanges);
+ buffer().params().trackChanges);
}
return true;
}
}
+bool InsetTabular::completionSupported(Cursor const & cur) const
+{
+ Cursor const & bvCur = cur.bv().cursor();
+ if (&bvCur.inset() != this)
+ return false;
+ return cur.text()->completionSupported(cur);
+}
+
+
+bool InsetTabular::inlineCompletionSupported(Cursor const & cur) const
+{
+ return completionSupported(cur);
+}
+
+
+bool InsetTabular::automaticInlineCompletion() const
+{
+ return lyxrc.completion_inline_text;
+}
+
+
+bool InsetTabular::automaticPopupCompletion() const
+{
+ return lyxrc.completion_popup_text;
+}
+
+
+bool InsetTabular::showCompletionCursor() const
+{
+ return lyxrc.completion_cursor_text;
+}
+
+
+CompletionList const * InsetTabular::createCompletionList(Cursor const & cur) const
+{
+ return completionSupported(cur) ? cur.text()->createCompletionList(cur) : 0;
+}
+
+
+docstring InsetTabular::completionPrefix(Cursor const & cur) const
+{
+ if (!completionSupported(cur))
+ return docstring();
+ return cur.text()->completionPrefix(cur);
+}
+
+
+bool InsetTabular::insertCompletion(Cursor & cur, docstring const & s, bool finished)
+{
+ if (!completionSupported(cur))
+ return false;
+
+ return cur.text()->insertCompletion(cur, s, finished);
+}
+
+
+void InsetTabular::completionPosAndDim(Cursor const & cur, int & x, int & y,
+ Dimension & dim) const
+{
+ TextMetrics const & tm = cur.bv().textMetrics(cur.text());
+ tm.completionPosAndDim(cur, x, y, dim);
+}
string const InsetTabularMailer::name_("tabular");
// by Buffer::readInset
lex >> token;
if (!lex || token != "Tabular")
- return print_mailer_error("InsetTabularMailer", in, 2,
- "Tabular");
+ return print_mailer_error("InsetTabularMailer", in, 2, "Tabular");
- Buffer const & buffer = inset.buffer();
- inset.read(buffer, lex);
+ inset.read(lex);
}
{
ostringstream data;
data << name_ << ' ';
- inset.write(inset.buffer(), data);
+ inset.write(data);
data << "\\end_inset\n";
return data.str();
}
projects / lyx.git / blobdiff