From ceeb10f1b04eaaea9a51f2ba435316638b1e6889 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=BCrgen=20Vigna?= Date: Fri, 27 Apr 2001 14:03:25 +0000 Subject: [PATCH] Reinsert the changes Lars reverted! git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@1969 a592a061-630c-0410-9148-cb99ea01b6c8 --- src/ChangeLog | 6 ++ src/insets/inset.C | 2 +- src/insets/insetcollapsable.C | 44 +++++++- src/insets/insetcollapsable.h | 11 ++ src/insets/insettabular.C | 166 ++++++++++++++++++------------ src/insets/insettabular.h | 18 +++- src/insets/insettext.C | 183 ++++++++++++++++++++++------------ src/insets/insettext.h | 26 ++++- src/insets/lyxinset.h | 26 ++++- src/tabular.C | 37 ++++--- src/tabular.h | 5 +- 11 files changed, 363 insertions(+), 161 deletions(-) diff --git a/src/ChangeLog b/src/ChangeLog index 42e7c5501b..af593e047d 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,9 @@ +2001-04-13 Juergen Vigna + + * tabular.C (GetAdditionalHeight): changed parameter from cell to row. + (LyXTabular): tried to minimize operator= operations (and realized + hopfully Lars wish). + 2001-04-27 Juergen Vigna * spellchecker.C (sc_check_word): fixed Assert to lyx::Assert. diff --git a/src/insets/inset.C b/src/insets/inset.C index 38fcb1e36d..bb97e2bc10 100644 --- a/src/insets/inset.C +++ b/src/insets/inset.C @@ -205,7 +205,7 @@ void UpdatableInset::scroll(BufferView * bv, int offset) const scx += offset; } } - // bv->updateInset(const_cast(this), false); +// bv->updateInset(const_cast(this), false); } diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C index 795ac50025..e73455ce2a 100644 --- a/src/insets/insetcollapsable.C +++ b/src/insets/insetcollapsable.C @@ -172,6 +172,9 @@ void InsetCollapsable::draw_collapsed(Painter & pain, LyXFont const &, void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, int baseline, float & x, bool cleared) const { + if (nodraw()) + return; + Painter & pain = bv->painter(); button_length = widthCollapsed; @@ -185,11 +188,27 @@ void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, return; } + float old_x = x; + +#if 0 + UpdatableInset::draw(bv, f, baseline, x, cleared); +#else + if (!owner()) + x += static_cast(scroll()); +#endif if (!cleared && (inset.need_update == InsetText::FULL || inset.need_update == InsetText::INIT || top_x != int(x) || - top_baseline != baseline)) { - int w = owner() ? width(bv, f) : pain.paperWidth(); + top_baseline != baseline)) + { +#if 1 + // we don't need anymore to clear here we just have to tell + // the underlying LyXText that it should do the RowClear! + inset.SetUpdateStatus(bv, InsetText::FULL); + bv->text->status = LyXText::CHANGED_IN_DRAW; + return; +#else + int w = owner() ? width(bv, f) : pain.paperWidth(); int h = ascent(bv, f) + descent(bv, f); int const tx = (needFullRow() && !owner()) ? 0 : int(x); int const ty = max(0, baseline - ascent(bv, f)); @@ -202,15 +221,15 @@ void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, h += (baseline - ascent(bv, f)); pain.fillRectangle(tx, ty - 1, w, h + 2); cleared = true; +#endif } top_x = int(x); top_baseline = baseline; - float dummy = x; int const bl = baseline - ascent(bv, f) + ascent_collapsed(pain, f); - draw_collapsed(pain, f, bl, dummy); + draw_collapsed(pain, f, bl, old_x); inset.draw(bv, f, bl + descent_collapsed(pain, f) + inset.ascent(bv, f), x, cleared); @@ -251,6 +270,8 @@ void InsetCollapsable::InsetUnlock(BufferView * bv) collapsed = true; } inset.InsetUnlock(bv); + if (scroll()) + scroll(bv, 0.0F); bv->updateInset(this, false); } @@ -472,3 +493,18 @@ std::vector const InsetCollapsable::getLabelList() const { return inset.getLabelList(); } + +bool InsetCollapsable::nodraw() const +{ + return inset.nodraw(); +} + +int InsetCollapsable::scroll(bool recursive) const +{ + int sx = UpdatableInset::scroll(false); + + if (recursive) + sx += inset.scroll(recursive); + + return sx; +} diff --git a/src/insets/insetcollapsable.h b/src/insets/insetcollapsable.h index 3632e6b091..5b89661942 100644 --- a/src/insets/insetcollapsable.h +++ b/src/insets/insetcollapsable.h @@ -131,6 +131,17 @@ public: void resizeLyXText(BufferView *) const; /// std::vector const getLabelList() const; + /// + bool nodraw() const; + /// + int scroll(bool recursive=true) const; + void scroll(BufferView *bv, float sx) const { + UpdatableInset::scroll(bv, sx); + } + void scroll(BufferView *bv, int offset) const { + UpdatableInset::scroll(bv, offset); + } + protected: /// int ascent_collapsed(Painter &, LyXFont const &) const; diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index 3f2afa9880..679698de1e 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -133,7 +133,6 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns) actrow = actcell = 0; clearSelection(); need_update = INIT; - no_draw = false; } @@ -147,7 +146,6 @@ InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf) actrow = actcell = 0; sel_cell_start = sel_cell_end = 0; need_update = INIT; - no_draw = false; } @@ -223,15 +221,24 @@ 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) - return; - + if (nodraw()) + return; + if (bv->text->status == LyXText::CHANGED_IN_DRAW) + return; + +// lyxerr << "InsetTabular::draw(" << need_update << ")\n"; + 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))) { int h = ascent(bv, font) + descent(bv, font); @@ -251,9 +258,6 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline, } top_x = int(x); top_baseline = baseline; - if (bv->text->status == LyXText::CHANGED_IN_DRAW) - return; - bool dodraw; x += ADD_TO_TABULAR_WIDTH; if (cleared) { int cell = 0; @@ -261,32 +265,41 @@ 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(); @@ -305,24 +318,23 @@ 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)) + // copute 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); @@ -435,12 +447,9 @@ void InsetTabular::update(BufferView * bv, LyXFont const & font, bool reinit) owner()->update(bv, font, true); 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(); - } + switch (need_update) { case INIT: case FULL: @@ -496,9 +505,9 @@ void InsetTabular::InsetUnlock(BufferView * bv) no_selection = false; oldcell = -1; locked = false; - if (scroll() || hasSelection()) { + if (scroll(false) || hasSelection()) { sel_cell_start = sel_cell_end = 0; - if (scroll()) { + if (scroll(false)) { scroll(bv, 0.0F); } UpdateLocal(bv, FULL, false); @@ -558,7 +567,10 @@ bool InsetTabular::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset, if (the_locking_inset == inset) { the_locking_inset->InsetUnlock(bv); the_locking_inset = 0; - UpdateLocal(bv, CELL, false); + if (scroll(false)) + scroll(bv, 0.0F); + else + UpdateLocal(bv, CELL, false); ShowInsetCursor(bv, false); return true; } @@ -772,7 +784,10 @@ InsetTabular::LocalDispatch(BufferView * bv, sel_cell_start = sel_cell_end = actcell; if (hs) UpdateLocal(bv, SELECTION, false); - ShowInsetCursor(bv); + if (!the_locking_inset) { + ShowInsetCursor(bv); + return DISPATCHED_NOUPDATE; + } return result; } // this to avoid compiler warnings. @@ -1031,19 +1046,19 @@ InsetTabular::LocalDispatch(BufferView * bv, result = UNDISPATCHED; if (the_locking_inset) break; - no_draw = true; + nodraw(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; + nodraw(false); the_locking_inset = 0; return UNDISPATCHED; } - no_draw = false; - the_locking_inset->ToggleInsetCursor(bv); + nodraw(false); +// the_locking_inset->ToggleInsetCursor(bv); UpdateLocal(bv, CELL, false); - the_locking_inset->ToggleInsetCursor(bv); +// the_locking_inset->ToggleInsetCursor(bv); return result; } break; @@ -1173,8 +1188,7 @@ void InsetTabular::ShowInsetCursor(BufferView * bv, bool show) int const desc = lyxfont::maxDescent(font); 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); } } @@ -1200,13 +1214,9 @@ void InsetTabular::setPos(BufferView * bv, int x, int y) const // 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))); + cursor.y(cursor.y() + tabular->GetDescentOfRow(actrow) + + tabular->GetAscentOfRow(actrow + 1) + + tabular->GetAdditionalHeight(actrow + 1)); ++actrow; ly = cursor.y() + tabular->GetDescentOfRow(actrow); } @@ -1260,10 +1270,9 @@ void InsetTabular::resetPos(BufferView * bv) const 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; } } @@ -1273,9 +1282,10 @@ void InsetTabular::resetPos(BufferView * bv) const new_x += offset; cursor.x(new_x); // cursor.x(getCellXPos(actcell) + offset); - if (scroll() && (tabular->GetWidthOfTabular() < bv->workWidth()-20)) + if (scroll(false) && (tabular->GetWidthOfTabular() < bv->workWidth()-20)) { scroll(bv, 0.0F); - else if (the_locking_inset && + 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)) @@ -1287,6 +1297,7 @@ void InsetTabular::resetPos(BufferView * bv) const xx = 60; scroll(bv, xx); } + UpdateLocal(bv, FULL, false); } else if ((cursor.x() - offset) > 20 && (cursor.x() - offset + tabular->GetWidthOfColumn(actcell)) > (bv->workWidth() - 20)) { @@ -1295,9 +1306,10 @@ void InsetTabular::resetPos(BufferView * bv) const } else if ((cursor.x() - offset) < 20) { scroll(bv, 20 - cursor.x() + offset); UpdateLocal(bv, FULL, false); - } else if (scroll() && top_x > 20 && + } else if (scroll(false) && top_x > 20 && (top_x + tabular->GetWidthOfTabular()) > (bv->workWidth() - 20)) { scroll(bv, old_x - cursor.x()); + UpdateLocal(bv, FULL, false); } if ((!the_locking_inset || !the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE)) && @@ -2293,3 +2305,31 @@ bool InsetTabular::isRightToLeft(BufferView *bv ) { return bv->getParentLanguage(this)->RightToLeft(); } + +bool InsetTabular::nodraw() const +{ + if (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)); +} +/* Emacs: + * Local variables: + * tab-width: 4 + * End: + * vi:set tabstop=4: + */ diff --git a/src/insets/insettabular.h b/src/insets/insettabular.h index 39521dbbba..ba72465347 100644 --- a/src/insets/insettabular.h +++ b/src/insets/insettabular.h @@ -101,7 +101,7 @@ public: /// void Edit(BufferView *, int x, int y, unsigned int); /// - bool doClearArea() const { return !locked; }; + bool doClearArea() const; /// void InsetUnlock(BufferView *); /// @@ -178,6 +178,20 @@ public: LyXFunc::func_status getStatus(string const & argument) const; /// std::vector const getLabelList() const; + /// + void nodraw(bool b) { + UpdatableInset::nodraw(b); + } + bool nodraw() const; + /// + int scroll(bool recursive=true) const; + void scroll(BufferView *bv, float sx) const { + UpdatableInset::scroll(bv, sx); + } + void scroll(BufferView *bv, int offset) const { + UpdatableInset::scroll(bv, offset); + } + // // Public structures and variables /// @@ -283,8 +297,6 @@ private: /// bool no_selection; /// - bool no_draw; - /// mutable bool locked; /// mutable UpdateCodes need_update; diff --git a/src/insets/insettext.C b/src/insets/insettext.C index 6107391f1f..b693257621 100644 --- a/src/insets/insettext.C +++ b/src/insets/insettext.C @@ -47,6 +47,7 @@ #include "lyxscreen.h" #include "WorkArea.h" #include "gettext.h" +#include "lyxfunc.h" using std::ostream; using std::ifstream; @@ -97,18 +98,19 @@ void InsetText::init(InsetText const * ins) drawTextXOffset = 0; drawTextYOffset = 0; autoBreakRows = false; - drawFrame = NEVER; + drawFrame_ = NEVER; xpos = 0.0; if (ins) { - SetParagraphData(ins->par); - autoBreakRows = ins->autoBreakRows; - drawFrame = ins->drawFrame; + SetParagraphData(ins->par); + autoBreakRows = ins->autoBreakRows; + drawFrame_ = ins->drawFrame_; } par->SetInsetOwner(this); frame_color = LColor::insetframe; locked = false; old_par = 0; last_drawn_width = -1; + frame_is_visible = false; } @@ -297,26 +299,29 @@ int InsetText::textWidth(BufferView * bv) const void InsetText::draw(BufferView * bv, LyXFont const & f, int baseline, float & x, bool cleared) const { + if (nodraw()) + return; + Painter & pain = bv->painter(); // no draw is necessary !!! - if ((drawFrame == LOCKED) && !locked && !par->size()) { - if (!cleared && (need_update & CLEAR_FRAME)) { - pain.rectangle(top_x + 1, baseline - insetAscent + 1, - width(bv, f) - 1, - insetAscent + insetDescent - 1, - LColor::background); - } - top_x = int(x); - top_baseline = baseline; - x += width(bv, f); - need_update = NONE; - return; + if ((drawFrame_ == LOCKED) && !locked && !par->size()) { + top_x = int(x); + top_baseline = baseline; + x += width(bv, f); + if (!cleared && (need_update & CLEAR_FRAME)) + clearFrame(pain, cleared); + need_update = NONE; + return; } xpos = x; +#if 0 UpdatableInset::draw(bv, f, baseline, x, cleared); - +#else + if (!owner()) + x += static_cast(scroll()); +#endif // update insetWidth and insetHeight with dummy calls (void)ascent(bv, f); (void)descent(bv, f); @@ -324,8 +329,9 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, // if top_x differs we have a rule down and we don't have to clear anything if (!cleared && (top_x == int(x)) && - ((need_update == INIT) || (need_update == FULL) || (top_baseline != baseline) || - (last_drawn_width!=insetWidth))) { + ((need_update&(INIT|FULL)) || (top_baseline!=baseline) || + (last_drawn_width!=insetWidth))) + { int w = insetWidth; int h = insetAscent + insetDescent; int ty = baseline - insetAscent; @@ -346,11 +352,14 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, return; if (top_x != int(x)) { - need_update = INIT; + need_update |= INIT; top_x = int(x); bv->text->status = LyXText::CHANGED_IN_DRAW; return; } + +// lyxerr << "InsetText::draw[" << this << "](" << need_update << ":" << int(x) << ":" << top_x << ")\n"; + if (cleared || (last_drawn_width != insetWidth)) { need_update |= FULL; last_drawn_width = insetWidth; @@ -366,6 +375,7 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, inset_y = cy(bv) + drawTextYOffset; } if (!cleared && (need_update == CURSOR) && !TEXT(bv)->selection) { + drawFrame(pain, cleared); x += width(bv, f); need_update = NONE; return; @@ -392,7 +402,7 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, if (y_offset < 0) y_offset = y; TEXT(bv)->first = first; - if (cleared) { // (need_update&FULL) || (need_update&INIT) + if (cleared) { int yf = y_offset; y = 0; while ((row != 0) && (yf < ph)) { @@ -425,30 +435,46 @@ void InsetText::draw(BufferView * bv, LyXFont const & f, TEXT(bv)->refresh_y = 0; TEXT(bv)->status = LyXText::UNCHANGED; if ((need_update != CURSOR_PAR) && - ((drawFrame == ALWAYS) || ((drawFrame == LOCKED) && locked))) - { - pain.rectangle(top_x + 1, baseline - insetAscent + 1, - width(bv, f) - 1, - insetAscent + insetDescent - 1, - frame_color); - } else if (need_update & CLEAR_FRAME) { - pain.rectangle(top_x + 1, baseline - insetAscent + 1, - width(bv, f) - 1, - insetAscent + insetDescent - 1, - LColor::background); - } + ((drawFrame_ == ALWAYS) || ((drawFrame_ == LOCKED) && locked))) + drawFrame(pain, cleared); + else if (need_update & CLEAR_FRAME) + clearFrame(pain, cleared); x += width(bv, f) - TEXT_TO_INSET_OFFSET; if (bv->text->status==LyXText::CHANGED_IN_DRAW) { - need_update = INIT; + need_update |= INIT; } else if (need_update != INIT) need_update = NONE; } +void InsetText::drawFrame(Painter & pain, bool cleared) const +{ + if (!frame_is_visible || cleared) { + pain.rectangle(top_x + 1, top_baseline - insetAscent + 1, + insetWidth - 1, insetAscent + insetDescent - 1, + frame_color); + frame_is_visible = true; + } +} + + +void InsetText::clearFrame(Painter & pain, bool cleared) const +{ + if (frame_is_visible) { + if (!cleared) { + pain.rectangle(top_x + 1, top_baseline - insetAscent + 1, + insetWidth - 1, insetAscent + insetDescent - 1, + LColor::background); + } + frame_is_visible = false; + } +} + + void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit) { - if (reinit) { // && (need_update != CURSOR)) { - need_update = INIT; + if (reinit) { + need_update |= INIT; resizeLyXText(bv); if (owner()) owner()->update(bv, font, true); @@ -459,47 +485,39 @@ void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit) inset_y = cy(bv) + drawTextYOffset; the_locking_inset->update(bv, font, reinit); } +#if 0 if (need_update == INIT) { resizeLyXText(bv); - need_update = FULL; + need_update |= FULL; } - int oldw = insetWidth; -#if 1 - insetWidth = TEXT(bv)->width + (2 * TEXT_TO_INSET_OFFSET); - // max(textWidth(bv->painter()), - // static_cast(TEXT(bv)->width) + drawTextXOffset) + - // (2 * TEXT_TO_INSET_OFFSET); -#else - insetWidth = textWidth(bv); - if (insetWidth < 0) - insetWidth = static_cast(TEXT(bv)->width); #endif + int oldw = insetWidth; + insetWidth = TEXT(bv)->width + (2 * TEXT_TO_INSET_OFFSET); if (oldw != insetWidth) { -// printf("TW(%p): %d-%d-%d-%d\n",this,insetWidth, oldw, -// textWidth(bv->painter()),static_cast(TEXT(bv)->width)); resizeLyXText(bv); - need_update = FULL; - update(bv, font, reinit); + need_update |= FULL; +// update(bv, font, reinit); return; } - if ((need_update == CURSOR_PAR) && (TEXT(bv)->status == LyXText::UNCHANGED) && + if ((need_update&CURSOR_PAR) && (TEXT(bv)->status==LyXText::UNCHANGED) && the_locking_inset) { TEXT(bv)->UpdateInset(bv, the_locking_inset); } if (TEXT(bv)->status == LyXText::NEED_MORE_REFRESH) - need_update = FULL; - + need_update |= FULL; +#if 0 int y_temp = 0; Row * row = TEXT(bv)->GetRowNearY(y_temp); insetAscent = row->ascent_of_text() + TEXT_TO_INSET_OFFSET; insetDescent = TEXT(bv)->height - row->ascent_of_text() + TEXT_TO_INSET_OFFSET; +#endif } -void InsetText::SetUpdateStatus(BufferView * bv, int what) +void InsetText::SetUpdateStatus(BufferView * bv, int what) const { need_update |= what; if (TEXT(bv)->status == LyXText::NEED_MORE_REFRESH) @@ -556,7 +574,7 @@ void InsetText::Edit(BufferView * bv, int x, int y, unsigned int button) TEXT(bv)->sel_cursor = TEXT(bv)->cursor; bv->text->FinishUndo(); ShowInsetCursor(bv); - UpdateLocal(bv, FULL, false); + UpdateLocal(bv, CURSOR, false); // If the inset is empty set the language of the current font to the // language to the surronding text. @@ -642,7 +660,10 @@ bool InsetText::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset, if (lr) moveRight(bv, false); old_par = 0; // force layout setting - UpdateLocal(bv, CURSOR_PAR, false); + if (scroll()) + scroll(bv, 0.0F); + else + UpdateLocal(bv, CURSOR, false); return true; } return the_locking_inset->UnlockInsetInInset(bv, inset, lr); @@ -1078,8 +1099,8 @@ InsetText::LocalDispatch(BufferView * bv, // and current buffer's textclass (number). */ LyXTextClassList::ClassList::size_type tclass = bv->buffer()->params.textclass; - std::pair layout = - textclasslist.NumberOfLayout(tclass, arg); + std::pair layout = + textclasslist.NumberOfLayout(tclass, arg); // If the entry is obsolete, use the new one instead. if (layout.first) { @@ -1092,7 +1113,7 @@ InsetText::LocalDispatch(BufferView * bv, // see if we found the layout number: if (!layout.first) { string const msg = string(N_("Layout ")) + arg + N_(" not known"); - bv->owner()->message(msg); + bv->owner()->getLyXFunc()->Dispatch(LFUN_MESSAGE, msg); break; } @@ -1515,7 +1536,7 @@ bool InsetText::checkAndActivateInset(BufferView * bv, bool behind) inset->Edit(bv, x, y, 0); if (!the_locking_inset) return false; - UpdateLocal(bv, CURSOR_PAR, false); + UpdateLocal(bv, CURSOR, false); return true; } return false; @@ -1525,8 +1546,10 @@ bool InsetText::checkAndActivateInset(BufferView * bv, bool behind) bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y, int button) { - int dummyx = x = x - drawTextXOffset; - int dummyy = y + insetAscent; + int dummyx, dummyy; + + dummyx = x = x - drawTextXOffset; + dummyy = y + insetAscent; Inset * inset = bv->checkInsetHit(TEXT(bv), dummyx, dummyy, button); if (inset) { @@ -1539,7 +1562,7 @@ bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y, inset->Edit(bv, x - inset_x, y - inset_y, button); if (!the_locking_inset) return false; - UpdateLocal(bv, CURSOR_PAR, false); + UpdateLocal(bv, CURSOR, false); return true; } return false; @@ -1636,8 +1659,8 @@ void InsetText::SetAutoBreakRows(bool flag) void InsetText::SetDrawFrame(BufferView * bv, DrawFrame how) { - if (how != drawFrame) { - drawFrame = how; + if (how != drawFrame_) { + drawFrame_ = how; if (bv) UpdateLocal(bv, DRAW_FRAME, false); } @@ -1840,3 +1863,31 @@ void InsetText::removeNewlines() } } } + +bool InsetText::nodraw() const +{ + if (the_locking_inset) + return the_locking_inset->nodraw(); + return UpdatableInset::nodraw(); +} + +int InsetText::scroll(bool recursive) const +{ + int sx = UpdatableInset::scroll(false); + + if (recursive && the_locking_inset) + sx += the_locking_inset->scroll(recursive); + + return sx; +} + +bool InsetText::doClearArea() const +{ + return !locked || (need_update & (FULL|INIT)); +} +/* Emacs: + * Local variables: + * tab-width: 4 + * End: + * vi:set tabstop=4: + */ diff --git a/src/insets/insettext.h b/src/insets/insettext.h index a473e81628..4d2c08985d 100644 --- a/src/insets/insettext.h +++ b/src/insets/insettext.h @@ -99,7 +99,7 @@ public: /// void update(BufferView *, LyXFont const &, bool =false); /// - void SetUpdateStatus(BufferView *, int what); + void SetUpdateStatus(BufferView *, int what) const; /// string const EditMessage() const; /// @@ -107,7 +107,7 @@ public: /// bool IsTextInset() const { return true; } /// - bool doClearArea() const { return !locked; } + bool doClearArea() const; /// void InsetUnlock(BufferView *); /// @@ -180,6 +180,16 @@ public: /// std::vector const getLabelList() const; /// + bool nodraw() const; + /// + int scroll(bool recursive=true) const; + void scroll(BufferView *bv, float sx) const { + UpdatableInset::scroll(bv, sx); + } + void scroll(BufferView *bv, int offset) const { + UpdatableInset::scroll(bv, offset); + } + LyXParagraph * par; /// mutable int need_update; @@ -194,7 +204,7 @@ protected: /// bool autoBreakRows; /// - DrawFrame drawFrame; + DrawFrame drawFrame_; /// LColor::color frame_color; @@ -237,8 +247,8 @@ private: /// bool checkAndActivateInset(BufferView * bv, int x = 0, int y = 0, int button = 0); + /// void removeNewlines(); - /// int cx(BufferView *) const; /// @@ -251,11 +261,15 @@ private: bool cboundary(BufferView *) const; /// Row * crow(BufferView *) const; - + /// /// This instead of a macro LyXText * TEXT(BufferView * bv) const { return getLyXText(bv); } + /// + void drawFrame(Painter &, bool cleared) const; + void clearFrame(Painter &, bool cleared) const; + /// /* Private structures and variables */ /// @@ -296,5 +310,7 @@ private: mutable Cache cache; /// mutable int last_drawn_width; + /// + mutable bool frame_is_visible; }; #endif diff --git a/src/insets/lyxinset.h b/src/insets/lyxinset.h index eea2d76d9e..ba83658890 100644 --- a/src/insets/lyxinset.h +++ b/src/insets/lyxinset.h @@ -234,7 +234,12 @@ public: /// virtual void resizeLyXText(BufferView *) const {} /// returns the actuall scroll-value - int scroll() const { return scx; } + virtual int scroll(bool recursive=true) const { + if (!recursive || !owner_) + return scx; + return 0; + } + protected: /// mutable int top_x; @@ -304,7 +309,8 @@ public: } /// - UpdatableInset() : cursor_visible_(false) {} + UpdatableInset() : cursor_visible_(false), block_drawing_(false) {} + /// virtual EDITABLE Editable() const; @@ -363,12 +369,21 @@ public: /// virtual int getMaxWidth(BufferView * bv, UpdatableInset const *) const; /// - int scroll() const { + int scroll(bool recursive=true) const { // We need this method to not clobber the real method in Inset - return Inset::scroll(); + return Inset::scroll(recursive); } /// virtual bool ShowInsetDialog(BufferView *) const { return false; } + /// + virtual void nodraw(bool b) { + block_drawing_ = b; + } + /// + virtual bool nodraw() const { + return block_drawing_; + } + protected: /// void toggleCursorVisible() const { @@ -382,8 +397,11 @@ protected: void scroll(BufferView *, float sx) const; /// scrolls offset pixels void scroll(BufferView *, int offset) const; + private: /// mutable bool cursor_visible_; + /// + bool block_drawing_; }; #endif diff --git a/src/tabular.C b/src/tabular.C index d7aadbd6bf..f0c61ed8b8 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -96,11 +96,13 @@ LyXTabular::LyXTabular(InsetTabular * inset, int rows_arg, int columns_arg) LyXTabular::LyXTabular(InsetTabular * inset, LyXTabular const & lt) { owner_ = inset; - Init(lt.rows_, lt.columns_); + Init(lt.rows_, lt.columns_, <); +#if 0 #ifdef WITH_WARNINGS #warning Jürgen, can you make it the other way round. So that copy assignment depends on the copy constructor and not the other way. (Lgb) #endif operator=(lt); +#endif } @@ -140,6 +142,7 @@ LyXTabular & LyXTabular::operator=(LyXTabular const & lt) LyXTabular * LyXTabular::Clone(InsetTabular * inset) { LyXTabular * result = new LyXTabular(inset, *this); +#if 0 // don't know if this is good but I need to Clone also // the text-insets here, this is for the Undo-facility! for (int i = 0; i < rows_; ++i) { @@ -148,12 +151,13 @@ LyXTabular * LyXTabular::Clone(InsetTabular * inset) result->cell_info[i][j].inset.setOwner(inset); } } +#endif return result; } -/* activates all lines and sets all widths to 0 */ -void LyXTabular::Init(int rows_arg, int columns_arg) +/* activates all lines and sets all widths to 0 */ +void LyXTabular::Init(int rows_arg, int columns_arg, LyXTabular const * lt) { rows_ = rows_arg; columns_ = columns_arg; @@ -161,6 +165,11 @@ void LyXTabular::Init(int rows_arg, int columns_arg) column_info = column_vector(columns_, columnstruct()); cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct())); + if (lt) { + operator=(*lt); + return; + } + int cellno = 0; for (int i = 0; i < rows_; ++i) { for (int j = 0; j < columns_; ++j) { @@ -428,10 +437,8 @@ bool LyXTabular::RightLine(int cell, bool onlycolumn) const bool LyXTabular::TopAlreadyDrawed(int cell) const { - if (GetAdditionalHeight(cell)) - return false; int row = row_of_cell(cell); - if (row > 0) { + if ((row > 0) && !GetAdditionalHeight(row)) { int column = column_of_cell(cell); --row; while (column @@ -469,11 +476,11 @@ bool LyXTabular::IsLastRow(int cell) const } -int LyXTabular::GetAdditionalHeight(int cell) const +int LyXTabular::GetAdditionalHeight(int row) const { - int const row = row_of_cell(cell); - if (!row) return 0; - + if (!row || row >= rows_) + return 0; + bool top = true; bool bottom = true; @@ -668,7 +675,7 @@ bool LyXTabular::SetMColumnPWidth(int cell, string const & width) bool LyXTabular::SetAlignSpecial(int cell, string const & special, - LyXTabular::Feature what) + LyXTabular::Feature what) { if (what == SET_SPECIAL_MULTI) cellinfo_of_cell(cell)->align_special = special; @@ -1881,7 +1888,7 @@ int LyXTabular::GetHeightOfTabular() const for (int row = 0; row < rows_; ++row) height += GetAscentOfRow(row) + GetDescentOfRow(row) + - GetAdditionalHeight(GetCellNumber(row, 0)); + GetAdditionalHeight(row); return height; } @@ -2585,3 +2592,9 @@ LyXTabular::BoxType LyXTabular::UseParbox(int cell) const return BOX_NONE; } #endif +/* Emacs: + * Local variables: + * tab-width: 4 + * End: + * vi:set tabstop=4: + */ diff --git a/src/tabular.h b/src/tabular.h index 4910024086..4ca7fdf940 100644 --- a/src/tabular.h +++ b/src/tabular.h @@ -182,8 +182,7 @@ public: bool IsLastRow(int cell) const; /// - int GetAdditionalHeight(int cell) const; - + int GetAdditionalHeight(int row) const; /// int GetAdditionalWidth(int cell) const; @@ -493,7 +492,7 @@ private: InsetTabular * owner_; /// - void Init(int columns_arg, int rows_arg); + void Init(int columns_arg, int rows_arg, LyXTabular const * lt = 0); /// void Reinit(); ///