X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=7f9ae0cf01b9cbf289de21f8a7a1c7c4abf4a5c2;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=82c19e806d653b23160d88b06255f230a42153d8;hpb=fd054e60b18496cef6527be18a99cd2ec3e48346;p=lyx.git diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index 82c19e806d..7f9ae0cf01 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -10,12 +10,6 @@ #include -#include -#include - -#include -#include -//#include #ifdef __GNUG__ #pragma implementation #endif @@ -30,17 +24,31 @@ #include "Painter.h" #include "font.h" #include "lyxtext.h" -#include "lyx_gui_misc.h" #include "LyXView.h" #include "insets/insettext.h" -#include "frontends/Dialogs.h" #include "debug.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; @@ -50,8 +58,9 @@ 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; @@ -61,7 +70,6 @@ struct TabularFeature { string feature; }; -//tabular_features * tabularFeatures = 0; TabularFeature tabularFeature[] = { @@ -131,11 +139,16 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns) // for now make it always display as display() inset // just for test!!! the_locking_inset = 0; - locked = no_selection = false; + old_locking_inset = 0; + locked = false; oldcell = -1; actrow = actcell = 0; clearSelection(); need_update = INIT; + in_update = false; + in_reset_pos = false; + inset_x = 0; + inset_y = 0; } @@ -143,13 +156,18 @@ InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf, bool same_id) : UpdatableInset(tab, same_id), buffer(&buf) { - tabular.reset(new LyXTabular(this, *(tab.tabular))); + tabular.reset(new LyXTabular(this, *(tab.tabular), same_id)); the_locking_inset = 0; - locked = no_selection = false; + old_locking_inset = 0; + locked = false; oldcell = -1; actrow = actcell = 0; - sel_cell_start = sel_cell_end = 0; + clearSelection(); need_update = INIT; + in_update = false; + in_reset_pos = false; + inset_x = 0; + inset_y = 0; } @@ -174,11 +192,8 @@ void InsetTabular::write(Buffer const * buf, ostream & os) const 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; @@ -187,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. " @@ -245,7 +260,8 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, 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(); @@ -262,6 +278,7 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, cleared = true; } top_x = int(x); + topx_set = true; top_baseline = baseline; x += ADD_TO_TABULAR_WIDTH; if (cleared) { @@ -287,11 +304,11 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, cx = nx + tabular->GetBeginningOfTextInCell(cell); if (first_visible_cell < 0) first_visible_cell = cell; - if (hasSelection()) + if (hasSelection()) { drawCellSelection(pain, nx, baseline, i, j, cell); + } - tabular->GetCellInset(cell)->draw(bv, font, baseline, cx, - cleared); + tabular->GetCellInset(cell)->draw(bv, font, baseline, cx, cleared); drawCellLines(pain, nx, baseline, i, cell); nx += tabular->GetWidthOfColumn(cell); ++cell; @@ -309,11 +326,12 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, 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); @@ -345,45 +363,69 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, } 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); + // + // 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 - if (bv->text->status == LyXText::CHANGED_IN_DRAW) - return; -#endif // 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, - backgroundColor()); + 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, - backgroundColor()); + 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) { int i = 0; - for(Inset * inset=owner(); inset; ++i) + for(Inset * inset = owner(); inset; ++i) inset = inset->owner(); if (calculate_dimensions_of_cells(bv, font, false)) need_update = INIT; @@ -394,7 +436,7 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, void InsetTabular::drawCellLines(Painter & pain, int x, int baseline, - int row, int cell) const + int row, int cell) const { int x2 = x + tabular->GetWidthOfColumn(cell); bool on_off; @@ -431,6 +473,7 @@ void InsetTabular::drawCellLines(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) { @@ -442,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); @@ -455,11 +499,22 @@ 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) @@ -478,11 +533,12 @@ 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; } @@ -497,7 +553,7 @@ void InsetTabular::edit(BufferView * bv, int x, int y, unsigned int 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; @@ -505,7 +561,7 @@ 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; + clearSelection(); finishUndo(); if (insetHit(bv, x, y) && (button != 3)) { activateCellInsetAbs(bv, x, y, button); @@ -518,7 +574,7 @@ void InsetTabular::edit(BufferView * bv, bool front) UpdatableInset::edit(bv, front); if (!bv->lockInset(this)) { - lyxerr[Debug::INSETS] << "InsetTabular::Cannot lock inset" << endl; + lyxerr[Debug::INSETTEXT] << "InsetTabular::Cannot lock inset" << endl; return; } locked = true; @@ -529,7 +585,7 @@ void InsetTabular::edit(BufferView * bv, bool front) actcell = 0; else actcell = tabular->GetNumberOfCells() - 1; - sel_cell_start = sel_cell_end = actcell; + clearSelection(); resetPos(bv); finishUndo(); } @@ -542,11 +598,10 @@ void InsetTabular::insetUnlock(BufferView * bv) the_locking_inset = 0; } hideInsetCursor(bv); - no_selection = false; oldcell = -1; locked = false; if (scroll(false) || hasSelection()) { - sel_cell_start = sel_cell_end = 0; + clearSelection(); if (scroll(false)) { scroll(bv, 0.0F); } @@ -556,12 +611,19 @@ void InsetTabular::insetUnlock(BufferView * bv) void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what, - bool mark_dirty) const + 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); @@ -573,28 +635,42 @@ void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what, 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; + 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; } @@ -647,7 +723,6 @@ unsigned int InsetTabular::insetInInsetY() { if (!the_locking_inset) return 0; - return inset_y + the_locking_inset->insetInInsetY(); } @@ -687,8 +762,6 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button) updateLocal(bv, SELECTION, false); } - no_selection = false; - int const ocell = actcell; int const orow = actrow; @@ -696,7 +769,8 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button) setPos(bv, x, y); if (actrow != orow) updateLocal(bv, NONE, false); - sel_cell_start = sel_cell_end = actcell; + clearSelection(); +#if 0 if (button == 3) { if ((ocell != actcell) && the_locking_inset) { the_locking_inset->insetUnlock(bv); @@ -705,6 +779,7 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button) showInsetCursor(bv); return; } +#endif bool const inset_hit = insetHit(bv, x, y); @@ -734,27 +809,18 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button) } -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; } @@ -767,17 +833,18 @@ void InsetTabular::insetMotionNotify(BufferView * bv, int x, int y, int button) 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); } @@ -791,14 +858,12 @@ void InsetTabular::insetKeyPress(XKeyEvent * xke) 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); if (result == DISPATCHED || result == DISPATCHED_NOUPDATE) { @@ -812,34 +877,30 @@ 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: - { - if (getFirstLockingInsetOfType(Inset::TABULAR_CODE) != this) - break; - hideInsetCursor(bv); - if (the_locking_inset) { + // 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); - the_locking_inset = 0; - } - 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); - if (!the_locking_inset) { - showInsetCursor(bv); - return DISPATCHED_NOUPDATE; + 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; } - return result; - } - // this to avoid compiler warnings. - default: - break; } if (the_locking_inset) { @@ -858,104 +919,148 @@ InsetTabular::localDispatch(BufferView * 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; + 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; + } + + 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); 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; + } + + 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); 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); + // 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) + 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); + // 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); 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 @@ -964,22 +1069,36 @@ 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)) result = UNDISPATCHED; @@ -1009,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; @@ -1034,11 +1153,11 @@ 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)); ++cols; @@ -1046,7 +1165,7 @@ InsetTabular::localDispatch(BufferView * bv, break; case '\n': paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op)); - while(cols++ < maxCols) + while (cols++ < maxCols) ++cell; cols = 0; break; @@ -1076,33 +1195,56 @@ InsetTabular::localDispatch(BufferView * bv, } // 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; 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)) { + if ((result == UNDISPATCHED) || (result >= FINISHED)) { unlockInsetInInset(bv, the_locking_inset); nodraw(false); - the_locking_inset = 0; // 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; } nodraw(false); -// the_locking_inset->ToggleInsetCursor(bv); updateLocal(bv, CELL, false); -// the_locking_inset->ToggleInsetCursor(bv); return result; } break; } - if (result!=FINISHED) { + if (result < FINISHED) { if (!the_locking_inset) { showInsetCursor(bv); } @@ -1113,28 +1255,53 @@ InsetTabular::localDispatch(BufferView * bv, int InsetTabular::latex(Buffer const * buf, ostream & os, - bool fragile, bool fp) const + 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; } @@ -1145,8 +1312,8 @@ void InsetTabular::validate(LaTeXFeatures & features) const 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; @@ -1169,9 +1336,6 @@ bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv, changed = tabular->SetDescentOfRow(actrow, maxDesc + ADD_TO_HEIGHT) || changed; return changed; } -#if 0 - cur_cell = -1; -#endif for (int i = 0; i < tabular->rows(); ++i) { maxAsc = 0; maxDesc = 0; @@ -1180,7 +1344,7 @@ bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv, 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)); @@ -1189,6 +1353,8 @@ 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; } @@ -1206,6 +1372,11 @@ void InsetTabular::getCursorPos(BufferView * bv, int & x, int & y) const void InsetTabular::toggleInsetCursor(BufferView * bv) { + if (nodraw()) { + if (isCursorVisible()) + bv->hideLockedInsetCursor(); + return; + } if (the_locking_inset) { the_locking_inset->toggleInsetCursor(bv); return; @@ -1226,6 +1397,8 @@ void InsetTabular::toggleInsetCursor(BufferView * bv) void InsetTabular::showInsetCursor(BufferView * bv, bool show) { + if (nodraw()) + return; if (!isCursorVisible()) { LyXFont font; // = GetFont(par, cursor.pos); @@ -1245,8 +1418,20 @@ void InsetTabular::hideInsetCursor(BufferView * bv) 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); } @@ -1258,7 +1443,7 @@ void InsetTabular::setPos(BufferView * bv, int x, int y) const int ly = tabular->GetDescentOfRow(actrow); // first search the right row - while((ly < y) && (actrow < tabular->rows())) { + while ((ly < y) && ((actrow+1) < tabular->rows())) { cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) + tabular->GetAscentOfRow(actrow + 1) + tabular->GetAdditionalHeight(actrow + 1)); @@ -1270,21 +1455,10 @@ void InsetTabular::setPos(BufferView * bv, int x, int y) const // now search the right column int lx = tabular->GetWidthOfColumn(actcell) - tabular->GetAdditionalWidth(actcell); -#if 0 -#ifdef WITH_WARNINGS -#warning Jürgen, can you rewrite this to _not_ use the sequencing operator. (Lgb) -#endif - 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); resetPos(bv); } @@ -1306,11 +1480,13 @@ 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); for (; (cell < actcell) && !tabular->IsLastRow(cell); ++cell) { @@ -1321,6 +1497,13 @@ void InsetTabular::resetPos(BufferView * bv) const ++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(); @@ -1360,6 +1543,10 @@ void InsetTabular::resetPos(BufferView * bv) const 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)) && actcell != oldcell) { @@ -1367,6 +1554,7 @@ void InsetTabular::resetPos(BufferView * bv) const bv->owner()->getDialogs()->updateTabular(inset); oldcell = actcell; } + in_reset_pos = false; } @@ -1379,7 +1567,7 @@ UpdatableInset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) bool moved = isRightToLeft(bv) ? movePrevCell(bv) : moveNextCell(bv); if (!moved) - return FINISHED; + return FINISHED_RIGHT; if (lock && activateCellInset(bv)) return DISPATCHED; } @@ -1407,7 +1595,7 @@ 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; @@ -1428,7 +1616,7 @@ 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; @@ -1502,10 +1690,8 @@ bool InsetTabular::movePrevCell(BufferView * bv, bool lock) } -bool InsetTabular::Delete() +bool InsetTabular::deletable() const { -#warning Is this func correctly named? Or should it be "deletable"? (Lgb?) -#warning I guess this could be 'deletable'! (Jug) return true; } @@ -1514,8 +1700,7 @@ void InsetTabular::setFont(BufferView * bv, LyXFont const & font, bool tall, bool selectall) { if (selectall) { - sel_cell_start = 0; - sel_cell_end = tabular->GetNumberOfCells() - 1; + setSelection(0, tabular->GetNumberOfCells() - 1); } if (hasSelection()) { setUndo(bv, Undo::EDIT, @@ -1568,10 +1753,28 @@ bool InsetTabular::tabularFeatures(BufferView * bv, string const & what) 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) + LyXTabular::Feature feature, + string const & value) { int sel_col_start; int sel_col_end; @@ -1584,27 +1787,27 @@ void InsetTabular::tabularFeatures(BufferView * bv, 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; @@ -1619,19 +1822,24 @@ void InsetTabular::tabularFeatures(BufferView * bv, 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); } @@ -1639,8 +1847,11 @@ void InsetTabular::tabularFeatures(BufferView * bv, 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))-> @@ -1653,6 +1864,7 @@ void InsetTabular::tabularFeatures(BufferView * bv, 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 @@ -1669,19 +1881,23 @@ void InsetTabular::tabularFeatures(BufferView * bv, 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); + 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); 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); + 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); break; @@ -1776,7 +1992,7 @@ void InsetTabular::tabularFeatures(BufferView * bv, case LyXTabular::MULTICOLUMN: { if (sel_row_start != sel_row_end) { - WriteAlert(_("Impossible Operation!"), + Alert::alert(_("Impossible Operation!"), _("Multicolumns can only be horizontally."), _("Sorry.")); return; @@ -1807,7 +2023,7 @@ void InsetTabular::tabularFeatures(BufferView * bv, } tabular->SetMultiColumn(s_start, s_end - s_start + 1); actcell = s_start; - sel_cell_end = sel_cell_start; + clearSelection(); updateLocal(bv, INIT, true); break; } @@ -1858,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 @@ -1924,38 +2156,22 @@ bool InsetTabular::insetHit(BufferView *, int x, int) const // in pixels if we have a pwidth for this cell. 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 { - int cell = tabular->cur_cell; - if (tabular->GetCellInset(cell) != inset) { - cell = actcell; - if (tabular->GetCellInset(cell) != inset) { - - lyxerr << "Actcell not equal to actual cell!\n"; - cell = -1; - } - } - - int const n = tabular->GetNumberOfCells(); + int cell = tabular->GetCellFromInset(inset, actcell); if (cell == -1) { - for (cell = 0; cell < n; ++cell) { - if (tabular->GetCellInset(cell) == inset) - break; - } - } - - if (cell >= n) { - lyxerr << "Own inset not found, shouldn't really happen!\n"; + lyxerr << "Own inset not found, shouldn't really happen!" + << endl; return -1; } @@ -2029,17 +2245,15 @@ 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. // -func_status::value_type InsetTabular::getStatus(string const & what) const +FuncStatus InsetTabular::getStatus(string const & what) const { int action = LyXTabular::LAST_ACTION; - func_status::value_type status = func_status::OK; + FuncStatus status; int i = 0; for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) { @@ -2051,14 +2265,17 @@ func_status::value_type InsetTabular::getStatus(string const & what) const break; } } - if (action == LyXTabular::LAST_ACTION) - return func_status::Unknown; - + 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()) { @@ -2072,8 +2289,7 @@ func_status::value_type InsetTabular::getStatus(string const & what) const case LyXTabular::SET_MPWIDTH: case LyXTabular::SET_SPECIAL_COLUMN: case LyXTabular::SET_SPECIAL_MULTI: - status |= func_status::Disabled; - return status; + return status.disabled(true); case LyXTabular::APPEND_ROW: case LyXTabular::APPEND_COLUMN: @@ -2081,176 +2297,107 @@ func_status::value_type InsetTabular::getStatus(string const & what) const case LyXTabular::DELETE_COLUMN: case LyXTabular::SET_ALL_LINES: case LyXTabular::UNSET_ALL_LINES: - status |= func_status::OK; - return status; + return status.clear(); case LyXTabular::MULTICOLUMN: - if (tabular->IsMultiColumn(actcell)) - status |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::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 |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER); break; case LyXTabular::SET_LONGTABULAR: - if (tabular->IsLongTabular()) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->IsLongTabular()); break; case LyXTabular::UNSET_LONGTABULAR: - if (!tabular->IsLongTabular()) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(!tabular->IsLongTabular()); break; case LyXTabular::SET_ROTATE_TABULAR: - if (tabular->GetRotateTabular()) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetRotateTabular()); break; case LyXTabular::UNSET_ROTATE_TABULAR: - if (!tabular->GetRotateTabular()) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(!tabular->GetRotateTabular()); break; case LyXTabular::SET_ROTATE_CELL: - if (tabular->GetRotateCell(actcell)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetRotateCell(actcell)); break; case LyXTabular::UNSET_ROTATE_CELL: - if (!tabular->GetRotateCell(actcell)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(!tabular->GetRotateCell(actcell)); break; case LyXTabular::SET_USEBOX: - if (strToInt(argument) == tabular->GetUsebox(actcell)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(strToInt(argument) == tabular->GetUsebox(actcell)); break; case LyXTabular::SET_LTFIRSTHEAD: - if (tabular->GetRowOfLTHead(actcell, dummy)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTHEAD: - if (tabular->GetRowOfLTHead(actcell, dummy)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTFOOT: - if (tabular->GetRowOfLTFoot(actcell, dummy)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTLASTFOOT: - if (tabular->GetRowOfLTFoot(actcell, dummy)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt)); break; case LyXTabular::SET_LTNEWPAGE: - if (tabular->GetLTNewPage(actcell)) - status |= func_status::ToggleOn; - else - status |= func_status::ToggleOff; + status.setOnOff(tabular->GetLTNewPage(sel_row_start)); break; default: - status = func_status::Disabled; + status.clear(); + status.disabled(true); break; } return status; } -std::vector const InsetTabular::getLabelList() const +vector const InsetTabular::getLabelList() const { return tabular->getLabelList(); } @@ -2282,10 +2429,10 @@ bool InsetTabular::copySelection(BufferView * bv) paste_tabular = new LyXTabular(this, *tabular); // rows, columns); 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); @@ -2296,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; } @@ -2340,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) { @@ -2356,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) { @@ -2376,7 +2513,7 @@ bool InsetTabular::cutSelection() } -bool InsetTabular::isRightToLeft(BufferView *bv ) +bool InsetTabular::isRightToLeft(BufferView * bv) { return bv->getParentLanguage(this)->RightToLeft(); } @@ -2407,21 +2544,28 @@ bool InsetTabular::doClearArea() const } -void InsetTabular::getSelection(int & srow, int & erow, int & scol, int & ecol) const +void InsetTabular::getSelection(int & srow, int & erow, + int & scol, int & ecol) const { - srow = tabular->row_of_cell(sel_cell_start); - erow = tabular->row_of_cell(sel_cell_end); - if (srow > erow) - swap(srow, 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) { + swap(srow, erow); + } - scol = tabular->column_of_cell(sel_cell_start); - ecol = tabular->column_of_cell(sel_cell_end); - if (scol > ecol) - swap(scol, ecol); - else - ecol = tabular->right_column_of_cell(sel_cell_end); + 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; @@ -2434,6 +2578,7 @@ Paragraph * InsetTabular::getParFromID(int id) const return 0; } + Paragraph * InsetTabular::firstParagraph() const { if (the_locking_inset) @@ -2441,6 +2586,15 @@ Paragraph * InsetTabular::firstParagraph() const 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) @@ -2455,8 +2609,8 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const return const_cast(this); Inset * result; - for(int i=0; i < tabular->rows(); ++i) { - for(int j=0; j < tabular->columns(); ++j) { + 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; } @@ -2465,37 +2619,41 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const } -string InsetTabular::selectNextWord(BufferView * bv, float & value) const +string const +InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const { + nodraw(true); if (the_locking_inset) { - string str; - str = the_locking_inset->selectNextWord(bv, value); - if (!str.empty()) + 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 str = selectNextWordInt(bv, value); + 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 str; - str = the_locking_inset->selectNextWord(bv, value); + string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value)); if (!str.empty()) return str; @@ -2507,7 +2665,7 @@ string InsetTabular::selectNextWordInt(BufferView * bv, float & value) const // 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); + inset->edit(bv); return selectNextWordInt(bv, value); } @@ -2521,6 +2679,7 @@ void InsetTabular::selectSelectedWord(BufferView * bv) return; } + void InsetTabular::toggleSelection(BufferView * bv, bool kill_selection) { if (the_locking_inset) { @@ -2530,48 +2689,79 @@ void InsetTabular::toggleSelection(BufferView * bv, bool kill_selection) bool InsetTabular::searchForward(BufferView * bv, string const & str, - bool const & cs, bool const & mw) + bool cs, bool mw) { + nodraw(true); if (the_locking_inset) { - if (the_locking_inset->searchForward(bv, str, cs, mw)) + 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; } - nodraw(true); // otherwise we have to lock the next inset and search there UpdatableInset * inset = static_cast(tabular->GetCellInset(actcell)); inset->edit(bv); - bool res = searchForward(bv, str, cs, mw); - updateLocal(bv, NONE, false); + bool const ret = searchForward(bv, str, cs, mw); nodraw(false); - bv->updateInset(const_cast(this), false); - return res; + updateLocal(bv, CELL, false); + return ret; } + bool InsetTabular::searchBackward(BufferView * bv, string const & str, - bool const & cs, bool const & mw) + bool cs, bool mw) { + nodraw(true); if (the_locking_inset) { - if (the_locking_inset->searchBackward(bv, str, cs, mw)) + 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; } - nodraw(true); // otherwise we have to lock the next inset and search there UpdatableInset * inset = static_cast(tabular->GetCellInset(actcell)); inset->edit(bv, false); - bool res = searchBackward(bv, str, cs, mw); + bool const ret = searchBackward(bv, str, cs, mw); nodraw(false); - bv->updateInset(const_cast(this), false); - return res; + 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; }