}
-InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
- : tabular(buf.params(), max(rows, 1), max(columns, 1)),
- buffer_(&buf), cursorx_(0)
+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), cursorx_(0)
{}
BOOST_ASSERT(false);
}
- for (int i = 0, cell = -1; i < tabular.rows(); ++i) {
+ row_type i = 0;
+ for (idx_type cell = 0; i < tabular.rows(); ++i) {
int maxAsc = 0;
int maxDesc = 0;
- for (int j = 0; j < tabular.columns(); ++j) {
+ for (col_type j = 0; j < tabular.columns(); ++j) {
if (tabular.isPartOfMultiColumn(i, j))
continue;
- ++cell;
Dimension dim;
MetricsInfo m = mi;
LyXLength p_width = tabular.column_info[j].p_width;
maxAsc = max(maxAsc, dim.asc);
maxDesc = max(maxDesc, dim.des);
tabular.setWidthOfCell(cell, dim.wid);
+ ++cell;
}
tabular.setAscentOfRow(i, maxAsc + ADD_TO_HEIGHT);
tabular.setDescentOfRow(i, maxDesc + ADD_TO_HEIGHT);
x += scroll();
x += ADD_TO_TABULAR_WIDTH;
- int idx = 0;
- first_visible_cell = -1;
- for (int i = 0; i < tabular.rows(); ++i) {
+ idx_type idx = 0;
+ first_visible_cell = LyXTabular::npos;
+ for (row_type i = 0; i < tabular.rows(); ++i) {
int nx = x;
int const a = tabular.getAscentOfRow(i);
int const d = tabular.getDescentOfRow(i);
+ tabular.getAdditionalHeight(i + 1);
continue;
}
- for (int j = 0; j < tabular.columns(); ++j) {
+ for (col_type j = 0; j < tabular.columns(); ++j) {
if (tabular.isPartOfMultiColumn(i, j))
continue;
- if (first_visible_cell < 0)
+ if (first_visible_cell == LyXTabular::npos)
first_visible_cell = idx;
int const cx = nx + tabular.getBeginningOfTextInCell(idx);
x += ADD_TO_TABULAR_WIDTH;
if (tablemode(cur)) {
- int rs, re, cs, ce;
+ row_type rs, re;
+ col_type cs, ce;
getSelection(cur, rs, re, cs, ce);
- for (int j = 0; j < tabular.rows(); ++j) {
+ for (row_type j = 0; j < tabular.rows(); ++j) {
int const a = tabular.getAscentOfRow(j);
int const h = a + tabular.getDescentOfRow(j);
int xx = x;
y += tabular.getAdditionalHeight(j);
- for (int i = 0; i < tabular.columns(); ++i) {
+ for (col_type i = 0; i < tabular.columns(); ++i) {
if (tabular.isPartOfMultiColumn(j, i))
continue;
- int const cell = tabular.getCellNumber(j, i);
+ idx_type const cell =
+ tabular.getCellNumber(j, i);
int const w = tabular.getWidthOfColumn(cell);
if (i >= cs && i <= ce && j >= rs && j <= re)
pi.pain.fillRectangle(xx, y - a, w, h,
void InsetTabular::drawCellLines(Painter & pain, int x, int y,
- int row, int cell) const
+ row_type row, idx_type cell) const
{
int x2 = x + tabular.getWidthOfColumn(cell);
bool on_off = false;
// case LFUN_NEXT: {
// //if (hasSelection())
// // cur.selection() = false;
-// int const col = tabular.column_of_cell(cur.idx());
+// col_type const col = tabular.column_of_cell(cur.idx());
// int const t = cur.bv().top_y() + cur.bv().painter().paperHeight();
// if (t < yo() + tabular.getHeightOfTabular()) {
// cur.bv().scrollDocView(t);
// case LFUN_PRIOR: {
// //if (hasSelection())
// // cur.selection() = false;
-// int const col = tabular.column_of_cell(cur.idx());
+// col_type const col = tabular.column_of_cell(cur.idx());
// int const t = cur.bv().top_y() + cur.bv().painter().paperHeight();
// if (yo() < 0) {
// cur.bv().scrollDocView(t);
if (clip.empty())
break;
if (clip.find('\t') != string::npos) {
- int cols = 1;
- int rows = 1;
- int maxCols = 1;
+ col_type cols = 1;
+ row_type rows = 1;
+ col_type maxCols = 1;
size_t len = clip.length();
for (size_t p = 0; p < len; ++p) {
p = clip.find_first_of("\t\n", p);
new LyXTabular(cur.buffer().params(), rows, maxCols));
string::size_type op = 0;
- int cell = 0;
- int const cells = paste_tabular->getNumberOfCells();
+ idx_type cell = 0;
+ idx_type const cells =
+ paste_tabular->getNumberOfCells();
cols = 0;
LyXFont font;
for (size_t p = 0; cell < cells && p < len; ++p) {
string const argument
= ltrim(cmd.argument.substr(tabularFeature[i].feature.length()));
- int sel_row_start = 0;
- int sel_row_end = 0;
- int dummy;
+ row_type sel_row_start = 0;
+ row_type sel_row_end = 0;
+ col_type dummy;
LyXTabular::ltType dummyltt;
bool flag = true;
}
-shared_ptr<InsetText const> InsetTabular::cell(int idx) const
+shared_ptr<InsetText const> InsetTabular::cell(idx_type idx) const
{
return tabular.getCellInset(idx);
}
-shared_ptr<InsetText> InsetTabular::cell(int idx)
+shared_ptr<InsetText> InsetTabular::cell(idx_type idx)
{
return tabular.getCellInset(idx);
}
InsetBase * InsetTabular::setPos(LCursor & cur, int x, int y) const
{
lyxerr << "# InsetTabular::setPos() x=" << x << " y=" << y << endl;
- int idx_min = 0;
+ idx_type idx_min = 0;
int dist_min = std::numeric_limits<int>::max();
for (idx_type i = 0; i < nargs(); ++i) {
if (theCoords.insets_.has(tabular.getCellInset(i).get())) {
}
-int InsetTabular::getCellXPos(int const cell) const
+int InsetTabular::getCellXPos(idx_type const cell) const
{
- int c = cell;
+ idx_type c = cell;
for (; !tabular.isFirstCellInRow(c); --c)
;
BufferView & bv = cur.bv();
-
-// int const actcol = tabular.column_of_cell(cur.idx());
+// col_type const actcol = tabular.column_of_cell(cur.idx());
// int const offset = ADD_TO_TABULAR_WIDTH + 2;
// int const new_x = getCellXPos(cur.idx()) + offset;
// int const old_x = cursorx_;
if (isRightToLeft(cur)) {
lyxerr << "InsetTabular::moveNextCell A cur: " << endl;
if (tabular.isFirstCellInRow(cur.idx())) {
- int const row = tabular.row_of_cell(cur.idx());
+ row_type const row = tabular.row_of_cell(cur.idx());
if (row == tabular.rows() - 1)
return;
cur.idx() = tabular.getCellBelow(tabular.getLastCellInRow(row));
{
if (isRightToLeft(cur)) {
if (tabular.isLastCellInRow(cur.idx())) {
- int const row = tabular.row_of_cell(cur.idx());
+ row_type const row = tabular.row_of_cell(cur.idx());
if (row == 0)
return;
cur.idx() = tabular.getFirstCellInRow(row);
LyXTabular::Feature feature, string const & value)
{
BufferView & bv = cur.bv();
- int sel_col_start;
- int sel_col_end;
- int sel_row_start;
- int sel_row_end;
+ col_type sel_col_start;
+ col_type sel_col_end;
+ row_type sel_row_start;
+ row_type sel_row_end;
bool setLines = false;
LyXAlignment setAlign = LYX_ALIGN_LEFT;
LyXTabular::VAlignment setVAlign = LyXTabular::LYX_VALIGN_TOP;
recordUndo(cur, Undo::ATOMIC);
getSelection(cur, sel_row_start, sel_row_end, sel_col_start, sel_col_end);
- int const row = tabular.row_of_cell(cur.idx());
- int const column = tabular.column_of_cell(cur.idx());
+ row_type const row = tabular.row_of_cell(cur.idx());
+ col_type const column = tabular.column_of_cell(cur.idx());
bool flag = true;
LyXTabular::ltType ltt;
break;
case LyXTabular::DELETE_ROW:
- for (int i = sel_row_start; i <= sel_row_end; ++i)
+ for (row_type i = sel_row_start; i <= sel_row_end; ++i)
tabular.deleteRow(sel_row_start);
if (sel_row_start >= tabular.rows())
--sel_row_start;
break;
case LyXTabular::DELETE_COLUMN:
- for (int i = sel_col_start; i <= sel_col_end; ++i)
+ for (col_type i = sel_col_start; i <= sel_col_end; ++i)
tabular.deleteColumn(sel_col_start);
if (sel_col_start >= tabular.columns())
--sel_col_start;
flag = false;
case LyXTabular::TOGGLE_LINE_TOP: {
bool lineSet = !tabular.topLine(cur.idx(), flag);
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i, j),
lineSet, flag);
flag = false;
case LyXTabular::TOGGLE_LINE_BOTTOM: {
bool lineSet = !tabular.bottomLine(cur.idx(), flag);
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i, j),
lineSet,
flag = false;
case LyXTabular::TOGGLE_LINE_LEFT: {
bool lineSet = !tabular.leftLine(cur.idx(), flag);
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i,j),
lineSet,
flag = false;
case LyXTabular::TOGGLE_LINE_RIGHT: {
bool lineSet = !tabular.rightLine(cur.idx(), flag);
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i,j),
lineSet,
case LyXTabular::ALIGN_RIGHT:
case LyXTabular::ALIGN_CENTER:
case LyXTabular::ALIGN_BLOCK:
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i, j),
setAlign,
case LyXTabular::VALIGN_TOP:
case LyXTabular::VALIGN_BOTTOM:
case LyXTabular::VALIGN_MIDDLE:
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i, j),
setVAlign, flag);
}
// we have a selection so this means we just add all this
// cells to form a multicolumn cell
- CursorSlice::idx_type const s_start = cur.selBegin().idx();
- CursorSlice::idx_type const s_end = cur.selEnd().idx();
+ 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);
cur.idx() = s_start;
cur.pit() = 0;
setLines = true;
case LyXTabular::UNSET_ALL_LINES:
#if 0
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.setAllLines(
tabular.getCellNumber(i,j), setLines);
#endif
break;
case LyXTabular::SET_ROTATE_CELL:
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i, j), true);
break;
case LyXTabular::UNSET_ROTATE_CELL:
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.getCellNumber(i, j), false);
break;
LyXTabular::BoxType val = LyXTabular::BoxType(strToInt(value));
if (val == tabular.getUsebox(cur.idx()))
val = LyXTabular::BOX_NONE;
- for (int i = sel_row_start; i <= sel_row_end; ++i)
- for (int j = sel_col_start; j <= sel_col_end; ++j)
+ 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.setUsebox(tabular.getCellNumber(i, j), val);
break;
}
if (!cur.selection())
return false;
- int rs, re, cs, ce;
+ row_type rs, re;
+ col_type cs, ce;
getSelection(cur, rs, re, cs, ce);
paste_tabular.reset(new LyXTabular(tabular));
- for (int i = 0; i < rs; ++i)
+ for (row_type i = 0; i < rs; ++i)
paste_tabular->deleteRow(0);
- int const rows = re - rs + 1;
+ row_type const rows = re - rs + 1;
while (paste_tabular->rows() > rows)
paste_tabular->deleteRow(rows);
paste_tabular->setBottomLine(paste_tabular->getFirstCellInRow(rows - 1),
true, true);
- for (int i = 0; i < cs; ++i)
+ for (col_type i = 0; i < cs; ++i)
paste_tabular->deleteColumn(0);
- int const columns = ce - cs + 1;
+ col_type const columns = ce - cs + 1;
while (paste_tabular->columns() > columns)
paste_tabular->deleteColumn(columns);
{
if (!paste_tabular)
return false;
- int const actcol = tabular.column_of_cell(cur.idx());
- int const actrow = tabular.row_of_cell(cur.idx());
- for (int r1 = 0, r2 = actrow;
+ col_type const actcol = tabular.column_of_cell(cur.idx());
+ row_type const actrow = tabular.row_of_cell(cur.idx());
+ for (row_type r1 = 0, r2 = actrow;
r1 < paste_tabular->rows() && r2 < tabular.rows();
++r1, ++r2) {
- for (int c1 = 0, c2 = actcol;
+ for (col_type c1 = 0, c2 = actcol;
c1 < paste_tabular->columns() && c2 < tabular.columns();
++c1, ++c2) {
if (paste_tabular->isPartOfMultiColumn(r1, c1) &&
return;
bool const track = cur.buffer().params().tracking_changes;
- int rs, re, cs, ce;
+ row_type rs, re;
+ col_type cs, ce;
getSelection(cur, rs, re, cs, ce);
- for (int i = rs; i <= re; ++i)
- for (int j = cs; j <= ce; ++j)
+ for (row_type i = rs; i <= re; ++i)
+ for (col_type j = cs; j <= ce; ++j)
cell(tabular.getCellNumber(i, j))->clear(track);
// cursor position might be invalid now
void InsetTabular::getSelection(LCursor & cur,
- int & rs, int & re, int & cs, int & ce) const
+ row_type & rs, row_type & re, col_type & cs, col_type & ce) const
{
CursorSlice const & beg = cur.selBegin();
CursorSlice const & end = cur.selEnd();
bool InsetTabular::forceDefaultParagraphs(InsetBase const *) const
{
#if 0
- int const cell = tabular.getCellFromInset(in);
+ idx_type const cell = tabular.getCellFromInset(in);
+ // FIXME: getCellFromInset() returns now always a valid cell, so
+ // the stuff below can be deleted, and instead we have:
+ return tabular.getPWidth(cell).zero();
- if (cell != -1)
+ if (cell != npos)
return tabular.getPWidth(cell).zero();
// this is a workaround for a crash (New, Insert->Tabular,
if (buf.length() <= 0)
return true;
- int cols = 1;
- int rows = 1;
- int maxCols = 1;
+ col_type cols = 1;
+ row_type rows = 1;
+ col_type maxCols = 1;
string::size_type const len = buf.length();
string::size_type p = 0;
}
maxCols = max(cols, maxCols);
LyXTabular * loctab;
- int cell = 0;
- int ocol = 0;
- int row = 0;
+ idx_type cell = 0;
+ col_type ocol = 0;
+ row_type row = 0;
if (usePaste) {
paste_tabular.reset(
new LyXTabular(bv.buffer()->params(), rows, maxCols));
}
string::size_type op = 0;
- int const cells = loctab->getNumberOfCells();
+ idx_type const cells = loctab->getNumberOfCells();
p = 0;
cols = ocol;
rows = loctab->rows();
- int const columns = loctab->columns();
+ col_type const columns = loctab->columns();
while (cell < cells && p < len && row < rows &&
(p = buf.find_first_of("\t\n", p)) != string::npos)
void InsetTabular::addPreview(PreviewLoader & loader) const
{
- int const rows = tabular.rows();
- int const columns = tabular.columns();
- for (int i = 0; i < rows; ++i) {
- for (int j = 0; j < columns; ++j)
+ row_type const rows = tabular.rows();
+ col_type const columns = tabular.columns();
+ for (row_type i = 0; i < rows; ++i) {
+ for (col_type j = 0; j < columns; ++j)
tabular.getCellInset(i, j)->addPreview(loader);
}
}
}
+string const write_attribute(string const & name, LyXTabular::idx_type const & i)
+{
+ // we write only true attribute values so we remove a bit of the
+ // file format bloat for tabulars.
+ return i ? write_attribute(name, tostr(i)) : string();
+}
+
+
string const write_attribute(string const & name, LyXLength const & value)
{
// we write only the value if we really have one same reson as above.
{}
-LyXTabular::LyXTabular(BufferParams const & bp, int rows_arg, int columns_arg)
+LyXTabular::LyXTabular(BufferParams const & bp, row_type rows_arg,
+ col_type columns_arg)
{
init(bp, rows_arg, columns_arg);
}
// activates all lines and sets all widths to 0
-void LyXTabular::init(BufferParams const & bp, int rows_arg, int columns_arg)
+void LyXTabular::init(BufferParams const & bp, row_type rows_arg,
+ col_type columns_arg)
{
rows_ = rows_arg;
columns_ = columns_arg;
column_info.reserve(10);
cell_info.reserve(100);
fixCellNums();
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
cell_info[i].back().right_line = true;
row_info.back().bottom_line = true;
row_info.front().bottom_line = true;
void LyXTabular::fixCellNums()
{
- int cellno = 0;
- for (int i = 0; i < rows_; ++i) {
- for (int j = 0; j < columns_; ++j) {
+ idx_type cellno = 0;
+ for (row_type i = 0; i < rows_; ++i) {
+ for (col_type j = 0; j < columns_; ++j) {
// When debugging it can be nice to set
// this to true.
cell_info[i][j].inset->setDrawFrame(false);
}
-void LyXTabular::appendRow(BufferParams const & bp, int const cell)
+void LyXTabular::appendRow(BufferParams const & bp, idx_type const cell)
{
++rows_;
- int const row = row_of_cell(cell);
+ row_type const row = row_of_cell(cell);
row_vector::iterator rit = row_info.begin() + row;
row_info.insert(rit, rowstruct());
row_info[row] = row_info[row + 1];
cell_vvector old(rows_ - 1);
- for (int i = 0; i < rows_ - 1; ++i)
+ for (row_type i = 0; i < rows_ - 1; ++i)
swap(cell_info[i], old[i]);
cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp)));
- for (int i = 0; i <= row; ++i)
+ for (row_type i = 0; i <= row; ++i)
swap(cell_info[i], old[i]);
- for (int i = row + 2; i < rows_; ++i)
+ for (row_type i = row + 2; i < rows_; ++i)
swap(cell_info[i], old[i - 1]);
if (bp.tracking_changes)
- for (int j = 0; j < columns_; ++j)
+ for (col_type j = 0; j < columns_; ++j)
cell_info[row + 1][j].inset->markNew(true);
set_row_column_number_info();
}
-void LyXTabular::deleteRow(int const row)
+void LyXTabular::deleteRow(row_type const row)
{
// Not allowed to delete last row
if (rows_ == 1)
}
-void LyXTabular::appendColumn(BufferParams const & bp, int const cell)
+void LyXTabular::appendColumn(BufferParams const & bp, idx_type const cell)
{
++columns_;
- int const column = column_of_cell(cell);
+ col_type const column = column_of_cell(cell);
column_vector::iterator cit = column_info.begin() + column + 1;
column_info.insert(cit, columnstruct());
// set the column values of the column before
column_info[column + 1] = column_info[column];
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
cell_info[i].insert(cell_info[i].begin() + column + 1, cellstruct(bp));
// care about multicolumns
cell_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL;
}
//++column;
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
cell_info[i][column + 1].inset->clear(false);
if (bp.tracking_changes)
cell_info[i][column + 1].inset->markNew(true);
}
-void LyXTabular::deleteColumn(int const column)
+void LyXTabular::deleteColumn(col_type const column)
{
// Not allowed to delete last column
if (columns_ == 1)
return;
column_info.erase(column_info.begin() + column);
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
cell_info[i].erase(cell_info[i].begin() + column);
--columns_;
fixCellNums();
void LyXTabular::set_row_column_number_info()
{
- numberofcells = -1;
- for (int row = 0; row < rows_; ++row) {
- for (int column = 0; column < columns_; ++column) {
+ numberofcells = 0;
+ for (row_type row = 0; row < rows_; ++row) {
+ for (col_type column = 0; column < columns_; ++column) {
if (cell_info[row][column].multicolumn
!= LyXTabular::CELL_PART_OF_MULTICOLUMN)
++numberofcells;
- cell_info[row][column].cellno = numberofcells;
+ if (numberofcells == 0)
+ // FIXME: Is this intended?
+ cell_info[row][column].cellno = npos;
+ else
+ cell_info[row][column].cellno =
+ numberofcells - 1;
}
}
- ++numberofcells; // because this is one more than as we start from 0
rowofcell.resize(numberofcells);
columnofcell.resize(numberofcells);
- for (int row = 0, column = 0, c = 0;
+ row_type row = 0;
+ col_type column = 0;
+ for (idx_type c = 0;
c < numberofcells && row < rows_ && column < columns_;) {
rowofcell[c] = row;
columnofcell[c] = column;
}
}
- for (int row = 0; row < rows_; ++row) {
- for (int column = 0; column < columns_; ++column) {
+ for (row_type row = 0; row < rows_; ++row) {
+ for (col_type column = 0; column < columns_; ++column) {
if (isPartOfMultiColumn(row,column))
continue;
cell_info[row][column].inset->setAutoBreakRows(
}
-int LyXTabular::getNumberOfCells() const
+LyXTabular::idx_type LyXTabular::getNumberOfCells() const
{
return numberofcells;
}
-int LyXTabular::numberOfCellsInRow(int const cell) const
+LyXTabular::idx_type LyXTabular::numberOfCellsInRow(idx_type const cell) const
{
- int const row = row_of_cell(cell);
- int result = 0;
- for (int i = 0; i < columns_; ++i)
+ row_type const row = row_of_cell(cell);
+ idx_type result = 0;
+ for (col_type i = 0; i < columns_; ++i)
if (cell_info[row][i].multicolumn != LyXTabular::CELL_PART_OF_MULTICOLUMN)
++result;
return result;
// returns 1 if there is a topline, returns 0 if not
-bool LyXTabular::topLine(int const cell, bool const onlycolumn) const
+bool LyXTabular::topLine(idx_type const cell, bool const onlycolumn) const
{
if (!onlycolumn && isMultiColumn(cell))
return cellinfo_of_cell(cell).top_line;
}
-bool LyXTabular::bottomLine(int cell, bool onlycolumn) const
+bool LyXTabular::bottomLine(idx_type const cell, bool onlycolumn) const
{
if (!onlycolumn && isMultiColumn(cell))
return cellinfo_of_cell(cell).bottom_line;
}
-bool LyXTabular::leftLine(int cell, bool onlycolumn) const
+bool LyXTabular::leftLine(idx_type cell, bool onlycolumn) const
{
if (!onlycolumn && isMultiColumn(cell) &&
(isFirstCellInRow(cell) || isMultiColumn(cell-1)))
}
-bool LyXTabular::rightLine(int cell, bool onlycolumn) const
+bool LyXTabular::rightLine(idx_type cell, bool onlycolumn) const
{
if (!onlycolumn && isMultiColumn(cell) &&
(isLastCellInRow(cell) || isMultiColumn(cell + 1)))
}
-bool LyXTabular::topAlreadyDrawn(int cell) const
+bool LyXTabular::topAlreadyDrawn(idx_type cell) const
{
- int row = row_of_cell(cell);
+ row_type row = row_of_cell(cell);
if (row > 0 && !getAdditionalHeight(row)) {
- int column = column_of_cell(cell);
+ col_type column = column_of_cell(cell);
--row;
while (column
&& cell_info[row][column].multicolumn
}
-bool LyXTabular::leftAlreadyDrawn(int cell) const
+bool LyXTabular::leftAlreadyDrawn(idx_type cell) const
{
- int column = column_of_cell(cell);
+ col_type column = column_of_cell(cell);
if (column > 0) {
- int row = row_of_cell(cell);
+ row_type row = row_of_cell(cell);
while (--column &&
(cell_info[row][column].multicolumn ==
LyXTabular::CELL_PART_OF_MULTICOLUMN));
}
-bool LyXTabular::isLastRow(int cell) const
+bool LyXTabular::isLastRow(idx_type cell) const
{
return row_of_cell(cell) == rows_ - 1;
}
-int LyXTabular::getAdditionalHeight(int row) const
+int LyXTabular::getAdditionalHeight(row_type row) const
{
if (!row || row >= rows_)
return 0;
bool top = true;
bool bottom = true;
- for (int column = 0; column < columns_ && bottom; ++column) {
+ for (col_type column = 0; column < columns_ && bottom; ++column) {
switch (cell_info[row - 1][column].multicolumn) {
case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN:
bottom = cell_info[row - 1][column].bottom_line;
bottom = row_info[row - 1].bottom_line;
}
}
- for (int column = 0; column < columns_ && top; ++column) {
+ for (col_type column = 0; column < columns_ && top; ++column) {
switch (cell_info[row][column].multicolumn) {
case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN:
top = cell_info[row][column].top_line;
}
-int LyXTabular::getAdditionalWidth(int cell) const
+int LyXTabular::getAdditionalWidth(idx_type cell) const
{
// internally already set in setWidthOfCell
// used to get it back in text.C
- int const col = right_column_of_cell(cell);
- int const row = row_of_cell(cell);
+ col_type const col = right_column_of_cell(cell);
+ row_type const row = row_of_cell(cell);
if (col < columns_ - 1 && rightLine(cell) &&
leftLine(cell_info[row][col+1].cellno)) // column_info[col+1].left_line)
{
// returns the maximum over all rows
-int LyXTabular::getWidthOfColumn(int cell) const
+int LyXTabular::getWidthOfColumn(idx_type cell) const
{
- int const column1 = column_of_cell(cell);
- int const column2 = right_column_of_cell(cell);
+ col_type const column1 = column_of_cell(cell);
+ col_type const column2 = right_column_of_cell(cell);
int result = 0;
- for (int i = column1; i <= column2; ++i)
+ for (col_type i = column1; i <= column2; ++i)
result += column_info[i].width_of_column;
return result;
}
// returns true if a complete update is necessary, otherwise false
-bool LyXTabular::setWidthOfMulticolCell(int cell, int new_width)
+bool LyXTabular::setWidthOfMulticolCell(idx_type cell, int new_width)
{
if (!isMultiColumn(cell))
return false;
- int const row = row_of_cell(cell);
- int const column1 = column_of_cell(cell);
- int const column2 = right_column_of_cell(cell);
+ row_type const row = row_of_cell(cell);
+ col_type const column1 = column_of_cell(cell);
+ col_type const column2 = right_column_of_cell(cell);
int const old_val = cell_info[row][column2].width_of_cell;
// first set columns to 0 so we can calculate the right width
- for (int i = column1; i <= column2; ++i) {
+ for (col_type i = column1; i <= column2; ++i) {
cell_info[row][i].width_of_cell = 0;
}
// set the width to MAX_WIDTH until width > 0
int width = new_width + 2 * WIDTH_OF_LINE;
- int i = column1;
+ col_type i = column1;
for (; i < column2 && width > column_info[i].width_of_column; ++i) {
cell_info[row][i].width_of_cell = column_info[i].width_of_column;
width -= column_info[i].width_of_column;
}
-void LyXTabular::recalculateMulticolumnsOfColumn(int column)
+void LyXTabular::recalculateMulticolumnsOfColumn(col_type column)
{
// the last column does not have to be recalculated because all
// multicolumns will have here there last multicolumn cell which
// always will have the whole rest of the width of the cell.
if (column > (columns_ - 2))
return;
- for(int row = 0; row < rows_; ++row) {
+ for(row_type row = 0; row < rows_; ++row) {
int mc = cell_info[row][column].multicolumn;
int nmc = cell_info[row][column+1].multicolumn;
// we only have to update multicolumns which do not have this
(mc == CELL_PART_OF_MULTICOLUMN &&
nmc == CELL_PART_OF_MULTICOLUMN))
{
- int const cellno = cell_info[row][column].cellno;
+ idx_type const cellno = cell_info[row][column].cellno;
setWidthOfMulticolCell(cellno,
getWidthOfCell(cellno) - 2 * WIDTH_OF_LINE);
}
// returns 1 if a complete update is necessary, otherwise 0
-void LyXTabular::setWidthOfCell(int cell, int new_width)
+void LyXTabular::setWidthOfCell(idx_type cell, int new_width)
{
- int const row = row_of_cell(cell);
- int const column1 = column_of_cell(cell);
+ row_type const row = row_of_cell(cell);
+ col_type const column1 = column_of_cell(cell);
bool tmp = false;
int width = 0;
int add_width = 0;
recalculateMulticolumnsOfColumn(column1);
}
if (tmp) {
- for (int i = 0; i < columns_; ++i)
+ for (col_type i = 0; i < columns_; ++i)
calculate_width_of_column(i);
calculate_width_of_tabular();
}
}
-void LyXTabular::setAlignment(int cell, LyXAlignment align, bool onlycolumn)
+void LyXTabular::setAlignment(idx_type cell, LyXAlignment align,
+ bool onlycolumn)
{
if (!isMultiColumn(cell) || onlycolumn)
column_info[column_of_cell(cell)].alignment = align;
}
-void LyXTabular::setVAlignment(int cell, VAlignment align, bool onlycolumn)
+void LyXTabular::setVAlignment(idx_type cell, VAlignment align,
+ bool onlycolumn)
{
if (!isMultiColumn(cell) || onlycolumn)
column_info[column_of_cell(cell)].valignment = align;
}
-void LyXTabular::setColumnPWidth(int cell, LyXLength const & width)
+void LyXTabular::setColumnPWidth(idx_type cell, LyXLength const & width)
{
- int const j = column_of_cell(cell);
+ col_type const j = column_of_cell(cell);
column_info[j].p_width = width;
- for (int i = 0; i < rows_; ++i) {
- int const cell = getCellNumber(i, j);
+ for (row_type i = 0; i < rows_; ++i) {
+ idx_type const cell = getCellNumber(i, j);
// because of multicolumns
getCellInset(cell)->setAutoBreakRows(!getPWidth(cell).zero());
}
}
-bool LyXTabular::setMColumnPWidth(int cell, LyXLength const & width)
+bool LyXTabular::setMColumnPWidth(idx_type cell, LyXLength const & width)
{
if (!isMultiColumn(cell))
return false;
}
-void LyXTabular::setAlignSpecial(int cell, string const & special,
+void LyXTabular::setAlignSpecial(idx_type cell, string const & special,
LyXTabular::Feature what)
{
if (what == SET_SPECIAL_MULTI)
}
-void LyXTabular::setAllLines(int cell, bool line)
+void LyXTabular::setAllLines(idx_type cell, bool line)
{
setTopLine(cell, line);
setBottomLine(cell, line);
}
-void LyXTabular::setTopLine(int cell, bool line, bool onlycolumn)
+void LyXTabular::setTopLine(idx_type cell, bool line, bool onlycolumn)
{
- int const row = row_of_cell(cell);
+ row_type const row = row_of_cell(cell);
if (onlycolumn || !isMultiColumn(cell))
row_info[row].top_line = line;
else
}
-void LyXTabular::setBottomLine(int cell, bool line, bool onlycolumn)
+void LyXTabular::setBottomLine(idx_type cell, bool line, bool onlycolumn)
{
if (onlycolumn || !isMultiColumn(cell))
row_info[row_of_cell(cell)].bottom_line = line;
}
-void LyXTabular::setLeftLine(int cell, bool line, bool onlycolumn)
+void LyXTabular::setLeftLine(idx_type cell, bool line, bool onlycolumn)
{
if (onlycolumn || !isMultiColumn(cell))
column_info[column_of_cell(cell)].left_line = line;
}
-void LyXTabular::setRightLine(int cell, bool line, bool onlycolumn)
+void LyXTabular::setRightLine(idx_type cell, bool line, bool onlycolumn)
{
if (onlycolumn || !isMultiColumn(cell))
column_info[right_column_of_cell(cell)].right_line = line;
}
-LyXAlignment LyXTabular::getAlignment(int cell, bool onlycolumn) const
+LyXAlignment LyXTabular::getAlignment(idx_type cell, bool onlycolumn) const
{
if (!onlycolumn && isMultiColumn(cell))
return cellinfo_of_cell(cell).alignment;
LyXTabular::VAlignment
-LyXTabular::getVAlignment(int cell, bool onlycolumn) const
+LyXTabular::getVAlignment(idx_type cell, bool onlycolumn) const
{
if (!onlycolumn && isMultiColumn(cell))
return cellinfo_of_cell(cell).valignment;
}
-LyXLength const LyXTabular::getPWidth(int cell) const
+LyXLength const LyXTabular::getPWidth(idx_type cell) const
{
if (isMultiColumn(cell))
return cellinfo_of_cell(cell).p_width;
}
-LyXLength const LyXTabular::getColumnPWidth(int cell) const
+LyXLength const LyXTabular::getColumnPWidth(idx_type cell) const
{
return column_info[column_of_cell(cell)].p_width;
}
-LyXLength const LyXTabular::getMColumnPWidth(int cell) const
+LyXLength const LyXTabular::getMColumnPWidth(idx_type cell) const
{
if (isMultiColumn(cell))
return cellinfo_of_cell(cell).p_width;
}
-string const LyXTabular::getAlignSpecial(int cell, int what) const
+string const LyXTabular::getAlignSpecial(idx_type cell, int what) const
{
if (what == SET_SPECIAL_MULTI)
return cellinfo_of_cell(cell).align_special;
}
-int LyXTabular::getWidthOfCell(int cell) const
+int LyXTabular::getWidthOfCell(idx_type cell) const
{
- int const row = row_of_cell(cell);
- int const column1 = column_of_cell(cell);
- int const column2 = right_column_of_cell(cell);
+ row_type const row = row_of_cell(cell);
+ col_type const column1 = column_of_cell(cell);
+ col_type const column2 = right_column_of_cell(cell);
int result = 0;
- for (int i = column1; i <= column2; ++i)
+ for (col_type i = column1; i <= column2; ++i)
result += cell_info[row][i].width_of_cell;
return result;
}
-int LyXTabular::getBeginningOfTextInCell(int cell) const
+int LyXTabular::getBeginningOfTextInCell(idx_type cell) const
{
int x = 0;
}
-bool LyXTabular::isFirstCellInRow(int cell) const
+bool LyXTabular::isFirstCellInRow(idx_type cell) const
{
return column_of_cell(cell) == 0;
}
-int LyXTabular::getFirstCellInRow(int row) const
+LyXTabular::idx_type LyXTabular::getFirstCellInRow(row_type row) const
{
if (row > rows_ - 1)
row = rows_ - 1;
}
-bool LyXTabular::isLastCellInRow(int cell) const
+bool LyXTabular::isLastCellInRow(idx_type cell) const
{
return right_column_of_cell(cell) == columns_ - 1;
}
-int LyXTabular::getLastCellInRow(int row) const
+LyXTabular::idx_type LyXTabular::getLastCellInRow(row_type row) const
{
if (row > rows_ - 1)
row = rows_ - 1;
}
-void LyXTabular::calculate_width_of_column(int column)
+void LyXTabular::calculate_width_of_column(col_type column)
{
int maximum = 0;
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
maximum = max(cell_info[i][column].width_of_cell, maximum);
column_info[column].width_of_column = maximum;
}
// column of this multicolumn cell as this gives an added width to the
// column, all the rest should be adapted!
//
-bool LyXTabular::calculate_width_of_column_NMC(int column)
+bool LyXTabular::calculate_width_of_column_NMC(col_type column)
{
int const old_column_width = column_info[column].width_of_column;
int max = 0;
- for (int i = 0; i < rows_; ++i) {
- int cell = getCellNumber(i, column);
+ for (row_type i = 0; i < rows_; ++i) {
+ idx_type cell = getCellNumber(i, column);
bool ismulti = isMultiColumnReal(cell);
if ((!ismulti || column == right_column_of_cell(cell)) &&
cell_info[i][column].width_of_cell > max)
void LyXTabular::calculate_width_of_tabular()
{
width_of_tabular = 0;
- for (int i = 0; i < columns_; ++i)
+ for (col_type i = 0; i < columns_; ++i)
width_of_tabular += column_info[i].width_of_column;
}
-int LyXTabular::row_of_cell(int cell) const
+LyXTabular::row_type LyXTabular::row_of_cell(idx_type cell) const
{
if (cell >= numberofcells)
return rows_ - 1;
- if (cell < 0)
+ if (cell == npos)
return 0;
return rowofcell[cell];
}
-int LyXTabular::column_of_cell(int cell) const
+LyXTabular::col_type LyXTabular::column_of_cell(idx_type cell) const
{
if (cell >= numberofcells)
return columns_ - 1;
- if (cell < 0)
+ if (cell == npos)
return 0;
return columnofcell[cell];
}
-int LyXTabular::right_column_of_cell(int cell) const
+LyXTabular::col_type LyXTabular::right_column_of_cell(idx_type cell) const
{
- int const row = row_of_cell(cell);
- int column = column_of_cell(cell);
+ row_type const row = row_of_cell(cell);
+ col_type column = column_of_cell(cell);
while (column < columns_ - 1 &&
cell_info[row][column + 1].multicolumn == LyXTabular::CELL_PART_OF_MULTICOLUMN)
++column;
<< write_attribute("lastFootBottomDL", endlastfoot.bottomDL)
<< write_attribute("lastFootEmpty", endlastfoot.empty)
<< ">\n";
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
os << "<column"
<< write_attribute("alignment", column_info[j].alignment)
<< write_attribute("valignment", column_info[j].valignment)
<< write_attribute("special", column_info[j].align_special)
<< ">\n";
}
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
os << "<row"
<< write_attribute("topline", row_info[i].top_line)
<< write_attribute("bottomline", row_info[i].bottom_line)
<< write_attribute("endlastfoot", row_info[i].endlastfoot)
<< write_attribute("newpage", row_info[i].newpage)
<< ">\n";
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
os << "<cell"
<< write_attribute("multicolumn", cell_info[i][j].multicolumn)
<< write_attribute("alignment", cell_info[i][j].alignment)
}
-void LyXTabular::setHeaderFooterRows(int hr, int fhr, int fr, int lfr)
+void LyXTabular::setHeaderFooterRows(row_type hr, row_type fhr,
+ row_type fr, row_type lfr)
{
// set header info
while (hr > 0) {
getTokenValue(line, "lastFootBottomDL", endlastfoot.bottomDL);
getTokenValue(line, "lastFootEmpty", endlastfoot.empty);
}
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
l_getline(is,line);
if (!prefixIs(line,"<column")) {
lyxerr << "Wrong tabular format (expected <column ...> got"
getTokenValue(line, "special", column_info[j].align_special);
}
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
l_getline(is, line);
if (!prefixIs(line, "<row")) {
lyxerr << "Wrong tabular format (expected <row ...> got"
getTokenValue(line, "endfoot", row_info[i].endfoot);
getTokenValue(line, "endlastfoot", row_info[i].endlastfoot);
getTokenValue(line, "newpage", row_info[i].newpage);
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
l_getline(is, line);
if (!prefixIs(line, "<cell")) {
lyxerr << "Wrong tabular format (expected <cell ...> got"
}
-bool LyXTabular::isMultiColumn(int cell) const
+bool LyXTabular::isMultiColumn(idx_type cell) const
{
return cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL;
}
-bool LyXTabular::isMultiColumnReal(int cell) const
+bool LyXTabular::isMultiColumnReal(idx_type cell) const
{
return column_of_cell(cell) != right_column_of_cell(cell) &&
cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL;
}
-LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(int cell) const
+LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(idx_type cell) const
{
return cell_info[row_of_cell(cell)][column_of_cell(cell)];
}
-void LyXTabular::setMultiColumn(Buffer * buffer, int cell, int number)
+void LyXTabular::setMultiColumn(Buffer * buffer, idx_type cell,
+ idx_type number)
{
cellstruct & cs = cellinfo_of_cell(cell);
cs.multicolumn = CELL_BEGIN_OF_MULTICOLUMN;
cs.top_line = row_info[row_of_cell(cell)].top_line;
cs.bottom_line = row_info[row_of_cell(cell)].bottom_line;
cs.right_line = column_info[column_of_cell(cell+number-1)].right_line;
- for (int i = 1; i < number; ++i) {
+ for (idx_type i = 1; i < number; ++i) {
cellstruct & cs1 = cellinfo_of_cell(cell + i);
cs1.multicolumn = CELL_PART_OF_MULTICOLUMN;
cs.inset->appendParagraphs(buffer, cs1.inset->paragraphs());
}
-int LyXTabular::cells_in_multicolumn(int cell) const
+LyXTabular::idx_type LyXTabular::cells_in_multicolumn(idx_type cell) const
{
- int const row = row_of_cell(cell);
- int column = column_of_cell(cell);
- int result = 1;
+ row_type const row = row_of_cell(cell);
+ col_type column = column_of_cell(cell);
+ idx_type result = 1;
++column;
while (column < columns_ &&
cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN)
}
-int LyXTabular::unsetMultiColumn(int cell)
+LyXTabular::idx_type LyXTabular::unsetMultiColumn(idx_type cell)
{
- int const row = row_of_cell(cell);
- int column = column_of_cell(cell);
+ row_type const row = row_of_cell(cell);
+ col_type column = column_of_cell(cell);
- int result = 0;
+ idx_type result = 0;
if (cell_info[row][column].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) {
cell_info[row][column].multicolumn = CELL_NORMAL;
}
-void LyXTabular::setRotateCell(int cell, bool flag)
+void LyXTabular::setRotateCell(idx_type cell, bool flag)
{
cellinfo_of_cell(cell).rotate = flag;
}
-bool LyXTabular::getRotateCell(int cell) const
+bool LyXTabular::getRotateCell(idx_type cell) const
{
return cellinfo_of_cell(cell).rotate;
}
{
if (rotate)
return true;
- for (int i = 0; i < rows_; ++i)
- for (int j = 0; j < columns_; ++j)
+ for (row_type i = 0; i < rows_; ++i)
+ for (col_type j = 0; j < columns_; ++j)
if (cell_info[i][j].rotate)
return true;
return false;
}
-bool LyXTabular::isLastCell(int cell) const
+bool LyXTabular::isLastCell(idx_type cell) const
{
if (cell + 1 < numberofcells)
return false;
}
-int LyXTabular::getCellAbove(int cell) const
+LyXTabular::idx_type LyXTabular::getCellAbove(idx_type cell) const
{
if (row_of_cell(cell) > 0)
return cell_info[row_of_cell(cell)-1][column_of_cell(cell)].cellno;
}
-int LyXTabular::getCellBelow(int cell) const
+LyXTabular::idx_type LyXTabular::getCellBelow(idx_type cell) const
{
if (row_of_cell(cell) + 1 < rows_)
return cell_info[row_of_cell(cell)+1][column_of_cell(cell)].cellno;
}
-int LyXTabular::getLastCellAbove(int cell) const
+LyXTabular::idx_type LyXTabular::getLastCellAbove(idx_type cell) const
{
- if (row_of_cell(cell) <= 0)
+ if (row_of_cell(cell) == 0)
return cell;
if (!isMultiColumn(cell))
return getCellAbove(cell);
}
-int LyXTabular::getLastCellBelow(int cell) const
+LyXTabular::idx_type LyXTabular::getLastCellBelow(idx_type cell) const
{
if (row_of_cell(cell) + 1 >= rows_)
return cell;
}
-int LyXTabular::getCellNumber(int row, int column) const
+LyXTabular::idx_type LyXTabular::getCellNumber(row_type row,
+ col_type column) const
{
- BOOST_ASSERT(column >= 0 || column < columns_ || row >= 0 || row < rows_);
+ BOOST_ASSERT(column != npos && column < columns_ &&
+ row != npos && row < rows_);
return cell_info[row][column].cellno;
}
-void LyXTabular::setUsebox(int cell, BoxType type)
+void LyXTabular::setUsebox(idx_type cell, BoxType type)
{
cellinfo_of_cell(cell).usebox = type;
}
-LyXTabular::BoxType LyXTabular::getUsebox(int cell) const
+LyXTabular::BoxType LyXTabular::getUsebox(idx_type cell) const
{
if (column_info[column_of_cell(cell)].p_width.zero() &&
!(isMultiColumn(cell) && !cellinfo_of_cell(cell).p_width.zero()))
///
// This are functions used for the longtable support
///
-void LyXTabular::setLTHead(int row, bool flag, ltType const & hd, bool first)
+void LyXTabular::setLTHead(row_type row, bool flag, ltType const & hd,
+ bool first)
{
if (first) {
endfirsthead = hd;
}
-bool LyXTabular::getRowOfLTHead(int row, ltType & hd) const
+bool LyXTabular::getRowOfLTHead(row_type row, ltType & hd) const
{
hd = endhead;
hd.set = haveLTHead();
}
-bool LyXTabular::getRowOfLTFirstHead(int row, ltType & hd) const
+bool LyXTabular::getRowOfLTFirstHead(row_type row, ltType & hd) const
{
hd = endfirsthead;
hd.set = haveLTFirstHead();
}
-void LyXTabular::setLTFoot(int row, bool flag, ltType const & fd, bool last)
+void LyXTabular::setLTFoot(row_type row, bool flag, ltType const & fd,
+ bool last)
{
if (last) {
endlastfoot = fd;
}
-bool LyXTabular::getRowOfLTFoot(int row, ltType & fd) const
+bool LyXTabular::getRowOfLTFoot(row_type row, ltType & fd) const
{
fd = endfoot;
fd.set = haveLTFoot();
}
-bool LyXTabular::getRowOfLTLastFoot(int row, ltType & fd) const
+bool LyXTabular::getRowOfLTLastFoot(row_type row, ltType & fd) const
{
fd = endlastfoot;
fd.set = haveLTLastFoot();
}
-void LyXTabular::setLTNewPage(int row, bool what)
+void LyXTabular::setLTNewPage(row_type row, bool what)
{
row_info[row].newpage = what;
}
-bool LyXTabular::getLTNewPage(int row) const
+bool LyXTabular::getLTNewPage(row_type row) const
{
return row_info[row].newpage;
}
bool LyXTabular::haveLTHead() const
{
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
if (row_info[i].endhead)
return true;
return false;
{
if (endfirsthead.empty)
return false;
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
if (row_info[i].endfirsthead)
return true;
return false;
bool LyXTabular::haveLTFoot() const
{
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
if (row_info[i].endfoot)
return true;
return false;
{
if (endlastfoot.empty)
return false;
- for (int i = 0; i < rows_; ++i)
+ for (row_type i = 0; i < rows_; ++i)
if (row_info[i].endlastfoot)
return true;
return false;
// end longtable support functions
-void LyXTabular::setAscentOfRow(int row, int height)
+void LyXTabular::setAscentOfRow(row_type row, int height)
{
if (row >= rows_ || row_info[row].ascent_of_row == height)
return;
}
-void LyXTabular::setDescentOfRow(int row, int height)
+void LyXTabular::setDescentOfRow(row_type row, int height)
{
if (row >= rows_ || row_info[row].descent_of_row == height)
return;
}
-int LyXTabular::getAscentOfRow(int row) const
+int LyXTabular::getAscentOfRow(row_type row) const
{
if (row >= rows_)
return 0;
}
-int LyXTabular::getDescentOfRow(int row) const
+int LyXTabular::getDescentOfRow(row_type row) const
{
BOOST_ASSERT(row < rows_);
return row_info[row].descent_of_row;
int LyXTabular::getHeightOfTabular() const
{
int height = 0;
- for (int row = 0; row < rows_; ++row)
+ for (row_type row = 0; row < rows_; ++row)
height += getAscentOfRow(row) + getDescentOfRow(row) +
getAdditionalHeight(row);
return height;
}
-bool LyXTabular::isPartOfMultiColumn(int row, int column) const
+bool LyXTabular::isPartOfMultiColumn(row_type row, col_type column) const
{
BOOST_ASSERT(row < rows_);
BOOST_ASSERT(column < columns_);
}
-int LyXTabular::TeXTopHLine(ostream & os, int row) const
+int LyXTabular::TeXTopHLine(ostream & os, row_type row) const
{
- BOOST_ASSERT(row >= 0);
+ // FIXME: assert or return 0 as in TeXBottomHLine()?
+ BOOST_ASSERT(row != npos);
BOOST_ASSERT(row < rows_);
- int const fcell = getFirstCellInRow(row);
- int const n = numberOfCellsInRow(fcell) + fcell;
- int tmp = 0;
+ idx_type const fcell = getFirstCellInRow(row);
+ idx_type const n = numberOfCellsInRow(fcell) + fcell;
+ idx_type tmp = 0;
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (topLine(i))
++tmp;
}
if (tmp == n - fcell) {
os << "\\hline ";
} else if (tmp) {
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (topLine(i)) {
os << "\\cline{"
<< column_of_cell(i) + 1
}
-int LyXTabular::TeXBottomHLine(ostream & os, int row) const
+int LyXTabular::TeXBottomHLine(ostream & os, row_type row) const
{
- if (row < 0 || row >= rows_)
+ // FIXME: return 0 or assert as in TeXTopHLine()?
+ if (row == npos || row >= rows_)
return 0;
- int const fcell = getFirstCellInRow(row);
- int const n = numberOfCellsInRow(fcell) + fcell;
- int tmp = 0;
+ idx_type const fcell = getFirstCellInRow(row);
+ idx_type const n = numberOfCellsInRow(fcell) + fcell;
+ idx_type tmp = 0;
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (bottomLine(i))
++tmp;
}
if (tmp == n - fcell) {
os << "\\hline";
} else if (tmp) {
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (bottomLine(i)) {
os << "\\cline{"
<< column_of_cell(i) + 1
}
-int LyXTabular::TeXCellPreamble(ostream & os, int cell) const
+int LyXTabular::TeXCellPreamble(ostream & os, idx_type cell) const
{
int ret = 0;
}
-int LyXTabular::TeXCellPostamble(ostream & os, int cell) const
+int LyXTabular::TeXCellPostamble(ostream & os, idx_type cell) const
{
int ret = 0;
os << "\\hline\n";
++ret;
}
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (row_info[i].endhead) {
ret += TeXRow(os, i, buf, runparams);
}
os << "\\hline\n";
++ret;
}
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (row_info[i].endfirsthead) {
ret += TeXRow(os, i, buf, runparams);
}
os << "\\hline\n";
++ret;
}
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (row_info[i].endfoot) {
ret += TeXRow(os, i, buf, runparams);
}
os << "\\hline\n";
++ret;
}
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (row_info[i].endlastfoot) {
ret += TeXRow(os, i, buf, runparams);
}
}
-bool LyXTabular::isValidRow(int row) const
+bool LyXTabular::isValidRow(row_type row) const
{
if (!is_long_tabular)
return true;
}
-int LyXTabular::TeXRow(ostream & os, int i, Buffer const & buf,
+int LyXTabular::TeXRow(ostream & os, row_type i, Buffer const & buf,
OutputParams const & runparams) const
{
- int cell = getCellNumber(i, 0);
+ idx_type cell = getCellNumber(i, 0);
int ret = TeXTopHLine(os, i);
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
if (isPartOfMultiColumn(i, j))
continue;
ret += TeXCellPreamble(os, cell);
os << "\\begin{longtable}{";
else
os << "\\begin{tabular}{";
- for (int i = 0; i < columns_; ++i) {
+ for (col_type i = 0; i < columns_; ++i) {
if (!column_info[i].align_special.empty()) {
os << column_info[i].align_special;
} else {
//+ the single row and columns (cells) +
//+---------------------------------------------------------------------
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (isValidRow(i)) {
ret += TeXRow(os, i, buf, runparams);
if (is_long_tabular && row_info[i].newpage) {
const OutputParams & runparams) const
{
os << "<tabular ca=\"";
- for (int i = 0; i < columns_; ++i) {
+ for (col_type i = 0; i < columns_; ++i) {
switch (column_info[i].alignment) {
case LYX_ALIGN_LEFT:
os << 'l';
}
}
os << "\">\n";
- int cell = 0;
+ idx_type cell = 0;
int ret = 0;
- for (int i = 0; i < rows_; ++i) {
- for (int j = 0; j < columns_; ++j) {
+ for (row_type i = 0; i < rows_; ++i) {
+ for (col_type j = 0; j < columns_; ++j) {
if (isPartOfMultiColumn(i, j))
continue;
shared_ptr<InsetText> inset = getCellInset(cell);
}
-int LyXTabular::docbookRow(Buffer const & buf, ostream & os, int row,
+int LyXTabular::docbookRow(Buffer const & buf, ostream & os, row_type row,
OutputParams const & runparams) const
{
int ret = 0;
- int cell = getFirstCellInRow(row);
+ idx_type cell = getFirstCellInRow(row);
os << "<row>\n";
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
if (isPartOfMultiColumn(row, j))
continue;
os << "<tgroup cols=\"" << columns_
<< "\" colsep=\"1\" rowsep=\"1\">\n";
- for (int i = 0; i < columns_; ++i) {
+ for (col_type i = 0; i < columns_; ++i) {
os << "<colspec colname=\"col" << i << "\" align=\"";
switch (column_info[i].alignment) {
case LYX_ALIGN_LEFT:
if (haveLTHead() || haveLTFirstHead()) {
os << "<thead>\n";
++ret;
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (row_info[i].endhead || row_info[i].endfirsthead) {
ret += docbookRow(buf, os, i, runparams);
}
if (haveLTFoot() || haveLTLastFoot()) {
os << "<tfoot>\n";
++ret;
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (row_info[i].endfoot || row_info[i].endlastfoot) {
ret += docbookRow(buf, os, i, runparams);
}
os << "<tbody>\n";
++ret;
- for (int i = 0; i < rows_; ++i) {
+ for (row_type i = 0; i < rows_; ++i) {
if (isValidRow(i)) {
ret += docbookRow(buf, os, i, runparams);
}
}
-int LyXTabular::asciiTopHLine(ostream & os, int row,
+int LyXTabular::asciiTopHLine(ostream & os, row_type row,
vector<unsigned int> const & clen) const
{
- int const fcell = getFirstCellInRow(row);
- int const n = numberOfCellsInRow(fcell) + fcell;
- int tmp = 0;
+ idx_type const fcell = getFirstCellInRow(row);
+ idx_type const n = numberOfCellsInRow(fcell) + fcell;
+ idx_type tmp = 0;
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (topLine(i)) {
++tmp;
break;
return 0;
unsigned char ch;
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (topLine(i)) {
if (leftLine(i))
os << "+-";
os << " ";
ch = ' ';
}
- int column = column_of_cell(i);
+ col_type column = column_of_cell(i);
int len = clen[column];
while (column < columns_ - 1
&& isPartOfMultiColumn(row, ++column))
}
-int LyXTabular::asciiBottomHLine(ostream & os, int row,
+int LyXTabular::asciiBottomHLine(ostream & os, row_type row,
vector<unsigned int> const & clen) const
{
- int const fcell = getFirstCellInRow(row);
- int const n = numberOfCellsInRow(fcell) + fcell;
- int tmp = 0;
+ idx_type const fcell = getFirstCellInRow(row);
+ idx_type const n = numberOfCellsInRow(fcell) + fcell;
+ idx_type tmp = 0;
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (bottomLine(i)) {
++tmp;
break;
return 0;
unsigned char ch;
- for (int i = fcell; i < n; ++i) {
+ for (idx_type i = fcell; i < n; ++i) {
if (bottomLine(i)) {
if (leftLine(i))
os << "+-";
os << " ";
ch = ' ';
}
- int column = column_of_cell(i);
+ col_type column = column_of_cell(i);
int len = clen[column];
while (column < columns_ -1
&& isPartOfMultiColumn(row, ++column))
int LyXTabular::asciiPrintCell(Buffer const & buf, ostream & os,
OutputParams const & runparams,
- int cell, int row, int column,
+ idx_type cell, row_type row, col_type column,
vector<unsigned int> const & clen,
bool onlydata) const
{
if (!onlydata) {
// first all non (real) multicolumn cells!
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
clen[j] = 0;
- for (int i = 0; i < rows_; ++i) {
- int cell = getCellNumber(i, j);
+ for (row_type i = 0; i < rows_; ++i) {
+ idx_type cell = getCellNumber(i, j);
if (isMultiColumnReal(cell))
continue;
ostringstream sstr;
}
}
// then all (real) multicolumn cells!
- for (int j = 0; j < columns_; ++j) {
- for (int i = 0; i < rows_; ++i) {
- int cell = getCellNumber(i, j);
+ for (col_type j = 0; j < columns_; ++j) {
+ for (row_type i = 0; i < rows_; ++i) {
+ idx_type cell = getCellNumber(i, j);
if (!isMultiColumnReal(cell) || isPartOfMultiColumn(i, j))
continue;
ostringstream sstr;
getCellInset(cell)->plaintext(buf, sstr, runparams);
int len = int(sstr.str().length());
- int const n = cells_in_multicolumn(cell);
- for (int k = j; len > 0 && k < j + n - 1; ++k)
+ idx_type const n = cells_in_multicolumn(cell);
+ for (col_type k = j; len > 0 && k < j + n - 1; ++k)
len -= clen[k];
if (len > int(clen[j + n - 1]))
clen[j + n - 1] = len;
}
}
}
- int cell = 0;
- for (int i = 0; i < rows_; ++i) {
+ idx_type cell = 0;
+ for (row_type i = 0; i < rows_; ++i) {
if (!onlydata && asciiTopHLine(os, i, clen))
os << string(depth * 2, ' ');
- for (int j = 0; j < columns_; ++j) {
+ for (col_type j = 0; j < columns_; ++j) {
if (isPartOfMultiColumn(i, j))
continue;
if (onlydata && j > 0)
}
-shared_ptr<InsetText> LyXTabular::getCellInset(int cell) const
+shared_ptr<InsetText> LyXTabular::getCellInset(idx_type cell) const
{
return cell_info[row_of_cell(cell)][column_of_cell(cell)].inset;
}
-shared_ptr<InsetText> LyXTabular::getCellInset(int row, int column) const
+shared_ptr<InsetText> LyXTabular::getCellInset(row_type row,
+ col_type column) const
{
return cell_info[row][column].inset;
}
-int LyXTabular::getCellFromInset(InsetBase const * inset) const
+LyXTabular::idx_type
+LyXTabular::getCellFromInset(InsetBase const * inset) const
{
// is this inset part of the tabular?
if (!inset) {
BOOST_ASSERT(false);
}
- for (int cell = 0, n = getNumberOfCells(); cell < n; ++cell)
+ for (idx_type cell = 0, n = getNumberOfCells(); cell < n; ++cell)
if (getCellInset(cell).get() == inset) {
lyxerr[Debug::INSETTEXT] << "LyXTabular::getCellFromInset: "
<< "cell=" << cell << endl;
features.require("longtable");
if (needRotating())
features.require("rotating");
- for (int cell = 0; cell < numberofcells; ++cell) {
+ for (idx_type cell = 0; cell < numberofcells; ++cell) {
if (getVAlignment(cell) != LYX_VALIGN_TOP ||
(!getPWidth(cell).zero() && !isMultiColumn(cell)))
features.require("array");
void LyXTabular::getLabelList(Buffer const & buffer,
std::vector<string> & list) const
{
- for (int i = 0; i < rows_; ++i)
- for (int j = 0; j < columns_; ++j)
+ for (row_type i = 0; i < rows_; ++i)
+ for (col_type j = 0; j < columns_; ++j)
getCellInset(i, j)->getLabelList(buffer, list);
}
-LyXTabular::BoxType LyXTabular::useParbox(int cell) const
+LyXTabular::BoxType LyXTabular::useParbox(idx_type cell) const
{
ParagraphList const & parlist = getCellInset(cell)->paragraphs();
ParagraphList::const_iterator cit = parlist.begin();
bool empty;
};
+ /// type for row numbers
+ typedef size_t row_type;
+ /// type for column numbers
+ typedef size_t col_type;
+ /// type for cell indices
+ typedef size_t idx_type;
+ /// index indicating an invalid position
+ static const idx_type npos = static_cast<idx_type>(-1);
+
/// constructor
- LyXTabular(BufferParams const &, int columns_arg, int rows_arg);
+ LyXTabular(BufferParams const &, col_type columns_arg,
+ row_type rows_arg);
/// Returns true if there is a topline, returns false if not
- bool topLine(int cell, bool onlycolumn = false) const;
+ bool topLine(idx_type cell, bool onlycolumn = false) const;
/// Returns true if there is a topline, returns false if not
- bool bottomLine(int cell, bool onlycolumn = false) const;
+ bool bottomLine(idx_type cell, bool onlycolumn = false) const;
/// Returns true if there is a topline, returns false if not
- bool leftLine(int cell, bool onlycolumn = false) const;
+ bool leftLine(idx_type cell, bool onlycolumn = false) const;
/// Returns true if there is a topline, returns false if not
- bool rightLine(int cell, bool onlycolumn = false) const;
+ bool rightLine(idx_type cell, bool onlycolumn = false) const;
///
- bool topAlreadyDrawn(int cell) const;
+ bool topAlreadyDrawn(idx_type cell) const;
///
- bool leftAlreadyDrawn(int cell) const;
+ bool leftAlreadyDrawn(idx_type cell) const;
///
- bool isLastRow(int cell) const;
+ bool isLastRow(idx_type cell) const;
///
- int getAdditionalHeight(int row) const;
+ int getAdditionalHeight(row_type row) const;
///
- int getAdditionalWidth(int cell) const;
+ int getAdditionalWidth(idx_type cell) const;
/* returns the maximum over all rows */
///
- int getWidthOfColumn(int cell) const;
+ int getWidthOfColumn(idx_type cell) const;
///
int getWidthOfTabular() const;
///
- int getAscentOfRow(int row) const;
+ int getAscentOfRow(row_type row) const;
///
- int getDescentOfRow(int row) const;
+ int getDescentOfRow(row_type row) const;
///
int getHeightOfTabular() const;
///
- void setAscentOfRow(int row, int height);
+ void setAscentOfRow(row_type row, int height);
///
- void setDescentOfRow(int row, int height);
+ void setDescentOfRow(row_type row, int height);
///
- void setWidthOfCell(int cell, int new_width);
+ void setWidthOfCell(idx_type cell, int new_width);
///
- void setAllLines(int cell, bool line);
+ void setAllLines(idx_type cell, bool line);
///
- void setTopLine(int cell, bool line, bool onlycolumn = false);
+ void setTopLine(idx_type cell, bool line, bool onlycolumn = false);
///
- void setBottomLine(int cell, bool line, bool onlycolumn = false);
+ void setBottomLine(idx_type cell, bool line, bool onlycolumn = false);
///
- void setLeftLine(int cell, bool line, bool onlycolumn = false);
+ void setLeftLine(idx_type cell, bool line, bool onlycolumn = false);
///
- void setRightLine(int cell, bool line, bool onlycolumn = false);
+ void setRightLine(idx_type cell, bool line, bool onlycolumn = false);
///
- void setAlignment(int cell, LyXAlignment align,
+ void setAlignment(idx_type cell, LyXAlignment align,
bool onlycolumn = false);
///
- void setVAlignment(int cell, VAlignment align,
+ void setVAlignment(idx_type cell, VAlignment align,
bool onlycolumn = false);
///
- void setColumnPWidth(int cell, LyXLength const & width);
+ void setColumnPWidth(idx_type cell, LyXLength const & width);
///
- bool setMColumnPWidth(int cell, LyXLength const & width);
+ bool setMColumnPWidth(idx_type cell, LyXLength const & width);
///
- void setAlignSpecial(int cell, std::string const & special, Feature what);
+ void setAlignSpecial(idx_type cell, std::string const & special,
+ Feature what);
///
- LyXAlignment getAlignment(int cell, bool onlycolumn = false) const;
+ LyXAlignment getAlignment(idx_type cell,
+ bool onlycolumn = false) const;
///
- VAlignment getVAlignment(int cell, bool onlycolumn = false) const;
+ VAlignment getVAlignment(idx_type cell,
+ bool onlycolumn = false) const;
///
- LyXLength const getPWidth(int cell) const;
+ LyXLength const getPWidth(idx_type cell) const;
///
- LyXLength const getColumnPWidth(int cell) const;
+ LyXLength const getColumnPWidth(idx_type cell) const;
///
- LyXLength const getMColumnPWidth(int cell) const;
+ LyXLength const getMColumnPWidth(idx_type cell) const;
///
- std::string const getAlignSpecial(int cell, int what) const;
+ std::string const getAlignSpecial(idx_type cell, int what) const;
///
- int getWidthOfCell(int cell) const;
+ int getWidthOfCell(idx_type cell) const;
///
- int getBeginningOfTextInCell(int cell) const;
+ int getBeginningOfTextInCell(idx_type cell) const;
///
- void appendRow(BufferParams const &, int cell);
+ void appendRow(BufferParams const &, idx_type cell);
///
- void deleteRow(int row);
+ void deleteRow(row_type row);
///
- void appendColumn(BufferParams const &, int cell);
+ void appendColumn(BufferParams const &, idx_type cell);
///
- void deleteColumn(int column);
+ void deleteColumn(col_type column);
///
- bool isFirstCellInRow(int cell) const;
+ bool isFirstCellInRow(idx_type cell) const;
///
- int getFirstCellInRow(int row) const;
+ idx_type getFirstCellInRow(row_type row) const;
///
- bool isLastCellInRow(int cell) const;
+ bool isLastCellInRow(idx_type cell) const;
///
- int getLastCellInRow(int row) const;
+ idx_type getLastCellInRow(row_type row) const;
///
- int getNumberOfCells() const;
+ idx_type getNumberOfCells() const;
///
- int numberOfCellsInRow(int cell) const;
+ idx_type numberOfCellsInRow(idx_type cell) const;
///
void write(Buffer const &, std::ostream &) const;
///
int const depth,
bool onlydata, unsigned char delim) const;
///
- bool isMultiColumn(int cell) const;
+ bool isMultiColumn(idx_type cell) const;
///
- bool isMultiColumnReal(int cell) const;
+ bool isMultiColumnReal(idx_type cell) const;
///
- void setMultiColumn(Buffer *, int cell, int number);
+ void setMultiColumn(Buffer *, idx_type cell, idx_type number);
///
- int unsetMultiColumn(int cell); // returns number of new cells
+ idx_type unsetMultiColumn(idx_type cell); // returns number of new cells
///
- bool isPartOfMultiColumn(int row, int column) const;
+ bool isPartOfMultiColumn(row_type row, col_type column) const;
///
- int row_of_cell(int cell) const;
+ row_type row_of_cell(idx_type cell) const;
///
- int column_of_cell(int cell) const;
+ col_type column_of_cell(idx_type cell) const;
///
- int right_column_of_cell(int cell) const;
+ col_type right_column_of_cell(idx_type cell) const;
///
void setLongTabular(bool);
///
///
bool getRotateTabular() const;
///
- void setRotateCell(int cell, bool);
+ void setRotateCell(idx_type cell, bool);
///
- bool getRotateCell(int cell) const;
+ bool getRotateCell(idx_type cell) const;
///
bool needRotating() const;
///
- bool isLastCell(int cell) const;
+ bool isLastCell(idx_type cell) const;
///
- int getCellAbove(int cell) const;
+ idx_type getCellAbove(idx_type cell) const;
///
- int getCellBelow(int cell) const;
+ idx_type getCellBelow(idx_type cell) const;
///
- int getLastCellAbove(int cell) const;
+ idx_type getLastCellAbove(idx_type cell) const;
///
- int getLastCellBelow(int cell) const;
+ idx_type getLastCellBelow(idx_type cell) const;
///
- int getCellNumber(int row, int column) const;
+ idx_type getCellNumber(row_type row, col_type column) const;
///
- void setUsebox(int cell, BoxType);
+ void setUsebox(idx_type cell, BoxType);
///
- BoxType getUsebox(int cell) const;
+ BoxType getUsebox(idx_type cell) const;
//
// Long Tabular Options support functions
///
- bool checkLTType(int row, ltType const &) const;
+ bool checkLTType(row_type row, ltType const &) const;
///
- void setLTHead(int row, bool flag, ltType const &, bool first);
+ void setLTHead(row_type row, bool flag, ltType const &, bool first);
///
- bool getRowOfLTHead(int row, ltType &) const;
+ bool getRowOfLTHead(row_type row, ltType &) const;
///
- bool getRowOfLTFirstHead(int row, ltType &) const;
+ bool getRowOfLTFirstHead(row_type row, ltType &) const;
///
- void setLTFoot(int row, bool flag, ltType const &, bool last);
+ void setLTFoot(row_type row, bool flag, ltType const &, bool last);
///
- bool getRowOfLTFoot(int row, ltType &) const;
+ bool getRowOfLTFoot(row_type row, ltType &) const;
///
- bool getRowOfLTLastFoot(int row, ltType &) const;
+ bool getRowOfLTLastFoot(row_type row, ltType &) const;
///
- void setLTNewPage(int row, bool what);
+ void setLTNewPage(row_type row, bool what);
///
- bool getLTNewPage(int row) const;
+ bool getLTNewPage(row_type row) const;
///
bool haveLTHead() const;
///
///
// end longtable support
///
- boost::shared_ptr<InsetText> getCellInset(int cell) const;
+ boost::shared_ptr<InsetText> getCellInset(idx_type cell) const;
///
- boost::shared_ptr<InsetText> getCellInset(int row, int column) const;
+ boost::shared_ptr<InsetText> getCellInset(row_type row,
+ col_type column) const;
/// Search for \param inset in the tabular, with the
///
- int getCellFromInset(InsetBase const * inset) const;
+ idx_type getCellFromInset(InsetBase const * inset) const;
///
- int rows() const { return rows_; }
+ row_type rows() const { return rows_; }
///
- int columns() const { return columns_;}
+ col_type columns() const { return columns_;}
///
void validate(LaTeXFeatures &) const;
/// Appends \c list with all labels found within this inset.
///
void swap(cellstruct & rhs);
///
- int cellno;
+ idx_type cellno;
///
int width_of_cell;
///
///
boost::shared_ptr<InsetText> inset;
};
- cellstruct & cellinfo_of_cell(int cell) const;
+ cellstruct & cellinfo_of_cell(idx_type cell) const;
///
typedef std::vector<cellstruct> cell_vector;
///
typedef std::vector<columnstruct> column_vector;
///
- int rows_;
+ row_type rows_;
///
- int columns_;
+ col_type columns_;
///
- int numberofcells;
+ idx_type numberofcells;
///
- std::vector<int> rowofcell;
+ std::vector<row_type> rowofcell;
///
- std::vector<int> columnofcell;
+ std::vector<col_type> columnofcell;
///
row_vector row_info;
///
ltType endlastfoot;
///
- void init(BufferParams const &, int rows_arg, int columns_arg);
+ void init(BufferParams const &, row_type rows_arg,
+ col_type columns_arg);
///
void set_row_column_number_info();
/// Returns true if a complete update is necessary, otherwise false
- bool setWidthOfMulticolCell(int cell, int new_width);
+ bool setWidthOfMulticolCell(idx_type cell, int new_width);
///
- void recalculateMulticolumnsOfColumn(int column);
+ void recalculateMulticolumnsOfColumn(col_type column);
/// Returns true if change
- void calculate_width_of_column(int column);
+ void calculate_width_of_column(col_type column);
///
- bool calculate_width_of_column_NMC(int column); // no multi cells
+ bool calculate_width_of_column_NMC(col_type column); // no multi cells
///
void calculate_width_of_tabular();
///
- void delete_column(int column);
+ void delete_column(col_type column);
///
- int cells_in_multicolumn(int cell) const;
+ idx_type cells_in_multicolumn(idx_type cell) const;
///
- BoxType useParbox(int cell) const;
+ BoxType useParbox(idx_type cell) const;
///
- void setHeaderFooterRows(int header, int fheader, int footer, int lfooter);
+ void setHeaderFooterRows(row_type header, row_type fheader,
+ row_type footer, row_type lfooter);
///
// helper function for Latex returns number of newlines
///
- int TeXTopHLine(std::ostream &, int row) const;
+ int TeXTopHLine(std::ostream &, row_type row) const;
///
- int TeXBottomHLine(std::ostream &, int row) const;
+ int TeXBottomHLine(std::ostream &, row_type row) const;
///
- int TeXCellPreamble(std::ostream &, int cell) const;
+ int TeXCellPreamble(std::ostream &, idx_type cell) const;
///
- int TeXCellPostamble(std::ostream &, int cell) const;
+ int TeXCellPostamble(std::ostream &, idx_type cell) const;
///
int TeXLongtableHeaderFooter(std::ostream &, Buffer const & buf,
OutputParams const &) const;
///
- bool isValidRow(int const row) const;
+ bool isValidRow(row_type const row) const;
///
- int TeXRow(std::ostream &, int const row, Buffer const & buf,
+ int TeXRow(std::ostream &, row_type const row, Buffer const & buf,
OutputParams const &) const;
///
// helper function for ASCII returns number of newlines
///
- int asciiTopHLine(std::ostream &, int row,
+ int asciiTopHLine(std::ostream &, row_type row,
std::vector<unsigned int> const &) const;
///
- int asciiBottomHLine(std::ostream &, int row,
+ int asciiBottomHLine(std::ostream &, row_type row,
std::vector<unsigned int> const &) const;
///
int asciiPrintCell(Buffer const &, std::ostream &,
OutputParams const &,
- int cell, int row, int column,
+ idx_type cell, row_type row, col_type column,
std::vector<unsigned int> const &,
bool onlydata) const;
/// auxiliary function for docbook
- int docbookRow(Buffer const & buf, std::ostream & os, int,
+ int docbookRow(Buffer const & buf, std::ostream & os, row_type,
OutputParams const &) const;
private:
projects / features.git / commitdiff