Fixed some redraw problems in InsetText/Tabular/Collapsable. Fixed problems

regarding automatic scrolling of Tabulars (still something wrong). Broken
MousePointer inside InsetText&co (hopefully easy to fix), but I still commit
so that people can have a look at it. It also should enhance speed of redraw
and minimize redraws (still some optimization possible).

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@1915 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/ChangeLog b/src/ChangeLog
index f0110ec73d7b8af96b465eeeacfb91ccee322f1b..6243069b669c400677bc76c20a3b9755e320b92f 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,9 @@
+2001-04-13  Juergen Vigna  <jug@sad.it>
+
+       * tabular.C (GetAdditionalHeight): changed parameter from cell to row.
+       (LyXTabular): tried to minimize operator= operations (and realized
+       hopfully Lars wish).
+
 2001-04-12  Dekel Tsur  <dekelts@tau.ac.il>
 
        * LaTeX.C (deplog): Always check that foundfile exists.

diff --git a/src/insets/ChangeLog b/src/insets/ChangeLog
index e16422c244f5b53ac958763e67a97696d395107d..86c9d14677bcf0ec43cb87abe35ebafed1ad1580 100644 (file)
--- a/src/insets/ChangeLog
+++ b/src/insets/ChangeLog
@@ -1,3 +1,18 @@
+2001-04-13  Juergen Vigna  <jug@sad.it>
+
+       * insettext.C: tried to avoid unneeded redraws.
+       (doClearArea): return true also if I need a FULL|INIT redraw.
+
+       * insettabular.C: tried to avoid unneeded redraws. Still one
+       problem with scrolling remains (resetPos).
+       (doClearArea): return true also if I need a FULL|INIT redraw.
+
+       * lyxinset.h: changed the scroll() function behaviour a bit.
+       Added nodraw() function so that I can block unneeded redraws.
+       Implemented the above 2 functions correctly in InsetText,
+       InsetTabular and InsetCollapsable. Now only the topmost Inset
+       owner is scrolled (as it should be) if a child inset requests this!
+
 2001-04-06  John Levon  <moz@compsoc.man.ac.uk>
 
        * insetexternal.h:

diff --git a/src/insets/inset.C b/src/insets/inset.C
index bae82b6f9c130d8345b7fea29754c3323826f386..344921e62066846892e38c00f628c71f9c8e1c27 100644 (file)
--- a/src/insets/inset.C
+++ b/src/insets/inset.C
@@ -152,7 +152,6 @@ void UpdatableInset::draw(BufferView *, LyXFont const &,
 void UpdatableInset::SetFont(BufferView *, LyXFont const &, bool )
 {}
 
-
 void UpdatableInset::scroll(BufferView * bv, float s) const
 {
        LyXFont font;
@@ -181,7 +180,8 @@ void UpdatableInset::scroll(BufferView * bv, float s) const
        if ((tmp_top_x + scx + width(bv, font)) < (workW / 2)) {
                scx += (workW / 2) - (tmp_top_x + scx + width(bv, font));
        }
-       // bv->updateInset(const_cast<UpdatableInset *>(this), false);
+       
+//     bv->updateInset(const_cast<UpdatableInset *>(this), false);
 }
 
 void UpdatableInset::scroll(BufferView * bv, int offset) const
@@ -204,7 +204,7 @@ void UpdatableInset::scroll(BufferView * bv, int offset) const
                        scx += offset;
                }
        }
-       // bv->updateInset(const_cast<UpdatableInset *>(this), false);
+//     bv->updateInset(const_cast<UpdatableInset *>(this), false);
 }
 
 

diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C
index 6a3643c4f3bcc0b2c932119a4e336d6d0d676586..ba3b72318cf0becac025cdf2bddcd57fbdfa7ee5 100644 (file)
--- a/src/insets/insetcollapsable.C
+++ b/src/insets/insetcollapsable.C
@@ -169,9 +169,12 @@ void InsetCollapsable::draw_collapsed(Painter & pain, LyXFont const &,
 }
 
 
-void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, 
-                           int baseline, float & x, bool cleared) 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,10 +188,26 @@ 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 += (float)scroll();
+#endif
        if (!cleared && (inset.need_update == InsetText::FULL ||
                         inset.need_update == InsetText::INIT ||
                         top_x != int(x) ||
-                        top_baseline != baseline)) {
+                        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);
@@ -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);
 }
 
@@ -381,7 +402,8 @@ bool InsetCollapsable::UnlockInsetInInset(BufferView * bv, UpdatableInset * in,
                bv->unlockInset(this);
                return true;
        }
-       return inset.UnlockInsetInInset(bv, in, lr);
+       bool ret = inset.UnlockInsetInInset(bv, in, lr);
+       return ret;
 }
 
 
@@ -472,3 +494,18 @@ std::vector<string> 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 3632e6b09122f8be0b8a2903526be155340da797..5b89661942708c4becd8c7732c131fd2a729fed1 100644 (file)
--- a/src/insets/insetcollapsable.h
+++ b/src/insets/insetcollapsable.h
@@ -131,6 +131,17 @@ public:
        void resizeLyXText(BufferView *) const;
        ///
        std::vector<string> 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 b3436ed22f22194f43b4fc369353e8d72f0dfba9..752e0d8565d2430c8d5a308930257dbab41df786 100644 (file)
--- a/src/insets/insettabular.C
+++ b/src/insets/insettabular.C
@@ -139,7 +139,6 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
        actrow = actcell = 0;
        clearSelection();
        need_update = INIT;
-       no_draw = false;
 }
 
 
@@ -157,7 +156,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;
 }
 
 
@@ -233,15 +231,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)
+       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 += (float)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);
@@ -261,9 +268,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;
@@ -271,32 +275,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))<pain.paperHeight();
+                       cell = tabular->GetCellNumber(i, 0);
+                       if (!((baseline + tabular->GetDescentOfRow(i)) > 0) &&
+                               (baseline - tabular->GetAscentOfRow(i))<pain.paperHeight())
+                       {
+                               baseline += tabular->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();
@@ -315,24 +328,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);
@@ -445,12 +457,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:
@@ -506,9 +515,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);
@@ -568,7 +577,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;
        }
@@ -782,7 +794,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.
@@ -1041,19 +1056,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;
@@ -1183,8 +1198,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);
        }
 }
@@ -1210,13 +1224,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);
        }
@@ -1268,10 +1278,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;
                }
        }
@@ -1281,9 +1290,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))
@@ -1295,6 +1305,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)) {
@@ -1303,9 +1314,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)) &&
@@ -2301,3 +2313,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 39521dbbbaa6d3a61776df2d100e7e834699361d..ba72465347d888035e94748d4bc635afc9f47c52 100644 (file)
--- 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<string> 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 c8060e5dea7d398013201dfed65a76dd975ad9c0..33ffcfa753f1de780fe19a34ed1e2dc1d2670c78 100644 (file)
--- a/src/insets/insettext.C
+++ b/src/insets/insettext.C
@@ -100,18 +100,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;
 }
 
 
@@ -298,28 +299,31 @@ int InsetText::textWidth(BufferView * bv) const
 
 
 void InsetText::draw(BufferView * bv, LyXFont const & f,
-                        int baseline, float & x, bool cleared) const
+                     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);
-               }
+       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 += (float)scroll();
+#endif
        // update insetWidth and insetHeight with dummy calls
        (void)ascent(bv, f);
        (void)descent(bv, f);
@@ -327,8 +331,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;
@@ -349,11 +354,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;
@@ -369,6 +377,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;
@@ -376,6 +385,7 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
        x += TEXT_TO_INSET_OFFSET;
 
 #warning Jürgen, why is this a block of its own? (Lgb)
+#warning because you told me to define variables only in local contest (Jug)!
        {
        int y = 0;
        Row * row = TEXT(bv)->GetRowNearY(y);
@@ -391,7 +401,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)) {
@@ -424,30 +434,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);
@@ -458,47 +484,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;
        }
+#endif
        int oldw = insetWidth;
-#if 1
        insetWidth = TEXT(bv)->width + (2 * TEXT_TO_INSET_OFFSET);
-       // max(textWidth(bv->painter()),
-       // static_cast<int>(TEXT(bv)->width) + drawTextXOffset) +
-       // (2 * TEXT_TO_INSET_OFFSET);
-#else
-       insetWidth = textWidth(bv);
-       if (insetWidth < 0)
-               insetWidth = static_cast<int>(TEXT(bv)->width);
-#endif
        if (oldw != insetWidth) {
-//         printf("TW(%p): %d-%d-%d-%d\n",this,insetWidth, oldw,
-//                textWidth(bv->painter()),static_cast<int>(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)
@@ -554,7 +572,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.
@@ -640,7 +658,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);
@@ -1514,7 +1535,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;
@@ -1540,7 +1561,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;
@@ -1637,8 +1658,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);
        }
@@ -1841,3 +1862,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 a473e816287eaddf69e396af0a598046c50e52ee..4d2c08985d4c060b58a36f2d92e085ca47be1443 100644 (file)
--- 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<string> 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 e47c9b47b1ad6c90f336b7b1a1d8e39e35bfc31f..daad04e8e402bfe2176796545e71cad30a0c1637 100644 (file)
--- 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;
@@ -305,7 +310,7 @@ public:
 
 
        ///
-       UpdatableInset() : cursor_visible_(false) {}
+       UpdatableInset() : cursor_visible_(false), block_drawing_(false) {}
 
        ///
        virtual EDITABLE Editable() const;
@@ -365,12 +370,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 {
@@ -384,8 +398,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/lyxfunc.C b/src/lyxfunc.C
index d1843badfca188e7d5dc1efe9cb21cbf4ac48ae9..c31da43748e3c64d1e4ad2194cd0d3768a58e167 100644 (file)
--- a/src/lyxfunc.C
+++ b/src/lyxfunc.C
@@ -550,7 +550,7 @@ string const LyXFunc::Dispatch(int ac,
        }
     
        selection_possible = false;
-       
+
        if (owner->view()->available())
                owner->view()->hideCursor();
 

diff --git a/src/lyxrc.h b/src/lyxrc.h
index 5b0882b51e18d26016ce673d7c6889bdca03ba6a..941e6ce2cf9f29f85877fb46c43c10704f0d5686 100644 (file)
--- a/src/lyxrc.h
+++ b/src/lyxrc.h
@@ -187,8 +187,8 @@ enum LyXRCTags {
        string ps_command;
        /// option for telling the dvi viewer about the paper size
        string view_dvi_paper_option;
-        /// default paper size for local xdvi/dvips/ghostview/whatever
-        BufferParams::PAPER_SIZE default_papersize;
+       /// default paper size for local xdvi/dvips/ghostview/whatever
+       BufferParams::PAPER_SIZE default_papersize;
        /// command to run chktex incl. options
        string chktex_command;
        ///

diff --git a/src/tabular.C b/src/tabular.C
index 483670419cfe7db217d48ba785348037dff1885e..bc3a9264a835d66da556d4d6622fd51a84112717 100644 (file)
--- 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_, &lt);
+#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)
+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,10 +476,10 @@ 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 a04e70714ab1ecbcacfcec891b7040ba91d2affc..8f4c08ec63cb1762591619c83b9c8a78a23ee5cc 100644 (file)
--- a/src/tabular.h
+++ b/src/tabular.h
@@ -182,7 +182,7 @@ public:
        bool IsLastRow(int cell) const;
        
        ///
-       int GetAdditionalHeight(int cell) const;
+       int GetAdditionalHeight(int row) const;
        ///
        int GetAdditionalWidth(int cell) const;
        
@@ -492,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();
        ///

diff --git a/src/text.C b/src/text.C
index 25ba26e4f1eedc6a7d34fc4469f03e7645b2438f..e9245db6639d79476e419e8220ae8c999f4de6f8 100644 (file)
--- a/src/text.C
+++ b/src/text.C
@@ -1159,7 +1159,7 @@ LyXText::NextBreakPoint(BufferView * bview, Row const * row, int width) const
 int LyXText::Fill(BufferView * bview, Row * row, int paper_width) const
 {
        if (paper_width < 0)
-               return 0;
+               return 20;
 
        int w;
        // get the pure distance
@@ -1204,6 +1204,8 @@ int LyXText::Fill(BufferView * bview, Row * row, int paper_width) const
        }
        
        int const fill = paper_width - w - RightMargin(bview->buffer(), row);
+       if (fill < 0)
+               return 0;
        return fill;
 }
 
@@ -1414,7 +1416,7 @@ void LyXText::SetHeightOfRow(BufferView * bview, Row * row_ptr) const
                   tmpfont = GetFont(bview->buffer(), row_ptr->par(), pos);
                   tmpinset = row_ptr->par()->GetInset(pos);
                   if (tmpinset) {
-                          tmpinset->update(bview, tmpfont);
+//                        tmpinset->update(bview, tmpfont);
                           asc = tmpinset->ascent(bview, tmpfont);
                           desc = tmpinset->descent(bview, tmpfont);
                           maxwidth += tmpinset->width(bview, tmpfont);