X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=d21030ee98d11ebc7413c5f57dcac73490420171;hb=4a5b7a5952ad2381fcdf4830511293e184c7c5a1;hp=6e68763d7d0ce0c7a157d146bf3ee0e8b008d6ff;hpb=9987ffaee8932c18807af7f6ce076eb57f0a54cf;p=lyx.git diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index 6e68763d7d..d21030ee98 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -48,6 +48,8 @@ #include //#include + +using std::vector; using std::ostream; using std::ifstream; using std::max; @@ -138,6 +140,7 @@ 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; + old_locking_inset = 0; locked = false; oldcell = -1; actrow = actcell = 0; @@ -145,6 +148,8 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns) need_update = INIT; in_update = false; in_reset_pos = false; + inset_x = 0; + inset_y = 0; } @@ -154,6 +159,7 @@ InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf, { tabular.reset(new LyXTabular(this, *(tab.tabular), same_id)); the_locking_inset = 0; + old_locking_inset = 0; locked = false; oldcell = -1; actrow = actcell = 0; @@ -161,6 +167,8 @@ InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf, need_update = INIT; in_update = false; in_reset_pos = false; + inset_x = 0; + inset_y = 0; } @@ -362,40 +370,57 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, float dx = nx + tabular->GetBeginningOfTextInCell(cell); float cx = dx; 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 (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 - pain.fillRectangle( - nx + 1, - baseline + the_locking_inset->descent(bv, font) + 1, - tabular->GetWidthOfColumn(cell) - - tabular->GetAdditionalWidth(cell) - 1, - tabular->GetAscentOfRow(i) + - tabular->GetDescentOfRow(i) - - the_locking_inset->ascent(bv, font) - - the_locking_inset->descent(bv, font) - - TEXT_TO_INSET_OFFSET - 1, - backgroundColor()); + 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); @@ -595,9 +620,11 @@ void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what, } if (need_update < what) // only set this if it has greater update need_update = what; +#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); @@ -633,9 +660,7 @@ bool InsetTabular::lockInsetInInset(BufferView * bv, UpdatableInset * inset) } if (in->getInsetFromID(id)) { actcell = i; - the_locking_inset = in; - locked = true; - resetPos(bv); + in->edit(bv); return the_locking_inset->lockInsetInInset(bv, inset); } } @@ -699,7 +724,6 @@ unsigned int InsetTabular::insetInInsetY() { if (!the_locking_inset) return 0; - return inset_y + the_locking_inset->insetInInsetY(); } @@ -791,7 +815,8 @@ bool InsetTabular::insetButtonRelease(BufferView * bv, { bool ret = false; if (the_locking_inset) - ret = the_locking_inset->insetButtonRelease(bv, x, y, button); + ret = the_locking_inset->insetButtonRelease(bv, x - inset_x, + y - inset_y, button); if (button == 3 && !ret) { bv->owner()->getDialogs()->showTabular(this); return true; @@ -961,14 +986,16 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action, int const ocell = actcell; // if we are starting a selection, only select // the current cell at the beginning - if (hasSelection()) { + 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); } - 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)); updateLocal(bv, SELECTION, false); } break; @@ -986,12 +1013,14 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action, // 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); } - 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)); updateLocal(bv, SELECTION, false); } break; @@ -1053,6 +1082,10 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action, 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); @@ -1091,7 +1124,7 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action, while (p < len && ((p = clip.find_first_of("\t\n", p)) != string::npos)) { - switch(clip[p]) { + switch (clip[p]) { case '\t': ++cols; break; @@ -1115,7 +1148,7 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action, (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; @@ -1206,7 +1239,12 @@ int InsetTabular::ascii(Buffer const * buf, ostream & os, int ll) const int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const { - return tabular->ascii(buf,os, (int)parOwner()->params().depth(), false, 0); + os << "ascii(buf,os, + (int)parOwner()->params().depth(), + false, 0); + os << "]]>"; + return ret; } @@ -1301,6 +1339,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; @@ -1321,6 +1364,8 @@ void InsetTabular::toggleInsetCursor(BufferView * bv) void InsetTabular::showInsetCursor(BufferView * bv, bool show) { + if (nodraw()) + return; if (!isCursorVisible()) { LyXFont font; // = GetFont(par, cursor.pos); @@ -1402,17 +1447,13 @@ int InsetTabular::getCellXPos(int cell) const void InsetTabular::resetPos(BufferView * bv) const { - if (!locked || nodraw()) - return; #warning This should be fixed in the right manner (20011128 Jug) // fast hack to fix infinite repaintings! if (in_reset_pos) return; - in_reset_pos = true; - - 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) { @@ -1423,6 +1464,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(); @@ -2079,37 +2127,18 @@ int InsetTabular::getMaxWidthOfCell(BufferView * bv, int cell) const if (len.zero()) return -1; -#ifdef WITH_WARNINGS -#warning Remove use of VSpace as soon as LyXLength::inPixels exists (JMarc) -#endif - return VSpace(len).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[Debug::INSETTEXT] << "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; } @@ -2185,16 +2214,13 @@ void InsetTabular::openLayoutDialog(BufferView * bv) const // -// 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) { @@ -2206,9 +2232,11 @@ 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; @@ -2228,8 +2256,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: @@ -2237,176 +2264,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(sel_row_start, dummyltt)) - 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(sel_row_start, dummyltt)) - 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(sel_row_start, dummyltt)) - 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(sel_row_start, dummyltt)) - 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(sel_row_start)) - 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(); } @@ -2522,7 +2480,7 @@ bool InsetTabular::cutSelection() } -bool InsetTabular::isRightToLeft(BufferView *bv ) +bool InsetTabular::isRightToLeft(BufferView * bv) { return bv->getParentLanguage(this)->RightToLeft(); } @@ -2631,17 +2589,20 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const 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()) + if (!str.empty()) { + nodraw(false); return str; + } if (tabular->IsLastCell(actcell)) { bv->unlockInset(const_cast(this)); + nodraw(false); return string(); } ++actcell; } - nodraw(true); // otherwise we have to lock the next inset and ask for it's selecttion UpdatableInset * inset = static_cast(tabular->GetCellInset(actcell)); @@ -2695,12 +2656,17 @@ 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; } @@ -2710,24 +2676,25 @@ bool InsetTabular::searchForward(BufferView * bv, string const & str, UpdatableInset * inset = static_cast(tabular->GetCellInset(actcell)); inset->edit(bv); -#if 0 - bool const res = searchForward(bv, str, cs, mw); - updateLocal(bv, NONE, false); - bv->updateInset(const_cast(this), false); - return res; -#else - return searchForward(bv, str, cs, mw); -#endif + 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 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; } @@ -2737,13 +2704,10 @@ bool InsetTabular::searchBackward(BufferView * bv, string const & str, UpdatableInset * inset = static_cast(tabular->GetCellInset(actcell)); inset->edit(bv, false); -#if 0 - bool const res = searchBackward(bv, str, cs, mw); - bv->updateInset(const_cast(this), false); - return res; -#else - return searchBackward(bv, str, cs, mw); -#endif + bool const ret = searchBackward(bv, str, cs, mw); + nodraw(false); + updateLocal(bv, CELL, false); + return ret; } @@ -2753,3 +2717,18 @@ bool InsetTabular::insetAllowed(Inset::Code code) const 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; +}