X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=7f9ae0cf01b9cbf289de21f8a7a1c7c4abf4a5c2;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=be9a89dbd4c33bd9199f8decb6b519193e1d041d;hpb=e59e72d1d10e6184fafa1bd4daedaf5512a1e23b;p=lyx.git diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index be9a89dbd4..7f9ae0cf01 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -3,18 +3,13 @@ * * LyX, The Document Processor * - * Copyright 2000 The LyX Team. + * Copyright 2001 The LyX Team. * * ====================================================== */ #include -#include -#include - -#include - #ifdef __GNUG__ #pragma implementation #endif @@ -23,22 +18,37 @@ #include "buffer.h" #include "commandtags.h" +#include "lyxfunc.h" #include "debug.h" #include "LaTeXFeatures.h" #include "Painter.h" #include "font.h" #include "lyxtext.h" -#include "lyx_gui_misc.h" #include "LyXView.h" -#include "lyxfunc.h" #include "insets/insettext.h" -#include "frontends/Dialogs.h" #include "debug.h" -#include "lyxfunc.h" #include "WorkArea.h" #include "gettext.h" #include "language.h" +#include "BufferView.h" +#include "undo_funcs.h" +#include "lyxlength.h" +#include "ParagraphParameters.h" + +#include "frontends/Dialogs.h" +#include "frontends/Alert.h" + +#include "support/LAssert.h" +#include "support/lstrings.h" + +#include +#include +#include +#include +//#include + +using std::vector; using std::ostream; using std::ifstream; using std::max; @@ -46,23 +56,22 @@ using std::endl; using std::swap; using std::max; - namespace { -const int ADD_TO_HEIGHT = 2; -const int ADD_TO_TABULAR_WIDTH = 2; +int const ADD_TO_HEIGHT = 2; +int const ADD_TO_TABULAR_WIDTH = 2; + /// LyXTabular * paste_tabular = 0; -struct tabular_features { +struct TabularFeature { LyXTabular::Feature action; string feature; }; -//tabular_features * tabularFeatures = 0; -tabular_features tabularFeatures[] = +TabularFeature tabularFeature[] = { { LyXTabular::APPEND_ROW, "append-row" }, { LyXTabular::APPEND_COLUMN, "append-column" }, @@ -126,72 +135,65 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns) rows = 1; if (columns <= 0) columns = 1; - //tabular = new LyXTabular(this, rows,columns); - tabular.reset(new LyXTabular(this, rows,columns)); + tabular.reset(new LyXTabular(this, rows, columns)); // for now make it always display as display() inset // just for test!!! the_locking_inset = 0; - locked = no_selection = false; -#if 0 - cursor_visible = false; -#endif + old_locking_inset = 0; + locked = false; oldcell = -1; actrow = actcell = 0; clearSelection(); need_update = INIT; - no_draw = false; + in_update = false; + in_reset_pos = false; + inset_x = 0; + inset_y = 0; } -InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf) - : buffer(&buf) +InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf, + bool same_id) + : UpdatableInset(tab, same_id), buffer(&buf) { - //tabular = new LyXTabular(this, *(tab.tabular)); - tabular.reset(new LyXTabular(this, *(tab.tabular))); + tabular.reset(new LyXTabular(this, *(tab.tabular), same_id)); the_locking_inset = 0; - locked = no_selection = false; -#if 0 - cursor_visible = false; -#endif + old_locking_inset = 0; + locked = false; oldcell = -1; actrow = actcell = 0; - sel_cell_start = sel_cell_end = 0; + clearSelection(); need_update = INIT; - no_draw = false; + in_update = false; + in_reset_pos = false; + inset_x = 0; + inset_y = 0; } InsetTabular::~InsetTabular() { - //delete tabular; hideDialog(); } -Inset * InsetTabular::Clone(Buffer const & buf) const +Inset * InsetTabular::clone(Buffer const & buf, bool same_id) const { - InsetTabular * t = new InsetTabular(*this, buf); - //delete t->tabular; - //t->tabular = tabular->Clone(t); - t->tabular.reset(tabular->Clone(t)); - return t; + return new InsetTabular(*this, buf, same_id); } -void InsetTabular::Write(Buffer const * buf, ostream & os) const +void InsetTabular::write(Buffer const * buf, ostream & os) const { os << " Tabular" << endl; tabular->Write(buf, os); } -void InsetTabular::Read(Buffer const * buf, LyXLex & lex) +void InsetTabular::read(Buffer const * buf, LyXLex & lex) { - bool const old_format = (lex.GetString() == "\\LyXTable"); + bool const old_format = (lex.getString() == "\\LyXTable"); - //if (tabular) - //delete tabular; - //tabular = new LyXTabular(buf, this, lex); tabular.reset(new LyXTabular(buf, this, lex)); need_update = INIT; @@ -200,10 +202,10 @@ void InsetTabular::Read(Buffer const * buf, LyXLex & lex) return; lex.nextToken(); - string token = lex.GetString(); - while (lex.IsOK() && (token != "\\end_inset")) { + string token = lex.getString(); + while (lex.isOK() && (token != "\\end_inset")) { lex.nextToken(); - token = lex.GetString(); + token = lex.getString(); } if (token != "\\end_inset") { lex.printError("Missing \\end_inset at this point. " @@ -233,17 +235,33 @@ int InsetTabular::width(BufferView *, LyXFont const &) const void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, float & x, bool cleared) const { - if (no_draw) + if (nodraw()) { + if (cleared) + need_update = FULL; return; - + } +#if 0 + if (need_update == INIT) { + if (calculate_dimensions_of_cells(bv, font, true)) + bv->text->status = LyXText::CHANGED_IN_DRAW; + need_update = FULL; + } +#endif + Painter & pain = bv->painter(); int i; int j; int nx; - + +#if 0 UpdatableInset::draw(bv, font, baseline, x, cleared); +#else + if (!owner()) + x += static_cast(scroll()); +#endif if (!cleared && ((need_update == INIT) || (need_update == FULL) || - (top_x != int(x)) || (top_baseline != baseline))) { + (top_x != int(x)) || (top_baseline != baseline))) + { int h = ascent(bv, font) + descent(bv, font); int const tx = display() || !owner() ? 0 : top_x; int w = tx ? width(bv, font) : pain.paperWidth(); @@ -255,15 +273,13 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, h = pain.paperHeight(); if ((top_x + w) > pain.paperWidth()) w = pain.paperWidth(); - pain.fillRectangle(tx, ty, w, h); + pain.fillRectangle(tx, ty, w, h, backgroundColor()); need_update = FULL; cleared = true; } top_x = int(x); + topx_set = true; top_baseline = baseline; - if (bv->text->status == LyXText::CHANGED_IN_DRAW) - return; - bool dodraw; x += ADD_TO_TABULAR_WIDTH; if (cleared) { int cell = 0; @@ -271,40 +287,51 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, first_visible_cell = -1; for (i = 0; i < tabular->rows(); ++i) { nx = int(x); - dodraw = ((baseline + tabular->GetDescentOfRow(i)) > 0) && - (baseline - tabular->GetAscentOfRow(i))GetCellNumber(i, 0); + if (!((baseline + tabular->GetDescentOfRow(i)) > 0) && + (baseline - tabular->GetAscentOfRow(i))GetDescentOfRow(i) + + tabular->GetAscentOfRow(i + 1) + + tabular->GetAdditionalHeight(i + 1); + continue; + } for (j = 0; j < tabular->columns(); ++j) { + if (nx > bv->workWidth()) + break; if (tabular->IsPartOfMultiColumn(i, j)) continue; cx = nx + tabular->GetBeginningOfTextInCell(cell); - if (dodraw) { - if (first_visible_cell < 0) - first_visible_cell = cell; - if (hasSelection()) - DrawCellSelection(pain, nx, baseline, i, j, cell); - tabular->GetCellInset(cell)->draw(bv, font, baseline, cx, - cleared); - DrawCellLines(pain, nx, baseline, i, cell); + if (first_visible_cell < 0) + first_visible_cell = cell; + if (hasSelection()) { + drawCellSelection(pain, nx, baseline, i, j, cell); } + + tabular->GetCellInset(cell)->draw(bv, font, baseline, cx, cleared); + drawCellLines(pain, nx, baseline, i, cell); nx += tabular->GetWidthOfColumn(cell); ++cell; } baseline += tabular->GetDescentOfRow(i) + tabular->GetAscentOfRow(i + 1) + - tabular->GetAdditionalHeight(cell); + tabular->GetAdditionalHeight(i + 1); } } else if (need_update == CELL) { int cell = 0; nx = int(x); - if (the_locking_inset) { + if (the_locking_inset && + tabular->GetCellInset(actcell) != the_locking_inset) + { Inset * inset = tabular->GetCellInset(cell); for (i = 0; inset != the_locking_inset && i < tabular->rows(); - ++i) { + ++i) + { for (j = 0; - inset != the_locking_inset - && j < tabular->columns(); - ++j) { + inset != the_locking_inset && j < tabular->columns(); + ++j) + { if (tabular->IsPartOfMultiColumn(i, j)) continue; nx += tabular->GetWidthOfColumn(cell); @@ -315,69 +342,101 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, nx = int(x); baseline += tabular->GetDescentOfRow(i) + tabular->GetAscentOfRow(i + 1) + - tabular->GetAdditionalHeight(cell); + tabular->GetAdditionalHeight(i + 1); } } } else { - for (i = 0; - cell < actcell && i < tabular->rows(); ++i) { - for (j = 0; (cell < actcell) && (j < tabular->columns()); ++j) { - if (tabular->IsPartOfMultiColumn(i, j)) + // compute baseline for actual row + for (i = 0; i < actrow; ++i) { + baseline += tabular->GetDescentOfRow(i) + + tabular->GetAscentOfRow(i + 1) + + tabular->GetAdditionalHeight(i + 1); + } + // now compute the right x position + cell = tabular->GetCellNumber(actrow, 0); + for (j = 0; (cell < actcell) && (j < tabular->columns()); ++j) { + if (tabular->IsPartOfMultiColumn(actrow, j)) continue; nx += tabular->GetWidthOfColumn(cell); ++cell; - } - if (tabular->row_of_cell(cell) > i) { - nx = int(x); - baseline += tabular->GetDescentOfRow(i) + - tabular->GetAscentOfRow(i + 1) + - tabular->GetAdditionalHeight(cell); - } } } i = tabular->row_of_cell(cell); if (the_locking_inset != tabular->GetCellInset(cell)) { - lyxerr[Debug::INSETS] << "ERROR this shouldn't happen\n"; + lyxerr[Debug::INSETTEXT] << "ERROR this shouldn't happen\n"; return; } float dx = nx + tabular->GetBeginningOfTextInCell(cell); float cx = dx; - //cx = dx = nx + tabular->GetBeginningOfTextInCell(cell); - tabular->GetCellInset(cell)->draw(bv,font,baseline, dx, false); - if (bv->text->status == LyXText::CHANGED_IN_DRAW) - return; + tabular->GetCellInset(cell)->draw(bv, font, baseline, dx, false); + // + // Here we use rectangular backgroundColor patches to clean up + // within a cell around the cell's red inset box. As follows: + // + // +--------------------+ + // | C | The rectangles are A, B and C + // | A |------------| B | below, origin top left (tx, ty), + // | | inset box | | dimensions w(idth), h(eight). + // +---+------------+---+ x grows rightward, y downward + // | D | + // +--------------------+ + // +#if 0 // clear only if we didn't have a change - if (need_update == CELL) { + if (bv->text->status() != LyXText::CHANGED_IN_DRAW) { +#endif // clear before the inset - pain.fillRectangle( - nx + 1, - baseline - tabular->GetAscentOfRow(i) + 1, - int(cx - nx - 1), - tabular->GetAscentOfRow(i) + - tabular->GetDescentOfRow(i) - 1); + int tx, ty, w, h; + tx = nx + 1; + ty = baseline - tabular->GetAscentOfRow(i) + 1; + w = int(cx - nx - 1); + h = tabular->GetAscentOfRow(i) + + tabular->GetDescentOfRow(i) - 1; + pain.fillRectangle(tx, ty, w, h, backgroundColor()); // clear behind the inset - pain.fillRectangle( - int(cx + the_locking_inset->width(bv,font) + 1), - baseline - tabular->GetAscentOfRow(i) + 1, - tabular->GetWidthOfColumn(cell) - + tx = int(cx + the_locking_inset->width(bv,font) + 1); + ty = baseline - tabular->GetAscentOfRow(i) + 1; + w = tabular->GetWidthOfColumn(cell) - tabular->GetBeginningOfTextInCell(cell) - the_locking_inset->width(bv,font) - - tabular->GetAdditionalWidth(cell) - 1, - tabular->GetAscentOfRow(i) + - tabular->GetDescentOfRow(i) - 1); + tabular->GetAdditionalWidth(cell) - 1; + h = tabular->GetAscentOfRow(i) + tabular->GetDescentOfRow(i) - 1; + pain.fillRectangle(tx, ty, w, h, backgroundColor()); + // clear below the inset + tx = nx + 1; + ty = baseline + the_locking_inset->descent(bv, font) + 1; + w = tabular->GetWidthOfColumn(cell) - + tabular->GetAdditionalWidth(cell) - 1; + h = tabular->GetDescentOfRow(i) - + the_locking_inset->descent(bv, font) - 1; + pain.fillRectangle(tx, ty, w, h, backgroundColor()); + // clear above the inset + tx = nx + 1; + ty = baseline - tabular->GetAscentOfRow(i) + 1; + w = tabular->GetWidthOfColumn(cell) - + tabular->GetAdditionalWidth(cell) - 1; + h = tabular->GetAscentOfRow(i) - the_locking_inset->ascent(bv, font); + pain.fillRectangle(tx, ty, w, h, backgroundColor()); +#if 0 } +#endif } x -= ADD_TO_TABULAR_WIDTH; x += width(bv, font); - if (bv->text->status == LyXText::CHANGED_IN_DRAW) - need_update = INIT; - else + if (bv->text->status() == LyXText::CHANGED_IN_DRAW) { + int i = 0; + for(Inset * inset = owner(); inset; ++i) + inset = inset->owner(); + if (calculate_dimensions_of_cells(bv, font, false)) + need_update = INIT; + } else { need_update = NONE; + } } -void InsetTabular::DrawCellLines(Painter & pain, int x, int baseline, - int row, int cell) const +void InsetTabular::drawCellLines(Painter & pain, int x, int baseline, + int row, int cell) const { int x2 = x + tabular->GetWidthOfColumn(cell); bool on_off; @@ -411,9 +470,10 @@ void InsetTabular::DrawCellLines(Painter & pain, int x, int baseline, } -void InsetTabular::DrawCellSelection(Painter & pain, int x, int baseline, +void InsetTabular::drawCellSelection(Painter & pain, int x, int baseline, 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); if (cs > ce) { @@ -425,7 +485,8 @@ void InsetTabular::DrawCellSelection(Painter & pain, int x, int baseline, 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 (rs > re) + swap(rs, re); if ((column >= cs) && (column <= ce) && (row >= rs) && (row <= re)) { int w = tabular->GetWidthOfColumn(cell); @@ -438,19 +499,32 @@ void InsetTabular::DrawCellSelection(Painter & pain, int x, int baseline, void InsetTabular::update(BufferView * bv, LyXFont const & font, bool reinit) { + if (in_update) { + if (reinit) { + resetPos(bv); + if (owner()) + owner()->update(bv, font, true); + } + return; + } + in_update = true; if (reinit) { need_update = INIT; - calculate_dimensions_of_cells(bv, font, true); + if (calculate_dimensions_of_cells(bv, font, true)) + resetPos(bv); if (owner()) owner()->update(bv, font, true); + in_update = false; return; } - if (the_locking_inset) { + if (the_locking_inset) the_locking_inset->update(bv, font, reinit); -// resetPos(bv); -// inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); -// inset_y = cursor.y(); + if (need_update < FULL && + bv->text->status() == LyXText::NEED_MORE_REFRESH) + { + need_update = FULL; } + switch (need_update) { case INIT: case FULL: @@ -459,26 +533,27 @@ void InsetTabular::update(BufferView * bv, LyXFont const & font, bool reinit) need_update = INIT; break; case SELECTION: - need_update = INIT; + need_update = FULL; break; default: break; } + in_update = false; } -string const InsetTabular::EditMessage() const +string const InsetTabular::editMessage() const { return _("Opened Tabular Inset"); } -void InsetTabular::Edit(BufferView * bv, int x, int y, unsigned int button) +void InsetTabular::edit(BufferView * bv, int x, int y, unsigned int button) { - UpdatableInset::Edit(bv, x, y, button); + UpdatableInset::edit(bv, x, y, button); if (!bv->lockInset(this)) { - lyxerr[Debug::INSETS] << "InsetTabular::Cannot lock inset" << endl; + lyxerr[Debug::INSETTEXT] << "InsetTabular::Cannot lock inset" << endl; return; } locked = true; @@ -486,43 +561,69 @@ void InsetTabular::Edit(BufferView * bv, int x, int y, unsigned int button) inset_x = 0; inset_y = 0; setPos(bv, x, y); - sel_cell_start = sel_cell_end = actcell; - bv->text->FinishUndo(); - if (InsetHit(bv, x, y) && (button != 3)) { - ActivateCellInsetAbs(bv, x, y, button); + clearSelection(); + finishUndo(); + if (insetHit(bv, x, y) && (button != 3)) { + activateCellInsetAbs(bv, x, y, button); } -// UpdateLocal(bv, NONE, false); -// bv->getOwner()->getPopups().updateFormTabular(); } -void InsetTabular::InsetUnlock(BufferView * bv) +void InsetTabular::edit(BufferView * bv, bool front) +{ + UpdatableInset::edit(bv, front); + + if (!bv->lockInset(this)) { + lyxerr[Debug::INSETTEXT] << "InsetTabular::Cannot lock inset" << endl; + return; + } + locked = true; + the_locking_inset = 0; + inset_x = 0; + inset_y = 0; + if (front) + actcell = 0; + else + actcell = tabular->GetNumberOfCells() - 1; + clearSelection(); + resetPos(bv); + finishUndo(); +} + + +void InsetTabular::insetUnlock(BufferView * bv) { if (the_locking_inset) { - the_locking_inset->InsetUnlock(bv); + the_locking_inset->insetUnlock(bv); the_locking_inset = 0; } - HideInsetCursor(bv); - no_selection = false; + hideInsetCursor(bv); oldcell = -1; locked = false; - if (scroll() || hasSelection()) { - sel_cell_start = sel_cell_end = 0; - if (scroll()) { + if (scroll(false) || hasSelection()) { + clearSelection(); + if (scroll(false)) { scroll(bv, 0.0F); } - UpdateLocal(bv, FULL, false); + updateLocal(bv, FULL, false); } } -void InsetTabular::UpdateLocal(BufferView * bv, UpdateCodes what, - bool mark_dirty) const +void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what, + bool mark_dirty) const { + if (what == INIT) { + LyXFont font; + calculate_dimensions_of_cells(bv, font, true); + } if (need_update < what) // only set this if it has greater update need_update = what; - if ((what == INIT) && hasSelection()) +#if 0 // maybe this should not be done! + if ((what == INIT) && hasSelection()) { clearSelection(); + } +#endif // Dirty Cast! (Lgb) if (need_update != NONE) { bv->updateInset(const_cast(this), mark_dirty); @@ -532,49 +633,70 @@ void InsetTabular::UpdateLocal(BufferView * bv, UpdateCodes what, } -bool InsetTabular::LockInsetInInset(BufferView * bv, UpdatableInset * inset) +bool InsetTabular::lockInsetInInset(BufferView * bv, UpdatableInset * inset) { - lyxerr[Debug::INSETS] << "InsetTabular::LockInsetInInset(" + lyxerr[Debug::INSETTEXT] << "InsetTabular::LockInsetInInset(" << inset << "): "; if (!inset) return false; oldcell = -1; if (inset == tabular->GetCellInset(actcell)) { - lyxerr[Debug::INSETS] << "OK" << endl; + lyxerr[Debug::INSETTEXT] << "OK" << endl; the_locking_inset = tabular->GetCellInset(actcell); resetPos(bv); - inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); - inset_y = cursor.y(); return true; + } else if (!the_locking_inset) { + int const n = tabular->GetNumberOfCells(); + int const id = inset->id(); + for (int i = 0; i < n; ++i) { + InsetText * in = tabular->GetCellInset(i); + if (inset == in) { + actcell = i; + the_locking_inset = in; + locked = true; + resetPos(bv); + return true; + } + if (in->getInsetFromID(id)) { + actcell = i; + in->edit(bv); + return the_locking_inset->lockInsetInInset(bv, inset); + } + } } else if (the_locking_inset && (the_locking_inset == inset)) { - lyxerr[Debug::INSETS] << "OK" << endl; + lyxerr[Debug::INSETTEXT] << "OK" << endl; resetPos(bv); - inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); - inset_y = cursor.y(); } else if (the_locking_inset) { - lyxerr[Debug::INSETS] << "MAYBE" << endl; - return the_locking_inset->LockInsetInInset(bv, inset); + lyxerr[Debug::INSETTEXT] << "MAYBE" << endl; + return the_locking_inset->lockInsetInInset(bv, inset); } - lyxerr[Debug::INSETS] << "NOT OK" << endl; + lyxerr[Debug::INSETTEXT] << "NOT OK" << endl; return false; } -bool InsetTabular::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset, +bool InsetTabular::unlockInsetInInset(BufferView * bv, UpdatableInset * inset, bool lr) { if (!the_locking_inset) return false; if (the_locking_inset == inset) { - the_locking_inset->InsetUnlock(bv); + the_locking_inset->insetUnlock(bv); the_locking_inset = 0; - UpdateLocal(bv, CELL, false); - ShowInsetCursor(bv, false); +#ifdef WITH_WARNINGS +#warning fix scrolling when cellinset has requested a scroll (Jug)!!! +#endif +#if 0 + if (scroll(false)) + scroll(bv, 0.0F); +#endif + updateLocal(bv, CELL, false); + showInsetCursor(bv, false); return true; } - if (the_locking_inset->UnlockInsetInInset(bv, inset, lr)) { - if (inset->LyxCode() == TABULAR_CODE && - !the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE)) { + if (the_locking_inset->unlockInsetInInset(bv, inset, lr)) { + if (inset->lyxCode() == TABULAR_CODE && + !the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)) { bv->owner()->getDialogs()->updateTabular(this); oldcell = actcell; } @@ -584,176 +706,166 @@ bool InsetTabular::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset, } -bool InsetTabular::UpdateInsetInInset(BufferView * bv, Inset * inset) +bool InsetTabular::updateInsetInInset(BufferView * bv, Inset * inset) { if (!the_locking_inset) return false; if (the_locking_inset != inset) { - if (!the_locking_inset->UpdateInsetInInset(bv, inset)) + if (!the_locking_inset->updateInsetInInset(bv, inset)) return false; } - UpdateLocal(bv, CELL, false); + updateLocal(bv, CELL, false); return true; } -unsigned int InsetTabular::InsetInInsetY() +unsigned int InsetTabular::insetInInsetY() { if (!the_locking_inset) return 0; - - return inset_y + the_locking_inset->InsetInInsetY(); + return inset_y + the_locking_inset->insetInInsetY(); } -UpdatableInset * InsetTabular::GetLockingInset() +UpdatableInset * InsetTabular::getLockingInset() const { - return the_locking_inset ? the_locking_inset->GetLockingInset() : this; + return the_locking_inset ? the_locking_inset->getLockingInset() : + const_cast(this); } -UpdatableInset * InsetTabular::GetFirstLockingInsetOfType(Inset::Code c) +UpdatableInset * InsetTabular::getFirstLockingInsetOfType(Inset::Code c) { - if (c == LyxCode()) + if (c == lyxCode()) return this; if (the_locking_inset) - return the_locking_inset->GetFirstLockingInsetOfType(c); + return the_locking_inset->getFirstLockingInsetOfType(c); return 0; } -bool InsetTabular::InsertInset(BufferView * bv, Inset * inset) +bool InsetTabular::insertInset(BufferView * bv, Inset * inset) { if (the_locking_inset) - return the_locking_inset->InsertInset(bv, inset); + return the_locking_inset->insertInset(bv, inset); return false; } -void InsetTabular::InsetButtonPress(BufferView * bv, int x, int y, int button) +void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button) { if (hasSelection() && (button == 3)) return; if (hasSelection()) { clearSelection(); - UpdateLocal(bv, SELECTION, false); + updateLocal(bv, SELECTION, false); } - no_selection = false; - int const ocell = actcell; int const orow = actrow; - HideInsetCursor(bv); + hideInsetCursor(bv); setPos(bv, x, y); if (actrow != orow) - UpdateLocal(bv, NONE, false); - sel_cell_start = sel_cell_end = actcell; + updateLocal(bv, NONE, false); + clearSelection(); +#if 0 if (button == 3) { if ((ocell != actcell) && the_locking_inset) { - the_locking_inset->InsetUnlock(bv); + the_locking_inset->insetUnlock(bv); the_locking_inset = 0; } - ShowInsetCursor(bv); + showInsetCursor(bv); return; } +#endif - bool const inset_hit = InsetHit(bv, x, y); + bool const inset_hit = insetHit(bv, x, y); if ((ocell == actcell) && the_locking_inset && inset_hit) { resetPos(bv); - the_locking_inset->InsetButtonPress(bv, + the_locking_inset->insetButtonPress(bv, x - inset_x, y - inset_y, button); return; } else if (the_locking_inset) { - the_locking_inset->InsetUnlock(bv); + the_locking_inset->insetUnlock(bv); } the_locking_inset = 0; if (button == 2) { - LocalDispatch(bv, LFUN_PASTESELECTION, "paragraph"); + localDispatch(bv, LFUN_PASTESELECTION, "paragraph"); return; } if (inset_hit && bv->theLockingInset()) { - if (ActivateCellInsetAbs(bv, x, y, button)) - the_locking_inset->InsetButtonPress(bv, + if (activateCellInsetAbs(bv, x, y, button)) + the_locking_inset->insetButtonPress(bv, x - inset_x, y - inset_y, button); return; } - ShowInsetCursor(bv); + showInsetCursor(bv); } -void InsetTabular::InsetButtonRelease(BufferView * bv, - int x, int y, int button) +bool InsetTabular::insetButtonRelease(BufferView * bv, + int x, int y, int button) { - if (button == 3) { - if (the_locking_inset) { - UpdatableInset * i; - if ((i=the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE))) { - i->InsetButtonRelease(bv, x, y, button); - return; - } - } + bool ret = false; + if (the_locking_inset) + ret = the_locking_inset->insetButtonRelease(bv, x - inset_x, + y - inset_y, button); + if (button == 3 && !ret) { bv->owner()->getDialogs()->showTabular(this); - return; - } - if (the_locking_inset) { - the_locking_inset->InsetButtonRelease(bv, - x - inset_x, y - inset_y, - button); - return; + return true; } - no_selection = false; + return ret; } -void InsetTabular::InsetMotionNotify(BufferView * bv, int x, int y, int button) +void InsetTabular::insetMotionNotify(BufferView * bv, int x, int y, int button) { if (the_locking_inset) { - the_locking_inset->InsetMotionNotify(bv, + the_locking_inset->insetMotionNotify(bv, x - inset_x, y - inset_y, button); return; } - if (!no_selection) { - HideInsetCursor(bv); - int const old_cell = actcell; - - setPos(bv, x, y); - sel_cell_end = actcell; - if (sel_cell_end != old_cell) - UpdateLocal(bv, SELECTION, false); - ShowInsetCursor(bv); + + hideInsetCursor(bv); +// int const old_cell = actcell; + + setPos(bv, x, y); + if (!hasSelection()) { + setSelection(actcell, actcell); + } else { + setSelection(sel_cell_start, actcell); } - no_selection = false; + updateLocal(bv, SELECTION, false); + showInsetCursor(bv); } -void InsetTabular::InsetKeyPress(XKeyEvent * xke) +void InsetTabular::insetKeyPress(XKeyEvent * xke) { if (the_locking_inset) { - the_locking_inset->InsetKeyPress(xke); + the_locking_inset->insetKeyPress(xke); return; } } UpdatableInset::RESULT -InsetTabular::LocalDispatch(BufferView * bv, - kb_action action, - string const & arg) +InsetTabular::localDispatch(BufferView * bv, kb_action action, + string const & arg) { // We need to save the value of the_locking_inset as the call to // the_locking_inset->LocalDispatch might unlock it. old_locking_inset = the_locking_inset; - no_selection = false; UpdatableInset::RESULT result = - UpdatableInset::LocalDispatch(bv, action, arg); + UpdatableInset::localDispatch(bv, action, arg); if (result == DISPATCHED || result == DISPATCHED_NOUPDATE) { resetPos(bv); return result; @@ -764,146 +876,191 @@ InsetTabular::LocalDispatch(BufferView * bv, bool hs = hasSelection(); - result=DISPATCHED; - // this one have priority over the locked InsetText! - switch (action) { - case LFUN_SHIFT_TAB: - case LFUN_TAB: - { - HideInsetCursor(bv); - if (the_locking_inset) { - UnlockInsetInInset(bv, the_locking_inset); - the_locking_inset = 0; + 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) { + switch (action) { + case LFUN_SHIFT_TAB: + case LFUN_TAB: + hideInsetCursor(bv); + unlockInsetInInset(bv, the_locking_inset); + if (action == LFUN_TAB) + moveNextCell(bv, old_locking_inset != 0); + else + movePrevCell(bv, old_locking_inset != 0); + clearSelection(); + if (hs) + updateLocal(bv, SELECTION, false); + if (!the_locking_inset) { + showInsetCursor(bv); + return DISPATCHED_NOUPDATE; + } + return result; + // this to avoid compiler warnings. + default: + break; } - if (action == LFUN_TAB) - moveNextCell(bv, old_locking_inset != 0); - else - movePrevCell(bv, old_locking_inset != 0); - sel_cell_start = sel_cell_end = actcell; - if (hs) - UpdateLocal(bv, SELECTION, false); - ShowInsetCursor(bv); - return result; - } - // this to avoid compiler warnings. - default: - break; } if (the_locking_inset) { - result=the_locking_inset->LocalDispatch(bv, action, arg); + result = the_locking_inset->localDispatch(bv, action, arg); if (result == DISPATCHED_NOUPDATE) { int sc = scroll(); resetPos(bv); if (sc != scroll()) { // inset has been scrolled - the_locking_inset->ToggleInsetCursor(bv); - UpdateLocal(bv, FULL, false); - the_locking_inset->ToggleInsetCursor(bv); + the_locking_inset->toggleInsetCursor(bv); + updateLocal(bv, FULL, false); + the_locking_inset->toggleInsetCursor(bv); } return result; } else if (result == DISPATCHED) { - the_locking_inset->ToggleInsetCursor(bv); - UpdateLocal(bv, CELL, false); - the_locking_inset->ToggleInsetCursor(bv); + the_locking_inset->toggleInsetCursor(bv); + updateLocal(bv, CELL, false); + the_locking_inset->toggleInsetCursor(bv); return result; - } else if (result == FINISHED) { + } else if (result == FINISHED_UP) { + action = LFUN_UP; + } else if (result == FINISHED_DOWN) { + action = LFUN_DOWN; + } else if (result == FINISHED_RIGHT) { + action = LFUN_RIGHT; } } - HideInsetCursor(bv); - result=DISPATCHED; + hideInsetCursor(bv); + result = DISPATCHED; switch (action) { // --- Cursor Movements ---------------------------------- - case LFUN_RIGHTSEL: - if (tabular->IsLastCellInRow(actcell)) + case LFUN_RIGHTSEL: { + int const start = hasSelection() ? sel_cell_start : actcell; + if (tabular->IsLastCellInRow(actcell)) { + setSelection(start, actcell); break; - moveRight(bv, false); - sel_cell_end = actcell; - UpdateLocal(bv, SELECTION, false); + } + + int end = actcell; + // if we are starting a selection, only select + // the current cell at the beginning + if (hasSelection()) { + moveRight(bv, false); + end = actcell; + } + setSelection(start, end); + updateLocal(bv, SELECTION, false); break; + } case LFUN_RIGHT: result = moveRight(bv); - sel_cell_start = sel_cell_end = actcell; + clearSelection(); if (hs) - UpdateLocal(bv, SELECTION, false); + updateLocal(bv, SELECTION, false); break; - case LFUN_LEFTSEL: - if (tabular->IsFirstCellInRow(actcell)) + case LFUN_LEFTSEL: { + int const start = hasSelection() ? sel_cell_start : actcell; + if (tabular->IsFirstCellInRow(actcell)) { + setSelection(start, actcell); break; - moveLeft(bv, false); - sel_cell_end = actcell; - UpdateLocal(bv, SELECTION, false); + } + + int end = actcell; + // if we are starting a selection, only select + // the current cell at the beginning + if (hasSelection()) { + moveLeft(bv, false); + end = actcell; + } + setSelection(start, end); + updateLocal(bv, SELECTION, false); break; + } case LFUN_LEFT: result = moveLeft(bv); - sel_cell_start = sel_cell_end = actcell; + clearSelection(); if (hs) - UpdateLocal(bv, SELECTION, false); + updateLocal(bv, SELECTION, false); break; - case LFUN_DOWNSEL: - { + case LFUN_DOWNSEL: { + int const start = hasSelection() ? sel_cell_start : actcell; int const ocell = actcell; - moveDown(bv, false); - if ((ocell == sel_cell_end) || - (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell))) - sel_cell_end = tabular->GetCellBelow(sel_cell_end); - else - sel_cell_end = tabular->GetLastCellBelow(sel_cell_end); - UpdateLocal(bv, SELECTION, false); + // if we are starting a selection, only select + // 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)); + else + setSelection(start, tabular->GetLastCellBelow(sel_cell_end)); + } else { + setSelection(start, start); + } + updateLocal(bv, SELECTION, false); } break; case LFUN_DOWN: result = moveDown(bv, old_locking_inset != 0); - sel_cell_start = sel_cell_end = actcell; - if (hs) - UpdateLocal(bv, SELECTION, false); + clearSelection(); + if (hs) { + updateLocal(bv, SELECTION, false); + } break; - case LFUN_UPSEL: - { + case LFUN_UPSEL: { + int const start = hasSelection() ? sel_cell_start : actcell; int const ocell = actcell; - moveUp(bv, false); - if ((ocell == sel_cell_end) || - (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell))) - sel_cell_end = tabular->GetCellAbove(sel_cell_end); - else - sel_cell_end = tabular->GetLastCellAbove(sel_cell_end); - UpdateLocal(bv, SELECTION, false); + // if we are starting a selection, only select + // the current cell at the beginning + 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)); + else + setSelection(start, tabular->GetLastCellAbove(sel_cell_end)); + } else { + setSelection(start, start); + } + updateLocal(bv, SELECTION, false); } break; case LFUN_UP: result = moveUp(bv, old_locking_inset != 0); - sel_cell_start = sel_cell_end = actcell; + clearSelection(); if (hs) - UpdateLocal(bv, SELECTION, false); + updateLocal(bv, SELECTION, false); break; case LFUN_NEXT: { - int column = actcol; - if (the_locking_inset) { - UnlockInsetInInset(bv, the_locking_inset); - the_locking_inset = 0; + UpdateCodes code = CURSOR; + if (hs) { + clearSelection(); + code = SELECTION; } + int column = actcol; + unlockInsetInInset(bv, the_locking_inset); if (bv->text->first + bv->painter().paperHeight() < (top_baseline + tabular->GetHeightOfTabular())) { bv->scrollCB(bv->text->first + bv->painter().paperHeight()); - UpdateLocal(bv, FULL, false); + code = FULL; actcell = tabular->GetCellBelow(first_visible_cell) + column; } else { actcell = tabular->GetFirstCellInRow(tabular->rows() - 1) + column; } resetPos(bv); - UpdateLocal(bv, CURSOR, false); + updateLocal(bv, code, false); break; } case LFUN_PRIOR: { - int column = actcol; - if (the_locking_inset) { - UnlockInsetInInset(bv, the_locking_inset); - the_locking_inset = 0; + UpdateCodes code = CURSOR; + if (hs) { + clearSelection(); + code = SELECTION; } + int column = actcol; + unlockInsetInInset(bv, the_locking_inset); if (top_baseline < 0) { bv->scrollCB(bv->text->first - bv->painter().paperHeight()); - UpdateLocal(bv, FULL, false); + code = FULL; if (top_baseline > 0) actcell = column; else @@ -912,50 +1069,58 @@ InsetTabular::LocalDispatch(BufferView * bv, actcell = column; } resetPos(bv); - UpdateLocal(bv, CURSOR, false); - break; - } + updateLocal(bv, code, false); + break; + } + // none of these make sense for insettabular, + // but we must catch them to prevent any + // selection from being confused + case LFUN_PRIORSEL: + case LFUN_NEXTSEL: + case LFUN_WORDLEFT: + case LFUN_WORDLEFTSEL: + case LFUN_WORDRIGHT: + case LFUN_WORDRIGHTSEL: + case LFUN_DOWN_PARAGRAPH: + case LFUN_DOWN_PARAGRAPHSEL: + case LFUN_UP_PARAGRAPH: + case LFUN_UP_PARAGRAPHSEL: case LFUN_BACKSPACE: - break; case LFUN_DELETE: - break; case LFUN_HOME: - break; + case LFUN_HOMESEL: case LFUN_END: + case LFUN_ENDSEL: + case LFUN_BEGINNINGBUF: + case LFUN_BEGINNINGBUFSEL: + case LFUN_ENDBUF: + case LFUN_ENDBUFSEL: break; case LFUN_LAYOUT_TABULAR: - { bv->owner()->getDialogs()->showTabular(this); - } - break; + break; case LFUN_TABULAR_FEATURE: - if (!TabularFeatures(bv, arg)) + if (!tabularFeatures(bv, arg)) result = UNDISPATCHED; break; case LFUN_CUT: if (!copySelection(bv)) break; - bv->text->SetUndo(bv->buffer(), Undo::DELETE, -#ifndef NEW_INSETS - bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->previous_, - bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->next_ -#else - bv->text->cursor.par()->previous(), - bv->text->cursor.par()->next() -#endif - ); + setUndo(bv, Undo::DELETE, + bv->text->cursor.par(), + bv->text->cursor.par()->next()); cutSelection(); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LFUN_COPY: if (!hasSelection()) break; - bv->text->FinishUndo(); + finishUndo(); copySelection(bv); break; case LFUN_PASTESELECTION: { - string clip(bv->workarea()->getClipboard()); + string const clip(bv->getClipboard()); if (clip.empty()) break; @@ -963,12 +1128,12 @@ InsetTabular::LocalDispatch(BufferView * bv, int cols = 1; int rows = 1; int maxCols = 1; - unsigned int len = clip.length(); + string::size_type len = clip.length(); string::size_type p = 0; - while(p < len && + while (p < len && ((p = clip.find_first_of("\t\n", p)) != string::npos)) { - switch(clip[p]) { + switch (clip[p]) { case '\t': ++cols; break; @@ -988,19 +1153,19 @@ InsetTabular::LocalDispatch(BufferView * bv, int cell = 0; int cells = paste_tabular->GetNumberOfCells(); p = cols = 0; - while((cell < cells) && (p < len) && + while ((cell < cells) && (p < len) && (p = clip.find_first_of("\t\n", p)) != string::npos) { if (p >= len) break; - switch(clip[p]) { + 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)); - while(cols++ < maxCols) + paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op)); + while (cols++ < maxCols) ++cell; cols = 0; break; @@ -1010,7 +1175,7 @@ InsetTabular::LocalDispatch(BufferView * bv, } // 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 { // so that the clipboard is used and it goes on // to default @@ -1021,46 +1186,67 @@ InsetTabular::LocalDispatch(BufferView * bv, } case LFUN_PASTE: if (hasPasteBuffer()) { - bv->text->SetUndo(bv->buffer(), Undo::INSERT, -#ifndef NEW_INSETS - bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->previous_, - bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->next_ -#else - bv->text->cursor.par()->previous(), - bv->text->cursor.par()->next() -#endif - ); + setUndo(bv, Undo::INSERT, + bv->text->cursor.par(), + bv->text->cursor.par()->next()); pasteSelection(bv); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; } // ATTENTION: the function above has to be PASTE and PASTESELECTION!!! default: + // handle font changing stuff on selection before we lock the inset + // in the default part! + result = UNDISPATCHED; + if (hs) { + switch(action) { + case LFUN_LANGUAGE: + case LFUN_EMPH: + case LFUN_BOLD: + case LFUN_NOUN: + case LFUN_CODE: + case LFUN_SANS: + case LFUN_ROMAN: + case LFUN_DEFAULT: + case LFUN_UNDERLINE: + case LFUN_FONT_SIZE: + if (bv->Dispatch(action, arg)) + result = DISPATCHED; + break; + default: + break; + } + } // we try to activate the actual inset and put this event down to // the insets dispatch function. - result = UNDISPATCHED; - if (the_locking_inset) + if ((result == DISPATCHED) || the_locking_inset) break; - no_draw = true; - if (ActivateCellInset(bv)) { - result = the_locking_inset->LocalDispatch(bv, action, arg); - if ((result == UNDISPATCHED) || (result == FINISHED)) { - UnlockInsetInInset(bv, the_locking_inset); - no_draw = false; - the_locking_inset = 0; + nodraw(true); + if (activateCellInset(bv)) { + // reset need_update setted in above function! + need_update = NONE; + result = the_locking_inset->localDispatch(bv, action, arg); + if ((result == UNDISPATCHED) || (result >= FINISHED)) { + unlockInsetInInset(bv, the_locking_inset); + nodraw(false); + // we need to update if this was requested before + updateLocal(bv, NONE, false); 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; } - no_draw = false; - the_locking_inset->ToggleInsetCursor(bv); - UpdateLocal(bv, CELL, false); - the_locking_inset->ToggleInsetCursor(bv); + nodraw(false); + updateLocal(bv, CELL, false); return result; } break; } - if (result!=FINISHED) { + if (result < FINISHED) { if (!the_locking_inset) { - ShowInsetCursor(bv); + showInsetCursor(bv); } } else bv->unlockInset(this); @@ -1068,41 +1254,66 @@ InsetTabular::LocalDispatch(BufferView * bv, } -int InsetTabular::Latex(Buffer const * buf, ostream & os, - bool fragile, bool fp) const +int InsetTabular::latex(Buffer const * buf, ostream & os, + bool fragile, bool fp) const { - return tabular->Latex(buf, os, fragile, fp); + return tabular->latex(buf, os, fragile, fp); } -int InsetTabular::Ascii(Buffer const * buf, ostream & os, int) const +int InsetTabular::ascii(Buffer const * buf, ostream & os, int ll) const { - // This should be changed to a real ascii export - return tabular->Ascii(buf, os); + if (ll > 0) + return tabular->ascii(buf, os, (int)parOwner()->params().depth(), + false,0); + return tabular->ascii(buf, os, 0, false,0); } -int InsetTabular::Linuxdoc(Buffer const *, ostream &) const +int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const { - return 0; + os << "ascii(buf,os, + (int)parOwner()->params().depth(), + false, 0); + os << "]]>"; + return ret; } -int InsetTabular::DocBook(Buffer const * buf, ostream & os) const +int InsetTabular::docbook(Buffer const * buf, ostream & os) const { - return tabular->DocBook(buf,os); + int ret = 0; + Inset * 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()); + + if (!master) { + os << "\n"; + ret++; + } + ret+= tabular->docBook(buf,os); + if (!master) { + os << "\n"; + ret++; + } + return ret; } -void InsetTabular::Validate(LaTeXFeatures & features) const +void InsetTabular::validate(LaTeXFeatures & features) const { tabular->Validate(features); } bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv, - LyXFont const & font, - bool reinit) const + LyXFont const & font, + bool reinit) const { int cell = -1; int maxAsc = 0; @@ -1128,12 +1339,12 @@ bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv, for (int i = 0; i < tabular->rows(); ++i) { maxAsc = 0; maxDesc = 0; - for (int j= 0; j < tabular->columns(); ++j) { + for (int j = 0; j < tabular->columns(); ++j) { if (tabular->IsPartOfMultiColumn(i,j)) continue; ++cell; inset = tabular->GetCellInset(cell); - if (!reinit) + if (!reinit && !tabular->GetPWidth(cell).zero()) inset->update(bv, font, false); maxAsc = max(maxAsc, inset->ascent(bv, font)); maxDesc = max(maxDesc, inset->descent(bv, font)); @@ -1142,22 +1353,32 @@ bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv, changed = tabular->SetAscentOfRow(i, maxAsc + ADD_TO_HEIGHT) || changed; changed = tabular->SetDescentOfRow(i, maxDesc + ADD_TO_HEIGHT) || changed; } + if (changed) + tabular->reinit(); return changed; } -void InsetTabular::GetCursorPos(BufferView *, - int & x, int & y) const +void InsetTabular::getCursorPos(BufferView * bv, int & x, int & y) const { - x = cursor.x() - top_x; - y = cursor.y(); + if (the_locking_inset) { + the_locking_inset->getCursorPos(bv, x, y); + return; + } + x = cursor_.x() - top_x; + y = cursor_.y(); } -void InsetTabular::ToggleInsetCursor(BufferView * bv) +void InsetTabular::toggleInsetCursor(BufferView * bv) { + if (nodraw()) { + if (isCursorVisible()) + bv->hideLockedInsetCursor(); + return; + } if (the_locking_inset) { - the_locking_inset->ToggleInsetCursor(bv); + the_locking_inset->toggleInsetCursor(bv); return; } @@ -1169,76 +1390,76 @@ void InsetTabular::ToggleInsetCursor(BufferView * bv) if (isCursorVisible()) bv->hideLockedInsetCursor(); else - bv->showLockedInsetCursor(cursor.x(), cursor.y(), asc, desc); + bv->showLockedInsetCursor(cursor_.x(), cursor_.y(), asc, desc); toggleCursorVisible(); } -void InsetTabular::ShowInsetCursor(BufferView * bv, bool show) +void InsetTabular::showInsetCursor(BufferView * bv, bool show) { + if (nodraw()) + return; if (!isCursorVisible()) { LyXFont font; // = GetFont(par, cursor.pos); int const asc = lyxfont::maxAscent(font); int const desc = lyxfont::maxDescent(font); - bv->fitLockedInsetCursor(cursor.x(), cursor.y(), asc, desc); + bv->fitLockedInsetCursor(cursor_.x(), cursor_.y(), asc, desc); if (show) - bv->showLockedInsetCursor(cursor.x(), cursor.y(), - asc, desc); + bv->showLockedInsetCursor(cursor_.x(), cursor_.y(), asc, desc); setCursorVisible(true); } } -void InsetTabular::HideInsetCursor(BufferView * bv) +void InsetTabular::hideInsetCursor(BufferView * bv) { if (isCursorVisible()) { bv->hideLockedInsetCursor(); setCursorVisible(false); } -// if (cursor_visible) -// ToggleInsetCursor(bv); +} + + +void InsetTabular::fitInsetCursor(BufferView * bv) const +{ + if (the_locking_inset) { + the_locking_inset->fitInsetCursor(bv); + return; + } + LyXFont font; + + int const asc = lyxfont::maxAscent(font); + int const desc = lyxfont::maxDescent(font); + bv->fitLockedInsetCursor(cursor_.x(), cursor_.y(), asc, desc); } void InsetTabular::setPos(BufferView * bv, int x, int y) const { - cursor.y(0); + cursor_.y(0); actcell = actrow = actcol = 0; int ly = tabular->GetDescentOfRow(actrow); // first search the right row - while((ly < y) && (actrow < tabular->rows())) { - cursor.y(cursor.y() - + tabular->GetDescentOfRow(actrow) - + tabular->GetAscentOfRow(actrow + 1) - + tabular-> - GetAdditionalHeight(tabular-> - GetCellNumber(actrow + 1, - actcol))); + while ((ly < y) && ((actrow+1) < tabular->rows())) { + cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) + + tabular->GetAscentOfRow(actrow + 1) + + tabular->GetAdditionalHeight(actrow + 1)); ++actrow; - ly = cursor.y() + tabular->GetDescentOfRow(actrow); + ly = cursor_.y() + tabular->GetDescentOfRow(actrow); } actcell = tabular->GetCellNumber(actrow, actcol); // now search the right column int lx = tabular->GetWidthOfColumn(actcell) - tabular->GetAdditionalWidth(actcell); -#if 0 -#warning Jürgen, can you rewrite this to _not_ use the sequencing operator. (Lgb) - for (; !tabular->IsLastCellInRow(actcell) && (lx < x); - ++actcell,lx += tabular->GetWidthOfColumn(actcell) + - tabular->GetAdditionalWidth(actcell - 1)); -#else - // Jürgen, you should check that this is correct. (Lgb) for (; !tabular->IsLastCellInRow(actcell) && lx < x; ++actcell) { lx += tabular->GetWidthOfColumn(actcell + 1) + tabular->GetAdditionalWidth(actcell); } - -#endif - cursor.x(lx - tabular->GetWidthOfColumn(actcell) + top_x + 2); + cursor_.x(lx - tabular->GetWidthOfColumn(actcell) + top_x + 2); resetPos(bv); } @@ -1259,75 +1480,95 @@ int InsetTabular::getCellXPos(int cell) const void InsetTabular::resetPos(BufferView * bv) const { - if (!locked) +#warning This should be fixed in the right manner (20011128 Jug) + // fast hack to fix infinite repaintings! + if (in_reset_pos) return; - actcol = tabular->column_of_cell(actcell); int cell = 0; + actcol = tabular->column_of_cell(actcell); actrow = 0; - cursor.y(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(cell + 1)); + cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) + + tabular->GetAscentOfRow(actrow + 1) + + tabular->GetAdditionalHeight(actrow + 1)); ++actrow; } } + if (!locked || nodraw()) { + if (the_locking_inset) + inset_y = cursor_.y(); + return; + } + // we need this only from here on!!! + in_reset_pos = true; static int const offset = ADD_TO_TABULAR_WIDTH + 2; int new_x = getCellXPos(actcell); - int old_x = cursor.x(); + int old_x = cursor_.x(); new_x += offset; - cursor.x(new_x); + cursor_.x(new_x); // cursor.x(getCellXPos(actcell) + offset); - if (scroll() && (tabular->GetWidthOfTabular() < bv->workWidth()-20)) + if ((actcol < tabular->columns()-1) && scroll(false) && + (tabular->GetWidthOfTabular() < bv->workWidth()-20)) + { scroll(bv, 0.0F); - else if (the_locking_inset && - (tabular->GetWidthOfColumn(actcell) > bv->workWidth()-20)) { - int xx = cursor.x() - offset + bv->text->GetRealCursorX(bv); - if (xx > (bv->workWidth()-20)) + updateLocal(bv, FULL, false); + } else if (the_locking_inset && + (tabular->GetWidthOfColumn(actcell) > bv->workWidth()-20)) + { + int xx = cursor_.x() - offset + bv->text->getRealCursorX(bv); + if (xx > (bv->workWidth()-20)) { scroll(bv, -(xx - bv->workWidth() + 60)); - else if (xx < 20) { + updateLocal(bv, FULL, false); + } else if (xx < 20) { if (xx < 0) xx = -xx + 60; else xx = 60; scroll(bv, xx); + updateLocal(bv, FULL, false); } - } else if ((cursor.x() - offset) > 20 && - (cursor.x() - offset + tabular->GetWidthOfColumn(actcell)) + } else if ((cursor_.x() - offset) > 20 && + (cursor_.x() - offset + tabular->GetWidthOfColumn(actcell)) > (bv->workWidth() - 20)) { scroll(bv, -tabular->GetWidthOfColumn(actcell) - 20); - UpdateLocal(bv, FULL, false); - } else if ((cursor.x() - offset) < 20) { - scroll(bv, 20 - cursor.x() + offset); - UpdateLocal(bv, FULL, false); - } else if (scroll() && top_x > 20 && + updateLocal(bv, FULL, false); + } else if ((cursor_.x() - offset) < 20) { + scroll(bv, 20 - cursor_.x() + offset); + updateLocal(bv, FULL, false); + } else if (scroll(false) && top_x > 20 && (top_x + tabular->GetWidthOfTabular()) > (bv->workWidth() - 20)) { - scroll(bv, old_x - cursor.x()); + scroll(bv, old_x - cursor_.x()); + updateLocal(bv, FULL, false); + } + if (the_locking_inset) { + inset_x = cursor_.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); + inset_y = cursor_.y(); } if ((!the_locking_inset || - !the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE)) && + !the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)) && actcell != oldcell) { InsetTabular * inset = const_cast(this); bv->owner()->getDialogs()->updateTabular(inset); oldcell = actcell; } + in_reset_pos = false; } UpdatableInset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) { if (lock && !old_locking_inset) { - if (ActivateCellInset(bv)) + if (activateCellInset(bv)) return DISPATCHED; } else { bool moved = isRightToLeft(bv) ? movePrevCell(bv) : moveNextCell(bv); if (!moved) - return FINISHED; - if (lock && ActivateCellInset(bv)) + return FINISHED_RIGHT; + if (lock && activateCellInset(bv)) return DISPATCHED; } resetPos(bv); @@ -1341,7 +1582,7 @@ UpdatableInset::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock) if (!moved) return FINISHED; if (lock) { // behind the inset - if (ActivateCellInset(bv, 0, 0, 0, true)) + if (activateCellInset(bv, 0, 0, 0, true)) return DISPATCHED; } resetPos(bv); @@ -1354,16 +1595,16 @@ UpdatableInset::RESULT InsetTabular::moveUp(BufferView * bv, bool lock) int const ocell = actcell; actcell = tabular->GetCellAbove(actcell); if (actcell == ocell) // we moved out of the inset - return FINISHED; + return FINISHED_UP; resetPos(bv); if (lock) { int x = 0; int y = 0; if (old_locking_inset) { - old_locking_inset->GetCursorPos(bv, x, y); - x -= cursor.x() + tabular->GetBeginningOfTextInCell(actcell); + old_locking_inset->getCursorPos(bv, x, y); + x -= cursor_.x() + tabular->GetBeginningOfTextInCell(actcell); } - if (ActivateCellInset(bv, x, 0)) + if (activateCellInset(bv, x, 0)) return DISPATCHED; } return DISPATCHED_NOUPDATE; @@ -1375,16 +1616,16 @@ UpdatableInset::RESULT InsetTabular::moveDown(BufferView * bv, bool lock) int const ocell = actcell; actcell = tabular->GetCellBelow(actcell); if (actcell == ocell) // we moved out of the inset - return FINISHED; + return FINISHED_DOWN; resetPos(bv); if (lock) { int x = 0; int y = 0; if (old_locking_inset) { - old_locking_inset->GetCursorPos(bv, x, y); - x -= cursor.x() + tabular->GetBeginningOfTextInCell(actcell); + old_locking_inset->getCursorPos(bv, x, y); + x -= cursor_.x() + tabular->GetBeginningOfTextInCell(actcell); } - if (ActivateCellInset(bv, x, 0)) + if (activateCellInset(bv, x, 0)) return DISPATCHED; } return DISPATCHED_NOUPDATE; @@ -1411,9 +1652,9 @@ bool InsetTabular::moveNextCell(BufferView * bv, bool lock) ++actcell; } if (lock) { - bool rtl = tabular->GetCellInset(actcell)->par-> + bool rtl = tabular->GetCellInset(actcell)->paragraph()-> isRightToLeftPar(bv->buffer()->params); - ActivateCellInset(bv, 0, 0, 0, !rtl); + activateCellInset(bv, 0, 0, 0, !rtl); } resetPos(bv); return true; @@ -1440,40 +1681,66 @@ bool InsetTabular::movePrevCell(BufferView * bv, bool lock) --actcell; } if (lock) { - bool rtl = tabular->GetCellInset(actcell)->par-> + bool rtl = tabular->GetCellInset(actcell)->paragraph()-> isRightToLeftPar(bv->buffer()->params); - ActivateCellInset(bv, 0, 0, 0, !rtl); + activateCellInset(bv, 0, 0, 0, !rtl); } resetPos(bv); return true; } -bool InsetTabular::Delete() +bool InsetTabular::deletable() const { return true; } -void InsetTabular::SetFont(BufferView * bv, LyXFont const & font, bool tall) +void InsetTabular::setFont(BufferView * bv, LyXFont const & font, bool tall, + bool selectall) { + if (selectall) { + setSelection(0, tabular->GetNumberOfCells() - 1); + } + if (hasSelection()) { + setUndo(bv, Undo::EDIT, + bv->text->cursor.par(), + bv->text->cursor.par()->next()); + bool frozen = undo_frozen; + if (!frozen) + freezeUndo(); + // apply the fontchange on the whole selection + int sel_row_start; + int sel_row_end; + 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); + } + } + if (!frozen) + unFreezeUndo(); + updateLocal(bv, INIT, true); + } if (the_locking_inset) - the_locking_inset->SetFont(bv, font, tall); + the_locking_inset->setFont(bv, font, tall); } -bool InsetTabular::TabularFeatures(BufferView * bv, string const & what) +bool InsetTabular::tabularFeatures(BufferView * bv, string const & what) { LyXTabular::Feature action = LyXTabular::LAST_ACTION; int i = 0; - for (; tabularFeatures[i].action != LyXTabular::LAST_ACTION; ++i) { - string const tmp = tabularFeatures[i].feature; + for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) { + string const tmp = tabularFeature[i].feature; if (tmp == what.substr(0, tmp.length())) { //if (!compare(tabularFeatures[i].feature.c_str(), what.c_str(), //tabularFeatures[i].feature.length())) { - action = tabularFeatures[i].action; + action = tabularFeature[i].action; break; } } @@ -1481,18 +1748,34 @@ bool InsetTabular::TabularFeatures(BufferView * bv, string const & what) return false; string const val = - frontStrip(what.substr(tabularFeatures[i].feature.length())); - TabularFeatures(bv, action, val); + frontStrip(what.substr(tabularFeature[i].feature.length())); + tabularFeatures(bv, action, val); return true; } +static void checkLongtableSpecial(LyXTabular::ltType & ltt, + string const & special, bool & flag) +{ + if (special == "dl_above") { + ltt.topDL = flag; + ltt.set = false; + } else if (special == "dl_below") { + ltt.bottomDL = flag; + ltt.set = false; + } else if (special == "empty") { + ltt.empty = flag; + ltt.set = false; + } else if (flag) { + ltt.empty = false; + ltt.set = true; + } +} + -void InsetTabular::TabularFeatures(BufferView * bv, - LyXTabular::Feature feature, - string const & value) +void InsetTabular::tabularFeatures(BufferView * bv, + LyXTabular::Feature feature, + string const & value) { - //int i; - //int j; int sel_col_start; int sel_col_end; int sel_row_start; @@ -1500,134 +1783,123 @@ void InsetTabular::TabularFeatures(BufferView * bv, bool setLines = false; LyXAlignment setAlign = LYX_ALIGN_LEFT; LyXTabular::VAlignment setVAlign = LyXTabular::LYX_VALIGN_TOP; - //int lineSet; - //bool what; switch (feature) { case LyXTabular::M_ALIGN_LEFT: case LyXTabular::ALIGN_LEFT: - setAlign=LYX_ALIGN_LEFT; + setAlign = LYX_ALIGN_LEFT; break; case LyXTabular::M_ALIGN_RIGHT: case LyXTabular::ALIGN_RIGHT: - setAlign=LYX_ALIGN_RIGHT; + setAlign = LYX_ALIGN_RIGHT; break; case LyXTabular::M_ALIGN_CENTER: case LyXTabular::ALIGN_CENTER: - setAlign=LYX_ALIGN_CENTER; + setAlign = LYX_ALIGN_CENTER; break; case LyXTabular::M_VALIGN_TOP: case LyXTabular::VALIGN_TOP: - setVAlign=LyXTabular::LYX_VALIGN_TOP; + setVAlign = LyXTabular::LYX_VALIGN_TOP; break; case LyXTabular::M_VALIGN_BOTTOM: case LyXTabular::VALIGN_BOTTOM: - setVAlign=LyXTabular::LYX_VALIGN_BOTTOM; + setVAlign = LyXTabular::LYX_VALIGN_BOTTOM; break; case LyXTabular::M_VALIGN_CENTER: case LyXTabular::VALIGN_CENTER: - setVAlign=LyXTabular::LYX_VALIGN_CENTER; + setVAlign = LyXTabular::LYX_VALIGN_CENTER; break; default: break; } if (hasSelection()) { - sel_col_start = tabular->column_of_cell(sel_cell_start); - sel_col_end = tabular->column_of_cell(sel_cell_end); - if (sel_col_start > sel_col_end) { - sel_col_end = sel_col_start; - sel_col_start = tabular->column_of_cell(sel_cell_end); - } else { - sel_col_end = tabular->right_column_of_cell(sel_cell_end); - } - - sel_row_start = tabular->row_of_cell(sel_cell_start); - sel_row_end = tabular->row_of_cell(sel_cell_end); - if (sel_row_start > sel_row_end) { - //int tmp = sel_row_start; - //sel_row_start = sel_row_end; - //sel_row_end = tmp; - swap(sel_row_start, sel_row_end); - } + 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); } - bv->text->SetUndo(bv->buffer(), Undo::FINISH, -#ifndef NEW_INSETS - bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->previous_, - bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->next_ -#else - bv->text->cursor.par()->previous(), - bv->text->cursor.par()->next() -#endif - ); + setUndo(bv, Undo::FINISH, + bv->text->cursor.par(), + bv->text->cursor.par()->next()); - int row = tabular->row_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: { - bool const update = (tabular->GetColumnPWidth(actcell) != value); - tabular->SetColumnPWidth(actcell,value); + LyXLength const vallen(value); + LyXLength const & tmplen = tabular->GetColumnPWidth(actcell); + + bool const update = (tmplen != vallen); + tabular->SetColumnPWidth(actcell, vallen); if (update) { + int cell; for (int i = 0; i < tabular->rows(); ++i) { - tabular->GetCellInset(tabular->GetCellNumber(i, column))-> - resizeLyXText(bv); + cell = tabular->GetCellNumber(i,column); + tabular->GetCellInset(cell)->resizeLyXText(bv); } - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); } } break; case LyXTabular::SET_MPWIDTH: { - bool const update = (tabular->GetPWidth(actcell) != value); - tabular->SetMColumnPWidth(actcell,value); + LyXLength const vallen(value); + LyXLength const & tmplen = tabular->GetPWidth(actcell); + + bool const update = (tmplen != 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, true); + updateLocal(bv, INIT, true); } } break; case LyXTabular::SET_SPECIAL_COLUMN: case LyXTabular::SET_SPECIAL_MULTI: tabular->SetAlignSpecial(actcell,value,feature); + updateLocal(bv, FULL, true); break; case LyXTabular::APPEND_ROW: // append the row into the tabular - UnlockInsetInInset(bv, the_locking_inset); + unlockInsetInInset(bv, the_locking_inset); tabular->AppendRow(actcell); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::APPEND_COLUMN: // append the column into the tabular - UnlockInsetInInset(bv, the_locking_inset); + unlockInsetInInset(bv, the_locking_inset); tabular->AppendColumn(actcell); actcell = tabular->GetCellNumber(row, column); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::DELETE_ROW: - UnlockInsetInInset(bv, the_locking_inset); - tabular->DeleteRow(tabular->row_of_cell(actcell)); - if ((row+1) > tabular->rows()) - --row; - actcell = tabular->GetCellNumber(row, column); + unlockInsetInInset(bv, the_locking_inset); + for(int i = sel_row_start; i <= sel_row_end; ++i) { + tabular->DeleteRow(sel_row_start); + } + if (sel_row_start >= tabular->rows()) + --sel_row_start; + actcell = tabular->GetCellNumber(sel_row_start, column); clearSelection(); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::DELETE_COLUMN: - UnlockInsetInInset(bv, the_locking_inset); - tabular->DeleteColumn(tabular->column_of_cell(actcell)); - if ((column+1) > tabular->columns()) - --column; - actcell = tabular->GetCellNumber(row, column); + unlockInsetInInset(bv, the_locking_inset); + for(int i = sel_col_start; i <= sel_col_end; ++i) { + tabular->DeleteColumn(sel_col_start); + } + if (sel_col_start >= tabular->columns()) + --sel_col_start; + actcell = tabular->GetCellNumber(row, sel_col_start); clearSelection(); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::M_TOGGLE_LINE_TOP: flag = false; @@ -1639,7 +1911,7 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->SetTopLine( tabular->GetCellNumber(i, j), lineSet, flag); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; } @@ -1654,7 +1926,7 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->GetCellNumber(i, j), lineSet, flag); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; } @@ -1669,7 +1941,7 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->GetCellNumber(i,j), lineSet, flag); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; } @@ -1684,7 +1956,7 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->GetCellNumber(i,j), lineSet, flag); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; } @@ -1701,7 +1973,7 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->GetCellNumber(i, j), setAlign, flag); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::M_VALIGN_TOP: case LyXTabular::M_VALIGN_BOTTOM: @@ -1715,12 +1987,12 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->SetVAlignment( tabular->GetCellNumber(i, j), setVAlign, flag); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::MULTICOLUMN: { if (sel_row_start != sel_row_end) { - WriteAlert(_("Impossible Operation!"), + Alert::alert(_("Impossible Operation!"), _("Multicolumns can only be horizontally."), _("Sorry.")); return; @@ -1730,10 +2002,10 @@ void InsetTabular::TabularFeatures(BufferView * bv, // check wether we are completly in a multicol if (tabular->IsMultiColumn(actcell)) { tabular->UnsetMultiColumn(actcell); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); } else { tabular->SetMultiColumn(actcell, 1); - UpdateLocal(bv, CELL, true); + updateLocal(bv, CELL, true); } return; } @@ -1751,8 +2023,8 @@ void InsetTabular::TabularFeatures(BufferView * bv, } tabular->SetMultiColumn(s_start, s_end - s_start + 1); actcell = s_start; - sel_cell_end = sel_cell_start; - UpdateLocal(bv, INIT, true); + clearSelection(); + updateLocal(bv, INIT, true); break; } case LyXTabular::SET_ALL_LINES: @@ -1762,15 +2034,15 @@ void InsetTabular::TabularFeatures(BufferView * bv, for (int j = sel_col_start; j <= sel_col_end; ++j) tabular->SetAllLines( tabular->GetCellNumber(i,j), setLines); - UpdateLocal(bv, INIT, true); + updateLocal(bv, INIT, true); break; case LyXTabular::SET_LONGTABULAR: tabular->SetLongTabular(true); - UpdateLocal(bv, INIT, true); // because this toggles displayed + updateLocal(bv, INIT, true); // because this toggles displayed break; case LyXTabular::UNSET_LONGTABULAR: tabular->SetLongTabular(false); - UpdateLocal(bv, INIT, true); // because this toggles displayed + updateLocal(bv, INIT, true); // because this toggles displayed break; case LyXTabular::SET_ROTATE_TABULAR: tabular->SetRotateTabular(true); @@ -1802,22 +2074,38 @@ void InsetTabular::TabularFeatures(BufferView * bv, tabular->GetCellNumber(i, j), val); break; } + case LyXTabular::UNSET_LTFIRSTHEAD: + flag = false; case LyXTabular::SET_LTFIRSTHEAD: - tabular->SetLTHead(actcell, true); + (void)tabular->GetRowOfLTFirstHead(row, ltt); + checkLongtableSpecial(ltt, value, flag); + tabular->SetLTHead(row, flag, ltt, true); break; + case LyXTabular::UNSET_LTHEAD: + flag = false; case LyXTabular::SET_LTHEAD: - tabular->SetLTHead(actcell, false); + (void)tabular->GetRowOfLTHead(row, ltt); + checkLongtableSpecial(ltt, value, flag); + tabular->SetLTHead(row, flag, ltt, false); break; + case LyXTabular::UNSET_LTFOOT: + flag = false; case LyXTabular::SET_LTFOOT: - tabular->SetLTFoot(actcell, false); + (void)tabular->GetRowOfLTFoot(row, ltt); + checkLongtableSpecial(ltt, value, flag); + tabular->SetLTFoot(row, flag, ltt, false); break; + case LyXTabular::UNSET_LTLASTFOOT: + flag = false; case LyXTabular::SET_LTLASTFOOT: - tabular->SetLTFoot(actcell, true); + (void)tabular->GetRowOfLTLastFoot(row, ltt); + checkLongtableSpecial(ltt, value, flag); + tabular->SetLTFoot(row, flag, ltt, true); break; case LyXTabular::SET_LTNEWPAGE: { - bool what = !tabular->GetLTNewPage(actcell); - tabular->SetLTNewPage(actcell, what); + bool what = !tabular->GetLTNewPage(row); + tabular->SetLTNewPage(row, what); break; } // dummy stuff just to avoid warnings @@ -1827,7 +2115,7 @@ void InsetTabular::TabularFeatures(BufferView * bv, } -bool InsetTabular::ActivateCellInset(BufferView * bv, int x, int y, int button, +bool InsetTabular::activateCellInset(BufferView * bv, int x, int y, int button, bool behind) { UpdatableInset * inset = @@ -1839,93 +2127,117 @@ bool InsetTabular::ActivateCellInset(BufferView * bv, int x, int y, int button, } //inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); //inset_y = cursor.y(); - inset->Edit(bv, x, y, button); + inset->edit(bv, x, y, button); if (!the_locking_inset) return false; - UpdateLocal(bv, CELL, false); + updateLocal(bv, CELL, false); return (the_locking_inset != 0); } -bool InsetTabular::ActivateCellInsetAbs(BufferView * bv, int x, int y, +bool InsetTabular::activateCellInsetAbs(BufferView * bv, int x, int y, int button) { - inset_x = cursor.x() + inset_x = cursor_.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); - inset_y = cursor.y(); - return ActivateCellInset(bv, x - inset_x, y - inset_y, button); + inset_y = cursor_.y(); + return activateCellInset(bv, x - inset_x, y - inset_y, button); } -bool InsetTabular::InsetHit(BufferView *, int x, int) const +bool InsetTabular::insetHit(BufferView *, int x, int) const { return (x + top_x) - > (cursor.x() + tabular->GetBeginningOfTextInCell(actcell)); + > (cursor_.x() + 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 +int InsetTabular::getMaxWidthOfCell(BufferView * bv, int cell) const { - string const s = tabular->GetPWidth(cell); + LyXLength const len = tabular->GetPWidth(cell); - if (s.empty()) + if (len.zero()) return -1; - return VSpace(s).inPixels(bv); + return len.inPixels(latexTextWidth(bv), bv->text->defaultHeight()); } int InsetTabular::getMaxWidth(BufferView * bv, - UpdatableInset const * inset) const + UpdatableInset const * inset) const { - int const n = tabular->GetNumberOfCells(); - int cell = 0; - for (; cell < n; ++cell) { - if (tabular->GetCellInset(cell) == inset) - break; - } - if (cell >= n) + 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) + } + + 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::resizeLyXText(BufferView *) const +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; } LyXText * InsetTabular::getLyXText(BufferView const * bv, - bool const recursive) const + bool const recursive) const { 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); } -bool InsetTabular::ShowInsetDialog(BufferView * bv) const +bool InsetTabular::showInsetDialog(BufferView * bv) const { - if (!the_locking_inset || !the_locking_inset->ShowInsetDialog(bv)) + if (!the_locking_inset || !the_locking_inset->showInsetDialog(bv)) bv->owner()->getDialogs() ->showTabular(const_cast(this)); return true; } -void InsetTabular::OpenLayoutDialog(BufferView * bv) const +void InsetTabular::openLayoutDialog(BufferView * bv) const { if (the_locking_inset) { InsetTabular * i = static_cast - (the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE)); + (the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE)); if (i) { - i->OpenLayoutDialog(bv); + i->openLayoutDialog(bv); return; } } @@ -1933,47 +2245,41 @@ void InsetTabular::OpenLayoutDialog(BufferView * bv) const const_cast(this)); } + // -// functions returns: -// 0 ... disabled -// 1 ... enabled -// 2 ... toggled on -// 3 ... toggled off +// function returns an object as defined in func_status.h: +// states OK, Unknown, Disabled, On, Off. // -LyXFunc::func_status InsetTabular::getStatus(string const & what) const +FuncStatus InsetTabular::getStatus(string const & what) const { int action = LyXTabular::LAST_ACTION; - LyXFunc::func_status status = LyXFunc::OK; + FuncStatus status; int i = 0; - for (; tabularFeatures[i].action != LyXTabular::LAST_ACTION; ++i) { - string const tmp = tabularFeatures[i].feature; + for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) { + string const tmp = tabularFeature[i].feature; if (tmp == what.substr(0, tmp.length())) { //if (!compare(tabularFeatures[i].feature.c_str(), what.c_str(), // tabularFeatures[i].feature.length())) { - action = tabularFeatures[i].action; + action = tabularFeature[i].action; break; } } - if (action == LyXTabular::LAST_ACTION) - return LyXFunc::Unknown; - - string const argument = frontStrip(what.substr(tabularFeatures[i].feature.length())); + if (action == LyXTabular::LAST_ACTION) { + status.clear(); + return status.unknown(true); + } + + string const argument = frontStrip(what.substr(tabularFeature[i].feature.length())); int sel_row_start; int sel_row_end; int dummy; + LyXTabular::ltType dummyltt; bool flag = true; if (hasSelection()) { - sel_row_start = tabular->row_of_cell(sel_cell_start); - sel_row_end = tabular->row_of_cell(sel_cell_end); - if (sel_row_start > sel_row_end) { - //int tmp = sel_row_start; - //sel_row_start = sel_row_end; - //sel_row_end = tmp; - swap(sel_row_start, sel_row_end); - } + getSelection(sel_row_start, sel_row_end, dummy, dummy); } else { sel_row_start = sel_row_end = tabular->row_of_cell(actcell); } @@ -1983,8 +2289,7 @@ LyXFunc::func_status InsetTabular::getStatus(string const & what) const case LyXTabular::SET_MPWIDTH: case LyXTabular::SET_SPECIAL_COLUMN: case LyXTabular::SET_SPECIAL_MULTI: - status |= LyXFunc::Disabled; - return status; + return status.disabled(true); case LyXTabular::APPEND_ROW: case LyXTabular::APPEND_COLUMN: @@ -1992,185 +2297,116 @@ LyXFunc::func_status InsetTabular::getStatus(string const & what) const case LyXTabular::DELETE_COLUMN: case LyXTabular::SET_ALL_LINES: case LyXTabular::UNSET_ALL_LINES: - status |= LyXFunc::OK; - return status; + return status.clear(); case LyXTabular::MULTICOLUMN: - if (tabular->IsMultiColumn(actcell)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->IsMultiColumn(actcell)); break; case LyXTabular::M_TOGGLE_LINE_TOP: flag = false; case LyXTabular::TOGGLE_LINE_TOP: - if (tabular->TopLine(actcell, flag)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->TopLine(actcell, flag)); break; case LyXTabular::M_TOGGLE_LINE_BOTTOM: flag = false; case LyXTabular::TOGGLE_LINE_BOTTOM: - if (tabular->BottomLine(actcell, flag)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->BottomLine(actcell, flag)); break; case LyXTabular::M_TOGGLE_LINE_LEFT: flag = false; case LyXTabular::TOGGLE_LINE_LEFT: - if (tabular->LeftLine(actcell, flag)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->LeftLine(actcell, flag)); break; case LyXTabular::M_TOGGLE_LINE_RIGHT: flag = false; case LyXTabular::TOGGLE_LINE_RIGHT: - if (tabular->RightLine(actcell, flag)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->RightLine(actcell, flag)); break; case LyXTabular::M_ALIGN_LEFT: flag = false; case LyXTabular::ALIGN_LEFT: - if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT); break; case LyXTabular::M_ALIGN_RIGHT: flag = false; case LyXTabular::ALIGN_RIGHT: - if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT); break; case LyXTabular::M_ALIGN_CENTER: flag = false; case LyXTabular::ALIGN_CENTER: - if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER); break; case LyXTabular::M_VALIGN_TOP: flag = false; case LyXTabular::VALIGN_TOP: - if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP); break; case LyXTabular::M_VALIGN_BOTTOM: flag = false; case LyXTabular::VALIGN_BOTTOM: - if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM); break; case LyXTabular::M_VALIGN_CENTER: flag = false; case LyXTabular::VALIGN_CENTER: - if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER); break; case LyXTabular::SET_LONGTABULAR: - if (tabular->IsLongTabular()) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->IsLongTabular()); break; case LyXTabular::UNSET_LONGTABULAR: - if (!tabular->IsLongTabular()) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(!tabular->IsLongTabular()); break; case LyXTabular::SET_ROTATE_TABULAR: - if (tabular->GetRotateTabular()) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetRotateTabular()); break; case LyXTabular::UNSET_ROTATE_TABULAR: - if (!tabular->GetRotateTabular()) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(!tabular->GetRotateTabular()); break; case LyXTabular::SET_ROTATE_CELL: - if (tabular->GetRotateCell(actcell)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetRotateCell(actcell)); break; case LyXTabular::UNSET_ROTATE_CELL: - if (!tabular->GetRotateCell(actcell)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(!tabular->GetRotateCell(actcell)); break; case LyXTabular::SET_USEBOX: - if (strToInt(argument) == tabular->GetUsebox(actcell)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(strToInt(argument) == tabular->GetUsebox(actcell)); break; case LyXTabular::SET_LTFIRSTHEAD: - if (tabular->GetRowOfLTHead(actcell, dummy)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTHEAD: - if (tabular->GetRowOfLTHead(actcell, dummy)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTFOOT: - if (tabular->GetRowOfLTFoot(actcell, dummy)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTLASTFOOT: - if (tabular->GetRowOfLTFoot(actcell, dummy)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTNEWPAGE: - if (tabular->GetLTNewPage(actcell)) - status |= LyXFunc::ToggleOn; - else - status |= LyXFunc::ToggleOff; + status.setOnOff(tabular->GetLTNewPage(sel_row_start)); break; default: - status = LyXFunc::Disabled; + status.clear(); + status.disabled(true); break; } return status; } +vector const InsetTabular::getLabelList() const +{ + return tabular->getLabelList(); +} + + bool InsetTabular::copySelection(BufferView * bv) { if (!hasSelection()) return false; - //delete paste_tabular; - - //int sel_col_start; - //int sel_col_end; - //int sel_row_start; - //int sel_row_end; int sel_col_start = tabular->column_of_cell(sel_cell_start); int sel_col_end = tabular->column_of_cell(sel_cell_end); @@ -2185,22 +2421,18 @@ bool InsetTabular::copySelection(BufferView * bv) 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 tmp tmp = sel_row_start; - //sel_row_start = sel_row_end; - //sel_row_end = tmp; swap(sel_row_start, sel_row_end); } int const rows = sel_row_end - sel_row_start + 1; delete paste_tabular; paste_tabular = new LyXTabular(this, *tabular); // rows, columns); - //int i; for (int i = 0; i < sel_row_start; ++i) paste_tabular->DeleteRow(0); - while(paste_tabular->rows() > rows) + 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->SetBottomLine(paste_tabular->GetFirstCellInRow(rows - 1), true, true); for (int i = 0; i < sel_col_start; ++i) paste_tabular->DeleteColumn(0); @@ -2211,7 +2443,8 @@ bool InsetTabular::copySelection(BufferView * bv) true, true); ostringstream sstr; - paste_tabular->Ascii(bv->buffer(), sstr); + paste_tabular->ascii(bv->buffer(), sstr, + (int)parOwner()->params().depth(), true, '\t'); bv->stuffClipboard(sstr.str().c_str()); return true; } @@ -2255,11 +2488,6 @@ bool InsetTabular::cutSelection() if (!hasSelection()) return false; - //int sel_col_start; - //int sel_col_end; - //int sel_row_start; - //int sel_row_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) { @@ -2271,15 +2499,9 @@ bool InsetTabular::cutSelection() 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 tmp = sel_row_start; - //sel_row_start = sel_row_end; - //sel_row_end = tmp; swap(sel_row_start, sel_row_end); } if (sel_cell_start > sel_cell_end) { - //int tmp = sel_cell_start; - //sel_cell_start = sel_cell_end; - //sel_cell_end = tmp; swap(sel_cell_start, sel_cell_end); } for (int i = sel_row_start; i <= sel_row_end; ++i) { @@ -2291,7 +2513,255 @@ bool InsetTabular::cutSelection() } -bool InsetTabular::isRightToLeft(BufferView *bv ) +bool InsetTabular::isRightToLeft(BufferView * bv) { return bv->getParentLanguage(this)->RightToLeft(); } + + +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); + + if (recursive && the_locking_inset) + sx += the_locking_inset->scroll(recursive); + + return sx; +} + + +bool InsetTabular::doClearArea() const +{ + return !locked || (need_update & (FULL|INIT)); +} + + +void InsetTabular::getSelection(int & srow, int & erow, + int & scol, int & ecol) const +{ + 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) { + swap(srow, erow); + } + + 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); + } +} + + +Paragraph * InsetTabular::getParFromID(int id) const +{ + Paragraph * result; + for(int i = 0; i < tabular->rows(); ++i) { + for(int j = 0; j < tabular->columns(); ++j) { + if ((result = tabular->GetCellInset(i, j)->getParFromID(id))) + return result; + } + } + return 0; +} + + +Paragraph * InsetTabular::firstParagraph() const +{ + if (the_locking_inset) + return the_locking_inset->firstParagraph(); + return 0; +} + + +Paragraph * InsetTabular::getFirstParagraph(int i) const +{ + return (i < tabular->GetNumberOfCells()) + ? tabular->GetCellInset(i)->getFirstParagraph(0) + : 0; +} + + +LyXCursor const & InsetTabular::cursor(BufferView * bv) const +{ + if (the_locking_inset) + return the_locking_inset->cursor(bv); + return Inset::cursor(bv); +} + + +Inset * 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; + } + } + return 0; +} + + +string const +InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const +{ + nodraw(true); + if (the_locking_inset) { + string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value)); + if (!str.empty()) { + nodraw(false); + return str; + } + if (tabular->IsLastCell(actcell)) { + bv->unlockInset(const_cast(this)); + nodraw(false); + return string(); + } + ++actcell; + } + // otherwise we have to lock the next inset and ask for it's selecttion + UpdatableInset * inset = + static_cast(tabular->GetCellInset(actcell)); + inset->edit(bv, 0, 0, 0); + string const str(selectNextWordInt(bv, value)); + nodraw(false); + if (!str.empty()) + resetPos(bv); + return str; +} + + +string InsetTabular::selectNextWordInt(BufferView * bv, float & value) const +{ + // when entering this function the inset should be ALWAYS locked! + lyx::Assert(the_locking_inset); + + string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value)); + if (!str.empty()) + return str; + + if (tabular->IsLastCell(actcell)) { + bv->unlockInset(const_cast(this)); + return string(); + } + + // otherwise we have to lock the next inset and ask for it's selecttion + UpdatableInset * inset = + static_cast(tabular->GetCellInset(++actcell)); + inset->edit(bv); + return selectNextWordInt(bv, value); +} + + +void InsetTabular::selectSelectedWord(BufferView * bv) +{ + 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); + } +} + + +bool InsetTabular::searchForward(BufferView * bv, string const & str, + bool cs, bool mw) +{ + nodraw(true); + if (the_locking_inset) { + if (the_locking_inset->searchForward(bv, str, cs, mw)) { + nodraw(false); + updateLocal(bv, CELL, false); + return true; + } + if (tabular->IsLastCell(actcell)) { + nodraw(false); + bv->unlockInset(const_cast(this)); + return false; + } + ++actcell; + } + // otherwise we have to lock the next inset and search there + UpdatableInset * inset = + static_cast(tabular->GetCellInset(actcell)); + inset->edit(bv); + bool const ret = searchForward(bv, str, cs, mw); + nodraw(false); + updateLocal(bv, CELL, false); + return ret; +} + + +bool InsetTabular::searchBackward(BufferView * bv, string const & str, + bool cs, bool mw) +{ + nodraw(true); + if (the_locking_inset) { + if (the_locking_inset->searchBackward(bv, str, cs, mw)) { + nodraw(false); + updateLocal(bv, CELL, false); + return true; + } + if (!actcell) { // we are already in the first cell + nodraw(false); + bv->unlockInset(const_cast(this)); + return false; + } + --actcell; + } + // otherwise we have to lock the next inset and search there + UpdatableInset * inset = + static_cast(tabular->GetCellInset(actcell)); + inset->edit(bv, false); + bool const ret = searchBackward(bv, str, cs, mw); + nodraw(false); + updateLocal(bv, CELL, false); + return ret; +} + + +bool InsetTabular::insetAllowed(Inset::Code code) const +{ + if (the_locking_inset) + return the_locking_inset->insetAllowed(code); + return false; +} + + +bool InsetTabular::forceDefaultParagraphs(Inset const * in) const +{ + const int cell = tabular->GetCellFromInset(in, actcell); + + if (cell != -1) + 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!!! + return false; +}