From: Georg Baum Date: Fri, 3 Dec 2004 13:57:50 +0000 (+0000) Subject: use better index types for tabular rows, columns and cells than int X-Git-Tag: 1.6.10~14768 X-Git-Url: https://git.lyx.org/gitweb/?a=commitdiff_plain;h=e70294c413c277ef4826565ea5a4b4993959efa2;p=features.git use better index types for tabular rows, columns and cells than int git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@9334 a592a061-630c-0410-9148-cb99ea01b6c8 --- diff --git a/src/ChangeLog b/src/ChangeLog index 0d6ed80ef7..9b0ab7b437 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,8 @@ +2004-12-02 Georg Baum + + * tabular.[Ch]: use size_t-like types for cell, row and column + indices + 2004-12-01 Jean-Marc Lasgouttes * lyxfunc.C (getStatus): do not lose previous information when diff --git a/src/frontends/controllers/ChangeLog b/src/frontends/controllers/ChangeLog index 8bfb5ff33c..fecfea49ea 100644 --- a/src/frontends/controllers/ChangeLog +++ b/src/frontends/controllers/ChangeLog @@ -1,3 +1,8 @@ +2004-12-02 Georg Baum + + * ControlTabular.[Ch], ControlTabularCreate.h: use size_t-like + types for cell, row and column indices + 2004-11-25 Angus Leeming * ControlBibtex.C: diff --git a/src/frontends/controllers/ControlTabular.C b/src/frontends/controllers/ControlTabular.C index 5fa7c20cac..6cfb5df188 100644 --- a/src/frontends/controllers/ControlTabular.C +++ b/src/frontends/controllers/ControlTabular.C @@ -25,7 +25,7 @@ namespace lyx { namespace frontend { ControlTabular::ControlTabular(Dialog & parent) - : Dialog::Controller(parent), active_cell_(-1) + : Dialog::Controller(parent), active_cell_(LyXTabular::npos) {} @@ -53,11 +53,11 @@ bool ControlTabular::initialiseParams(string const & data) void ControlTabular::clearParams() { params_.reset(); - active_cell_ = -1; + active_cell_ = LyXTabular::npos; } -int ControlTabular::getActiveCell() const +LyXTabular::idx_type ControlTabular::getActiveCell() const { return active_cell_; } diff --git a/src/frontends/controllers/ControlTabular.h b/src/frontends/controllers/ControlTabular.h index 51533accca..acd260139f 100644 --- a/src/frontends/controllers/ControlTabular.h +++ b/src/frontends/controllers/ControlTabular.h @@ -36,7 +36,7 @@ public: virtual bool isBufferDependent() const { return true; } /// - int getActiveCell() const; + LyXTabular::idx_type getActiveCell() const; /// get the contained tabular LyXTabular const & tabular() const; /// return true if units should default to metric @@ -71,7 +71,7 @@ public: private: /// - int active_cell_; + LyXTabular::idx_type active_cell_; /// boost::scoped_ptr params_; }; diff --git a/src/frontends/controllers/ControlTabularCreate.h b/src/frontends/controllers/ControlTabularCreate.h index 62dede1eba..815cb26bd3 100644 --- a/src/frontends/controllers/ControlTabularCreate.h +++ b/src/frontends/controllers/ControlTabularCreate.h @@ -34,7 +34,7 @@ public: virtual bool isBufferDependent() const { return true; } /// - typedef std::pair rowsCols; + typedef std::pair rowsCols; /// rowsCols & params() { return params_; } diff --git a/src/frontends/gtk/ChangeLog b/src/frontends/gtk/ChangeLog index 24b28c16ab..e1267dcf3e 100644 --- a/src/frontends/gtk/ChangeLog +++ b/src/frontends/gtk/ChangeLog @@ -1,3 +1,8 @@ +2004-12-02 Georg Baum + + * GTableCreate.C: use size_t-like types for cell, row and column + indices + 2004-11-29 John Spray * GToolbar.C: Make layouts combobox not expand to full height diff --git a/src/frontends/gtk/GTableCreate.C b/src/frontends/gtk/GTableCreate.C index 3405f60265..c8b57c4ac8 100644 --- a/src/frontends/gtk/GTableCreate.C +++ b/src/frontends/gtk/GTableCreate.C @@ -53,8 +53,8 @@ void GTableCreate::doBuild() void GTableCreate::apply() { - int const rows = rows_->get_value_as_int(); - int const columns = columns_->get_value_as_int(); + size_t const rows = rows_->get_value_as_int(); + size_t const columns = columns_->get_value_as_int(); controller().params() = std::make_pair(columns, rows); } diff --git a/src/frontends/qt2/ChangeLog b/src/frontends/qt2/ChangeLog index 2992d03646..5ff7f433b4 100644 --- a/src/frontends/qt2/ChangeLog +++ b/src/frontends/qt2/ChangeLog @@ -1,3 +1,7 @@ +2004-12-02 Georg Baum + + * QTabular.C: use size_t-like types for cell, row and column indices + 2004-12-03 Jürgen Spitzmüller * lengthvalidator.C: revert to correct if clause. diff --git a/src/frontends/qt2/QTabular.C b/src/frontends/qt2/QTabular.C index 850b6d5316..4f851221f9 100644 --- a/src/frontends/qt2/QTabular.C +++ b/src/frontends/qt2/QTabular.C @@ -92,7 +92,7 @@ bool QTabular::isValid() void QTabular::update_borders() { LyXTabular const & tabular = controller().tabular(); - int const cell = controller().getActiveCell(); + LyXTabular::idx_type const cell = controller().getActiveCell(); bool const isMulticolumnCell = tabular.isMultiColumn(cell); if (!isMulticolumnCell) { @@ -134,10 +134,10 @@ void QTabular::update_borders() void QTabular::update_contents() { LyXTabular const & tabular(controller().tabular()); - int const cell = controller().getActiveCell(); + LyXTabular::idx_type const cell = controller().getActiveCell(); - int const row(tabular.row_of_cell(cell)); - int const col(tabular.column_of_cell(cell)); + LyXTabular::row_type const row(tabular.row_of_cell(cell)); + LyXTabular::col_type const col(tabular.column_of_cell(cell)); dialog_->tabularRowED->setText(toqstr(tostr(row + 1))); dialog_->tabularColumnED->setText(toqstr(tostr(col + 1))); @@ -333,7 +333,7 @@ void QTabular::closeGUI() LyXTabular const & tabular(controller().tabular()); // apply the fixed width values - int const cell = controller().getActiveCell(); + LyXTabular::idx_type const cell = controller().getActiveCell(); bool const multicol = tabular.isMultiColumn(cell); string width = widgetsToLength(dialog_->widthED, dialog_->widthUnit); string width2; diff --git a/src/frontends/xforms/ChangeLog b/src/frontends/xforms/ChangeLog index e5c3a2bbd0..8efd04b289 100644 --- a/src/frontends/xforms/ChangeLog +++ b/src/frontends/xforms/ChangeLog @@ -1,3 +1,8 @@ +2004-12-02 Georg Baum + + * FormTabular.[Ch], FormTabularCreate.C: use size_t-like types for + cell, row and column indices + 2004-11-26 Angus Leeming * xscreen.C: diff --git a/src/frontends/xforms/FormTabular.C b/src/frontends/xforms/FormTabular.C index cc395ba822..c307dcb9d3 100644 --- a/src/frontends/xforms/FormTabular.C +++ b/src/frontends/xforms/FormTabular.C @@ -11,13 +11,13 @@ #include #include "FormTabular.h" -#include "ControlTabular.h" #include "forms/form_tabular.h" #include "xforms_helpers.h" #include "xformsBC.h" #include "controllers/ButtonController.h" +#include "controllers/ControlTabular.h" #include "controllers/helper_funcs.h" #include "support/lstrings.h" @@ -54,7 +54,7 @@ typedef FormController > base_class; FormTabular::FormTabular(Dialog & parent) : base_class(parent, _("Table Settings"), scalableTabfolders), - closing_(false), actCell_(-1) + closing_(false), actCell_(LyXTabular::npos) { } @@ -156,9 +156,9 @@ void FormTabular::update() LyXLength pwidth; string special; - int const cell = controller().getActiveCell(); + LyXTabular::idx_type const cell = controller().getActiveCell(); actCell_ = cell; - int column = tabular.column_of_cell(cell) + 1; + LyXTabular::col_type column = tabular.column_of_cell(cell) + 1; clearMessage(); fl_activate_object(column_options_->input_special_alignment); fl_activate_object(cell_options_->input_special_multialign); @@ -167,7 +167,7 @@ void FormTabular::update() sprintf(buf, "%d", column); fl_set_input(dialog_->input_tabular_column, buf); fl_deactivate_object(dialog_->input_tabular_column); - int row = tabular.row_of_cell(cell); + LyXTabular::row_type row = tabular.row_of_cell(cell); sprintf(buf, "%d", row + 1); fl_set_input(dialog_->input_tabular_row, buf); fl_deactivate_object(dialog_->input_tabular_row); @@ -491,7 +491,7 @@ ButtonPolicy::SMInput FormTabular::input(FL_OBJECT * ob, long) LyXTabular const & tabular = controller().tabular(); - int const cell = controller().getActiveCell(); + LyXTabular::idx_type const cell = controller().getActiveCell(); // ugly hack to auto-apply the stuff that hasn't been // yet. don't let this continue to exist ... diff --git a/src/frontends/xforms/FormTabular.h b/src/frontends/xforms/FormTabular.h index 1d7bbe249b..d56dbe1133 100644 --- a/src/frontends/xforms/FormTabular.h +++ b/src/frontends/xforms/FormTabular.h @@ -66,7 +66,7 @@ private: bool closing_; /// - int actCell_; + size_t actCell_; }; } // namespace frontend diff --git a/src/frontends/xforms/FormTabularCreate.C b/src/frontends/xforms/FormTabularCreate.C index 909a78145b..f928a8780e 100644 --- a/src/frontends/xforms/FormTabularCreate.C +++ b/src/frontends/xforms/FormTabularCreate.C @@ -11,7 +11,7 @@ #include #include "FormTabularCreate.h" -#include "ControlTabularCreate.h" +#include "controllers/ControlTabularCreate.h" #include "forms/form_tabular_create.h" #include "Tooltips.h" @@ -51,8 +51,10 @@ void FormTabularCreate::build() void FormTabularCreate::apply() { - unsigned int ysize = (unsigned int)(fl_get_slider_value(dialog_->slider_columns) + 0.5); - unsigned int xsize = (unsigned int)(fl_get_slider_value(dialog_->slider_rows) + 0.5); + size_t ysize = static_cast( + fl_get_slider_value(dialog_->slider_columns) + 0.5); + size_t xsize = static_cast( + fl_get_slider_value(dialog_->slider_rows) + 0.5); controller().params() = make_pair(xsize, ysize); } diff --git a/src/insets/ChangeLog b/src/insets/ChangeLog index 9f1b85ff69..7c43580d22 100644 --- a/src/insets/ChangeLog +++ b/src/insets/ChangeLog @@ -1,3 +1,8 @@ +2004-12-02 Georg Baum + + * insettabular.[Ch]: use size_t-like types for cell, row and column + indices + 2004-12-02 José Matos * insetlatexaccent.C (checkContents): remove compatibility code, diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index 5124d2198f..5c0083bc47 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -156,9 +156,10 @@ bool InsetTabular::hasPasteBuffer() const } -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) {} @@ -230,13 +231,13 @@ void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const 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; @@ -247,6 +248,7 @@ void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const 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); @@ -274,9 +276,9 @@ void InsetTabular::draw(PainterInfo & pi, int x, int y) const 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); @@ -286,10 +288,10 @@ void InsetTabular::draw(PainterInfo & pi, int x, int y) const + 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); @@ -325,17 +327,19 @@ void InsetTabular::drawSelection(PainterInfo & pi, int x, int y) const 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, @@ -353,7 +357,7 @@ void InsetTabular::drawSelection(PainterInfo & pi, int x, int y) const 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; @@ -559,7 +563,7 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd) // 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); @@ -576,7 +580,7 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd) // 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); @@ -643,9 +647,9 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd) 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); @@ -669,8 +673,9 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd) 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) { @@ -751,9 +756,9 @@ bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd, 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; @@ -966,13 +971,13 @@ void InsetTabular::validate(LaTeXFeatures & features) const } -shared_ptr InsetTabular::cell(int idx) const +shared_ptr InsetTabular::cell(idx_type idx) const { return tabular.getCellInset(idx); } -shared_ptr InsetTabular::cell(int idx) +shared_ptr InsetTabular::cell(idx_type idx) { return tabular.getCellInset(idx); } @@ -1044,7 +1049,7 @@ int dist(InsetOld const & inset, int x, int y) 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::max(); for (idx_type i = 0; i < nargs(); ++i) { if (theCoords.insets_.has(tabular.getCellInset(i).get())) { @@ -1061,9 +1066,9 @@ InsetBase * InsetTabular::setPos(LCursor & cur, int x, int y) const } -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) ; @@ -1080,8 +1085,7 @@ void InsetTabular::resetPos(LCursor & cur) const 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_; @@ -1130,7 +1134,7 @@ void InsetTabular::moveNextCell(LCursor & cur) 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)); @@ -1156,7 +1160,7 @@ void InsetTabular::movePrevCell(LCursor & cur) { 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); @@ -1229,10 +1233,10 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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; @@ -1280,8 +1284,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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; @@ -1319,7 +1323,7 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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; @@ -1330,7 +1334,7 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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; @@ -1344,8 +1348,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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); @@ -1356,8 +1360,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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, @@ -1369,8 +1373,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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, @@ -1382,8 +1386,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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, @@ -1399,8 +1403,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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, @@ -1414,8 +1418,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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); @@ -1441,8 +1445,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, } // 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; @@ -1455,8 +1459,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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 @@ -1479,15 +1483,15 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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; @@ -1496,8 +1500,8 @@ void InsetTabular::tabularFeatures(LCursor & cur, 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; } @@ -1572,15 +1576,16 @@ bool InsetTabular::copySelection(LCursor & cur) 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); @@ -1588,10 +1593,10 @@ bool InsetTabular::copySelection(LCursor & cur) 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); @@ -1611,12 +1616,12 @@ bool InsetTabular::pasteSelection(LCursor & cur) { 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) && @@ -1645,10 +1650,11 @@ void InsetTabular::cutSelection(LCursor & cur) 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 @@ -1668,7 +1674,7 @@ bool InsetTabular::isRightToLeft(LCursor & cur) const 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(); @@ -1710,9 +1716,12 @@ void InsetTabular::markErased() 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, @@ -1734,9 +1743,9 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf, 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; @@ -1756,9 +1765,9 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf, } 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)); @@ -1772,11 +1781,11 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf, } 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) @@ -1825,10 +1834,10 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf, 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); } } diff --git a/src/insets/insettabular.h b/src/insets/insettabular.h index e69f7621f8..b405518834 100644 --- a/src/insets/insettabular.h +++ b/src/insets/insettabular.h @@ -48,7 +48,8 @@ class CursorSlice; class InsetTabular : public UpdatableInset { public: /// - InsetTabular(Buffer const &, int rows = 1, int columns = 1); + InsetTabular(Buffer const &, row_type rows = 1, + col_type columns = 1); /// ~InsetTabular(); /// @@ -105,9 +106,9 @@ public: /// number of cells size_t nargs() const; /// - boost::shared_ptr cell(int) const; + boost::shared_ptr cell(idx_type) const; /// - boost::shared_ptr cell(int); + boost::shared_ptr cell(idx_type); /// LyXText * getText(int) const; @@ -149,7 +150,8 @@ private: virtual std::auto_ptr doClone() const; /// - void drawCellLines(Painter &, int x, int y, int row, int cell) const; + void drawCellLines(Painter &, int x, int y, row_type row, + idx_type cell) const; /// InsetBase * setPos(LCursor & cur, int x, int y) const; @@ -158,7 +160,7 @@ private: /// void movePrevCell(LCursor & cur); /// - int getCellXPos(int cell) const; + int getCellXPos(idx_type cell) const; /// void resetPos(LCursor & cur) const; /// @@ -174,8 +176,8 @@ private: /// bool isRightToLeft(LCursor & cur) const; /// - void getSelection(LCursor & cur, - int & rs, int & re, int & cs, int & ce) const; + void getSelection(LCursor & cur, row_type & rs, row_type & re, + col_type & cs, col_type & ce) const; /// bool insertAsciiString(BufferView &, std::string const & buf, bool usePaste); /// are we operating on several cells? @@ -186,7 +188,7 @@ private: /// mutable int cursorx_; /// - mutable int first_visible_cell; + mutable idx_type first_visible_cell; }; diff --git a/src/tabular.C b/src/tabular.C index 6343b925ae..21eaa46ad6 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -92,6 +92,14 @@ string const write_attribute(string const & name, int const & i) } +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. @@ -390,14 +398,16 @@ LyXTabular::ltType::ltType() {} -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; @@ -408,7 +418,7 @@ void LyXTabular::init(BufferParams const & bp, int rows_arg, int 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; @@ -420,9 +430,9 @@ void LyXTabular::init(BufferParams const & bp, int rows_arg, int columns_arg) 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); @@ -435,11 +445,11 @@ void LyXTabular::fixCellNums() } -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()); @@ -447,25 +457,25 @@ void LyXTabular::appendRow(BufferParams const & bp, int const cell) 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) @@ -478,17 +488,17 @@ void LyXTabular::deleteRow(int const row) } -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 @@ -500,7 +510,7 @@ void LyXTabular::appendColumn(BufferParams const & bp, int const cell) 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); @@ -509,14 +519,14 @@ void LyXTabular::appendColumn(BufferParams const & bp, int const cell) } -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(); @@ -525,21 +535,27 @@ void LyXTabular::deleteColumn(int const column) 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; @@ -556,8 +572,8 @@ void LyXTabular::set_row_column_number_info() } } - 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( @@ -567,17 +583,17 @@ void LyXTabular::set_row_column_number_info() } -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; @@ -585,7 +601,7 @@ int LyXTabular::numberOfCellsInRow(int const cell) const // 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; @@ -593,7 +609,7 @@ bool LyXTabular::topLine(int const cell, bool const onlycolumn) const } -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; @@ -601,7 +617,7 @@ bool LyXTabular::bottomLine(int cell, bool onlycolumn) const } -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))) @@ -616,7 +632,7 @@ bool LyXTabular::leftLine(int cell, bool onlycolumn) const } -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))) @@ -631,11 +647,11 @@ bool LyXTabular::rightLine(int cell, bool onlycolumn) const } -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 @@ -650,11 +666,11 @@ bool LyXTabular::topAlreadyDrawn(int cell) const } -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)); @@ -666,13 +682,13 @@ bool LyXTabular::leftAlreadyDrawn(int cell) const } -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; @@ -680,7 +696,7 @@ int LyXTabular::getAdditionalHeight(int row) const 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; @@ -689,7 +705,7 @@ int LyXTabular::getAdditionalHeight(int row) const 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; @@ -704,12 +720,12 @@ int LyXTabular::getAdditionalHeight(int row) const } -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) { @@ -720,12 +736,12 @@ int LyXTabular::getAdditionalWidth(int cell) const // 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; } @@ -738,23 +754,23 @@ int LyXTabular::getWidthOfTabular() const // 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; @@ -773,14 +789,14 @@ bool LyXTabular::setWidthOfMulticolCell(int cell, int new_width) } -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 @@ -789,7 +805,7 @@ void LyXTabular::recalculateMulticolumnsOfColumn(int column) (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); } @@ -798,10 +814,10 @@ void LyXTabular::recalculateMulticolumnsOfColumn(int column) // 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; @@ -826,14 +842,15 @@ void LyXTabular::setWidthOfCell(int cell, int new_width) 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; @@ -842,7 +859,8 @@ void LyXTabular::setAlignment(int cell, LyXAlignment align, bool onlycolumn) } -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; @@ -851,20 +869,20 @@ void LyXTabular::setVAlignment(int cell, VAlignment align, bool onlycolumn) } -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; @@ -875,7 +893,7 @@ bool LyXTabular::setMColumnPWidth(int cell, LyXLength const & width) } -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) @@ -885,7 +903,7 @@ void LyXTabular::setAlignSpecial(int cell, string const & special, } -void LyXTabular::setAllLines(int cell, bool line) +void LyXTabular::setAllLines(idx_type cell, bool line) { setTopLine(cell, line); setBottomLine(cell, line); @@ -894,9 +912,9 @@ void LyXTabular::setAllLines(int cell, bool 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 @@ -904,7 +922,7 @@ void LyXTabular::setTopLine(int cell, bool line, bool onlycolumn) } -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; @@ -913,7 +931,7 @@ void LyXTabular::setBottomLine(int cell, bool line, bool onlycolumn) } -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; @@ -922,7 +940,7 @@ void LyXTabular::setLeftLine(int cell, bool line, bool onlycolumn) } -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; @@ -931,7 +949,7 @@ void LyXTabular::setRightLine(int cell, bool line, bool onlycolumn) } -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; @@ -940,7 +958,7 @@ LyXAlignment LyXTabular::getAlignment(int cell, bool onlycolumn) const 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; @@ -948,7 +966,7 @@ LyXTabular::getVAlignment(int cell, bool onlycolumn) const } -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; @@ -956,13 +974,13 @@ LyXLength const LyXTabular::getPWidth(int cell) const } -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; @@ -970,7 +988,7 @@ LyXLength const LyXTabular::getMColumnPWidth(int cell) const } -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; @@ -978,19 +996,19 @@ string const LyXTabular::getAlignSpecial(int cell, int what) const } -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; @@ -1013,13 +1031,13 @@ int LyXTabular::getBeginningOfTextInCell(int cell) const } -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; @@ -1027,13 +1045,13 @@ int LyXTabular::getFirstCellInRow(int row) const } -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; @@ -1041,10 +1059,10 @@ int LyXTabular::getLastCellInRow(int row) const } -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; } @@ -1056,12 +1074,12 @@ void LyXTabular::calculate_width_of_column(int column) // 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) @@ -1077,35 +1095,35 @@ bool LyXTabular::calculate_width_of_column_NMC(int column) 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; @@ -1136,7 +1154,7 @@ void LyXTabular::write(Buffer const & buf, ostream & os) const << 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 << "\n"; } - for (int i = 0; i < rows_; ++i) { + for (row_type i = 0; i < rows_; ++i) { os << "\n"; - for (int j = 0; j < columns_; ++j) { + for (col_type j = 0; j < columns_; ++j) { os << " 0) { @@ -1322,7 +1341,7 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) 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," got" @@ -1337,7 +1356,7 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) 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, " got" @@ -1351,7 +1370,7 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) 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, " got" @@ -1394,26 +1413,27 @@ void LyXTabular::read(Buffer const & buf, LyXLex & lex) } -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; @@ -1421,7 +1441,7 @@ void LyXTabular::setMultiColumn(Buffer * buffer, int cell, int number) 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()); @@ -1431,11 +1451,11 @@ void LyXTabular::setMultiColumn(Buffer * buffer, int cell, int number) } -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) @@ -1447,12 +1467,12 @@ int LyXTabular::cells_in_multicolumn(int cell) const } -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; @@ -1494,13 +1514,13 @@ bool LyXTabular::getRotateTabular() const } -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; } @@ -1510,15 +1530,15 @@ bool LyXTabular::needRotating() const { 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; @@ -1526,7 +1546,7 @@ bool LyXTabular::isLastCell(int cell) const } -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; @@ -1534,7 +1554,7 @@ int LyXTabular::getCellAbove(int cell) const } -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; @@ -1542,9 +1562,9 @@ int LyXTabular::getCellBelow(int cell) const } -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); @@ -1552,7 +1572,7 @@ int LyXTabular::getLastCellAbove(int cell) const } -int LyXTabular::getLastCellBelow(int cell) const +LyXTabular::idx_type LyXTabular::getLastCellBelow(idx_type cell) const { if (row_of_cell(cell) + 1 >= rows_) return cell; @@ -1562,20 +1582,22 @@ int LyXTabular::getLastCellBelow(int cell) const } -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())) @@ -1589,7 +1611,8 @@ LyXTabular::BoxType LyXTabular::getUsebox(int cell) const /// // 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; @@ -1603,7 +1626,7 @@ void LyXTabular::setLTHead(int row, bool flag, ltType const & hd, bool first) } -bool LyXTabular::getRowOfLTHead(int row, ltType & hd) const +bool LyXTabular::getRowOfLTHead(row_type row, ltType & hd) const { hd = endhead; hd.set = haveLTHead(); @@ -1611,7 +1634,7 @@ bool LyXTabular::getRowOfLTHead(int row, ltType & hd) const } -bool LyXTabular::getRowOfLTFirstHead(int row, ltType & hd) const +bool LyXTabular::getRowOfLTFirstHead(row_type row, ltType & hd) const { hd = endfirsthead; hd.set = haveLTFirstHead(); @@ -1619,7 +1642,8 @@ bool LyXTabular::getRowOfLTFirstHead(int row, ltType & hd) const } -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; @@ -1633,7 +1657,7 @@ void LyXTabular::setLTFoot(int row, bool flag, ltType const & fd, bool last) } -bool LyXTabular::getRowOfLTFoot(int row, ltType & fd) const +bool LyXTabular::getRowOfLTFoot(row_type row, ltType & fd) const { fd = endfoot; fd.set = haveLTFoot(); @@ -1641,7 +1665,7 @@ bool LyXTabular::getRowOfLTFoot(int row, ltType & fd) const } -bool LyXTabular::getRowOfLTLastFoot(int row, ltType & fd) const +bool LyXTabular::getRowOfLTLastFoot(row_type row, ltType & fd) const { fd = endlastfoot; fd.set = haveLTLastFoot(); @@ -1649,13 +1673,13 @@ bool LyXTabular::getRowOfLTLastFoot(int row, ltType & fd) const } -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; } @@ -1663,7 +1687,7 @@ bool LyXTabular::getLTNewPage(int row) const 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; @@ -1674,7 +1698,7 @@ bool LyXTabular::haveLTFirstHead() const { 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; @@ -1683,7 +1707,7 @@ bool LyXTabular::haveLTFirstHead() const 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; @@ -1694,7 +1718,7 @@ bool LyXTabular::haveLTLastFoot() const { 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; @@ -1703,7 +1727,7 @@ bool LyXTabular::haveLTLastFoot() const // 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; @@ -1711,7 +1735,7 @@ void LyXTabular::setAscentOfRow(int row, int height) } -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; @@ -1719,7 +1743,7 @@ void LyXTabular::setDescentOfRow(int row, int height) } -int LyXTabular::getAscentOfRow(int row) const +int LyXTabular::getAscentOfRow(row_type row) const { if (row >= rows_) return 0; @@ -1727,7 +1751,7 @@ int LyXTabular::getAscentOfRow(int row) const } -int LyXTabular::getDescentOfRow(int row) const +int LyXTabular::getDescentOfRow(row_type row) const { BOOST_ASSERT(row < rows_); return row_info[row].descent_of_row; @@ -1737,14 +1761,14 @@ int LyXTabular::getDescentOfRow(int row) const 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_); @@ -1752,23 +1776,24 @@ bool LyXTabular::isPartOfMultiColumn(int row, int column) const } -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 @@ -1785,23 +1810,24 @@ int LyXTabular::TeXTopHLine(ostream & os, int row) const } -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 @@ -1818,7 +1844,7 @@ int LyXTabular::TeXBottomHLine(ostream & os, int row) const } -int LyXTabular::TeXCellPreamble(ostream & os, int cell) const +int LyXTabular::TeXCellPreamble(ostream & os, idx_type cell) const { int ret = 0; @@ -1908,7 +1934,7 @@ int LyXTabular::TeXCellPreamble(ostream & os, int cell) const } -int LyXTabular::TeXCellPostamble(ostream & os, int cell) const +int LyXTabular::TeXCellPostamble(ostream & os, idx_type cell) const { int ret = 0; @@ -1943,7 +1969,7 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, 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); } @@ -1965,7 +1991,7 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, 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); } @@ -1983,7 +2009,7 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, 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); } @@ -2005,7 +2031,7 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, 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); } @@ -2021,7 +2047,7 @@ int LyXTabular::TeXLongtableHeaderFooter(ostream & os, Buffer const & buf, } -bool LyXTabular::isValidRow(int row) const +bool LyXTabular::isValidRow(row_type row) const { if (!is_long_tabular) return true; @@ -2030,13 +2056,13 @@ bool LyXTabular::isValidRow(int row) const } -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); @@ -2084,7 +2110,7 @@ int LyXTabular::latex(Buffer const & buf, ostream & os, 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 { @@ -2148,7 +2174,7 @@ int LyXTabular::latex(Buffer const & buf, ostream & os, //+ 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) { @@ -2179,7 +2205,7 @@ int LyXTabular::linuxdoc(Buffer const & buf, ostream & os, const OutputParams & runparams) const { 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 inset = getCellInset(cell); @@ -2217,14 +2243,14 @@ int LyXTabular::linuxdoc(Buffer const & buf, ostream & os, } -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 << "\n"; - for (int j = 0; j < columns_; ++j) { + for (col_type j = 0; j < columns_; ++j) { if (isPartOfMultiColumn(row, j)) continue; @@ -2281,7 +2307,7 @@ int LyXTabular::docbook(Buffer const & buf, ostream & os, os << "\n"; - for (int i = 0; i < columns_; ++i) { + for (col_type i = 0; i < columns_; ++i) { os << "\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); } @@ -2321,7 +2347,7 @@ int LyXTabular::docbook(Buffer const & buf, ostream & os, if (haveLTFoot() || haveLTLastFoot()) { os << "\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); } @@ -2336,7 +2362,7 @@ int LyXTabular::docbook(Buffer const & buf, ostream & os, os << "\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); } @@ -2354,14 +2380,14 @@ int LyXTabular::docbook(Buffer const & buf, ostream & os, } -int LyXTabular::asciiTopHLine(ostream & os, int row, +int LyXTabular::asciiTopHLine(ostream & os, row_type row, vector 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; @@ -2371,7 +2397,7 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, 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 << "+-"; @@ -2382,7 +2408,7 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, 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)) @@ -2402,14 +2428,14 @@ int LyXTabular::asciiTopHLine(ostream & os, int row, } -int LyXTabular::asciiBottomHLine(ostream & os, int row, +int LyXTabular::asciiBottomHLine(ostream & os, row_type row, vector 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; @@ -2419,7 +2445,7 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, 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 << "+-"; @@ -2430,7 +2456,7 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, 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)) @@ -2452,7 +2478,7 @@ int LyXTabular::asciiBottomHLine(ostream & os, int row, 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 const & clen, bool onlydata) const { @@ -2514,10 +2540,10 @@ int LyXTabular::plaintext(Buffer const & buf, ostream & os, 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; @@ -2527,27 +2553,27 @@ int LyXTabular::plaintext(Buffer const & buf, ostream & os, } } // 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) @@ -2567,19 +2593,21 @@ int LyXTabular::plaintext(Buffer const & buf, ostream & os, } -shared_ptr LyXTabular::getCellInset(int cell) const +shared_ptr LyXTabular::getCellInset(idx_type cell) const { return cell_info[row_of_cell(cell)][column_of_cell(cell)].inset; } -shared_ptr LyXTabular::getCellInset(int row, int column) const +shared_ptr 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) { @@ -2587,7 +2615,7 @@ int LyXTabular::getCellFromInset(InsetBase const * inset) const 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; @@ -2610,7 +2638,7 @@ void LyXTabular::validate(LaTeXFeatures & features) const 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"); @@ -2622,13 +2650,13 @@ void LyXTabular::validate(LaTeXFeatures & features) const void LyXTabular::getLabelList(Buffer const & buffer, std::vector & 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(); diff --git a/src/tabular.h b/src/tabular.h index 62de87e810..b7e1dc8de3 100644 --- a/src/tabular.h +++ b/src/tabular.h @@ -172,105 +172,118 @@ public: 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(-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; /// @@ -290,21 +303,21 @@ public: 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); /// @@ -314,47 +327,47 @@ public: /// 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; /// @@ -366,16 +379,17 @@ public: /// // end longtable support /// - boost::shared_ptr getCellInset(int cell) const; + boost::shared_ptr getCellInset(idx_type cell) const; /// - boost::shared_ptr getCellInset(int row, int column) const; + boost::shared_ptr 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. @@ -393,7 +407,7 @@ public: /// void swap(cellstruct & rhs); /// - int cellno; + idx_type cellno; /// int width_of_cell; /// @@ -421,7 +435,7 @@ public: /// boost::shared_ptr inset; }; - cellstruct & cellinfo_of_cell(int cell) const; + cellstruct & cellinfo_of_cell(idx_type cell) const; /// typedef std::vector cell_vector; /// @@ -477,15 +491,15 @@ public: typedef std::vector column_vector; /// - int rows_; + row_type rows_; /// - int columns_; + col_type columns_; /// - int numberofcells; + idx_type numberofcells; /// - std::vector rowofcell; + std::vector rowofcell; /// - std::vector columnofcell; + std::vector columnofcell; /// row_vector row_info; /// @@ -510,61 +524,63 @@ public: 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 const &) const; /// - int asciiBottomHLine(std::ostream &, int row, + int asciiBottomHLine(std::ostream &, row_type row, std::vector 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 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: