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

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.

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:

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,6 +180,7 @@ 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);
 }
 

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,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;
+}

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;

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,13 +275,21 @@ 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) &&
+			cell = tabular->GetCellNumber(i, 0);
-				(baseline - tabular->GetAscentOfRow(i))<pain.paperHeight();
+			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())
@@ -285,18 +297,19 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 				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,25 +328,24 @@ 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;
+			// copute baseline for actual row
-			     cell < actcell && i < tabular->rows(); ++i) {
+			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(i, j))
+					if (tabular->IsPartOfMultiColumn(actrow, j))
 						continue;
 					nx += tabular->GetWidthOfColumn(cell);
 					++cell;
 			}
-				if (tabular->row_of_cell(cell) > i) {
-					nx = int(x);
-					baseline += tabular->GetDescentOfRow(i) +
-						tabular->GetAscentOfRow(i + 1) +
-						tabular->GetAdditionalHeight(cell);
-				}
-			}
 		}
 		i = tabular->row_of_cell(cell);
 		if (the_locking_inset != tabular->GetCellInset(cell)) {
@@ -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,6 +577,9 @@ bool InsetTabular::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset,
 	if (the_locking_inset == inset) {
 		the_locking_inset->InsetUnlock(bv);
 		the_locking_inset = 0;
+		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);
+		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;
+			nodraw(false);
-			the_locking_inset->ToggleInsetCursor(bv);
+//			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(),
+			bv->showLockedInsetCursor(cursor.x(), cursor.y(), asc, desc);
-						  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()
+		cursor.y(cursor.y() + tabular->GetDescentOfRow(actrow) +
-			 + tabular->GetDescentOfRow(actrow)
+				 tabular->GetAscentOfRow(actrow + 1) +
-			 + tabular->GetAscentOfRow(actrow + 1)
+				 tabular->GetAdditionalHeight(actrow + 1));
-			 + tabular->
-			 GetAdditionalHeight(tabular->
-					     GetCellNumber(actrow + 1,
-							   actcol)));
 		++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()
+			cursor.y(cursor.y() + tabular->GetDescentOfRow(actrow) +
-				 + tabular->GetDescentOfRow(actrow)
+					 tabular->GetAscentOfRow(actrow + 1) +
-				 + tabular->GetAscentOfRow(actrow + 1)
+					 tabular->GetAdditionalHeight(actrow + 1));
-				 + tabular->GetAdditionalHeight(cell + 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:
+ */

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;

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;
+		drawFrame_ = ins->drawFrame_;
 	}
 	par->SetInsetOwner(this);
 	frame_color = LColor::insetframe;
 	locked = false;
 	old_par = 0;
 	last_drawn_width = -1;
+	frame_is_visible = false;
 }
 
 
@@ -300,26 +301,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 ((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);
+		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) ||
+		((need_update&(INIT|FULL)) || (top_baseline!=baseline) ||
-		 (last_drawn_width!=insetWidth))) {
+		 (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)))
+		((drawFrame_ == ALWAYS) || ((drawFrame_ == LOCKED) && locked)))
-	{
+		drawFrame(pain, cleared);
-		pain.rectangle(top_x + 1, baseline - insetAscent + 1,
+	else if (need_update & CLEAR_FRAME)
-			       width(bv, f) - 1,
+		clearFrame(pain, cleared);
-			       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);
-	}
 	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)) {
+	if (reinit) {
-		need_update = INIT;
+		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;
 	}
-	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
+	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<int>(TEXT(bv)->width));
 		resizeLyXText(bv);
-		need_update = FULL;
+		need_update |= FULL;
-		update(bv, font, reinit);
+//		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) {
+	if (how != drawFrame_) {
-		drawFrame = how;
+		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:
+ */

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

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

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 || row >= rows_)
-	if (!row) return 0;
+		return 0;
 
 	bool top = true;
 	bool bottom = true;
@@ -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:
+ */

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();
 	///

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);