X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=bbc4f28e2b3f849429b02fb1bc33ca30e900df3d;hb=fd36f5ad7612a4034c21c3162e29c3bca42e353e;hp=cec7de014a5e3d16e97a47c54161beccbf8c4a4b;hpb=453f294074a588ac62886d512e97619ff219c766;p=lyx.git diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index cec7de014a..bbc4f28e2b 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -5,57 +5,50 @@ * * \author Jürgen Vigna * - * Full author contact details are available in file CREDITS + * Full author contact details are available in file CREDITS. */ #include #include "insettabular.h" -#include "insettext.h" #include "buffer.h" #include "BufferView.h" -#include "lfuns.h" #include "debug.h" -#include "dimension.h" #include "funcrequest.h" +#include "FuncStatus.h" #include "gettext.h" #include "language.h" -#include "LaTeXFeatures.h" -#include "Lsstream.h" #include "lyx_cb.h" -#include "lyxfunc.h" -#include "lyxlength.h" #include "lyxlex.h" -#include "lyxtext.h" +#include "metricsinfo.h" +#include "paragraph.h" +#include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "undo_funcs.h" #include "WordLangTuple.h" -#include "Lsstream.h" #include "frontends/Alert.h" -#include "frontends/Dialogs.h" #include "frontends/font_metrics.h" #include "frontends/LyXView.h" #include "frontends/Painter.h" #include "support/LAssert.h" -#include "support/lstrings.h" -#include -#include -#include -#include -//#include +#include "support/std_sstream.h" +using namespace lyx::support; +using namespace lyx::graphics; -using std::vector; -using std::ostream; -using std::ifstream; -using std::max; using std::endl; -using std::swap; using std::max; +using std::swap; + +using std::auto_ptr; +using std::istringstream; +using std::ostream; +using std::ostringstream; + namespace { @@ -88,7 +81,7 @@ TabularFeature tabularFeature[] = { LyXTabular::ALIGN_BLOCK, "align-block" }, { LyXTabular::VALIGN_TOP, "valign-top" }, { LyXTabular::VALIGN_BOTTOM, "valign-bottom" }, - { LyXTabular::VALIGN_CENTER, "valign-center" }, + { LyXTabular::VALIGN_MIDDLE, "valign-middle" }, { LyXTabular::M_TOGGLE_LINE_TOP, "m-toggle-line-top" }, { LyXTabular::M_TOGGLE_LINE_BOTTOM, "m-toggle-line-bottom" }, { LyXTabular::M_TOGGLE_LINE_LEFT, "m-toggle-line-left" }, @@ -98,7 +91,7 @@ TabularFeature tabularFeature[] = { LyXTabular::M_ALIGN_CENTER, "m-align-center" }, { LyXTabular::M_VALIGN_TOP, "m-valign-top" }, { LyXTabular::M_VALIGN_BOTTOM, "m-valign-bottom" }, - { LyXTabular::M_VALIGN_CENTER, "m-valign-center" }, + { LyXTabular::M_VALIGN_MIDDLE, "m-valign-middle" }, { LyXTabular::MULTICOLUMN, "multicolumn" }, { LyXTabular::SET_ALL_LINES, "set-all-lines" }, { LyXTabular::UNSET_ALL_LINES, "unset-all-lines" }, @@ -151,13 +144,9 @@ bool InsetTabular::hasPasteBuffer() const InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns) - : buffer(&buf) + : tabular(buf.params(), this, max(rows, 1), max(columns, 1)), + buffer_(&buf), cursorx_(0), cursory_(0) { - if (rows <= 0) - rows = 1; - if (columns <= 0) - columns = 1; - tabular.reset(new LyXTabular(buf.params, this, rows, columns)); // for now make it always display as display() inset // just for test!!! the_locking_inset = 0; @@ -166,28 +155,23 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns) oldcell = -1; actrow = actcell = 0; clearSelection(); - need_update = INIT; - in_update = false; in_reset_pos = 0; inset_x = 0; inset_y = 0; } -InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf, - bool same_id) - : UpdatableInset(tab, same_id), buffer(&buf) +InsetTabular::InsetTabular(InsetTabular const & tab) + : UpdatableInset(tab), + tabular(tab.buffer_->params(), this, tab.tabular), + buffer_(tab.buffer_), cursorx_(0), cursory_(0) { - tabular.reset(new LyXTabular(buf.params, - this, *(tab.tabular), same_id)); the_locking_inset = 0; old_locking_inset = 0; locked = false; oldcell = -1; actrow = actcell = 0; clearSelection(); - need_update = INIT; - in_update = false; in_reset_pos = 0; inset_x = 0; inset_y = 0; @@ -196,37 +180,47 @@ InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf, InsetTabular::~InsetTabular() { - InsetTabularMailer mailer(*this); - mailer.hideDialog(); + InsetTabularMailer(*this).hideDialog(); +} + + +auto_ptr InsetTabular::clone() const +{ + return auto_ptr(new InsetTabular(*this)); } -Inset * InsetTabular::clone(Buffer const & buf, bool same_id) const +Buffer const & InsetTabular::buffer() const { - return new InsetTabular(*this, buf, same_id); + return *buffer_; } BufferView * InsetTabular::view() const { - return buffer->getUser(); + Assert(false); + return 0; } -void InsetTabular::write(Buffer const * buf, ostream & os) const +void InsetTabular::buffer(Buffer * b) { - os << " Tabular" << endl; - tabular->Write(buf, os); + buffer_ = b; } -void InsetTabular::read(Buffer const * buf, LyXLex & lex) +void InsetTabular::write(Buffer const & buf, ostream & os) const { - bool const old_format = (lex.getString() == "\\LyXTable"); + os << "Tabular" << endl; + tabular.write(buf, os); +} - tabular.reset(new LyXTabular(buf, this, lex)); - need_update = INIT; +void InsetTabular::read(Buffer const & buf, LyXLex & lex) +{ + bool const old_format = (lex.getString() == "\\LyXTable"); + + tabular.read(buf, lex); if (old_format) return; @@ -244,190 +238,152 @@ void InsetTabular::read(Buffer const * buf, LyXLex & lex) } -void InsetTabular::dimension(BufferView *, LyXFont const &, - Dimension & dim) const +void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const { - dim.a = tabular->GetAscentOfRow(0); - dim.d = tabular->GetHeightOfTabular() - tabular->GetAscentOfRow(0) + 1; - dim.w = tabular->GetWidthOfTabular() + 2 * ADD_TO_TABULAR_WIDTH; + //lyxerr << "InsetTabular::metrics: " << mi.base.bv << " width: " << + // mi.base.textwidth << "\n"; + if (!mi.base.bv) { + lyxerr << "InsetTabular::metrics: need bv" << endl; + Assert(0); + } + + calculate_dimensions_of_cells(mi); + + dim.asc = tabular.getAscentOfRow(0); + dim.des = tabular.getHeightOfTabular() - tabular.getAscentOfRow(0) + 1; + dim.wid = tabular.getWidthOfTabular() + 2 * ADD_TO_TABULAR_WIDTH; + dim_ = dim; } -void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, - float & x) const +void InsetTabular::draw(PainterInfo & pi, int x, int y) const { - if (nodraw()) { - need_update = FULL; - return; - } + //lyxerr << "InsetTabular::draw: " << x << " " << y << endl; - Painter & pain = bv->painter(); - int i; - int j; - int nx; + BufferView * bv = pi.base.bv; #if 0 - UpdatableInset::draw(bv, font, baseline, x); + UpdatableInset::draw(pi, x, y); #else if (!owner()) - x += static_cast(scroll()); + x += scroll(); #endif - top_x = int(x); - top_baseline = baseline; + top_x = x; + top_baseline = y; x += ADD_TO_TABULAR_WIDTH; int cell = 0; - float cx; first_visible_cell = -1; - for (i = 0; i < tabular->rows(); ++i) { - nx = int(x); - cell = tabular->GetCellNumber(i, 0); - if (!((baseline + tabular->GetDescentOfRow(i)) > 0) && - (baseline - tabular->GetAscentOfRow(i))GetDescentOfRow(i) + - tabular->GetAscentOfRow(i + 1) + - tabular->GetAdditionalHeight(i + 1); + y += tabular.getDescentOfRow(i) + + tabular.getAscentOfRow(i + 1) + + tabular.getAdditionalHeight(i + 1); continue; } - for (j = 0; j < tabular->columns(); ++j) { + for (int j = 0; j < tabular.columns(); ++j) { if (nx > bv->workWidth()) break; - if (tabular->IsPartOfMultiColumn(i, j)) + if (tabular.isPartOfMultiColumn(i, j)) continue; - cx = nx + tabular->GetBeginningOfTextInCell(cell); + int cx = nx + tabular.getBeginningOfTextInCell(cell); if (first_visible_cell < 0) first_visible_cell = cell; if (hasSelection()) { - drawCellSelection(pain, nx, baseline, i, j, cell); + drawCellSelection(pi.pain, nx, y, i, j, cell); } - tabular->GetCellInset(cell)->draw(bv, font, baseline, cx); - drawCellLines(pain, nx, baseline, i, cell); - nx += tabular->GetWidthOfColumn(cell); + tabular.getCellInset(cell).draw(pi, cx, y); + drawCellLines(pi.pain, nx, y, i, cell); + nx += tabular.getWidthOfColumn(cell); ++cell; } - baseline += tabular->GetDescentOfRow(i) + - tabular->GetAscentOfRow(i + 1) + - tabular->GetAdditionalHeight(i + 1); - } - x -= ADD_TO_TABULAR_WIDTH; - x += width(bv, font); - need_update = NONE; +// Would be nice, but for some completely unfathomable reason, +// on a col resize to a new fixed width, even though the insettexts +// are resized, the cell isn't, but drawing all cells in a tall table +// has the desired effect somehow. Complete dark magic. +#if 0 + // avoiding drawing the rest of a long table is + // a pretty big speedup + if (y > bv->workHeight()) + break; +#endif + + y += tabular.getDescentOfRow(i) + + tabular.getAscentOfRow(i + 1) + + tabular.getAdditionalHeight(i + 1); + } } -void InsetTabular::drawCellLines(Painter & pain, int x, int baseline, +void InsetTabular::drawCellLines(Painter & pain, int x, int y, int row, int cell) const { - int x2 = x + tabular->GetWidthOfColumn(cell); + int x2 = x + tabular.getWidthOfColumn(cell); bool on_off; - if (!tabular->topAlreadyDrawn(cell)) { - on_off = !tabular->TopLine(cell); - pain.line(x, baseline - tabular->GetAscentOfRow(row), - x2, baseline - tabular->GetAscentOfRow(row), + if (!tabular.topAlreadyDrawn(cell)) { + on_off = !tabular.topLine(cell); + pain.line(x, y - tabular.getAscentOfRow(row), + x2, y - tabular.getAscentOfRow(row), on_off ? LColor::tabularonoffline : LColor::tabularline, on_off ? Painter::line_onoffdash : Painter::line_solid); } - on_off = !tabular->BottomLine(cell); - pain.line(x, baseline + tabular->GetDescentOfRow(row), - x2, baseline + tabular->GetDescentOfRow(row), + on_off = !tabular.bottomLine(cell); + pain.line(x, y + tabular.getDescentOfRow(row), + x2, y + tabular.getDescentOfRow(row), on_off ? LColor::tabularonoffline : LColor::tabularline, on_off ? Painter::line_onoffdash : Painter::line_solid); - if (!tabular->leftAlreadyDrawn(cell)) { - on_off = !tabular->LeftLine(cell); - pain.line(x, baseline - tabular->GetAscentOfRow(row), - x, baseline + tabular->GetDescentOfRow(row), + if (!tabular.leftAlreadyDrawn(cell)) { + on_off = !tabular.leftLine(cell); + pain.line(x, y - tabular.getAscentOfRow(row), + x, y + tabular.getDescentOfRow(row), on_off ? LColor::tabularonoffline : LColor::tabularline, on_off ? Painter::line_onoffdash : Painter::line_solid); } - on_off = !tabular->RightLine(cell); - pain.line(x2 - tabular->GetAdditionalWidth(cell), - baseline - tabular->GetAscentOfRow(row), - x2 - tabular->GetAdditionalWidth(cell), - baseline + tabular->GetDescentOfRow(row), + on_off = !tabular.rightLine(cell); + pain.line(x2 - tabular.getAdditionalWidth(cell), + y - tabular.getAscentOfRow(row), + x2 - tabular.getAdditionalWidth(cell), + y + tabular.getDescentOfRow(row), on_off ? LColor::tabularonoffline : LColor::tabularline, on_off ? Painter::line_onoffdash : Painter::line_solid); } -void InsetTabular::drawCellSelection(Painter & pain, int x, int baseline, +void InsetTabular::drawCellSelection(Painter & pain, int x, int y, int row, int column, int cell) const { - lyx::Assert(hasSelection()); - int cs = tabular->column_of_cell(sel_cell_start); - int ce = tabular->column_of_cell(sel_cell_end); + Assert(hasSelection()); + int cs = tabular.column_of_cell(sel_cell_start); + int ce = tabular.column_of_cell(sel_cell_end); if (cs > ce) { ce = cs; - cs = tabular->column_of_cell(sel_cell_end); + cs = tabular.column_of_cell(sel_cell_end); } else { - ce = tabular->right_column_of_cell(sel_cell_end); + ce = tabular.right_column_of_cell(sel_cell_end); } - int rs = tabular->row_of_cell(sel_cell_start); - int re = tabular->row_of_cell(sel_cell_end); + int rs = tabular.row_of_cell(sel_cell_start); + int re = tabular.row_of_cell(sel_cell_end); if (rs > re) swap(rs, re); if ((column >= cs) && (column <= ce) && (row >= rs) && (row <= re)) { - int w = tabular->GetWidthOfColumn(cell); - int h = tabular->GetAscentOfRow(row) + tabular->GetDescentOfRow(row)-1; - pain.fillRectangle(x, baseline - tabular->GetAscentOfRow(row) + 1, + int w = tabular.getWidthOfColumn(cell); + int h = tabular.getAscentOfRow(row) + tabular.getDescentOfRow(row)-1; + pain.fillRectangle(x, y - tabular.getAscentOfRow(row) + 1, w, h, LColor::selection); } } -void InsetTabular::update(BufferView * bv, bool reinit) -{ - if (in_update) { - if (reinit) { - resetPos(bv); - if (owner()) - owner()->update(bv, true); - } - return; - } - in_update = true; - if (reinit) { - need_update = INIT; - if (calculate_dimensions_of_cells(bv, true)) - resetPos(bv); - if (owner()) - owner()->update(bv, true); - in_update = false; - return; - } - if (the_locking_inset) - the_locking_inset->update(bv, reinit); - if (need_update < FULL && - bv->text->refreshStatus() == LyXText::REFRESH_AREA) - { - need_update = FULL; - } - - switch (need_update) { - case INIT: - case FULL: - case CELL: - if (calculate_dimensions_of_cells(bv, false)) { - need_update = INIT; - resetPos(bv); - } - break; - case SELECTION: - need_update = FULL; - break; - default: - break; - } - in_update = false; -} - - string const InsetTabular::editMessage() const { return _("Opened table"); @@ -438,7 +394,7 @@ void InsetTabular::insetUnlock(BufferView * bv) { if (the_locking_inset) { the_locking_inset->insetUnlock(bv); - updateLocal(bv, CELL); + updateLocal(bv); the_locking_inset = 0; } actcell = 0; @@ -446,29 +402,18 @@ void InsetTabular::insetUnlock(BufferView * bv) locked = false; if (scroll(false) || hasSelection()) { clearSelection(); - if (scroll(false)) { + if (scroll(false)) scroll(bv, 0.0F); - } - updateLocal(bv, FULL); + updateLocal(bv); } } -void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what) const +void InsetTabular::updateLocal(BufferView * bv) const { - if (what == INIT) { - calculate_dimensions_of_cells(bv, true); - } - if (!locked && what == CELL) - what = FULL; - if (need_update < what) // only set this if it has greater update - need_update = what; - // Dirty Cast! (Lgb) - if (need_update != NONE) { - bv->updateInset(const_cast(this)); - if (locked) - resetPos(bv); - } + bv->updateInset(this); + if (locked) + resetPos(bv); } @@ -479,16 +424,16 @@ bool InsetTabular::lockInsetInInset(BufferView * bv, UpdatableInset * inset) if (!inset) return false; oldcell = -1; - if (inset == tabular->GetCellInset(actcell)) { + if (inset == &tabular.getCellInset(actcell)) { lyxerr[Debug::INSETTEXT] << "OK" << endl; - the_locking_inset = tabular->GetCellInset(actcell); + the_locking_inset = &tabular.getCellInset(actcell); resetPos(bv); return true; } else if (!the_locking_inset) { - int const n = tabular->GetNumberOfCells(); + int const n = tabular.getNumberOfCells(); int const id = inset->id(); for (int i = 0; i < n; ++i) { - InsetText * in = tabular->GetCellInset(i); + InsetText * in = &tabular.getCellInset(i); if (inset == in) { actcell = i; the_locking_inset = in; @@ -528,7 +473,7 @@ bool InsetTabular::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, if (scroll(false)) scroll(bv, 0.0F); #endif - updateLocal(bv, CELL); + updateLocal(bv); // this has to be here otherwise we don't redraw the cell! the_locking_inset = 0; return true; @@ -536,8 +481,7 @@ bool InsetTabular::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, if (the_locking_inset->unlockInsetInInset(bv, inset, lr)) { if (inset->lyxCode() == TABULAR_CODE && !the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)) { - InsetTabularMailer mailer(*this); - mailer.updateDialog(bv); + InsetTabularMailer(*this).updateDialog(bv); oldcell = actcell; } return true; @@ -546,25 +490,6 @@ bool InsetTabular::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, } -bool InsetTabular::updateInsetInInset(BufferView * bv, Inset * inset) -{ - Inset * tl_inset = inset; - // look if this inset is really inside myself! - while(tl_inset->owner() && tl_inset->owner() != this) - tl_inset = tl_inset->owner(); - // if we enter here it's not ower inset - if (!tl_inset->owner()) - return false; - // we only have to do this if this is a subinset of our cells - if (tl_inset != inset) { - if (!static_cast(tl_inset)->updateInsetInInset(bv, inset)) - return false; - } - updateLocal(bv, CELL); - return true; -} - - int InsetTabular::insetInInsetY() const { if (!the_locking_inset) @@ -580,7 +505,7 @@ UpdatableInset * InsetTabular::getLockingInset() const } -UpdatableInset * InsetTabular::getFirstLockingInsetOfType(Inset::Code c) +UpdatableInset * InsetTabular::getFirstLockingInsetOfType(InsetOld::Code c) { if (c == lyxCode()) return this; @@ -590,7 +515,7 @@ UpdatableInset * InsetTabular::getFirstLockingInsetOfType(Inset::Code c) } -bool InsetTabular::insertInset(BufferView * bv, Inset * inset) +bool InsetTabular::insertInset(BufferView * bv, InsetOld * inset) { if (the_locking_inset) return the_locking_inset->insertInset(bv, inset); @@ -605,11 +530,10 @@ void InsetTabular::lfunMousePress(FuncRequest const & cmd) if (hasSelection()) { clearSelection(); - updateLocal(cmd.view(), SELECTION); + updateLocal(cmd.view()); } int const ocell = actcell; - int const orow = actrow; BufferView * bv = cmd.view(); if (!locked) { @@ -619,19 +543,7 @@ void InsetTabular::lfunMousePress(FuncRequest const & cmd) inset_y = 0; } setPos(bv, cmd.x, cmd.y); - if (actrow != orow) - updateLocal(bv, NONE); clearSelection(); -#if 0 - if (cmd.button() == mouse_button::button3) { - if ((ocell != actcell) && the_locking_inset) { - the_locking_inset->insetUnlock(bv); - updateLocal(bv, CELL); - the_locking_inset = 0; - } - return; - } -#endif bool const inset_hit = insetHit(bv, cmd.x, cmd.y); @@ -646,7 +558,7 @@ void InsetTabular::lfunMousePress(FuncRequest const & cmd) if (the_locking_inset) { the_locking_inset->insetUnlock(bv); - updateLocal(bv, CELL); + updateLocal(bv); the_locking_inset = 0; } @@ -656,9 +568,7 @@ void InsetTabular::lfunMousePress(FuncRequest const & cmd) } if (inset_hit && bv->theLockingInset()) { - if (!bv->lockInset(static_cast - (tabular->GetCellInset(actcell)))) - { + if (!bv->lockInset(&tabular.getCellInset(actcell))) { lyxerr[Debug::INSETS] << "Cannot lock inset" << endl; return; } @@ -666,7 +576,6 @@ void InsetTabular::lfunMousePress(FuncRequest const & cmd) cmd1.x -= inset_x; cmd1.y -= inset_y; the_locking_inset->localDispatch(cmd1); - return; } } @@ -681,8 +590,7 @@ bool InsetTabular::lfunMouseRelease(FuncRequest const & cmd) ret = the_locking_inset->localDispatch(cmd1); } if (cmd.button() == mouse_button::button3 && !ret) { - InsetTabularMailer mailer(*this); - mailer.showDialog(cmd.view()); + InsetTabularMailer(*this).showDialog(cmd.view()); return true; } return ret; @@ -705,15 +613,15 @@ void InsetTabular::lfunMouseMotion(FuncRequest const & cmd) setPos(bv, cmd.x, cmd.y); if (!hasSelection()) { setSelection(actcell, actcell); - updateLocal(bv, SELECTION); + updateLocal(bv); } else if (old_cell != actcell) { setSelection(sel_cell_start, actcell); - updateLocal(bv, SELECTION); + updateLocal(bv); } } -Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) +InsetOld::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) { // We need to save the value of the_locking_inset as the call to // the_locking_inset->localDispatch might unlock it. @@ -737,14 +645,14 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) if (cmd.argument.size()) { if (cmd.argument == "left") { if (isRightToLeft(bv)) - actcell = tabular->GetLastCellInRow(0); + actcell = tabular.getLastCellInRow(0); else actcell = 0; } else { if (isRightToLeft(bv)) - actcell = tabular->GetFirstCellInRow(tabular->rows()-1); + actcell = tabular.getFirstCellInRow(tabular.rows()-1); else - actcell = tabular->GetNumberOfCells() - 1; + actcell = tabular.getNumberOfCells() - 1; } clearSelection(); resetPos(bv); @@ -775,7 +683,7 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) result = DISPATCHED; // this one have priority over the locked InsetText, if we're not already // inside another tabular then that one get's priority! - if (getFirstLockingInsetOfType(Inset::TABULAR_CODE) == this) { + if (getFirstLockingInsetOfType(InsetOld::TABULAR_CODE) == this) { switch (cmd.action) { case LFUN_MOUSE_PRESS: lfunMousePress(cmd); @@ -797,10 +705,9 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) movePrevCell(bv, old_locking_inset != 0); clearSelection(); if (hs) - updateLocal(bv, SELECTION); - if (!the_locking_inset) { + updateLocal(bv); + if (!the_locking_inset) return DISPATCHED_NOUPDATE; - } return result; // this to avoid compiler warnings. default: @@ -816,11 +723,11 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) int sc = scroll(); resetPos(bv); if (sc != scroll()) { // inset has been scrolled - updateLocal(bv, FULL); + updateLocal(bv); } return result; } else if (result == DISPATCHED) { - updateLocal(bv, CELL); + updateLocal(bv); return result; } else if (result == FINISHED_UP) { action = LFUN_UP; @@ -843,7 +750,7 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) // --- Cursor Movements ---------------------------------- case LFUN_RIGHTSEL: { int const start = hasSelection() ? sel_cell_start : actcell; - if (tabular->IsLastCellInRow(actcell)) { + if (tabular.isLastCellInRow(actcell)) { setSelection(start, actcell); break; } @@ -856,18 +763,18 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) end = actcell; } setSelection(start, end); - updateLocal(bv, SELECTION); + updateLocal(bv); break; } case LFUN_RIGHT: result = moveRight(bv); clearSelection(); if (hs) - updateLocal(bv, SELECTION); + updateLocal(bv); break; case LFUN_LEFTSEL: { int const start = hasSelection() ? sel_cell_start : actcell; - if (tabular->IsFirstCellInRow(actcell)) { + if (tabular.isFirstCellInRow(actcell)) { setSelection(start, actcell); break; } @@ -880,14 +787,14 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) end = actcell; } setSelection(start, end); - updateLocal(bv, SELECTION); + updateLocal(bv); break; } case LFUN_LEFT: result = moveLeft(bv); clearSelection(); if (hs) - updateLocal(bv, SELECTION); + updateLocal(bv); break; case LFUN_DOWNSEL: { int const start = hasSelection() ? sel_cell_start : actcell; @@ -896,23 +803,22 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) // the current cell at the beginning if (hasSelection()) { moveDown(bv, false); - if ((ocell == sel_cell_end) || - (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell))) - setSelection(start, tabular->GetCellBelow(sel_cell_end)); + if (ocell == sel_cell_end || + tabular.column_of_cell(ocell) > tabular.column_of_cell(actcell)) + setSelection(start, tabular.getCellBelow(sel_cell_end)); else - setSelection(start, tabular->GetLastCellBelow(sel_cell_end)); + setSelection(start, tabular.getLastCellBelow(sel_cell_end)); } else { setSelection(start, start); } - updateLocal(bv, SELECTION); + updateLocal(bv); } break; case LFUN_DOWN: result = moveDown(bv, old_locking_inset != 0); clearSelection(); - if (hs) { - updateLocal(bv, SELECTION); - } + if (hs) + updateLocal(bv); break; case LFUN_UPSEL: { int const start = hasSelection() ? sel_cell_start : actcell; @@ -922,63 +828,55 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) if (hasSelection()) { moveUp(bv, false); if ((ocell == sel_cell_end) || - (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell))) - setSelection(start, tabular->GetCellAbove(sel_cell_end)); + (tabular.column_of_cell(ocell)>tabular.column_of_cell(actcell))) + setSelection(start, tabular.getCellAbove(sel_cell_end)); else - setSelection(start, tabular->GetLastCellAbove(sel_cell_end)); + setSelection(start, tabular.getLastCellAbove(sel_cell_end)); } else { setSelection(start, start); } - updateLocal(bv, SELECTION); + updateLocal(bv); } break; case LFUN_UP: result = moveUp(bv, old_locking_inset != 0); clearSelection(); if (hs) - updateLocal(bv, SELECTION); + updateLocal(bv); break; case LFUN_NEXT: { - UpdateCodes code = CURSOR; - if (hs) { + if (hs) clearSelection(); - code = SELECTION; - } int column = actcol; unlockInsetInInset(bv, the_locking_inset); - if (bv->text->top_y() + bv->painter().paperHeight() < - (top_baseline + tabular->GetHeightOfTabular())) + if (bv->top_y() + bv->painter().paperHeight() < + top_baseline + tabular.getHeightOfTabular()) { - bv->scrollDocView(bv->text->top_y() + bv->painter().paperHeight()); - code = FULL; - actcell = tabular->GetCellBelow(first_visible_cell) + column; + bv->scrollDocView(bv->top_y() + bv->painter().paperHeight()); + actcell = tabular.getCellBelow(first_visible_cell) + column; } else { - actcell = tabular->GetFirstCellInRow(tabular->rows() - 1) + column; + actcell = tabular.getFirstCellInRow(tabular.rows() - 1) + column; } resetPos(bv); - updateLocal(bv, code); + updateLocal(bv); break; } case LFUN_PRIOR: { - UpdateCodes code = CURSOR; - if (hs) { + if (hs) clearSelection(); - code = SELECTION; - } int column = actcol; unlockInsetInInset(bv, the_locking_inset); if (top_baseline < 0) { - bv->scrollDocView(bv->text->top_y() - bv->painter().paperHeight()); - code = FULL; + bv->scrollDocView(bv->top_y() - bv->painter().paperHeight()); if (top_baseline > 0) actcell = column; else - actcell = tabular->GetCellBelow(first_visible_cell) + column; + actcell = tabular.getCellBelow(first_visible_cell) + column; } else { actcell = column; } resetPos(bv); - updateLocal(bv, code); + updateLocal(bv); break; } // none of these make sense for insettabular, @@ -1006,13 +904,11 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) case LFUN_ENDBUFSEL: break; case LFUN_LAYOUT_TABULAR: { - InsetTabularMailer mailer(*this); - mailer.showDialog(bv); + InsetTabularMailer(*this).showDialog(bv); break; } case LFUN_INSET_DIALOG_UPDATE: { - InsetTabularMailer mailer(*this); - mailer.updateDialog(bv); + InsetTabularMailer(*this).updateDialog(bv); break; } case LFUN_TABULAR_FEATURE: @@ -1027,7 +923,7 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) if (tmpstr.empty()) break; if (insertAsciiString(bv, tmpstr, false)) - updateLocal(bv, INIT); + updateLocal(bv); else result = UNDISPATCHED; break; @@ -1038,11 +934,9 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) break; // no break here! case LFUN_DELETE: - setUndo(bv, Undo::DELETE, - bv->text->cursor.par(), - boost::next(bv->text->cursor.par())); - cutSelection(bv->buffer()->params); - updateLocal(bv, INIT); + recordUndo(bv, Undo::DELETE); + cutSelection(bv->buffer()->params()); + updateLocal(bv); break; case LFUN_COPY: if (!hasSelection()) @@ -1080,11 +974,11 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) } maxCols = max(cols, maxCols); delete paste_tabular; - paste_tabular = new LyXTabular(bv->buffer()->params, + paste_tabular = new LyXTabular(bv->buffer()->params(), this, rows, maxCols); string::size_type op = 0; int cell = 0; - int cells = paste_tabular->GetNumberOfCells(); + int cells = paste_tabular->getNumberOfCells(); p = cols = 0; while ((cell < cells) && (p < len) && (p = clip.find_first_of("\t\n", p)) != string::npos) { @@ -1092,12 +986,12 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) break; switch (clip[p]) { case '\t': - paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op)); + paste_tabular->getCellInset(cell)->setText(clip.substr(op, p-op)); ++cols; ++cell; break; case '\n': - paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op)); + paste_tabular->getCellInset(cell)->setText(clip.substr(op, p-op)); while (cols++ < maxCols) ++cell; cols = 0; @@ -1108,7 +1002,7 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) } // check for the last cell if there is no trailing '\n' if ((cell < cells) && (op < len)) - paste_tabular->GetCellInset(cell)->setText(clip.substr(op, len-op)); + paste_tabular->getCellInset(cell)->setText(clip.substr(op, len-op)); } else #else if (!insertAsciiString(bv, clip, true)) @@ -1123,11 +1017,9 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) } case LFUN_PASTE: if (hasPasteBuffer()) { - setUndo(bv, Undo::INSERT, - bv->text->cursor.par(), - boost::next(bv->text->cursor.par())); + recordUndo(bv, Undo::INSERT); pasteSelection(bv); - updateLocal(bv, INIT); + updateLocal(bv); break; } // ATTENTION: the function above has to be PASTE and PASTESELECTION!!! @@ -1156,92 +1048,77 @@ Inset::RESULT InsetTabular::localDispatch(FuncRequest const & cmd) } // we try to activate the actual inset and put this event down to // the insets dispatch function. - if ((result == DISPATCHED) || the_locking_inset) + if (result == DISPATCHED || the_locking_inset) break; - nodraw(true); if (activateCellInset(bv)) { - // reset need_update setted in above function! - need_update = NONE; result = the_locking_inset->localDispatch(FuncRequest(bv, action, arg)); - if ((result == UNDISPATCHED) || (result >= FINISHED)) { + if (result == UNDISPATCHED || result >= FINISHED) { unlockInsetInInset(bv, the_locking_inset); - nodraw(false); // we need to update if this was requested before - updateLocal(bv, NONE); + updateLocal(bv); return UNDISPATCHED; - } else if (hs) { - clearSelection(); - // so the below CELL is not set because this is higher - // priority and we get a full redraw - need_update = SELECTION; } - nodraw(false); - updateLocal(bv, CELL); + if (hs) + clearSelection(); + updateLocal(bv); return result; } break; } if (result < FINISHED) { - if (!the_locking_inset) { - if (bv->fitCursor()) - updateLocal(bv, FULL); - } + if (!the_locking_inset && bv->fitCursor()) + updateLocal(bv); } else bv->unlockInset(this); return result; } -int InsetTabular::latex(Buffer const * buf, ostream & os, +int InsetTabular::latex(Buffer const & buf, ostream & os, LatexRunParams const & runparams) const { - return tabular->latex(buf, os, runparams); + return tabular.latex(buf, os, runparams); } -int InsetTabular::ascii(Buffer const * buf, ostream & os, int ll) const +int InsetTabular::ascii(Buffer const & buf, ostream & os, int ll) const { if (ll > 0) - return tabular->ascii(buf, os, (int)parOwner()->params().depth(), - false,0); - return tabular->ascii(buf, os, 0, false,0); + return tabular.ascii(buf, os, ownerPar(buf, this).params().depth(), + false, 0); + return tabular.ascii(buf, os, 0, false, 0); } -int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const +int InsetTabular::linuxdoc(Buffer const & buf, ostream & os) const { - os << "ascii(buf,os, - (int)parOwner()->params().depth(), - false, 0); - os << "]]>"; - return ret; + return tabular.linuxdoc(buf,os); } -int InsetTabular::docbook(Buffer const * buf, ostream & os, bool mixcont) const +int InsetTabular::docbook(Buffer const & buf, ostream & os, bool mixcont) const { int ret = 0; - Inset * master; + InsetOld * master; // if the table is inside a float it doesn't need the informaltable // wrapper. Search for it. - for(master = owner(); - master && master->lyxCode() != Inset::FLOAT_CODE; - master = master->owner()); + for (master = owner(); + master && master->lyxCode() != InsetOld::FLOAT_CODE; + master = master->owner()); if (!master) { os << ""; if (mixcont) os << endl; - ret++; + ++ret; } - ret+= tabular->docbook(buf, os, mixcont); + ret += tabular.docbook(buf, os, mixcont); if (!master) { os << ""; if (mixcont) os << endl; - ret++; + ++ret; } return ret; } @@ -1249,57 +1126,55 @@ int InsetTabular::docbook(Buffer const * buf, ostream & os, bool mixcont) const void InsetTabular::validate(LaTeXFeatures & features) const { - tabular->Validate(features); + tabular.validate(features); } -bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv, bool reinit) const +void InsetTabular::calculate_dimensions_of_cells(MetricsInfo & mi) const { - int cell = -1; - int maxAsc = 0; - int maxDesc = 0; - InsetText * inset; - bool changed = false; - - // FIXME: since InsetText ignores this anyway, it doesn't - // matter what we pass it. Ugly - LyXFont font; - +#if 1 // if we have a locking_inset we should have to check only this cell for - // change so I'll try this to have a boost, but who knows ;) - if ((need_update != INIT) && - (the_locking_inset == tabular->GetCellInset(actcell))) { - for(int i = 0; i < tabular->columns(); ++i) { - maxAsc = max(tabular->GetCellInset(actrow, i)->ascent(bv, font), - maxAsc); - maxDesc = max(tabular->GetCellInset(actrow, i)->descent(bv, font), - maxDesc); + // change so I'll try this to have a boost, but who knows ;) (Jug?) + // This is _really_ important (André) + if (the_locking_inset == &tabular.getCellInset(actcell)) { + int maxAsc = 0; + int maxDesc = 0; + for (int j = 0; j < tabular.columns(); ++j) { + Dimension dim; + MetricsInfo m = mi; + m.base.textwidth = + tabular.column_info[j].p_width.inPixels(mi.base.textwidth); + tabular.getCellInset(actrow, j).metrics(m, dim); + maxAsc = max(dim.asc, maxAsc); + maxDesc = max(dim.des, maxDesc); } - changed = tabular->SetWidthOfCell(actcell, the_locking_inset->width(bv, font)); - changed = tabular->SetAscentOfRow(actrow, maxAsc + ADD_TO_HEIGHT) || changed; - changed = tabular->SetDescentOfRow(actrow, maxDesc + ADD_TO_HEIGHT) || changed; - return changed; - } - for (int i = 0; i < tabular->rows(); ++i) { - maxAsc = 0; - maxDesc = 0; - for (int j = 0; j < tabular->columns(); ++j) { - if (tabular->IsPartOfMultiColumn(i,j)) + tabular.setWidthOfCell(actcell, the_locking_inset->width()); + tabular.setAscentOfRow(actrow, maxAsc + ADD_TO_HEIGHT); + tabular.setDescentOfRow(actrow, maxDesc + ADD_TO_HEIGHT); + return; + } +#endif + + int cell = -1; + for (int i = 0; i < tabular.rows(); ++i) { + int maxAsc = 0; + int maxDesc = 0; + for (int j = 0; j < tabular.columns(); ++j) { + if (tabular.isPartOfMultiColumn(i, j)) continue; ++cell; - inset = tabular->GetCellInset(cell); - if (!reinit && !tabular->GetPWidth(cell).zero()) - inset->update(bv, false); - maxAsc = max(maxAsc, inset->ascent(bv, font)); - maxDesc = max(maxDesc, inset->descent(bv, font)); - changed = tabular->SetWidthOfCell(cell, inset->width(bv, font)) || changed; + Dimension dim; + MetricsInfo m = mi; + m.base.textwidth = + tabular.column_info[j].p_width.inPixels(mi.base.textwidth); + tabular.getCellInset(cell).metrics(m, dim); + maxAsc = max(maxAsc, dim.asc); + maxDesc = max(maxDesc, dim.des); + tabular.setWidthOfCell(cell, dim.wid); } - changed = tabular->SetAscentOfRow(i, maxAsc + ADD_TO_HEIGHT) || changed; - changed = tabular->SetDescentOfRow(i, maxDesc + ADD_TO_HEIGHT) || changed; + tabular.setAscentOfRow(i, maxAsc + ADD_TO_HEIGHT); + tabular.setDescentOfRow(i, maxDesc + ADD_TO_HEIGHT); } - if (changed) - tabular->reinit(); - return changed; } @@ -1310,13 +1185,13 @@ void InsetTabular::getCursor(BufferView & bv, int & x, int & y) const return; } - x = cursor_.x(); - y = cursor_.y() + InsetTabular::y(); + x = cursorx_; + y = cursory_ + InsetTabular::y(); // Fun stuff - int desc = tabular->GetDescentOfRow(actrow); + int desc = tabular.getDescentOfRow(actrow); y += desc; - int ascdesc = tabular->GetAscentOfRow(actrow) + desc; + int ascdesc = tabular.getAscentOfRow(actrow) + desc; y -= ascdesc / 2; y += ADD_TO_HEIGHT * 2; y += TEXT_TO_INSET_OFFSET; @@ -1329,56 +1204,52 @@ void InsetTabular::getCursorPos(BufferView * bv, int & x, int & y) const the_locking_inset->getCursorPos(bv, x, y); return; } - x = cursor_.x() - top_x; - y = cursor_.y(); + x = cursorx_ - top_x; + y = cursory_; } void InsetTabular::fitInsetCursor(BufferView * bv) const { if (the_locking_inset) { - int old_top_y = bv->text->top_y(); the_locking_inset->fitInsetCursor(bv); - if (old_top_y != bv->text->top_y()) - need_update = FULL; return; } - LyXFont font; + LyXFont font; int const asc = font_metrics::maxAscent(font); int const desc = font_metrics::maxDescent(font); resetPos(bv); - if (bv->fitLockedInsetCursor(cursor_.x(), cursor_.y(), asc, desc)) - need_update = FULL; + bv->fitLockedInsetCursor(cursorx_, cursory_, asc, desc); } void InsetTabular::setPos(BufferView * bv, int x, int y) const { - cursor_.y(0); - + cursory_ = 0; actcell = actrow = actcol = 0; - int ly = tabular->GetDescentOfRow(actrow); + int ly = tabular.getDescentOfRow(actrow); // first search the right row - while ((ly < y) && ((actrow+1) < tabular->rows())) { - cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) + - tabular->GetAscentOfRow(actrow + 1) + - tabular->GetAdditionalHeight(actrow + 1)); + while (ly < y && actrow + 1 < tabular.rows()) { + cursory_ += tabular.getDescentOfRow(actrow) + + tabular.getAscentOfRow(actrow + 1) + + tabular.getAdditionalHeight(actrow + 1); ++actrow; - ly = cursor_.y() + tabular->GetDescentOfRow(actrow); + ly = cursory_ + tabular.getDescentOfRow(actrow); } - actcell = tabular->GetCellNumber(actrow, actcol); + actcell = tabular.getCellNumber(actrow, actcol); // now search the right column - int lx = tabular->GetWidthOfColumn(actcell) - - tabular->GetAdditionalWidth(actcell); - for (; !tabular->IsLastCellInRow(actcell) && lx < x; ++actcell) { - lx += tabular->GetWidthOfColumn(actcell + 1) - + tabular->GetAdditionalWidth(actcell); - } - cursor_.x(lx - tabular->GetWidthOfColumn(actcell) + top_x + 2); + int lx = tabular.getWidthOfColumn(actcell) - + tabular.getAdditionalWidth(actcell); + + for (; !tabular.isLastCellInRow(actcell) && lx < x; ++actcell) + lx += tabular.getWidthOfColumn(actcell + 1) + + tabular.getAdditionalWidth(actcell); + + cursorx_ = lx - tabular.getWidthOfColumn(actcell) + top_x + 2; resetPos(bv); } @@ -1387,13 +1258,13 @@ int InsetTabular::getCellXPos(int cell) const { int c = cell; - for (; !tabular->IsFirstCellInRow(c); --c) + for (; !tabular.isFirstCellInRow(c); --c) ; - int lx = tabular->GetWidthOfColumn(cell); - for (; c < cell; ++c) { - lx += tabular->GetWidthOfColumn(c); - } - return (lx - tabular->GetWidthOfColumn(cell) + top_x); + int lx = tabular.getWidthOfColumn(cell); + for (; c < cell; ++c) + lx += tabular.getWidthOfColumn(c); + + return (lx - tabular.getWidthOfColumn(cell) + top_x); } @@ -1407,80 +1278,78 @@ void InsetTabular::resetPos(BufferView * bv) const return; int cell = 0; - actcol = tabular->column_of_cell(actcell); + actcol = tabular.column_of_cell(actcell); actrow = 0; - cursor_.y(0); - for (; (cell < actcell) && !tabular->IsLastRow(cell); ++cell) { - if (tabular->IsLastCellInRow(cell)) { - cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) + - tabular->GetAscentOfRow(actrow + 1) + - tabular->GetAdditionalHeight(actrow + 1)); + cursory_ = 0; + for (; cell < actcell && !tabular.isLastRow(cell); ++cell) { + if (tabular.isLastCellInRow(cell)) { + cursory_ += tabular.getDescentOfRow(actrow) + + tabular.getAscentOfRow(actrow + 1) + + tabular.getAdditionalHeight(actrow + 1); ++actrow; } } - if (!locked || nodraw()) { + if (!locked) { if (the_locking_inset) - inset_y = cursor_.y(); + inset_y = cursory_; return; } // we need this only from here on!!! ++in_reset_pos; static int const offset = ADD_TO_TABULAR_WIDTH + 2; int new_x = getCellXPos(actcell); - int old_x = cursor_.x(); + int old_x = cursorx_; new_x += offset; - cursor_.x(new_x); + cursorx_ = new_x; // cursor.x(getCellXPos(actcell) + offset); - if ((actcol < tabular->columns() - 1) && scroll(false) && - (tabular->GetWidthOfTabular() < bv->workWidth()-20)) + if (actcol < tabular.columns() - 1 && scroll(false) && + tabular.getWidthOfTabular() < bv->workWidth()-20) { scroll(bv, 0.0F); - updateLocal(bv, FULL); + updateLocal(bv); } else if (the_locking_inset && - (tabular->GetWidthOfColumn(actcell) > bv->workWidth()-20)) + tabular.getWidthOfColumn(actcell) > bv->workWidth() - 20) { - int xx = cursor_.x() - offset + bv->text->getRealCursorX(); - if (xx > (bv->workWidth()-20)) { + int xx = cursorx_ - offset + bv->text->getRealCursorX(); + if (xx > bv->workWidth()-20) { scroll(bv, -(xx - bv->workWidth() + 60)); - updateLocal(bv, FULL); + updateLocal(bv); } else if (xx < 20) { if (xx < 0) xx = -xx + 60; else xx = 60; scroll(bv, xx); - updateLocal(bv, FULL); + updateLocal(bv); } - } else if ((cursor_.x() - offset) > 20 && - (cursor_.x() - offset + tabular->GetWidthOfColumn(actcell)) - > (bv->workWidth() - 20)) { - scroll(bv, -tabular->GetWidthOfColumn(actcell) - 20); - updateLocal(bv, FULL); - } else if ((cursor_.x() - offset) < 20) { - scroll(bv, 20 - cursor_.x() + offset); - updateLocal(bv, FULL); + } else if (cursorx_ - offset > 20 && + cursorx_ - offset + tabular.getWidthOfColumn(actcell) + > bv->workWidth() - 20) { + scroll(bv, -tabular.getWidthOfColumn(actcell) - 20); + updateLocal(bv); + } else if (cursorx_ - offset < 20) { + scroll(bv, 20 - cursorx_ + offset); + updateLocal(bv); } else if (scroll() && top_x > 20 && - (top_x + tabular->GetWidthOfTabular()) > (bv->workWidth() - 20)) { - scroll(bv, old_x - cursor_.x()); - updateLocal(bv, FULL); + (top_x + tabular.getWidthOfTabular()) > bv->workWidth() - 20) { + scroll(bv, old_x - cursorx_); + updateLocal(bv); } if (the_locking_inset) { - inset_x = cursor_.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); - inset_y = cursor_.y(); + inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell); + inset_y = cursory_; } if ((!the_locking_inset || !the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)) && actcell != oldcell) { - InsetTabular * inset = const_cast(this); - InsetTabularMailer mailer(*inset); - mailer.updateDialog(bv); + InsetTabularMailer(*this).updateDialog(bv); oldcell = actcell; } in_reset_pos = 0; } -Inset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) +InsetOld::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) { if (lock && !old_locking_inset) { if (activateCellInset(bv)) @@ -1498,7 +1367,7 @@ Inset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) } -Inset::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock) +InsetOld::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock) { bool moved = isRightToLeft(bv) ? moveNextCell(bv) : movePrevCell(bv); if (!moved) @@ -1512,10 +1381,10 @@ Inset::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock) } -Inset::RESULT InsetTabular::moveUp(BufferView * bv, bool lock) +InsetOld::RESULT InsetTabular::moveUp(BufferView * bv, bool lock) { int const ocell = actcell; - actcell = tabular->GetCellAbove(actcell); + actcell = tabular.getCellAbove(actcell); if (actcell == ocell) // we moved out of the inset return FINISHED_UP; resetPos(bv); @@ -1524,7 +1393,7 @@ Inset::RESULT InsetTabular::moveUp(BufferView * bv, bool lock) int y = 0; if (old_locking_inset) { old_locking_inset->getCursorPos(bv, x, y); - x -= cursor_.x() + tabular->GetBeginningOfTextInCell(actcell); + x -= cursorx_ + tabular.getBeginningOfTextInCell(actcell); } if (activateCellInset(bv, x, 0)) return DISPATCHED; @@ -1533,10 +1402,10 @@ Inset::RESULT InsetTabular::moveUp(BufferView * bv, bool lock) } -Inset::RESULT InsetTabular::moveDown(BufferView * bv, bool lock) +InsetOld::RESULT InsetTabular::moveDown(BufferView * bv, bool lock) { int const ocell = actcell; - actcell = tabular->GetCellBelow(actcell); + actcell = tabular.getCellBelow(actcell); if (actcell == ocell) // we moved out of the inset return FINISHED_DOWN; resetPos(bv); @@ -1545,7 +1414,7 @@ Inset::RESULT InsetTabular::moveDown(BufferView * bv, bool lock) int y = 0; if (old_locking_inset) { old_locking_inset->getCursorPos(bv, x, y); - x -= cursor_.x() + tabular->GetBeginningOfTextInCell(actcell); + x -= cursorx_ + tabular.getBeginningOfTextInCell(actcell); } if (activateCellInset(bv, x, 0)) return DISPATCHED; @@ -1557,25 +1426,25 @@ Inset::RESULT InsetTabular::moveDown(BufferView * bv, bool lock) bool InsetTabular::moveNextCell(BufferView * bv, bool lock) { if (isRightToLeft(bv)) { - if (tabular->IsFirstCellInRow(actcell)) { - int row = tabular->row_of_cell(actcell); - if (row == tabular->rows() - 1) + if (tabular.isFirstCellInRow(actcell)) { + int row = tabular.row_of_cell(actcell); + if (row == tabular.rows() - 1) return false; - actcell = tabular->GetLastCellInRow(row); - actcell = tabular->GetCellBelow(actcell); + actcell = tabular.getLastCellInRow(row); + actcell = tabular.getCellBelow(actcell); } else { if (!actcell) return false; --actcell; } } else { - if (tabular->IsLastCell(actcell)) + if (tabular.isLastCell(actcell)) return false; ++actcell; } if (lock) { - bool rtl = tabular->GetCellInset(actcell)->paragraphs.begin()-> - isRightToLeftPar(bv->buffer()->params); + bool rtl = tabular.getCellInset(actcell).paragraphs.begin()-> + isRightToLeftPar(bv->buffer()->params()); activateCellInset(bv, 0, 0, mouse_button::none, !rtl); } resetPos(bv); @@ -1586,14 +1455,14 @@ bool InsetTabular::moveNextCell(BufferView * bv, bool lock) bool InsetTabular::movePrevCell(BufferView * bv, bool lock) { if (isRightToLeft(bv)) { - if (tabular->IsLastCellInRow(actcell)) { - int row = tabular->row_of_cell(actcell); + if (tabular.isLastCellInRow(actcell)) { + int row = tabular.row_of_cell(actcell); if (row == 0) return false; - actcell = tabular->GetFirstCellInRow(row); - actcell = tabular->GetCellAbove(actcell); + actcell = tabular.getFirstCellInRow(row); + actcell = tabular.getCellAbove(actcell); } else { - if (tabular->IsLastCell(actcell)) + if (tabular.isLastCell(actcell)) return false; ++actcell; } @@ -1603,8 +1472,8 @@ bool InsetTabular::movePrevCell(BufferView * bv, bool lock) --actcell; } if (lock) { - bool rtl = tabular->GetCellInset(actcell)->paragraphs.begin()-> - isRightToLeftPar(bv->buffer()->params); + bool rtl = tabular.getCellInset(actcell).paragraphs.begin()-> + isRightToLeftPar(bv->buffer()->params()); activateCellInset(bv, 0, 0, mouse_button::none, !rtl); } resetPos(bv); @@ -1616,12 +1485,10 @@ void InsetTabular::setFont(BufferView * bv, LyXFont const & font, bool tall, bool selectall) { if (selectall) { - setSelection(0, tabular->GetNumberOfCells() - 1); + setSelection(0, tabular.getNumberOfCells() - 1); } if (hasSelection()) { - setUndo(bv, Undo::EDIT, - bv->text->cursor.par(), - boost::next(bv->text->cursor.par())); + recordUndo(bv, Undo::ATOMIC); bool const frozen = undo_frozen; if (!frozen) freezeUndo(); @@ -1631,16 +1498,15 @@ void InsetTabular::setFont(BufferView * bv, LyXFont const & font, bool tall, int sel_col_start; int sel_col_end; getSelection(sel_row_start, sel_row_end, sel_col_start, sel_col_end); - for(int i = sel_row_start; i <= sel_row_end; ++i) { - for(int j = sel_col_start; j <= sel_col_end; ++j) { - tabular->GetCellInset(i, j)->setFont(bv, font, tall, true); - } - } + for(int i = sel_row_start; i <= sel_row_end; ++i) + for(int j = sel_col_start; j <= sel_col_end; ++j) + tabular.getCellInset(i, j).setFont(bv, font, tall, true); + if (!frozen) unFreezeUndo(); if (selectall) clearSelection(); - updateLocal(bv, INIT); + updateLocal(bv); } if (the_locking_inset) the_locking_inset->setFont(bv, font, tall); @@ -1707,143 +1573,151 @@ void InsetTabular::tabularFeatures(BufferView * bv, LyXTabular::VAlignment setVAlign = LyXTabular::LYX_VALIGN_TOP; switch (feature) { + case LyXTabular::M_ALIGN_LEFT: case LyXTabular::ALIGN_LEFT: setAlign = LYX_ALIGN_LEFT; break; + case LyXTabular::M_ALIGN_RIGHT: case LyXTabular::ALIGN_RIGHT: setAlign = LYX_ALIGN_RIGHT; break; + case LyXTabular::M_ALIGN_CENTER: case LyXTabular::ALIGN_CENTER: setAlign = LYX_ALIGN_CENTER; break; + case LyXTabular::ALIGN_BLOCK: setAlign = LYX_ALIGN_BLOCK; break; + case LyXTabular::M_VALIGN_TOP: case LyXTabular::VALIGN_TOP: setVAlign = LyXTabular::LYX_VALIGN_TOP; break; + case LyXTabular::M_VALIGN_BOTTOM: case LyXTabular::VALIGN_BOTTOM: setVAlign = LyXTabular::LYX_VALIGN_BOTTOM; break; - case LyXTabular::M_VALIGN_CENTER: - case LyXTabular::VALIGN_CENTER: - setVAlign = LyXTabular::LYX_VALIGN_CENTER; + + case LyXTabular::M_VALIGN_MIDDLE: + case LyXTabular::VALIGN_MIDDLE: + setVAlign = LyXTabular::LYX_VALIGN_MIDDLE; break; + default: break; } + if (hasSelection()) { getSelection(sel_row_start, sel_row_end, sel_col_start, sel_col_end); } else { - sel_col_start = sel_col_end = tabular->column_of_cell(actcell); - sel_row_start = sel_row_end = tabular->row_of_cell(actcell); + sel_col_start = sel_col_end = tabular.column_of_cell(actcell); + sel_row_start = sel_row_end = tabular.row_of_cell(actcell); } - setUndo(bv, Undo::FINISH, - bv->text->cursor.par(), - boost::next(bv->text->cursor.par())); + recordUndo(bv, Undo::ATOMIC); - int row = tabular->row_of_cell(actcell); - int column = tabular->column_of_cell(actcell); + int row = tabular.row_of_cell(actcell); + int column = tabular.column_of_cell(actcell); bool flag = true; LyXTabular::ltType ltt; switch (feature) { + case LyXTabular::SET_PWIDTH: { LyXLength const vallen(value); - LyXLength const & tmplen = tabular->GetColumnPWidth(actcell); + LyXLength const & tmplen = tabular.getColumnPWidth(actcell); bool const update = (tmplen != vallen); - tabular->SetColumnPWidth(actcell, vallen); + tabular.setColumnPWidth(actcell, vallen); if (update) { - int cell; - for (int i = 0; i < tabular->rows(); ++i) { - cell = tabular->GetCellNumber(i,column); - tabular->GetCellInset(cell)->resizeLyXText(bv); - } - updateLocal(bv, INIT); + // We need this otherwise we won't resize + // the insettext of the active cell (if any) + // until later (see InsetText::do_resize) + unlockInsetInInset(bv, the_locking_inset); + bv->update(); } if (vallen.zero() - && tabular->GetAlignment(actcell, true) == LYX_ALIGN_BLOCK) + && tabular.getAlignment(actcell, true) == LYX_ALIGN_BLOCK) tabularFeatures(bv, LyXTabular::ALIGN_CENTER, string()); else if (!vallen.zero() - && tabular->GetAlignment(actcell, true) != LYX_ALIGN_BLOCK) + && tabular.getAlignment(actcell, true) != LYX_ALIGN_BLOCK) tabularFeatures(bv, LyXTabular::ALIGN_BLOCK, string()); + break; } - break; + case LyXTabular::SET_MPWIDTH: { LyXLength const vallen(value); - LyXLength const & tmplen = tabular->GetPWidth(actcell); + LyXLength const & tmplen = tabular.getPWidth(actcell); bool const update = (tmplen != vallen); - tabular->SetMColumnPWidth(actcell, vallen); + tabular.setMColumnPWidth(actcell, vallen); if (update) { - for (int i = 0; i < tabular->rows(); ++i) { - tabular->GetCellInset(tabular->GetCellNumber(i, column))-> - resizeLyXText(bv); - } - updateLocal(bv, INIT); + // We need this otherwise we won't resize + // the insettext of the active cell (if any) + // until later (see InsetText::do_resize) + unlockInsetInInset(bv, the_locking_inset); + updateLocal(bv); } } break; case LyXTabular::SET_SPECIAL_COLUMN: case LyXTabular::SET_SPECIAL_MULTI: - tabular->SetAlignSpecial(actcell,value,feature); - updateLocal(bv, FULL); + tabular.setAlignSpecial(actcell,value,feature); + updateLocal(bv); break; case LyXTabular::APPEND_ROW: // append the row into the tabular unlockInsetInInset(bv, the_locking_inset); - tabular->AppendRow(bv->buffer()->params, actcell); - updateLocal(bv, INIT); + tabular.appendRow(bv->buffer()->params(), actcell); + updateLocal(bv); break; case LyXTabular::APPEND_COLUMN: // append the column into the tabular unlockInsetInInset(bv, the_locking_inset); - tabular->AppendColumn(bv->buffer()->params, actcell); - actcell = tabular->GetCellNumber(row, column); - updateLocal(bv, INIT); + tabular.appendColumn(bv->buffer()->params(), actcell); + actcell = tabular.getCellNumber(row, column); + updateLocal(bv); break; case LyXTabular::DELETE_ROW: unlockInsetInInset(bv, the_locking_inset); for(int i = sel_row_start; i <= sel_row_end; ++i) { - tabular->DeleteRow(sel_row_start); + tabular.deleteRow(sel_row_start); } - if (sel_row_start >= tabular->rows()) + if (sel_row_start >= tabular.rows()) --sel_row_start; - actcell = tabular->GetCellNumber(sel_row_start, column); + actcell = tabular.getCellNumber(sel_row_start, column); clearSelection(); - updateLocal(bv, INIT); + updateLocal(bv); break; case LyXTabular::DELETE_COLUMN: unlockInsetInInset(bv, the_locking_inset); for(int i = sel_col_start; i <= sel_col_end; ++i) { - tabular->DeleteColumn(sel_col_start); + tabular.deleteColumn(sel_col_start); } - if (sel_col_start >= tabular->columns()) + if (sel_col_start >= tabular.columns()) --sel_col_start; - actcell = tabular->GetCellNumber(row, sel_col_start); + actcell = tabular.getCellNumber(row, sel_col_start); clearSelection(); - updateLocal(bv, INIT); + updateLocal(bv); break; case LyXTabular::M_TOGGLE_LINE_TOP: flag = false; case LyXTabular::TOGGLE_LINE_TOP: { - bool lineSet = !tabular->TopLine(actcell, flag); + bool lineSet = !tabular.topLine(actcell, flag); for (int i = sel_row_start; i <= sel_row_end; ++i) for (int j = sel_col_start; j <= sel_col_end; ++j) - tabular->SetTopLine( - tabular->GetCellNumber(i, j), + tabular.setTopLine( + tabular.getCellNumber(i, j), lineSet, flag); - updateLocal(bv, INIT); + updateLocal(bv); break; } @@ -1851,14 +1725,14 @@ void InsetTabular::tabularFeatures(BufferView * bv, flag = false; case LyXTabular::TOGGLE_LINE_BOTTOM: { - bool lineSet = !tabular->BottomLine(actcell, flag); + bool lineSet = !tabular.bottomLine(actcell, flag); for (int i = sel_row_start; i <= sel_row_end; ++i) for (int j = sel_col_start; j <= sel_col_end; ++j) - tabular->SetBottomLine( - tabular->GetCellNumber(i, j), + tabular.setBottomLine( + tabular.getCellNumber(i, j), lineSet, flag); - updateLocal(bv, INIT); + updateLocal(bv); break; } @@ -1866,14 +1740,14 @@ void InsetTabular::tabularFeatures(BufferView * bv, flag = false; case LyXTabular::TOGGLE_LINE_LEFT: { - bool lineSet = !tabular->LeftLine(actcell, flag); + bool lineSet = !tabular.leftLine(actcell, flag); for (int i = sel_row_start; i <= sel_row_end; ++i) for (int j = sel_col_start; j <= sel_col_end; ++j) - tabular->SetLeftLine( - tabular->GetCellNumber(i,j), + tabular.setLeftLine( + tabular.getCellNumber(i,j), lineSet, flag); - updateLocal(bv, INIT); + updateLocal(bv); break; } @@ -1881,14 +1755,14 @@ void InsetTabular::tabularFeatures(BufferView * bv, flag = false; case LyXTabular::TOGGLE_LINE_RIGHT: { - bool lineSet = !tabular->RightLine(actcell, flag); + bool lineSet = !tabular.rightLine(actcell, flag); for (int i = sel_row_start; i <= sel_row_end; ++i) for (int j = sel_col_start; j <= sel_col_end; ++j) - tabular->SetRightLine( - tabular->GetCellNumber(i,j), + tabular.setRightLine( + tabular.getCellNumber(i,j), lineSet, flag); - updateLocal(bv, INIT); + updateLocal(bv); break; } @@ -1902,28 +1776,29 @@ void InsetTabular::tabularFeatures(BufferView * bv, 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) - tabular->SetAlignment( - tabular->GetCellNumber(i, j), + tabular.setAlignment( + tabular.getCellNumber(i, j), setAlign, flag); - updateLocal(bv, INIT); + updateLocal(bv); break; + case LyXTabular::M_VALIGN_TOP: case LyXTabular::M_VALIGN_BOTTOM: - case LyXTabular::M_VALIGN_CENTER: + case LyXTabular::M_VALIGN_MIDDLE: flag = false; case LyXTabular::VALIGN_TOP: case LyXTabular::VALIGN_BOTTOM: - case LyXTabular::VALIGN_CENTER: + 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) - tabular->SetVAlignment( - tabular->GetCellNumber(i, j), + tabular.setVAlignment( + tabular.getCellNumber(i, j), setVAlign, flag); - updateLocal(bv, INIT); + updateLocal(bv); break; - case LyXTabular::MULTICOLUMN: - { + + case LyXTabular::MULTICOLUMN: { if (sel_row_start != sel_row_end) { #ifdef WITH_WARNINGS #warning Need I say it ? This is horrible. @@ -1935,13 +1810,11 @@ void InsetTabular::tabularFeatures(BufferView * bv, // just multicol for one Single Cell if (!hasSelection()) { // check wether we are completly in a multicol - if (tabular->IsMultiColumn(actcell)) { - tabular->UnsetMultiColumn(actcell); - updateLocal(bv, INIT); - } else { - tabular->SetMultiColumn(bv->buffer(), actcell, 1); - updateLocal(bv, CELL); - } + if (tabular.isMultiColumn(actcell)) + tabular.unsetMultiColumn(actcell); + else + tabular.setMultiColumn(bv->buffer(), actcell, 1); + updateLocal(bv); break; } // we have a selection so this means we just add all this @@ -1956,189 +1829,149 @@ void InsetTabular::tabularFeatures(BufferView * bv, s_start = sel_cell_start; s_end = sel_cell_end; } - tabular->SetMultiColumn(bv->buffer(), s_start, s_end - s_start + 1); + tabular.setMultiColumn(bv->buffer(), s_start, s_end - s_start + 1); actcell = s_start; clearSelection(); - updateLocal(bv, INIT); + updateLocal(bv); break; } + case LyXTabular::SET_ALL_LINES: setLines = true; case LyXTabular::UNSET_ALL_LINES: for (int i = sel_row_start; i <= sel_row_end; ++i) for (int j = sel_col_start; j <= sel_col_end; ++j) - tabular->SetAllLines( - tabular->GetCellNumber(i,j), setLines); - updateLocal(bv, INIT); + tabular.setAllLines( + tabular.getCellNumber(i,j), setLines); + updateLocal(bv); break; + case LyXTabular::SET_LONGTABULAR: - tabular->SetLongTabular(true); - updateLocal(bv, INIT); // because this toggles displayed + tabular.setLongTabular(true); + updateLocal(bv); // because this toggles displayed break; + case LyXTabular::UNSET_LONGTABULAR: - tabular->SetLongTabular(false); - updateLocal(bv, INIT); // because this toggles displayed + tabular.setLongTabular(false); + updateLocal(bv); // because this toggles displayed break; + case LyXTabular::SET_ROTATE_TABULAR: - tabular->SetRotateTabular(true); + tabular.setRotateTabular(true); break; + case LyXTabular::UNSET_ROTATE_TABULAR: - tabular->SetRotateTabular(false); + tabular.setRotateTabular(false); 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) - tabular->SetRotateCell( - tabular->GetCellNumber(i, j), - true); + 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) - tabular->SetRotateCell( - tabular->GetCellNumber(i, j), false); + tabular.setRotateCell( + tabular.getCellNumber(i, j), false); break; - case LyXTabular::SET_USEBOX: - { + + case LyXTabular::SET_USEBOX: { LyXTabular::BoxType val = LyXTabular::BoxType(strToInt(value)); - if (val == tabular->GetUsebox(actcell)) + if (val == tabular.getUsebox(actcell)) 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) - tabular->SetUsebox( - tabular->GetCellNumber(i, j), val); + tabular.setUsebox(tabular.getCellNumber(i, j), val); break; } + case LyXTabular::UNSET_LTFIRSTHEAD: flag = false; case LyXTabular::SET_LTFIRSTHEAD: - (void)tabular->GetRowOfLTFirstHead(row, ltt); + tabular.getRowOfLTFirstHead(row, ltt); checkLongtableSpecial(ltt, value, flag); - tabular->SetLTHead(row, flag, ltt, true); + tabular.setLTHead(row, flag, ltt, true); break; + case LyXTabular::UNSET_LTHEAD: flag = false; case LyXTabular::SET_LTHEAD: - (void)tabular->GetRowOfLTHead(row, ltt); + tabular.getRowOfLTHead(row, ltt); checkLongtableSpecial(ltt, value, flag); - tabular->SetLTHead(row, flag, ltt, false); + tabular.setLTHead(row, flag, ltt, false); break; + case LyXTabular::UNSET_LTFOOT: flag = false; case LyXTabular::SET_LTFOOT: - (void)tabular->GetRowOfLTFoot(row, ltt); + tabular.getRowOfLTFoot(row, ltt); checkLongtableSpecial(ltt, value, flag); - tabular->SetLTFoot(row, flag, ltt, false); + tabular.setLTFoot(row, flag, ltt, false); break; + case LyXTabular::UNSET_LTLASTFOOT: flag = false; case LyXTabular::SET_LTLASTFOOT: - (void)tabular->GetRowOfLTLastFoot(row, ltt); + tabular.getRowOfLTLastFoot(row, ltt); checkLongtableSpecial(ltt, value, flag); - tabular->SetLTFoot(row, flag, ltt, true); + tabular.setLTFoot(row, flag, ltt, true); break; - case LyXTabular::SET_LTNEWPAGE: - { - bool what = !tabular->GetLTNewPage(row); - tabular->SetLTNewPage(row, what); + + case LyXTabular::SET_LTNEWPAGE: { + bool what = !tabular.getLTNewPage(row); + tabular.setLTNewPage(row, what); break; } + // dummy stuff just to avoid warnings case LyXTabular::LAST_ACTION: break; } - InsetTabularMailer mailer(*this); - mailer.updateDialog(bv); + InsetTabularMailer(*this).updateDialog(bv); } -bool InsetTabular::activateCellInset(BufferView * bv, int x, int y, mouse_button::state button, - bool behind) +bool InsetTabular::activateCellInset(BufferView * bv, int x, int y, + mouse_button::state button, bool behind) { - UpdatableInset * inset = - static_cast(tabular->GetCellInset(actcell)); - LyXFont font(LyXFont::ALL_SANE); + UpdatableInset & inset = tabular.getCellInset(actcell); if (behind) { - x = inset->x() + inset->width(bv, font); - y = inset->descent(bv, font); +#warning metrics? + x = inset.x() + inset.width(); + y = inset.descent(); } - //inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); - //inset_y = cursor.y(); - inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, x, y, button)); + //inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell); + //inset_y = cursory_; + inset.localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, x, y, button)); if (!the_locking_inset) return false; - updateLocal(bv, CELL); - return (the_locking_inset != 0); + updateLocal(bv); + return the_locking_inset; } bool InsetTabular::activateCellInsetAbs(BufferView * bv, int x, int y, mouse_button::state button) { - inset_x = cursor_.x() - - top_x + tabular->GetBeginningOfTextInCell(actcell); - inset_y = cursor_.y(); + inset_x = cursorx_ - top_x + tabular.getBeginningOfTextInCell(actcell); + inset_y = cursory_; return activateCellInset(bv, x - inset_x, y - inset_y, button); } bool InsetTabular::insetHit(BufferView *, int x, int) const { - return (x + top_x) - > (cursor_.x() + tabular->GetBeginningOfTextInCell(actcell)); + return x + top_x > cursorx_ + tabular.getBeginningOfTextInCell(actcell); } -// This returns paperWidth() if the cell-width is unlimited or the width -// in pixels if we have a pwidth for this cell. -int InsetTabular::getMaxWidthOfCell(BufferView * bv, int cell) const +void InsetTabular::deleteLyXText(BufferView * /*bv*/, bool /*recursive*/) const { - LyXLength const len = tabular->GetPWidth(cell); - - if (len.zero()) - return -1; - return len.inPixels(latexTextWidth(bv)); -} - - -int InsetTabular::getMaxWidth(BufferView * bv, - UpdatableInset const * inset) const -{ - int cell = tabular->GetCellFromInset(inset, actcell); - - if (cell == -1) { - lyxerr << "Own inset not found, shouldn't really happen!" - << endl; - return -1; - } - - int w = getMaxWidthOfCell(bv, cell); - if (w > 0) { - // because the inset then subtracts it's top_x and owner->x() - w += (inset->x() - top_x); - } - - return w; -} - - -void InsetTabular::deleteLyXText(BufferView * bv, bool recursive) const -{ - resizeLyXText(bv, recursive); -} - - -void InsetTabular::resizeLyXText(BufferView * bv, bool force) const -{ - if (force) { - for(int i = 0; i < tabular->rows(); ++i) { - for(int j = 0; j < tabular->columns(); ++j) { - tabular->GetCellInset(i, j)->resizeLyXText(bv, true); - } - } - } - need_update = FULL; + //resizeLyXText(bv, recursive); } @@ -2147,26 +1980,14 @@ LyXText * InsetTabular::getLyXText(BufferView const * bv, { if (the_locking_inset) return the_locking_inset->getLyXText(bv, recursive); -#if 0 - // if we're locked lock the actual insettext and return it's LyXText!!! - if (locked) { - UpdatableInset * inset = - static_cast(tabular->GetCellInset(actcell)); - inset->edit(const_cast(bv), 0, 0, 0); - return the_locking_inset->getLyXText(bv, recursive); - } -#endif - return Inset::getLyXText(bv, recursive); + return InsetOld::getLyXText(bv, recursive); } bool InsetTabular::showInsetDialog(BufferView * bv) const { - if (!the_locking_inset || !the_locking_inset->showInsetDialog(bv)) { - InsetTabular * tmp = const_cast(this); - InsetTabularMailer mailer(*tmp); - mailer.showDialog(bv); - } + if (!the_locking_inset || !the_locking_inset->showInsetDialog(bv)) + InsetTabularMailer(*this).showDialog(bv); return true; } @@ -2174,16 +1995,14 @@ bool InsetTabular::showInsetDialog(BufferView * bv) const void InsetTabular::openLayoutDialog(BufferView * bv) const { if (the_locking_inset) { - InsetTabular * i = static_cast + InsetTabular * inset = static_cast (the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)); - if (i) { - i->openLayoutDialog(bv); + if (inset) { + inset->openLayoutDialog(bv); return; } } - InsetTabular * tmp = const_cast(this); - InsetTabularMailer mailer(*tmp); - mailer.showDialog(bv); + InsetTabularMailer(*this).showDialog(bv); } @@ -2211,7 +2030,8 @@ FuncStatus InsetTabular::getStatus(string const & what) const return status.unknown(true); } - string const argument = ltrim(what.substr(tabularFeature[i].feature.length())); + string const argument + = ltrim(what.substr(tabularFeature[i].feature.length())); int sel_row_start; int sel_row_end; @@ -2219,11 +2039,10 @@ FuncStatus InsetTabular::getStatus(string const & what) const LyXTabular::ltType dummyltt; bool flag = true; - if (hasSelection()) { + if (hasSelection()) getSelection(sel_row_start, sel_row_end, dummy, dummy); - } else { - sel_row_start = sel_row_end = tabular->row_of_cell(actcell); - } + else + sel_row_start = sel_row_end = tabular.row_of_cell(actcell); switch (action) { case LyXTabular::SET_PWIDTH: @@ -2239,98 +2058,122 @@ FuncStatus InsetTabular::getStatus(string const & what) const return status.clear(); case LyXTabular::MULTICOLUMN: - status.setOnOff(tabular->IsMultiColumn(actcell)); + status.setOnOff(tabular.isMultiColumn(actcell)); break; + case LyXTabular::M_TOGGLE_LINE_TOP: flag = false; case LyXTabular::TOGGLE_LINE_TOP: - status.setOnOff(tabular->TopLine(actcell, flag)); + status.setOnOff(tabular.topLine(actcell, flag)); break; + case LyXTabular::M_TOGGLE_LINE_BOTTOM: flag = false; case LyXTabular::TOGGLE_LINE_BOTTOM: - status.setOnOff(tabular->BottomLine(actcell, flag)); + status.setOnOff(tabular.bottomLine(actcell, flag)); break; + case LyXTabular::M_TOGGLE_LINE_LEFT: flag = false; case LyXTabular::TOGGLE_LINE_LEFT: - status.setOnOff(tabular->LeftLine(actcell, flag)); + status.setOnOff(tabular.leftLine(actcell, flag)); break; + case LyXTabular::M_TOGGLE_LINE_RIGHT: flag = false; case LyXTabular::TOGGLE_LINE_RIGHT: - status.setOnOff(tabular->RightLine(actcell, flag)); + status.setOnOff(tabular.rightLine(actcell, flag)); break; + case LyXTabular::M_ALIGN_LEFT: flag = false; case LyXTabular::ALIGN_LEFT: - status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT); + status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_LEFT); break; + case LyXTabular::M_ALIGN_RIGHT: flag = false; case LyXTabular::ALIGN_RIGHT: - status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT); + status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_RIGHT); break; + case LyXTabular::M_ALIGN_CENTER: flag = false; case LyXTabular::ALIGN_CENTER: - status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER); + status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_CENTER); break; + case LyXTabular::ALIGN_BLOCK: - status.disabled(tabular->GetPWidth(actcell).zero()); - status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_BLOCK); + status.disabled(tabular.getPWidth(actcell).zero()); + status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_BLOCK); break; + case LyXTabular::M_VALIGN_TOP: flag = false; case LyXTabular::VALIGN_TOP: - status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP); + status.setOnOff(tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP); break; + case LyXTabular::M_VALIGN_BOTTOM: flag = false; case LyXTabular::VALIGN_BOTTOM: - status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM); + status.setOnOff(tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM); break; - case LyXTabular::M_VALIGN_CENTER: + + case LyXTabular::M_VALIGN_MIDDLE: flag = false; - case LyXTabular::VALIGN_CENTER: - status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER); + case LyXTabular::VALIGN_MIDDLE: + status.setOnOff(tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_MIDDLE); break; + case LyXTabular::SET_LONGTABULAR: - status.setOnOff(tabular->IsLongTabular()); + status.setOnOff(tabular.isLongTabular()); break; + case LyXTabular::UNSET_LONGTABULAR: - status.setOnOff(!tabular->IsLongTabular()); + status.setOnOff(!tabular.isLongTabular()); break; + case LyXTabular::SET_ROTATE_TABULAR: - status.setOnOff(tabular->GetRotateTabular()); + status.setOnOff(tabular.getRotateTabular()); break; + case LyXTabular::UNSET_ROTATE_TABULAR: - status.setOnOff(!tabular->GetRotateTabular()); + status.setOnOff(!tabular.getRotateTabular()); break; + case LyXTabular::SET_ROTATE_CELL: - status.setOnOff(tabular->GetRotateCell(actcell)); + status.setOnOff(tabular.getRotateCell(actcell)); break; + case LyXTabular::UNSET_ROTATE_CELL: - status.setOnOff(!tabular->GetRotateCell(actcell)); + status.setOnOff(!tabular.getRotateCell(actcell)); break; + case LyXTabular::SET_USEBOX: - status.setOnOff(strToInt(argument) == tabular->GetUsebox(actcell)); + status.setOnOff(strToInt(argument) == tabular.getUsebox(actcell)); break; + case LyXTabular::SET_LTFIRSTHEAD: - status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt)); + status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt)); break; + case LyXTabular::SET_LTHEAD: - status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt)); + status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt)); break; + case LyXTabular::SET_LTFOOT: - status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt)); + status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt)); break; + case LyXTabular::SET_LTLASTFOOT: - status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt)); + status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt)); break; + case LyXTabular::SET_LTNEWPAGE: - status.setOnOff(tabular->GetLTNewPage(sel_row_start)); + status.setOnOff(tabular.getLTNewPage(sel_row_start)); break; + default: status.clear(); status.disabled(true); @@ -2340,9 +2183,9 @@ FuncStatus InsetTabular::getStatus(string const & what) const } -vector const InsetTabular::getLabelList() const +void InsetTabular::getLabelList(std::vector & list) const { - return tabular->getLabelList(); + tabular.getLabelList(list); } @@ -2351,45 +2194,49 @@ bool InsetTabular::copySelection(BufferView * bv) if (!hasSelection()) return false; - int sel_col_start = tabular->column_of_cell(sel_cell_start); - int sel_col_end = tabular->column_of_cell(sel_cell_end); + int sel_col_start = tabular.column_of_cell(sel_cell_start); + int sel_col_end = tabular.column_of_cell(sel_cell_end); if (sel_col_start > sel_col_end) { sel_col_start = sel_col_end; - sel_col_end = tabular->right_column_of_cell(sel_cell_start); + sel_col_end = tabular.right_column_of_cell(sel_cell_start); } else { - sel_col_end = tabular->right_column_of_cell(sel_cell_end); + sel_col_end = tabular.right_column_of_cell(sel_cell_end); } - int const columns = sel_col_end - sel_col_start + 1; - int sel_row_start = tabular->row_of_cell(sel_cell_start); - int sel_row_end = tabular->row_of_cell(sel_cell_end); - if (sel_row_start > sel_row_end) { + int sel_row_start = tabular.row_of_cell(sel_cell_start); + int sel_row_end = tabular.row_of_cell(sel_cell_end); + if (sel_row_start > sel_row_end) swap(sel_row_start, sel_row_end); - } - int const rows = sel_row_end - sel_row_start + 1; delete paste_tabular; - paste_tabular = new LyXTabular(bv->buffer()->params, - this, *tabular); // rows, columns); + paste_tabular = new LyXTabular(bv->buffer()->params(), this, tabular); + for (int i = 0; i < sel_row_start; ++i) - paste_tabular->DeleteRow(0); + paste_tabular->deleteRow(0); + + int const rows = sel_row_end - sel_row_start + 1; while (paste_tabular->rows() > rows) - paste_tabular->DeleteRow(rows); - paste_tabular->SetTopLine(0, true, true); - paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows - 1), + paste_tabular->deleteRow(rows); + + paste_tabular->setTopLine(0, true, true); + paste_tabular->setBottomLine(paste_tabular->getFirstCellInRow(rows - 1), true, true); + for (int i = 0; i < sel_col_start; ++i) - paste_tabular->DeleteColumn(0); + paste_tabular->deleteColumn(0); + + int const columns = sel_col_end - sel_col_start + 1; while (paste_tabular->columns() > columns) - paste_tabular->DeleteColumn(columns); - paste_tabular->SetLeftLine(0, true, true); - paste_tabular->SetRightLine(paste_tabular->GetLastCellInRow(0), + paste_tabular->deleteColumn(columns); + + paste_tabular->setLeftLine(0, true, true); + paste_tabular->setRightLine(paste_tabular->getLastCellInRow(0), true, true); - ostringstream sstr; - paste_tabular->ascii(bv->buffer(), sstr, - (int)parOwner()->params().depth(), true, '\t'); - bv->stuffClipboard(STRCONV(sstr.str())); + ostringstream os; + paste_tabular->ascii(*bv->buffer(), os, + ownerPar(*bv->buffer(), this).params().depth(), true, '\t'); + bv->stuffClipboard(STRCONV(os.str())); return true; } @@ -2400,28 +2247,27 @@ bool InsetTabular::pasteSelection(BufferView * bv) return false; for (int r1 = 0, r2 = actrow; - (r1 < paste_tabular->rows()) && (r2 < tabular->rows()); + r1 < paste_tabular->rows() && r2 < tabular.rows(); ++r1, ++r2) { - for(int c1 = 0, c2 = actcol; - (c1 < paste_tabular->columns()) && (c2 < tabular->columns()); + for (int c1 = 0, c2 = actcol; + c1 < paste_tabular->columns() && c2 < tabular.columns(); ++c1, ++c2) { - if (paste_tabular->IsPartOfMultiColumn(r1,c1) && - tabular->IsPartOfMultiColumn(r2,c2)) + if (paste_tabular->isPartOfMultiColumn(r1, c1) && + tabular.isPartOfMultiColumn(r2, c2)) continue; - if (paste_tabular->IsPartOfMultiColumn(r1,c1)) { + if (paste_tabular->isPartOfMultiColumn(r1, c1)) { --c2; continue; } - if (tabular->IsPartOfMultiColumn(r2,c2)) { + if (tabular.isPartOfMultiColumn(r2, c2)) { --c1; continue; } - int const n1 = paste_tabular->GetCellNumber(r1, c1); - int const n2 = tabular->GetCellNumber(r2, c2); - *(tabular->GetCellInset(n2)) = *(paste_tabular->GetCellInset(n1)); - tabular->GetCellInset(n2)->setOwner(this); - tabular->GetCellInset(n2)->deleteLyXText(bv); - tabular->GetCellInset(n2)->markNew(); + InsetText & inset = tabular.getCellInset(r2, c2); + inset = paste_tabular->getCellInset(r1, c1); + inset.setOwner(this); + inset.deleteLyXText(bv); + inset.markNew(); } } return true; @@ -2433,27 +2279,27 @@ bool InsetTabular::cutSelection(BufferParams const & bp) if (!hasSelection()) return false; - int sel_col_start = tabular->column_of_cell(sel_cell_start); - int sel_col_end = tabular->column_of_cell(sel_cell_end); + int sel_col_start = tabular.column_of_cell(sel_cell_start); + int sel_col_end = tabular.column_of_cell(sel_cell_end); if (sel_col_start > sel_col_end) { sel_col_start = sel_col_end; - sel_col_end = tabular->right_column_of_cell(sel_cell_start); + sel_col_end = tabular.right_column_of_cell(sel_cell_start); } else { - sel_col_end = tabular->right_column_of_cell(sel_cell_end); + sel_col_end = tabular.right_column_of_cell(sel_cell_end); } - int sel_row_start = tabular->row_of_cell(sel_cell_start); - int sel_row_end = tabular->row_of_cell(sel_cell_end); - if (sel_row_start > sel_row_end) { + + int sel_row_start = tabular.row_of_cell(sel_cell_start); + int sel_row_end = tabular.row_of_cell(sel_cell_end); + + if (sel_row_start > sel_row_end) swap(sel_row_start, sel_row_end); - } - if (sel_cell_start > sel_cell_end) { + + if (sel_cell_start > sel_cell_end) swap(sel_cell_start, sel_cell_end); - } - for (int i = sel_row_start; i <= sel_row_end; ++i) { - for (int j = sel_col_start; j <= sel_col_end; ++j) { - tabular->GetCellInset(tabular->GetCellNumber(i, j))->clear(bp.tracking_changes); - } - } + + for (int i = sel_row_start; i <= sel_row_end; ++i) + for (int j = sel_col_start; j <= sel_col_end; ++j) + tabular.getCellInset(tabular.getCellNumber(i, j)).clear(bp.tracking_changes); return true; } @@ -2464,14 +2310,6 @@ bool InsetTabular::isRightToLeft(BufferView * bv) } -bool InsetTabular::nodraw() const -{ - if (!UpdatableInset::nodraw() && the_locking_inset) - return the_locking_inset->nodraw(); - return UpdatableInset::nodraw(); -} - - int InsetTabular::scroll(bool recursive) const { int sx = UpdatableInset::scroll(false); @@ -2489,26 +2327,24 @@ void InsetTabular::getSelection(int & srow, int & erow, int const start = hasSelection() ? sel_cell_start : actcell; int const end = hasSelection() ? sel_cell_end : actcell; - srow = tabular->row_of_cell(start); - erow = tabular->row_of_cell(end); - if (srow > erow) { + srow = tabular.row_of_cell(start); + erow = tabular.row_of_cell(end); + if (srow > erow) swap(srow, erow); - } - scol = tabular->column_of_cell(start); - ecol = tabular->column_of_cell(end); - if (scol > ecol) { + scol = tabular.column_of_cell(start); + ecol = tabular.column_of_cell(end); + if (scol > ecol) swap(scol, ecol); - } else { - ecol = tabular->right_column_of_cell(end); - } + else + ecol = tabular.right_column_of_cell(end); } ParagraphList * InsetTabular::getParagraphs(int i) const { - return (i < tabular->GetNumberOfCells()) - ? tabular->GetCellInset(i)->getParagraphs(0) + return (i < tabular.getNumberOfCells()) + ? tabular.getCellInset(i).getParagraphs(0) : 0; } @@ -2517,20 +2353,20 @@ LyXCursor const & InsetTabular::cursor(BufferView * bv) const { if (the_locking_inset) return the_locking_inset->cursor(bv); - return Inset::cursor(bv); + return InsetOld::cursor(bv); } -Inset * InsetTabular::getInsetFromID(int id_arg) const +InsetOld * InsetTabular::getInsetFromID(int id_arg) const { if (id_arg == id()) return const_cast(this); - Inset * result; - for(int i = 0; i < tabular->rows(); ++i) { - for(int j = 0; j < tabular->columns(); ++j) { - if ((result = tabular->GetCellInset(i, j)->getInsetFromID(id_arg))) - return result; + for (int i = 0; i < tabular.rows(); ++i) { + for (int j = 0; j < tabular.columns(); ++j) { + InsetOld * inset = tabular.getCellInset(i, j).getInsetFromID(id_arg); + if (inset) + return inset; } } return 0; @@ -2540,26 +2376,20 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const WordLangTuple const InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const { - nodraw(true); if (the_locking_inset) { WordLangTuple word(the_locking_inset->selectNextWordToSpellcheck(bv, value)); - if (!word.word().empty()) { - nodraw(false); + if (!word.word().empty()) return word; - } - if (tabular->IsLastCell(actcell)) { + if (tabular.isLastCell(actcell)) { bv->unlockInset(const_cast(this)); - nodraw(false); return WordLangTuple(); } ++actcell; } // otherwise we have to lock the next inset and ask for it's selecttion - UpdatableInset * inset = - static_cast(tabular->GetCellInset(actcell)); - inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT)); + tabular.getCellInset(actcell) + .localDispatch(FuncRequest(bv, LFUN_INSET_EDIT)); WordLangTuple word(selectNextWordInt(bv, value)); - nodraw(false); if (!word.word().empty()) resetPos(bv); return word; @@ -2569,52 +2399,36 @@ InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const WordLangTuple InsetTabular::selectNextWordInt(BufferView * bv, float & value) const { // when entering this function the inset should be ALWAYS locked! - lyx::Assert(the_locking_inset); + Assert(the_locking_inset); WordLangTuple word(the_locking_inset->selectNextWordToSpellcheck(bv, value)); if (!word.word().empty()) return word; - if (tabular->IsLastCell(actcell)) { + if (tabular.isLastCell(actcell)) { bv->unlockInset(const_cast(this)); return WordLangTuple(); } // otherwise we have to lock the next inset and ask for it's selecttion - UpdatableInset * inset = - static_cast(tabular->GetCellInset(++actcell)); - inset->localDispatch(FuncRequest(bv, LFUN_INSET_EDIT)); + ++actcell; + tabular.getCellInset(actcell) + .localDispatch(FuncRequest(bv, LFUN_INSET_EDIT)); return selectNextWordInt(bv, value); } void InsetTabular::selectSelectedWord(BufferView * bv) { - if (the_locking_inset) { + if (the_locking_inset) the_locking_inset->selectSelectedWord(bv); - return; - } - return; -} - - -void InsetTabular::toggleSelection(BufferView * bv, bool kill_selection) -{ - if (the_locking_inset) { - the_locking_inset->toggleSelection(bv, kill_selection); - } } void InsetTabular::markErased() { - int cell = 0; - - while (!tabular->IsLastCell(cell)) { - ++cell; - InsetText * inset = tabular->GetCellInset(cell); - inset->markErased(); - } + for (int cell = 0; cell < tabular.getNumberOfCells(); ++cell) + tabular.getCellInset(cell).markErased(); } @@ -2622,23 +2436,23 @@ bool InsetTabular::nextChange(BufferView * bv, lyx::pos_type & length) { if (the_locking_inset) { if (the_locking_inset->nextChange(bv, length)) { - updateLocal(bv, CELL); + updateLocal(bv); return true; } - if (tabular->IsLastCell(actcell)) + if (tabular.isLastCell(actcell)) return false; ++actcell; } - InsetText * inset = tabular->GetCellInset(actcell); - if (inset->nextChange(bv, length)) { - updateLocal(bv, FULL); + InsetText & inset = tabular.getCellInset(actcell); + if (inset.nextChange(bv, length)) { + updateLocal(bv); return true; } - while (!tabular->IsLastCell(actcell)) { + while (!tabular.isLastCell(actcell)) { ++actcell; - inset = tabular->GetCellInset(actcell); - if (inset->nextChange(bv, length)) { - updateLocal(bv, FULL); + InsetText & inset = tabular.getCellInset(actcell); + if (inset.nextChange(bv, length)) { + updateLocal(bv); return true; } } @@ -2652,23 +2466,23 @@ bool InsetTabular::searchForward(BufferView * bv, string const & str, int cell = 0; if (the_locking_inset) { if (the_locking_inset->searchForward(bv, str, cs, mw)) { - updateLocal(bv, CELL); + updateLocal(bv); return true; } - if (tabular->IsLastCell(actcell)) + if (tabular.isLastCell(actcell)) return false; cell = actcell + 1; } - InsetText * inset = tabular->GetCellInset(cell); - if (inset->searchForward(bv, str, cs, mw)) { - updateLocal(bv, FULL); + InsetText & inset = tabular.getCellInset(cell); + if (inset.searchForward(bv, str, cs, mw)) { + updateLocal(bv); return true; } - while (!tabular->IsLastCell(cell)) { + while (!tabular.isLastCell(cell)) { ++cell; - inset = tabular->GetCellInset(cell); - if (inset->searchForward(bv, str, cs, mw)) { - updateLocal(bv, FULL); + InsetText & inset = tabular.getCellInset(cell); + if (inset.searchForward(bv, str, cs, mw)) { + updateLocal(bv); return true; } } @@ -2679,10 +2493,10 @@ bool InsetTabular::searchForward(BufferView * bv, string const & str, bool InsetTabular::searchBackward(BufferView * bv, string const & str, bool cs, bool mw) { - int cell = tabular->GetNumberOfCells(); + int cell = tabular.getNumberOfCells(); if (the_locking_inset) { if (the_locking_inset->searchBackward(bv, str, cs, mw)) { - updateLocal(bv, CELL); + updateLocal(bv); return true; } cell = actcell; @@ -2690,9 +2504,9 @@ bool InsetTabular::searchBackward(BufferView * bv, string const & str, while (cell) { --cell; - InsetText * inset = tabular->GetCellInset(cell); - if (inset->searchBackward(bv, str, cs, mw)) { - updateLocal(bv, CELL); + InsetText & inset = tabular.getCellInset(cell); + if (inset.searchBackward(bv, str, cs, mw)) { + updateLocal(bv); return true; } } @@ -2700,7 +2514,7 @@ bool InsetTabular::searchBackward(BufferView * bv, string const & str, } -bool InsetTabular::insetAllowed(Inset::Code code) const +bool InsetTabular::insetAllowed(InsetOld::Code code) const { if (the_locking_inset) return the_locking_inset->insetAllowed(code); @@ -2711,20 +2525,23 @@ bool InsetTabular::insetAllowed(Inset::Code code) const } -bool InsetTabular::forceDefaultParagraphs(Inset const * in) const +bool InsetTabular::forceDefaultParagraphs(InsetOld const * in) const { - const int cell = tabular->GetCellFromInset(in, actcell); + const int cell = tabular.getCellFromInset(in, actcell); if (cell != -1) - return tabular->GetPWidth(cell).zero(); + return tabular.getPWidth(cell).zero(); // well we didn't obviously find it so maybe our owner knows more if (owner()) return owner()->forceDefaultParagraphs(in); - // if we're here there is really something strange going on!!! + + lyxerr << "If we're here there is really something strange going on!" + << endl; return false; } + bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf, bool usePaste) { @@ -2737,9 +2554,7 @@ bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf, string::size_type len = buf.length(); string::size_type p = 0; - while (p < len && - ((p = buf.find_first_of("\t\n", p)) != string::npos)) - { + while (p < len && (p = buf.find_first_of("\t\n", p)) != string::npos) { switch (buf[p]) { case '\t': ++cols; @@ -2760,25 +2575,25 @@ bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf, int row = 0; if (usePaste) { delete paste_tabular; - paste_tabular = new LyXTabular(bv->buffer()->params, + paste_tabular = new LyXTabular(bv->buffer()->params(), this, rows, maxCols); loctab = paste_tabular; cols = 0; } else { - loctab = tabular.get(); + loctab = &tabular; cell = actcell; ocol = actcol; row = actrow; } string::size_type op = 0; - int cells = loctab->GetNumberOfCells(); + int cells = loctab->getNumberOfCells(); p = 0; cols = ocol; rows = loctab->rows(); int const columns = loctab->columns(); - while ((cell < cells) && (p < len) && (row < rows) && + while (cell < cells && p < len && row < rows && (p = buf.find_first_of("\t\n", p)) != string::npos) { if (p >= len) @@ -2787,10 +2602,10 @@ bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf, case '\t': // we can only set this if we are not too far right if (cols < columns) { - InsetText * ti = loctab->GetCellInset(cell); - LyXFont const font = ti->getLyXText(bv)-> - getFont(bv->buffer(), &*ti->paragraphs.begin(), 0); - ti->setText(buf.substr(op, p - op), font); + InsetText & inset = loctab->getCellInset(cell); + LyXFont const font = inset.getLyXText(bv)-> + getFont(inset.paragraphs.begin(), 0); + inset.setText(buf.substr(op, p - op), font); ++cols; ++cell; } @@ -2798,52 +2613,50 @@ bool InsetTabular::insertAsciiString(BufferView * bv, string const & buf, case '\n': // we can only set this if we are not too far right if (cols < columns) { - InsetText * ti = loctab->GetCellInset(cell); - LyXFont const font = ti->getLyXText(bv)-> - getFont(bv->buffer(), &*ti->paragraphs.begin(), 0); - ti->setText(buf.substr(op, p - op), font); + InsetText & inset = tabular.getCellInset(cell); + LyXFont const font = inset.getLyXText(bv)-> + getFont(inset.paragraphs.begin(), 0); + inset.setText(buf.substr(op, p - op), font); } cols = ocol; ++row; if (row < rows) - cell = loctab->GetCellNumber(row, cols); + cell = loctab->getCellNumber(row, cols); break; } ++p; op = p; } // check for the last cell if there is no trailing '\n' - if ((cell < cells) && (op < len)) { - InsetText * ti = loctab->GetCellInset(cell); - LyXFont const font = ti->getLyXText(bv)-> - getFont(bv->buffer(), &*ti->paragraphs.begin(), 0); - ti->setText(buf.substr(op, len - op), font); + if (cell < cells && op < len) { + InsetText & inset = loctab->getCellInset(cell); + LyXFont const font = inset.getLyXText(bv)-> + getFont(inset.paragraphs.begin(), 0); + inset.setText(buf.substr(op, len - op), font); } return true; } -void InsetTabular::addPreview(grfx::PreviewLoader & loader) const +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) { - tabular->GetCellInset(i,j)->addPreview(loader); - } - } + int const rows = tabular.rows(); + int const columns = tabular.columns(); + for (int i = 0; i < rows; ++i) + for (int j = 0; j < columns; ++j) + tabular.getCellInset(i, j).addPreview(loader); } -string const InsetTabularMailer:: name_("tabular"); +string const InsetTabularMailer::name_("tabular"); -InsetTabularMailer::InsetTabularMailer(InsetTabular & inset) - : inset_(inset) +InsetTabularMailer::InsetTabularMailer(InsetTabular const & inset) + : inset_(const_cast(inset)) {} -string const InsetTabularMailer::inset2string() const +string const InsetTabularMailer::inset2string(Buffer const &) const { return params2string(inset_); } @@ -2888,10 +2701,8 @@ int InsetTabularMailer::string2params(string const & in, InsetTabular & inset) if (!lex.isOK()) return -1; - BufferView * const bv = inset.view(); - Buffer const * const buffer = bv ? bv->buffer() : 0; - if (buffer) - inset.read(buffer, lex); + Buffer const & buffer = inset.buffer(); + inset.read(buffer, lex); // We can't set the active cell, but we can tell the frontend // what it is. @@ -2901,10 +2712,7 @@ int InsetTabularMailer::string2params(string const & in, InsetTabular & inset) string const InsetTabularMailer::params2string(InsetTabular const & inset) { - BufferView * const bv = inset.view(); - Buffer const * const buffer = bv ? bv->buffer() : 0; - if (!buffer) - return string(); + Buffer const & buffer = inset.buffer(); ostringstream data; data << name_ << " \\active_cell " << inset.getActCell() << '\n';