X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=7f9ae0cf01b9cbf289de21f8a7a1c7c4abf4a5c2;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=1b4f42bd10af6e98de7c6e8722e0a4a87ea44d02;hpb=08b1fdacad52474c2aceb6e5ff354e8e870ddc47;p=lyx.git

diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C
index 1b4f42bd10..7f9ae0cf01 100644
--- a/src/insets/insettabular.C
+++ b/src/insets/insettabular.C
@@ -10,12 +10,6 @@
 
 #include <config.h>
 
-#include <fstream>
-#include <algorithm>
-
-#include <cstdlib>
-#include <map>
-//#include <signal.h>
 #ifdef __GNUG__
 #pragma implementation
 #endif
@@ -30,20 +24,31 @@
 #include "Painter.h"
 #include "font.h"
 #include "lyxtext.h"
-#include "lyx_gui_misc.h"
 #include "LyXView.h"
 #include "insets/insettext.h"
-#include "frontends/Dialogs.h"
-#include "frontends/Alert.h"
 #include "debug.h"
 #include "WorkArea.h"
 #include "gettext.h"
 #include "language.h"
 #include "BufferView.h"
 #include "undo_funcs.h"
+#include "lyxlength.h"
+#include "ParagraphParameters.h"
+
+#include "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+
 #include "support/LAssert.h"
 #include "support/lstrings.h"
 
+#include <fstream>
+#include <algorithm>
+#include <cstdlib>
+#include <map>
+//#include <signal.h>
+
+
+using std::vector;
 using std::ostream;
 using std::ifstream;
 using std::max;
@@ -53,8 +58,9 @@ using std::max;
 
 namespace {
 
-const int ADD_TO_HEIGHT = 2;
-const int ADD_TO_TABULAR_WIDTH = 2;
+int const ADD_TO_HEIGHT = 2;
+int const ADD_TO_TABULAR_WIDTH = 2;
+
 ///
 LyXTabular * paste_tabular = 0;
 
@@ -64,7 +70,6 @@ struct TabularFeature {
 	string feature;
 };
 
-//tabular_features * tabularFeatures = 0;
 
 TabularFeature tabularFeature[] =
 {
@@ -134,13 +139,16 @@ InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
 	// for now make it always display as display() inset
 	// just for test!!!
 	the_locking_inset = 0;
-	locked = no_selection = false;
+	old_locking_inset = 0;
+	locked = false;
 	oldcell = -1;
 	actrow = actcell = 0;
 	clearSelection();
 	need_update = INIT;
 	in_update = false;
 	in_reset_pos = false;
+	inset_x = 0;
+	inset_y = 0;
 }
 
 
@@ -148,15 +156,18 @@ InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf,
 						   bool same_id)
 	: UpdatableInset(tab, same_id), buffer(&buf)
 {
-	tabular.reset(new LyXTabular(this, *(tab.tabular)));
+	tabular.reset(new LyXTabular(this, *(tab.tabular), same_id));
 	the_locking_inset = 0;
-	locked = no_selection = false;
+	old_locking_inset = 0;
+	locked = false;
 	oldcell = -1;
 	actrow = actcell = 0;
-	sel_cell_start = sel_cell_end = 0;
+	clearSelection();
 	need_update = INIT;
 	in_update = false;
 	in_reset_pos = false;
+	inset_x = 0;
+	inset_y = 0;
 }
 
 
@@ -183,9 +194,6 @@ void InsetTabular::read(Buffer const * buf, LyXLex & lex)
 {
 	bool const old_format = (lex.getString() == "\\LyXTable");
 
-	//if (tabular)
-	//delete tabular;
-	//tabular = new LyXTabular(buf, this, lex);
 	tabular.reset(new LyXTabular(buf, this, lex));
 
 	need_update = INIT;
@@ -296,11 +304,11 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 				cx = nx + tabular->GetBeginningOfTextInCell(cell);
 				if (first_visible_cell < 0)
 					first_visible_cell = cell;
-				if (hasSelection())
+				if (hasSelection()) {
 					drawCellSelection(pain, nx, baseline, i, j, cell);
+				}
 				
-				tabular->GetCellInset(cell)->draw(bv, font, baseline, cx,
-												  cleared);
+				tabular->GetCellInset(cell)->draw(bv, font, baseline, cx, cleared);
 				drawCellLines(pain, nx, baseline, i, cell);
 				nx += tabular->GetWidthOfColumn(cell);
 				++cell;
@@ -361,46 +369,63 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 		float dx = nx + tabular->GetBeginningOfTextInCell(cell);
 		float cx = dx;
 		tabular->GetCellInset(cell)->draw(bv, font, baseline, dx, false);
+		//
+		// Here we use rectangular backgroundColor patches to clean up
+		// within a cell around the cell's red inset box. As follows:
+		//
+		//  +--------------------+
+		//  |         C          |   The rectangles are A, B and C
+		//  | A |------------| B |   below, origin top left (tx, ty), 
+		//  |   |  inset box |   |   dimensions w(idth), h(eight).
+		//  +---+------------+---+   x grows rightward, y downward
+		//  |         D          |
+		//  +--------------------+
+		//
+#if 0
 		// clear only if we didn't have a change
 		if (bv->text->status() != LyXText::CHANGED_IN_DRAW) {
+#endif
 			// clear before the inset
-			pain.fillRectangle(
-				nx + 1,
-				baseline - tabular->GetAscentOfRow(i) + 1,
-				int(cx - nx - 1),
-				tabular->GetAscentOfRow(i) +
-				tabular->GetDescentOfRow(i) - 1,
-				backgroundColor());
+			int tx, ty, w, h;
+			tx = nx + 1; 
+			ty = baseline - tabular->GetAscentOfRow(i) + 1;
+			w = int(cx - nx - 1);
+			h = tabular->GetAscentOfRow(i) + 
+				tabular->GetDescentOfRow(i) - 1;
+			pain.fillRectangle(tx, ty, w, h, backgroundColor());
 			// clear behind the inset
-			pain.fillRectangle(
-				int(cx + the_locking_inset->width(bv,font) + 1),
-				baseline - tabular->GetAscentOfRow(i) + 1,
-				tabular->GetWidthOfColumn(cell) -
+			tx = int(cx + the_locking_inset->width(bv,font) + 1);
+			ty = baseline - tabular->GetAscentOfRow(i) + 1;
+			w = tabular->GetWidthOfColumn(cell) -
 				tabular->GetBeginningOfTextInCell(cell) -
 				the_locking_inset->width(bv,font) -
-				tabular->GetAdditionalWidth(cell) - 1,
-				tabular->GetAscentOfRow(i) +
-				tabular->GetDescentOfRow(i) - 1,
-				backgroundColor());
+				tabular->GetAdditionalWidth(cell) - 1;
+			h = tabular->GetAscentOfRow(i) + tabular->GetDescentOfRow(i) - 1;
+			pain.fillRectangle(tx, ty, w, h, backgroundColor());
 			// clear below the inset
-			pain.fillRectangle(
-				nx + 1,
-				baseline + the_locking_inset->descent(bv, font) + 1,
-				tabular->GetWidthOfColumn(cell) -
-				tabular->GetAdditionalWidth(cell) - 1,
-				tabular->GetAscentOfRow(i) +
-				tabular->GetDescentOfRow(i) -
-				the_locking_inset->ascent(bv, font) -
-				the_locking_inset->descent(bv, font) -
-				TEXT_TO_INSET_OFFSET - 1,
-				backgroundColor());
+			tx = nx + 1;
+			ty = baseline + the_locking_inset->descent(bv, font) + 1;
+			w = tabular->GetWidthOfColumn(cell) -
+				tabular->GetAdditionalWidth(cell) - 1;
+			h = tabular->GetDescentOfRow(i) -
+				the_locking_inset->descent(bv, font) - 1;
+			pain.fillRectangle(tx, ty, w, h, backgroundColor());
+			// clear above the inset
+			tx = nx + 1;
+			ty = baseline - tabular->GetAscentOfRow(i) + 1;
+			w = tabular->GetWidthOfColumn(cell) -
+				tabular->GetAdditionalWidth(cell) - 1;
+			h = tabular->GetAscentOfRow(i) - the_locking_inset->ascent(bv, font);
+			pain.fillRectangle(tx, ty, w, h, backgroundColor());
+#if 0
 		}
+#endif
 	}
 	x -= ADD_TO_TABULAR_WIDTH;
 	x += width(bv, font);
 	if (bv->text->status() == LyXText::CHANGED_IN_DRAW) {
 		int i = 0;
-		for(Inset * inset=owner(); inset; ++i)
+		for(Inset * inset = owner(); inset; ++i)
 			inset = inset->owner();
 		if (calculate_dimensions_of_cells(bv, font, false))
 			need_update = INIT;
@@ -411,7 +436,7 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 
 
 void InsetTabular::drawCellLines(Painter & pain, int x, int baseline,
-				 int row, int cell) const
+                                 int row, int cell) const
 {
 	int x2 = x + tabular->GetWidthOfColumn(cell);
 	bool on_off;
@@ -448,6 +473,7 @@ void InsetTabular::drawCellLines(Painter & pain, int x, int baseline,
 void InsetTabular::drawCellSelection(Painter & pain, int x, int baseline,
 				     int row, int column, int cell) const
 {
+	lyx::Assert(hasSelection());
 	int cs = tabular->column_of_cell(sel_cell_start);
 	int ce = tabular->column_of_cell(sel_cell_end);
 	if (cs > ce) {
@@ -459,7 +485,8 @@ void InsetTabular::drawCellSelection(Painter & pain, int x, int baseline,
 	
 	int rs = tabular->row_of_cell(sel_cell_start);
 	int re = tabular->row_of_cell(sel_cell_end);
-	if (rs > re) swap(rs, re);
+	if (rs > re)
+		swap(rs, re);
 	
 	if ((column >= cs) && (column <= ce) && (row >= rs) && (row <= re)) {
 		int w = tabular->GetWidthOfColumn(cell);
@@ -506,7 +533,7 @@ void InsetTabular::update(BufferView * bv, LyXFont const & font, bool reinit)
 			need_update = INIT;
 		break;
 	case SELECTION:
-		need_update = INIT;
+		need_update = FULL;
 		break;
 	default:
 		break;
@@ -534,7 +561,7 @@ void InsetTabular::edit(BufferView * bv, int x, int y, unsigned int button)
 	inset_x = 0;
 	inset_y = 0;
 	setPos(bv, x, y);
-	sel_cell_start = sel_cell_end = actcell;
+	clearSelection();
 	finishUndo();
 	if (insetHit(bv, x, y) && (button != 3)) {
 		activateCellInsetAbs(bv, x, y, button);
@@ -558,7 +585,7 @@ void InsetTabular::edit(BufferView * bv, bool front)
 		actcell = 0;
 	else
 		actcell = tabular->GetNumberOfCells() - 1;
-	sel_cell_start = sel_cell_end = actcell;
+	clearSelection();
 	resetPos(bv);
 	finishUndo();
 }
@@ -571,11 +598,10 @@ void InsetTabular::insetUnlock(BufferView * bv)
 		the_locking_inset = 0;
 	}
 	hideInsetCursor(bv);
-	no_selection = false;
 	oldcell = -1;
 	locked = false;
 	if (scroll(false) || hasSelection()) {
-		sel_cell_start = sel_cell_end = 0;
+		clearSelection();
 		if (scroll(false)) {
 			scroll(bv, 0.0F);
 		}
@@ -585,12 +611,19 @@ void InsetTabular::insetUnlock(BufferView * bv)
 
 
 void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what,
-			       bool mark_dirty) const
+                               bool mark_dirty) const
 {
+	if (what == INIT) {
+		LyXFont font;
+		calculate_dimensions_of_cells(bv, font, true);
+	}
 	if (need_update < what) // only set this if it has greater update
 		need_update = what;
-	if ((what == INIT) && hasSelection())
+#if 0 // maybe this should not be done!
+	if ((what == INIT) && hasSelection()) {
 		clearSelection();
+	}
+#endif
 	// Dirty Cast! (Lgb)
 	if (need_update != NONE) {
 		bv->updateInset(const_cast<InsetTabular *>(this), mark_dirty);
@@ -612,6 +645,24 @@ bool InsetTabular::lockInsetInInset(BufferView * bv, UpdatableInset * inset)
 		the_locking_inset = tabular->GetCellInset(actcell);
 		resetPos(bv);
 		return true;
+	} else if (!the_locking_inset) {
+		int const n = tabular->GetNumberOfCells();
+		int const id = inset->id();
+		for (int i = 0; i < n; ++i) {
+			InsetText * in = tabular->GetCellInset(i);
+			if (inset == in) {
+				actcell = i;
+				the_locking_inset = in;
+				locked = true;
+				resetPos(bv);
+				return true;
+			}
+			if (in->getInsetFromID(id)) {
+				actcell = i;
+				in->edit(bv);
+				return the_locking_inset->lockInsetInInset(bv, inset);
+			}
+		}
 	} else if (the_locking_inset && (the_locking_inset == inset)) {
 		lyxerr[Debug::INSETTEXT] << "OK" << endl;
 		resetPos(bv);
@@ -672,7 +723,6 @@ unsigned int InsetTabular::insetInInsetY()
 {
 	if (!the_locking_inset)
 		return 0;
-	
 	return inset_y + the_locking_inset->insetInInsetY();
 }
 
@@ -712,8 +762,6 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button)
 		updateLocal(bv, SELECTION, false);
 	}
 
-	no_selection = false;
-
 	int const ocell = actcell;
 	int const orow = actrow;
 
@@ -721,7 +769,8 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button)
 	setPos(bv, x, y);
 	if (actrow != orow)
 		updateLocal(bv, NONE, false);
-	sel_cell_start = sel_cell_end = actcell;
+	clearSelection();
+#if 0
 	if (button == 3) {
 		if ((ocell != actcell) && the_locking_inset) {
 			the_locking_inset->insetUnlock(bv);
@@ -730,6 +779,7 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button)
 		showInsetCursor(bv);
 		return;
 	}
+#endif
 
 	bool const inset_hit = insetHit(bv, x, y);
 
@@ -759,27 +809,18 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button)
 }
 
 
-void InsetTabular::insetButtonRelease(BufferView * bv,
-				      int x, int y, int button)
+bool InsetTabular::insetButtonRelease(BufferView * bv,
+                                      int x, int y, int button)
 {
-	if (button == 3) {
-		if (the_locking_inset) {
-			UpdatableInset * i;
-			if ((i = the_locking_inset->getFirstLockingInsetOfType(TABULAR_CODE))) {
-				i->insetButtonRelease(bv, x, y, button);
-				return;
-			}
-		}
+	bool ret = false;
+	if (the_locking_inset)
+		ret = the_locking_inset->insetButtonRelease(bv, x - inset_x,
+													y - inset_y, button);
+	if (button == 3 && !ret) {
 		bv->owner()->getDialogs()->showTabular(this);
-		return;
-	}
-	if (the_locking_inset) {
-		the_locking_inset->insetButtonRelease(bv,
-						      x - inset_x, y - inset_y,
-						      button);
-		return;
+		return true;
 	}
-	no_selection = false;
+	return ret;
 }
 
 
@@ -792,17 +833,18 @@ void InsetTabular::insetMotionNotify(BufferView * bv, int x, int y, int button)
 						     button);
 		return;
 	}
-	if (!no_selection) {
-		hideInsetCursor(bv);
-		int const old_cell = actcell;
-		
-		setPos(bv, x, y);
-		sel_cell_end = actcell;
-		if (sel_cell_end != old_cell)
-			updateLocal(bv, SELECTION, false);
-		showInsetCursor(bv);
+ 
+	hideInsetCursor(bv);
+//	int const old_cell = actcell;
+	
+	setPos(bv, x, y);
+	if (!hasSelection()) {
+		setSelection(actcell, actcell);
+	} else {
+		setSelection(sel_cell_start, actcell);
 	}
-	no_selection = false;
+	updateLocal(bv, SELECTION, false);
+	showInsetCursor(bv);
 }
 
 
@@ -822,7 +864,6 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 	// We need to save the value of the_locking_inset as the call to 
 	// the_locking_inset->LocalDispatch might unlock it.
 	old_locking_inset = the_locking_inset;
-	no_selection = false;
 	UpdatableInset::RESULT result =
 		UpdatableInset::localDispatch(bv, action, arg);
 	if (result == DISPATCHED || result == DISPATCHED_NOUPDATE) {
@@ -843,15 +884,12 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 		case LFUN_SHIFT_TAB:
 		case LFUN_TAB:
 			hideInsetCursor(bv);
-			if (the_locking_inset) {
-				unlockInsetInInset(bv, the_locking_inset);
-				the_locking_inset = 0;
-			}
+			unlockInsetInInset(bv, the_locking_inset);
 			if (action == LFUN_TAB)
 				moveNextCell(bv, old_locking_inset != 0);
 			else
 				movePrevCell(bv, old_locking_inset != 0);
-			sel_cell_start = sel_cell_end = actcell;
+			clearSelection();
 			if (hs)
 				updateLocal(bv, SELECTION, false);
 			if (!the_locking_inset) {
@@ -891,99 +929,138 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 	}
 
 	hideInsetCursor(bv);
-	result=DISPATCHED;
+	result = DISPATCHED;
 	switch (action) {
 		// --- Cursor Movements ----------------------------------
-	case LFUN_RIGHTSEL:
-		if (tabular->IsLastCellInRow(actcell))
+	case LFUN_RIGHTSEL: {
+		int const start = hasSelection() ? sel_cell_start : actcell;
+		if (tabular->IsLastCellInRow(actcell)) {
+			setSelection(start, actcell);
 			break;
-		moveRight(bv, false);
-		sel_cell_end = actcell;
+		}
+		
+		int end = actcell;
+		// if we are starting a selection, only select
+		// the current cell at the beginning
+		if (hasSelection()) {
+			moveRight(bv, false);
+			end = actcell;
+		}
+		setSelection(start, end);
 		updateLocal(bv, SELECTION, false);
 		break;
+	}
 	case LFUN_RIGHT:
 		result = moveRight(bv);
-		sel_cell_start = sel_cell_end = actcell;
+		clearSelection();
 		if (hs)
 			updateLocal(bv, SELECTION, false);
 		break;
-	case LFUN_LEFTSEL:
-		if (tabular->IsFirstCellInRow(actcell))
+	case LFUN_LEFTSEL: {
+		int const start = hasSelection() ? sel_cell_start : actcell;
+		if (tabular->IsFirstCellInRow(actcell)) {
+			setSelection(start, actcell);
 			break;
-		moveLeft(bv, false);
-		sel_cell_end = actcell;
+		}
+ 
+		int end = actcell;
+		// if we are starting a selection, only select
+		// the current cell at the beginning
+		if (hasSelection()) { 
+			moveLeft(bv, false);
+			end = actcell;
+		}
+		setSelection(start, end);
 		updateLocal(bv, SELECTION, false);
 		break;
+	}
 	case LFUN_LEFT:
 		result = moveLeft(bv);
-		sel_cell_start = sel_cell_end = actcell;
+		clearSelection();
 		if (hs)
 			updateLocal(bv, SELECTION, false);
 		break;
-	case LFUN_DOWNSEL:
-	{
+	case LFUN_DOWNSEL: {
+		int const start = hasSelection() ? sel_cell_start : actcell;
 		int const ocell = actcell;
-		moveDown(bv, false);
-		if ((ocell == sel_cell_end) ||
-		    (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
-			sel_cell_end = tabular->GetCellBelow(sel_cell_end);
-		else
-			sel_cell_end = tabular->GetLastCellBelow(sel_cell_end);
+		// if we are starting a selection, only select
+		// the current cell at the beginning
+		if (hasSelection()) {
+			moveDown(bv, false);
+			if ((ocell == sel_cell_end) ||
+			    (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
+				setSelection(start, tabular->GetCellBelow(sel_cell_end));
+			else
+				setSelection(start, tabular->GetLastCellBelow(sel_cell_end));
+		} else {
+			setSelection(start, start);
+		}
 		updateLocal(bv, SELECTION, false);
 	}
 	break;
 	case LFUN_DOWN:
 		result = moveDown(bv, old_locking_inset != 0);
-		sel_cell_start = sel_cell_end = actcell;
-		if (hs)
+		clearSelection();
+		if (hs) {
 			updateLocal(bv, SELECTION, false);
+		}
 		break;
-	case LFUN_UPSEL:
-	{
+	case LFUN_UPSEL: {
+		int const start = hasSelection() ? sel_cell_start : actcell;
 		int const ocell = actcell;
-		moveUp(bv, false);
-		if ((ocell == sel_cell_end) ||
-		    (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
-			sel_cell_end = tabular->GetCellAbove(sel_cell_end);
-		else
-			sel_cell_end = tabular->GetLastCellAbove(sel_cell_end);
+		// if we are starting a selection, only select
+		// the current cell at the beginning
+		if (hasSelection()) {
+			moveUp(bv, false);
+			if ((ocell == sel_cell_end) ||
+			    (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
+				setSelection(start, tabular->GetCellAbove(sel_cell_end));
+			else
+				setSelection(start, tabular->GetLastCellAbove(sel_cell_end));
+		} else {
+			setSelection(start, start);
+		}
 		updateLocal(bv, SELECTION, false);
 	}
 	break;
 	case LFUN_UP:
 		result = moveUp(bv, old_locking_inset != 0);
-		sel_cell_start = sel_cell_end = actcell;
+		clearSelection();
 		if (hs)
 			updateLocal(bv, SELECTION, false);
 		break;
 	case LFUN_NEXT: {
-		int column = actcol;
-		if (the_locking_inset) {
-			unlockInsetInInset(bv, the_locking_inset);
-			the_locking_inset = 0;
+		UpdateCodes code = CURSOR;
+		if (hs) {
+			clearSelection();
+			code = SELECTION;
 		}
+		int column = actcol;
+		unlockInsetInInset(bv, the_locking_inset);
 		if (bv->text->first + bv->painter().paperHeight() <
 		    (top_baseline + tabular->GetHeightOfTabular()))
 			{
 				bv->scrollCB(bv->text->first + bv->painter().paperHeight());
-				updateLocal(bv, FULL, false);
+				code = FULL;
 				actcell = tabular->GetCellBelow(first_visible_cell) + column;
 			} else {
 				actcell = tabular->GetFirstCellInRow(tabular->rows() - 1) + column;
 			}
 		resetPos(bv);
-		updateLocal(bv, CURSOR, false);
+		updateLocal(bv, code, false);
 		break;
 	}
 	case LFUN_PRIOR: {
-		int column = actcol;
-		if (the_locking_inset) {
-			unlockInsetInInset(bv, the_locking_inset);
-			the_locking_inset = 0;
+		UpdateCodes code = CURSOR;
+		if (hs) {
+			clearSelection();
+			code = SELECTION;
 		}
+		int column = actcol;
+		unlockInsetInInset(bv, the_locking_inset);
 		if (top_baseline < 0) {
 			bv->scrollCB(bv->text->first - bv->painter().paperHeight());
-			updateLocal(bv, FULL, false);
+			code = FULL;
 			if (top_baseline > 0)
 				actcell = column;
 			else
@@ -992,22 +1069,36 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 			actcell = column;
 		}
 		resetPos(bv);
-		updateLocal(bv, CURSOR, false);
-		break;
-	}
+		updateLocal(bv, code, false);
+		break;
+	}
+	// none of these make sense for insettabular,
+	// but we must catch them to prevent any
+	// selection from being confused
+	case LFUN_PRIORSEL:
+	case LFUN_NEXTSEL:
+	case LFUN_WORDLEFT:
+	case LFUN_WORDLEFTSEL:
+	case LFUN_WORDRIGHT: 
+	case LFUN_WORDRIGHTSEL:
+	case LFUN_DOWN_PARAGRAPH:
+	case LFUN_DOWN_PARAGRAPHSEL:
+	case LFUN_UP_PARAGRAPH:
+	case LFUN_UP_PARAGRAPHSEL:
 	case LFUN_BACKSPACE:
-		break;
 	case LFUN_DELETE:
-		break;
 	case LFUN_HOME:
-		break;
+	case LFUN_HOMESEL:
 	case LFUN_END:
+	case LFUN_ENDSEL:
+	case LFUN_BEGINNINGBUF:
+	case LFUN_BEGINNINGBUFSEL: 
+	case LFUN_ENDBUF:
+	case LFUN_ENDBUFSEL:
 		break;
 	case LFUN_LAYOUT_TABULAR:
-	{
 		bv->owner()->getDialogs()->showTabular(this);
-	}
-	break;
+		break;
 	case LFUN_TABULAR_FEATURE:
 		if (!tabularFeatures(bv, arg))
 			result = UNDISPATCHED;
@@ -1040,9 +1131,9 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 			string::size_type len = clip.length();
 			string::size_type p = 0;
 
-			while(p < len &&
+			while (p < len &&
 			      ((p = clip.find_first_of("\t\n", p)) != string::npos)) {
-				switch(clip[p]) {
+				switch (clip[p]) {
 				case '\t':
 					++cols;
 					break;
@@ -1062,11 +1153,11 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 			int cell = 0;
 			int cells = paste_tabular->GetNumberOfCells();
 			p = cols = 0;
-			while((cell < cells) && (p < len) &&
+			while ((cell < cells) && (p < len) &&
 			      (p = clip.find_first_of("\t\n", p)) != string::npos) {
 				if (p >= len)
 					break;
-				switch(clip[p]) {
+				switch (clip[p]) {
 				case '\t':
 					paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op));
 					++cols;
@@ -1074,7 +1165,7 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 					break;
 				case '\n':
 					paste_tabular->GetCellInset(cell)->setText(clip.substr(op, p-op));
-					while(cols++ < maxCols)
+					while (cols++ < maxCols)
 						++cell;
 					cols = 0;
 					break;
@@ -1104,10 +1195,31 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 		}
 		// ATTENTION: the function above has to be PASTE and PASTESELECTION!!!
 	default:
+		// handle font changing stuff on selection before we lock the inset
+		// in the default part!
+		result = UNDISPATCHED;
+		if (hs) {
+			switch(action) {
+			case LFUN_LANGUAGE:
+			case LFUN_EMPH:
+			case LFUN_BOLD:
+			case LFUN_NOUN:
+			case LFUN_CODE:
+			case LFUN_SANS:
+			case LFUN_ROMAN:
+			case LFUN_DEFAULT:
+			case LFUN_UNDERLINE:
+			case LFUN_FONT_SIZE:
+				if (bv->Dispatch(action, arg))
+					result = DISPATCHED;
+				break;
+			default:
+				break;
+			}
+		}
 		// we try to activate the actual inset and put this event down to
 		// the insets dispatch function.
-		result = UNDISPATCHED;
-		if (the_locking_inset)
+		if ((result == DISPATCHED) || the_locking_inset)
 			break;
 		nodraw(true);
 		if (activateCellInset(bv)) {
@@ -1117,12 +1229,14 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 			if ((result == UNDISPATCHED) || (result >= FINISHED)) {
 				unlockInsetInInset(bv, the_locking_inset);
 				nodraw(false);
-				the_locking_inset = 0;
 				// we need to update if this was requested before
 				updateLocal(bv, NONE, false);
 				return UNDISPATCHED;
 			} else if (hs) {
 				clearSelection();
+				// so the below CELL is not set because this is higher
+				// priority and we get a full redraw
+				need_update = SELECTION;
 			}
 			nodraw(false);
 			updateLocal(bv, CELL, false);
@@ -1141,22 +1255,29 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 
 
 int InsetTabular::latex(Buffer const * buf, ostream & os,
-			bool fragile, bool fp) const
+                        bool fragile, bool fp) const
 {
-	return tabular->Latex(buf, os, fragile, fp);
+	return tabular->latex(buf, os, fragile, fp);
 }
 
 
-int InsetTabular::ascii(Buffer const * buf, ostream & os, int) const
+int InsetTabular::ascii(Buffer const * buf, ostream & os, int ll) const
 {
-	// This should be changed to a real ascii export
-	return tabular->Ascii(buf, os);
+	if (ll > 0)
+		return tabular->ascii(buf, os, (int)parOwner()->params().depth(),
+		                      false,0);
+	return tabular->ascii(buf, os, 0, false,0);
 }
 
 
 int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const
 {
-	return tabular->Ascii(buf,os);
+	os << "<![CDATA[";
+	int const ret = tabular->ascii(buf,os,
+				       (int)parOwner()->params().depth(),
+				       false, 0);
+	os << "]]>";
+	return ret;
 }
 
 
@@ -1175,7 +1296,7 @@ int InsetTabular::docbook(Buffer const * buf, ostream & os) const
 		os << "<informaltable>\n";
 		ret++;
 	}
-	ret+= tabular->DocBook(buf,os);
+	ret+= tabular->docBook(buf,os);
 	if (!master) {
 		os << "</informaltable>\n";
 		ret++;
@@ -1223,7 +1344,7 @@ bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv,
 				continue;
 			++cell;
 			inset = tabular->GetCellInset(cell);
-			if (!reinit && !tabular->GetPWidth(cell).empty())
+			if (!reinit && !tabular->GetPWidth(cell).zero())
 				inset->update(bv, font, false);
 			maxAsc = max(maxAsc, inset->ascent(bv, font));
 			maxDesc = max(maxDesc, inset->descent(bv, font));
@@ -1232,6 +1353,8 @@ bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv,
 		changed = tabular->SetAscentOfRow(i, maxAsc + ADD_TO_HEIGHT) || changed;
 		changed = tabular->SetDescentOfRow(i, maxDesc + ADD_TO_HEIGHT) || changed;
 	}
+	if (changed)
+		tabular->reinit();
 	return changed;
 }
 
@@ -1249,6 +1372,11 @@ void InsetTabular::getCursorPos(BufferView * bv, int & x, int & y) const
 
 void InsetTabular::toggleInsetCursor(BufferView * bv)
 {
+	if (nodraw()) {
+		if (isCursorVisible())
+			bv->hideLockedInsetCursor();
+		return;
+	}
 	if (the_locking_inset) {
 		the_locking_inset->toggleInsetCursor(bv);
 		return;
@@ -1269,6 +1397,8 @@ void InsetTabular::toggleInsetCursor(BufferView * bv)
 
 void InsetTabular::showInsetCursor(BufferView * bv, bool show)
 {
+	if (nodraw())
+		return;
 	if (!isCursorVisible()) {
 		LyXFont font; // = GetFont(par, cursor.pos);
 	
@@ -1313,7 +1443,7 @@ void InsetTabular::setPos(BufferView * bv, int x, int y) const
 	int ly = tabular->GetDescentOfRow(actrow);
 
 	// first search the right row
-	while((ly < y) && ((actrow+1) < tabular->rows())) {
+	while ((ly < y) && ((actrow+1) < tabular->rows())) {
 		cursor_.y(cursor_.y() + tabular->GetDescentOfRow(actrow) +
 				 tabular->GetAscentOfRow(actrow + 1) +
 				 tabular->GetAdditionalHeight(actrow + 1));
@@ -1350,17 +1480,13 @@ int InsetTabular::getCellXPos(int cell) const
 
 void InsetTabular::resetPos(BufferView * bv) const
 {
-	if (!locked || nodraw())
-		return;
 #warning This should be fixed in the right manner (20011128 Jug)
 	// fast hack to fix infinite repaintings!
 	if (in_reset_pos)
 		return;
-	in_reset_pos = true;
-
-	actcol = tabular->column_of_cell(actcell);
 
 	int cell = 0;
+	actcol = tabular->column_of_cell(actcell);
 	actrow = 0;
 	cursor_.y(0);
 	for (; (cell < actcell) && !tabular->IsLastRow(cell); ++cell) {
@@ -1371,6 +1497,13 @@ void InsetTabular::resetPos(BufferView * bv) const
 			++actrow;
 		}
 	}
+	if (!locked || nodraw()) {
+		if (the_locking_inset)
+			inset_y = cursor_.y();
+		return;
+	}
+	// we need this only from here on!!!
+	in_reset_pos = true;
 	static int const offset = ADD_TO_TABULAR_WIDTH + 2;
 	int new_x = getCellXPos(actcell);
 	int old_x = cursor_.x();
@@ -1567,8 +1700,7 @@ void InsetTabular::setFont(BufferView * bv, LyXFont const & font, bool tall,
                            bool selectall)
 {
 	if (selectall) {
-		sel_cell_start = 0;
-		sel_cell_end = tabular->GetNumberOfCells() - 1;
+		setSelection(0, tabular->GetNumberOfCells() - 1);
 	}
 	if (hasSelection()) {
 		setUndo(bv, Undo::EDIT,
@@ -1621,6 +1753,24 @@ bool InsetTabular::tabularFeatures(BufferView * bv, string const & what)
 	return true;
 }
 
+static void checkLongtableSpecial(LyXTabular::ltType & ltt,
+                                  string const & special, bool & flag)
+{
+	if (special == "dl_above") {
+		ltt.topDL = flag;
+		ltt.set = false;
+	} else if (special == "dl_below") {
+		ltt.bottomDL = flag;
+		ltt.set = false;
+	} else if (special == "empty") {
+		ltt.empty = flag;
+		ltt.set = false;
+	} else if (flag) {
+		ltt.empty = false;
+		ltt.set = true;
+	}
+}
+
 
 void InsetTabular::tabularFeatures(BufferView * bv,
                                    LyXTabular::Feature feature,
@@ -1637,27 +1787,27 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 	switch (feature) {
 	case LyXTabular::M_ALIGN_LEFT:
 	case LyXTabular::ALIGN_LEFT:
-		setAlign=LYX_ALIGN_LEFT;
+		setAlign = LYX_ALIGN_LEFT;
 		break;
 	case LyXTabular::M_ALIGN_RIGHT:
 	case LyXTabular::ALIGN_RIGHT:
-		setAlign=LYX_ALIGN_RIGHT;
+		setAlign = LYX_ALIGN_RIGHT;
 		break;
 	case LyXTabular::M_ALIGN_CENTER:
 	case LyXTabular::ALIGN_CENTER:
-		setAlign=LYX_ALIGN_CENTER;
+		setAlign = LYX_ALIGN_CENTER;
 		break;
 	case LyXTabular::M_VALIGN_TOP:
 	case LyXTabular::VALIGN_TOP:
-		setVAlign=LyXTabular::LYX_VALIGN_TOP;
+		setVAlign = LyXTabular::LYX_VALIGN_TOP;
 		break;
 	case LyXTabular::M_VALIGN_BOTTOM:
 	case LyXTabular::VALIGN_BOTTOM:
-		setVAlign=LyXTabular::LYX_VALIGN_BOTTOM;
+		setVAlign = LyXTabular::LYX_VALIGN_BOTTOM;
 		break;
 	case LyXTabular::M_VALIGN_CENTER:
 	case LyXTabular::VALIGN_CENTER:
-		setVAlign=LyXTabular::LYX_VALIGN_CENTER;
+		setVAlign = LyXTabular::LYX_VALIGN_CENTER;
 		break;
 	default:
 		break;
@@ -1672,20 +1822,24 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 	        bv->text->cursor.par(),
 	        bv->text->cursor.par()->next());
 
-	LyXTabular::ltType ltt;
-	int row = ltt.row = tabular->row_of_cell(actcell);
+	int row =  tabular->row_of_cell(actcell);
 	int column = tabular->column_of_cell(actcell);
 	bool flag = true;
-
+	LyXTabular::ltType ltt;
+	
 	switch (feature) {
 	case LyXTabular::SET_PWIDTH:
 	{
-		bool const update = (tabular->GetColumnPWidth(actcell) != value);
-		tabular->SetColumnPWidth(actcell,value);
+		LyXLength const vallen(value);
+		LyXLength const & tmplen = tabular->GetColumnPWidth(actcell);
+		
+		bool const update = (tmplen != vallen);
+		tabular->SetColumnPWidth(actcell, vallen);
 		if (update) {
+			int cell;
 			for (int i = 0; i < tabular->rows(); ++i) {
-				tabular->GetCellInset(tabular->GetCellNumber(i, column))->
-					resizeLyXText(bv);
+				cell = tabular->GetCellNumber(i,column);
+				tabular->GetCellInset(cell)->resizeLyXText(bv);
 			}
 			updateLocal(bv, INIT, true);
 		}
@@ -1693,8 +1847,11 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 	break;
 	case LyXTabular::SET_MPWIDTH:
 	{
-		bool const update = (tabular->GetPWidth(actcell) != value);
-		tabular->SetMColumnPWidth(actcell,value);
+		LyXLength const vallen(value);
+		LyXLength const & tmplen = tabular->GetPWidth(actcell);
+		
+		bool const update = (tmplen != vallen);
+		tabular->SetMColumnPWidth(actcell, vallen);
 		if (update) {
 			for (int i = 0; i < tabular->rows(); ++i) {
 				tabular->GetCellInset(tabular->GetCellNumber(i, column))->
@@ -1866,7 +2023,7 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 		}
 		tabular->SetMultiColumn(s_start, s_end - s_start + 1);
 		actcell = s_start;
-		sel_cell_end = sel_cell_start;
+		clearSelection();
 		updateLocal(bv, INIT, true);
 		break;
 	}
@@ -1918,29 +2075,37 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 		break;
 	}
 	case LyXTabular::UNSET_LTFIRSTHEAD:
-		ltt.row = 0;
+		flag = false;
 	case LyXTabular::SET_LTFIRSTHEAD:
-		tabular->SetLTHead(ltt, true);
+		(void)tabular->GetRowOfLTFirstHead(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTHead(row, flag, ltt, true);
 		break;
 	case LyXTabular::UNSET_LTHEAD:
-		ltt.row = 0;
+		flag = false;
 	case LyXTabular::SET_LTHEAD:
-		tabular->SetLTHead(ltt, false);
+		(void)tabular->GetRowOfLTHead(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTHead(row, flag, ltt, false);
 		break;
 	case LyXTabular::UNSET_LTFOOT:
-		ltt.row = 0;
+		flag = false;
 	case LyXTabular::SET_LTFOOT:
-		tabular->SetLTFoot(ltt, false);
+		(void)tabular->GetRowOfLTFoot(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTFoot(row, flag, ltt, false);
 		break;
 	case LyXTabular::UNSET_LTLASTFOOT:
-		ltt.row = 0;
+		flag = false;
 	case LyXTabular::SET_LTLASTFOOT:
-		tabular->SetLTFoot(ltt, true);
+		(void)tabular->GetRowOfLTLastFoot(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTFoot(row, flag, ltt, true);
 		break;
 	case LyXTabular::SET_LTNEWPAGE:
 	{
-		bool what = !tabular->GetLTNewPage(actcell);
-		tabular->SetLTNewPage(actcell, what);
+		bool what = !tabular->GetLTNewPage(row);
+		tabular->SetLTNewPage(row, what);
 		break;
 	}
 	// dummy stuff just to avoid warnings
@@ -1991,38 +2156,22 @@ bool InsetTabular::insetHit(BufferView *, int x, int) const
 // in pixels if we have a pwidth for this cell.
 int InsetTabular::getMaxWidthOfCell(BufferView * bv, int cell) const
 {
-	string const s = tabular->GetPWidth(cell);
+	LyXLength const len = tabular->GetPWidth(cell);
 	
-	if (s.empty())
+	if (len.zero())
 		return -1;
-	return VSpace(s).inPixels(bv);
+	return len.inPixels(latexTextWidth(bv), bv->text->defaultHeight());
 }
 
 
 int InsetTabular::getMaxWidth(BufferView * bv,
                               UpdatableInset const * inset) const
 {
-	int cell = tabular->cur_cell;
-	if (tabular->GetCellInset(cell) != inset) {
-		cell = actcell;
-		if (tabular->GetCellInset(cell) != inset) {
-			
-			lyxerr[Debug::INSETTEXT] << "Actcell not equal to actual cell!\n";
-			cell = -1;
-		}
-	}
-	
-	int const n = tabular->GetNumberOfCells();
+	int cell = tabular->GetCellFromInset(inset, actcell);
 
 	if (cell == -1) {
-		for (cell = 0; cell < n; ++cell) {
-			if (tabular->GetCellInset(cell) == inset)
-				break;
-		}
-	}
-	
-	if (cell >= n) {
-		lyxerr << "Own inset not found, shouldn't really happen!\n";
+		lyxerr << "Own inset not found, shouldn't really happen!"
+		       << endl;
 		return -1;
 	}
 	
@@ -2098,16 +2247,13 @@ void InsetTabular::openLayoutDialog(BufferView * bv) const
 
 
 //
-// functions returns:
-// 0 ... disabled
-// 1 ... enabled
-// 2 ... toggled on
-// 3 ... toggled off
+// function returns an object as defined in func_status.h:
+// states OK, Unknown, Disabled, On, Off.
 //
-func_status::value_type InsetTabular::getStatus(string const & what) const
+FuncStatus InsetTabular::getStatus(string const & what) const
 {
 	int action = LyXTabular::LAST_ACTION;
-	func_status::value_type status = func_status::OK;
+	FuncStatus status;
 	
 	int i = 0;
 	for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) {
@@ -2119,9 +2265,11 @@ func_status::value_type InsetTabular::getStatus(string const & what) const
 			break;
 		}
 	}
-	if (action == LyXTabular::LAST_ACTION)
-		return func_status::Unknown;
-
+	if (action == LyXTabular::LAST_ACTION) {
+		status.clear();
+		return status.unknown(true);
+	}
+	
 	string const argument = frontStrip(what.substr(tabularFeature[i].feature.length()));
 
 	int sel_row_start;
@@ -2141,8 +2289,7 @@ func_status::value_type InsetTabular::getStatus(string const & what) const
 	case LyXTabular::SET_MPWIDTH:
 	case LyXTabular::SET_SPECIAL_COLUMN:
 	case LyXTabular::SET_SPECIAL_MULTI:
-		status |= func_status::Disabled;
-		return status;
+		return status.disabled(true);
 
 	case LyXTabular::APPEND_ROW:
 	case LyXTabular::APPEND_COLUMN:
@@ -2150,176 +2297,107 @@ func_status::value_type InsetTabular::getStatus(string const & what) const
 	case LyXTabular::DELETE_COLUMN:
 	case LyXTabular::SET_ALL_LINES:
 	case LyXTabular::UNSET_ALL_LINES:
-		status |= func_status::OK;
-		return status;
+		return status.clear();
 
 	case LyXTabular::MULTICOLUMN:
-		if (tabular->IsMultiColumn(actcell))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->IsMultiColumn(actcell));
 		break;
 	case LyXTabular::M_TOGGLE_LINE_TOP:
 		flag = false;
 	case LyXTabular::TOGGLE_LINE_TOP:
-		if (tabular->TopLine(actcell, flag))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->TopLine(actcell, flag));
 		break;
 	case LyXTabular::M_TOGGLE_LINE_BOTTOM:
 		flag = false;
 	case LyXTabular::TOGGLE_LINE_BOTTOM:
-		if (tabular->BottomLine(actcell, flag))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->BottomLine(actcell, flag));
 		break;
 	case LyXTabular::M_TOGGLE_LINE_LEFT:
 		flag = false;
 	case LyXTabular::TOGGLE_LINE_LEFT:
-		if (tabular->LeftLine(actcell, flag))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->LeftLine(actcell, flag));
 		break;
 	case LyXTabular::M_TOGGLE_LINE_RIGHT:
 		flag = false;
 	case LyXTabular::TOGGLE_LINE_RIGHT:
-		if (tabular->RightLine(actcell, flag))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->RightLine(actcell, flag));
 		break;
 	case LyXTabular::M_ALIGN_LEFT:
 		flag = false;
 	case LyXTabular::ALIGN_LEFT:
-		if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT)
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT);
 		break;
 	case LyXTabular::M_ALIGN_RIGHT:
 		flag = false;
 	case LyXTabular::ALIGN_RIGHT:
-		if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT)
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT);
 		break;
 	case LyXTabular::M_ALIGN_CENTER:
 		flag = false;
 	case LyXTabular::ALIGN_CENTER:
-		if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER)
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER);
 		break;
 	case LyXTabular::M_VALIGN_TOP:
 		flag = false;
 	case LyXTabular::VALIGN_TOP:
-		if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP)
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP);
 		break;
 	case LyXTabular::M_VALIGN_BOTTOM:
 		flag = false;
 	case LyXTabular::VALIGN_BOTTOM:
-		if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM)
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM);
 		break;
 	case LyXTabular::M_VALIGN_CENTER:
 		flag = false;
 	case LyXTabular::VALIGN_CENTER:
-		if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER)
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER);
 		break;
 	case LyXTabular::SET_LONGTABULAR:
-		if (tabular->IsLongTabular())
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->IsLongTabular());
 		break;
 	case LyXTabular::UNSET_LONGTABULAR:
-		if (!tabular->IsLongTabular())
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(!tabular->IsLongTabular());
 		break;
 	case LyXTabular::SET_ROTATE_TABULAR:
-		if (tabular->GetRotateTabular())
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetRotateTabular());
 		break;
 	case LyXTabular::UNSET_ROTATE_TABULAR:
-		if (!tabular->GetRotateTabular())
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(!tabular->GetRotateTabular());
 		break;
 	case LyXTabular::SET_ROTATE_CELL:
-		if (tabular->GetRotateCell(actcell))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetRotateCell(actcell));
 		break;
 	case LyXTabular::UNSET_ROTATE_CELL:
-		if (!tabular->GetRotateCell(actcell))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(!tabular->GetRotateCell(actcell));
 		break;
 	case LyXTabular::SET_USEBOX:
-		if (strToInt(argument) == tabular->GetUsebox(actcell))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(strToInt(argument) == tabular->GetUsebox(actcell));
 		break;
 	case LyXTabular::SET_LTFIRSTHEAD:
-		if (tabular->GetRowOfLTHead(actcell, dummyltt))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt));
 		break;
 	case LyXTabular::SET_LTHEAD:
-		if (tabular->GetRowOfLTHead(actcell, dummyltt))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetRowOfLTHead(sel_row_start, dummyltt));
 		break;
 	case LyXTabular::SET_LTFOOT:
-		if (tabular->GetRowOfLTFoot(actcell, dummyltt))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt));
 		break;
 	case LyXTabular::SET_LTLASTFOOT:
-		if (tabular->GetRowOfLTFoot(actcell, dummyltt))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetRowOfLTFoot(sel_row_start, dummyltt));
 		break;
 	case LyXTabular::SET_LTNEWPAGE:
-		if (tabular->GetLTNewPage(actcell))
-			status |= func_status::ToggleOn;
-		else
-			status |= func_status::ToggleOff;
+		status.setOnOff(tabular->GetLTNewPage(sel_row_start));
 		break;
 	default:
-		status = func_status::Disabled;
+		status.clear();
+		status.disabled(true);
 		break;
 	}
 	return status;
 }
 
 
-std::vector<string> const InsetTabular::getLabelList() const
+vector<string> const InsetTabular::getLabelList() const
 {
 	return tabular->getLabelList();
 }
@@ -2351,10 +2429,10 @@ bool InsetTabular::copySelection(BufferView * bv)
 	paste_tabular = new LyXTabular(this, *tabular); // rows, columns);
 	for (int i = 0; i < sel_row_start; ++i)
 		paste_tabular->DeleteRow(0);
-	while(paste_tabular->rows() > rows)
+	while (paste_tabular->rows() > rows)
 		paste_tabular->DeleteRow(rows);
 	paste_tabular->SetTopLine(0, true, true);
-	paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows-1),
+	paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows - 1),
 				     true, true);
 	for (int i = 0; i < sel_col_start; ++i)
 		paste_tabular->DeleteColumn(0);
@@ -2365,7 +2443,8 @@ bool InsetTabular::copySelection(BufferView * bv)
 				    true, true);
 
 	ostringstream sstr;
-	paste_tabular->Ascii(bv->buffer(), sstr);
+	paste_tabular->ascii(bv->buffer(), sstr,
+	                     (int)parOwner()->params().depth(), true, '\t');
 	bv->stuffClipboard(sstr.str().c_str());
 	return true;
 }
@@ -2434,7 +2513,7 @@ bool InsetTabular::cutSelection()
 }
 
 
-bool InsetTabular::isRightToLeft(BufferView *bv )
+bool InsetTabular::isRightToLeft(BufferView * bv)
 {
 	return bv->getParentLanguage(this)->RightToLeft();
 }
@@ -2465,19 +2544,25 @@ bool InsetTabular::doClearArea() const
 }
 
 
-void InsetTabular::getSelection(int & srow, int & erow, int & scol, int & ecol) const
+void InsetTabular::getSelection(int & srow, int & erow,
+				int & scol, int & ecol) const
 {
-		srow = tabular->row_of_cell(sel_cell_start);
-		erow = tabular->row_of_cell(sel_cell_end);
-		if (srow > erow)
-			swap(srow, erow);
+	int const start = hasSelection() ? sel_cell_start : actcell;
+	int const end = hasSelection() ? sel_cell_end : actcell;
+ 
+	srow = tabular->row_of_cell(start);
+	erow = tabular->row_of_cell(end);
+	if (srow > erow) {
+		swap(srow, erow);
+	}
 
-		scol = tabular->column_of_cell(sel_cell_start);
-		ecol = tabular->column_of_cell(sel_cell_end);
-		if (scol > ecol)
-			swap(scol, ecol);
-		else
-			ecol = tabular->right_column_of_cell(sel_cell_end);
+	scol = tabular->column_of_cell(start);
+	ecol = tabular->column_of_cell(end);
+	if (scol > ecol) {
+		swap(scol, ecol);
+	} else {
+		ecol = tabular->right_column_of_cell(end);
+	}
 }
 
 
@@ -2524,8 +2609,8 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const
 		return const_cast<InsetTabular *>(this);
 
 	Inset * result;
-	for(int i=0; i < tabular->rows(); ++i) {
-		for(int j=0; j < tabular->columns(); ++j) {
+	for(int i = 0; i < tabular->rows(); ++i) {
+		for(int j = 0; j < tabular->columns(); ++j) {
 			if ((result = tabular->GetCellInset(i, j)->getInsetFromID(id_arg)))
 				return result;
 		}
@@ -2534,19 +2619,23 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const
 }
 
 
-string const InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const
+string const
+InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const
 {
+	nodraw(true);
 	if (the_locking_inset) {
 		string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value));
-		if (!str.empty())
+		if (!str.empty()) {
+			nodraw(false);
 			return str;
+		}
 		if (tabular->IsLastCell(actcell)) {
 			bv->unlockInset(const_cast<InsetTabular *>(this));
+			nodraw(false);
 			return string();
 		}
 		++actcell;
 	}
-	nodraw(true);
 	// otherwise we have to lock the next inset and ask for it's selecttion
 	UpdatableInset * inset =
 		static_cast<UpdatableInset*>(tabular->GetCellInset(actcell));
@@ -2600,12 +2689,17 @@ void InsetTabular::toggleSelection(BufferView * bv, bool kill_selection)
 
 
 bool InsetTabular::searchForward(BufferView * bv, string const & str,
-                                 bool const & cs, bool const & mw)
+                                 bool cs, bool mw)
 {
+	nodraw(true);
 	if (the_locking_inset) {
-		if (the_locking_inset->searchForward(bv, str, cs, mw))
+		if (the_locking_inset->searchForward(bv, str, cs, mw)) {
+			nodraw(false);
+			updateLocal(bv, CELL, false);
 			return true;
+		}
 		if (tabular->IsLastCell(actcell)) {
+			nodraw(false);
 			bv->unlockInset(const_cast<InsetTabular *>(this));
 			return false;
 		}
@@ -2615,24 +2709,25 @@ bool InsetTabular::searchForward(BufferView * bv, string const & str,
 	UpdatableInset * inset =
 		static_cast<UpdatableInset*>(tabular->GetCellInset(actcell));
 	inset->edit(bv);
-#if 0
-	bool const res = searchForward(bv, str, cs, mw);
-	updateLocal(bv, NONE, false);
-	bv->updateInset(const_cast<InsetTabular *>(this), false);
-	return res;
-#else
-	return searchForward(bv, str, cs, mw);
-#endif
+	bool const ret = searchForward(bv, str, cs, mw);
+	nodraw(false);
+	updateLocal(bv, CELL, false);
+	return ret;
 }
 
 
 bool InsetTabular::searchBackward(BufferView * bv, string const & str,
-                               bool const & cs, bool const & mw)
+                               bool cs, bool mw)
 {
+	nodraw(true);
 	if (the_locking_inset) {
-		if (the_locking_inset->searchBackward(bv, str, cs, mw))
+		if (the_locking_inset->searchBackward(bv, str, cs, mw)) {
+			nodraw(false);
+			updateLocal(bv, CELL, false);
 			return true;
+		}
 		if (!actcell) { // we are already in the first cell
+			nodraw(false);
 			bv->unlockInset(const_cast<InsetTabular *>(this));
 			return false;
 		}
@@ -2642,13 +2737,10 @@ bool InsetTabular::searchBackward(BufferView * bv, string const & str,
 	UpdatableInset * inset =
 		static_cast<UpdatableInset*>(tabular->GetCellInset(actcell));
 	inset->edit(bv, false);
-#if 0
-	bool const res = searchBackward(bv, str, cs, mw);
-	bv->updateInset(const_cast<InsetTabular *>(this), false);
-	return res;
-#else
-	return searchBackward(bv, str, cs, mw);
-#endif
+	bool const ret = searchBackward(bv, str, cs, mw);
+	nodraw(false);
+	updateLocal(bv, CELL, false);
+	return ret;
 }
 
 
@@ -2658,3 +2750,18 @@ bool InsetTabular::insetAllowed(Inset::Code code) const
 		return the_locking_inset->insetAllowed(code);
 	return false;
 }
+
+
+bool InsetTabular::forceDefaultParagraphs(Inset const * in) const
+{
+	const int cell = tabular->GetCellFromInset(in, actcell);
+
+	if (cell != -1)
+		return tabular->GetPWidth(cell).zero();
+
+	// well we didn't obviously find it so maybe our owner knows more
+	if (owner())
+		return owner()->forceDefaultParagraphs(in);
+	// if we're here there is really something strange going on!!!
+	return false;
+}