X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=6e68763d7d0ce0c7a157d146bf3ee0e8b008d6ff;hb=b922cdd796f9e4b9a46a79808cdee596e04903eb;hp=f54ef6e196c6ec9ba6610c384219a86db1e87be8;hpb=45bd81a203238ef43a026463d6dcf0fd020beedb;p=lyx.git

diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C
index f54ef6e196..6e68763d7d 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
@@ -33,16 +27,27 @@
 #include "lyx_gui_misc.h"
 #include "LyXView.h"
 #include "insets/insettext.h"
-#include "frontends/Dialogs.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::ostream;
 using std::ifstream;
 using std::max;
@@ -52,8 +57,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;
 
@@ -63,7 +69,6 @@ struct TabularFeature {
 	string feature;
 };
 
-//tabular_features * tabularFeatures = 0;
 
 TabularFeature tabularFeature[] =
 {
@@ -133,12 +138,13 @@ 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;
+	locked = false;
 	oldcell = -1;
 	actrow = actcell = 0;
 	clearSelection();
 	need_update = INIT;
 	in_update = false;
+	in_reset_pos = false;
 }
 
 
@@ -146,14 +152,15 @@ 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;
+	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;
 }
 
 
@@ -180,9 +187,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;
@@ -293,11 +297,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;
@@ -352,7 +356,7 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 		}
 		i = tabular->row_of_cell(cell);
 		if (the_locking_inset != tabular->GetCellInset(cell)) {
-			lyxerr[Debug::INSETS] << "ERROR this shouldn't happen\n";
+			lyxerr[Debug::INSETTEXT] << "ERROR this shouldn't happen\n";
 			return;
 		}
 		float dx = nx + tabular->GetBeginningOfTextInCell(cell);
@@ -397,7 +401,7 @@ void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 	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;
@@ -408,7 +412,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;
@@ -445,6 +449,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) {
@@ -456,7 +461,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);
@@ -523,7 +529,7 @@ void InsetTabular::edit(BufferView * bv, int x, int y, unsigned int button)
 	UpdatableInset::edit(bv, x, y, button);
 	
 	if (!bv->lockInset(this)) {
-		lyxerr[Debug::INSETS] << "InsetTabular::Cannot lock inset" << endl;
+		lyxerr[Debug::INSETTEXT] << "InsetTabular::Cannot lock inset" << endl;
 		return;
 	}
 	locked = true;
@@ -531,7 +537,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);
@@ -544,7 +550,7 @@ void InsetTabular::edit(BufferView * bv, bool front)
 	UpdatableInset::edit(bv, front);
 	
 	if (!bv->lockInset(this)) {
-		lyxerr[Debug::INSETS] << "InsetTabular::Cannot lock inset" << endl;
+		lyxerr[Debug::INSETTEXT] << "InsetTabular::Cannot lock inset" << endl;
 		return;
 	}
 	locked = true;
@@ -555,7 +561,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();
 }
@@ -568,11 +574,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);
 		}
@@ -584,10 +589,15 @@ void InsetTabular::insetUnlock(BufferView * bv)
 void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what,
 			       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 ((what == INIT) && hasSelection()) {
 		clearSelection();
+	}
 	// Dirty Cast! (Lgb)
 	if (need_update != NONE) {
 		bv->updateInset(const_cast<InsetTabular *>(this), mark_dirty);
@@ -599,24 +609,44 @@ void InsetTabular::updateLocal(BufferView * bv, UpdateCodes what,
 
 bool InsetTabular::lockInsetInInset(BufferView * bv, UpdatableInset * inset)
 {
-	lyxerr[Debug::INSETS] << "InsetTabular::LockInsetInInset("
+	lyxerr[Debug::INSETTEXT] << "InsetTabular::LockInsetInInset("
 			      << inset << "): ";
 	if (!inset)
 		return false;
 	oldcell = -1;
 	if (inset == tabular->GetCellInset(actcell)) {
-		lyxerr[Debug::INSETS] << "OK" << endl;
+		lyxerr[Debug::INSETTEXT] << "OK" << endl;
 		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;
+				the_locking_inset = in;
+				locked = true;
+				resetPos(bv);
+				return the_locking_inset->lockInsetInInset(bv, inset);
+			}
+		}
 	} else if (the_locking_inset && (the_locking_inset == inset)) {
-		lyxerr[Debug::INSETS] << "OK" << endl;
+		lyxerr[Debug::INSETTEXT] << "OK" << endl;
 		resetPos(bv);
 	} else if (the_locking_inset) {
-		lyxerr[Debug::INSETS] << "MAYBE" << endl;
+		lyxerr[Debug::INSETTEXT] << "MAYBE" << endl;
 		return the_locking_inset->lockInsetInInset(bv, inset);
 	}
-	lyxerr[Debug::INSETS] << "NOT OK" << endl;
+	lyxerr[Debug::INSETTEXT] << "NOT OK" << endl;
 	return false;
 }
 
@@ -709,8 +739,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;
 
@@ -718,7 +746,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);
@@ -727,6 +756,7 @@ void InsetTabular::insetButtonPress(BufferView * bv, int x, int y, int button)
 		showInsetCursor(bv);
 		return;
 	}
+#endif
 
 	bool const inset_hit = insetHit(bv, x, y);
 
@@ -756,27 +786,17 @@ 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, 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;
 }
 
 
@@ -789,17 +809,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);
 }
 
 
@@ -819,7 +840,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) {
@@ -840,15 +860,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) {
@@ -878,81 +895,115 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 			updateLocal(bv, CELL, false);
 			the_locking_inset->toggleInsetCursor(bv);
 			return result;
+		} else if (result == FINISHED_UP) {
+			action = LFUN_UP;
+		} else if (result == FINISHED_DOWN) {
+			action = LFUN_DOWN;
+		} else if (result == FINISHED_RIGHT) {
+			action = LFUN_RIGHT;
 		}
 	}
 
 	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 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)))
-			sel_cell_end = tabular->GetCellBelow(sel_cell_end);
+			setSelection(start, tabular->GetCellBelow(sel_cell_end));
 		else
-			sel_cell_end = tabular->GetLastCellBelow(sel_cell_end);
+			setSelection(start, tabular->GetLastCellBelow(sel_cell_end));
 		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 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)))
-			sel_cell_end = tabular->GetCellAbove(sel_cell_end);
+			setSelection(start, tabular->GetCellAbove(sel_cell_end));
 		else
-			sel_cell_end = tabular->GetLastCellAbove(sel_cell_end);
+			setSelection(start, tabular->GetLastCellAbove(sel_cell_end));
 		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;
-		}
+		unlockInsetInInset(bv, the_locking_inset);
 		if (bv->text->first + bv->painter().paperHeight() <
 		    (top_baseline + tabular->GetHeightOfTabular()))
 			{
@@ -968,10 +1019,7 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 	}
 	case LFUN_PRIOR: {
 		int column = actcol;
-		if (the_locking_inset) {
-			unlockInsetInInset(bv, the_locking_inset);
-			the_locking_inset = 0;
-		}
+		unlockInsetInInset(bv, the_locking_inset);
 		if (top_baseline < 0) {
 			bv->scrollCB(bv->text->first - bv->painter().paperHeight());
 			updateLocal(bv, FULL, false);
@@ -986,19 +1034,29 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 		updateLocal(bv, CURSOR, 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:
 		break;
 	case LFUN_LAYOUT_TABULAR:
-	{
 		bv->owner()->getDialogs()->showTabular(this);
-	}
-	break;
+		break;
 	case LFUN_TABULAR_FEATURE:
 		if (!tabularFeatures(bv, arg))
 			result = UNDISPATCHED;
@@ -1028,10 +1086,10 @@ InsetTabular::localDispatch(BufferView * bv, kb_action action,
 			int cols = 1;
 			int rows = 1;
 			int maxCols = 1;
-			unsigned int len = clip.length();
+			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]) {
 				case '\t':
@@ -1053,7 +1111,7 @@ 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;
@@ -1065,7 +1123,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;
@@ -1108,7 +1166,6 @@ 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;
@@ -1132,28 +1189,48 @@ 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 *, ostream &) const
+int InsetTabular::linuxdoc(Buffer const * buf, ostream & os) const
 {
-	return 0;
+	return tabular->ascii(buf,os, (int)parOwner()->params().depth(), false, 0);
 }
 
 
-int InsetTabular::docBook(Buffer const * buf, ostream & os) const
+int InsetTabular::docbook(Buffer const * buf, ostream & os) const
 {
-	return tabular->DocBook(buf,os);
+	int ret = 0;
+	Inset * master;
+
+	// if the table is inside a float it doesn't need the informaltable
+	// wrapper. Search for it.
+	for(master = owner();
+	    master && master->lyxCode() != Inset::FLOAT_CODE;
+	    master = master->owner());
+
+	if (!master) {
+		os << "<informaltable>\n";
+		ret++;
+	}
+	ret+= tabular->docBook(buf,os);
+	if (!master) {
+		os << "</informaltable>\n";
+		ret++;
+	}
+	return ret;
 }
 
 
@@ -1196,7 +1273,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));
@@ -1205,6 +1282,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;
 }
 
@@ -1286,7 +1365,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));
@@ -1325,6 +1404,12 @@ 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;
@@ -1388,6 +1473,7 @@ void InsetTabular::resetPos(BufferView * bv) const
 		bv->owner()->getDialogs()->updateTabular(inset);
 		oldcell = actcell;
 	}
+	in_reset_pos = false;
 }
 
 
@@ -1523,7 +1609,7 @@ bool InsetTabular::movePrevCell(BufferView * bv, bool lock)
 }
 
 
-bool InsetTabular::deletable()
+bool InsetTabular::deletable() const
 {
 	return true;
 }
@@ -1533,8 +1619,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,
@@ -1587,6 +1672,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,
@@ -1603,27 +1706,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;
@@ -1638,19 +1741,24 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 	        bv->text->cursor.par(),
 	        bv->text->cursor.par()->next());
 
-	int 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);
 		}
@@ -1658,8 +1766,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))->
@@ -1800,7 +1911,7 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 	case LyXTabular::MULTICOLUMN:
 	{
 		if (sel_row_start != sel_row_end) {
-			WriteAlert(_("Impossible Operation!"), 
+			Alert::alert(_("Impossible Operation!"), 
 				   _("Multicolumns can only be horizontally."), 
 				   _("Sorry."));
 			return;
@@ -1831,7 +1942,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;
 	}
@@ -1882,22 +1993,38 @@ void InsetTabular::tabularFeatures(BufferView * bv,
 					tabular->GetCellNumber(i, j), val);
 		break;
 	}
+	case LyXTabular::UNSET_LTFIRSTHEAD:
+		flag = false;
 	case LyXTabular::SET_LTFIRSTHEAD:
-		tabular->SetLTHead(actcell, true);
+		(void)tabular->GetRowOfLTFirstHead(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTHead(row, flag, ltt, true);
 		break;
+	case LyXTabular::UNSET_LTHEAD:
+		flag = false;
 	case LyXTabular::SET_LTHEAD:
-		tabular->SetLTHead(actcell, false);
+		(void)tabular->GetRowOfLTHead(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTHead(row, flag, ltt, false);
 		break;
+	case LyXTabular::UNSET_LTFOOT:
+		flag = false;
 	case LyXTabular::SET_LTFOOT:
-		tabular->SetLTFoot(actcell, false);
+		(void)tabular->GetRowOfLTFoot(row, ltt);
+		checkLongtableSpecial(ltt, value, flag);
+		tabular->SetLTFoot(row, flag, ltt, false);
 		break;
+	case LyXTabular::UNSET_LTLASTFOOT:
+		flag = false;
 	case LyXTabular::SET_LTLASTFOOT:
-		tabular->SetLTFoot(actcell, 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
@@ -1948,11 +2075,14 @@ 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);
+#ifdef WITH_WARNINGS
+#warning Remove use of VSpace as soon as LyXLength::inPixels exists (JMarc)
+#endif
+	return VSpace(len).inPixels(bv);
 }
 
 
@@ -1964,7 +2094,7 @@ int InsetTabular::getMaxWidth(BufferView * bv,
 		cell = actcell;
 		if (tabular->GetCellInset(cell) != inset) {
 			
-			lyxerr << "Actcell not equal to actual cell!\n";
+			lyxerr[Debug::INSETTEXT] << "Actcell not equal to actual cell!\n";
 			cell = -1;
 		}
 	}
@@ -2084,6 +2214,7 @@ func_status::value_type InsetTabular::getStatus(string const & what) const
 	int sel_row_start;
 	int sel_row_end;
 	int dummy;
+	LyXTabular::ltType dummyltt;
 	bool flag = true;
 
 	if (hasSelection()) {
@@ -2238,31 +2369,31 @@ func_status::value_type InsetTabular::getStatus(string const & what) const
 			status |= func_status::ToggleOff;
 		break;
 	case LyXTabular::SET_LTFIRSTHEAD:
-		if (tabular->GetRowOfLTHead(actcell, dummy))
+		if (tabular->GetRowOfLTHead(sel_row_start, dummyltt))
 			status |= func_status::ToggleOn;
 		else
 			status |= func_status::ToggleOff;
 		break;
 	case LyXTabular::SET_LTHEAD:
-		if (tabular->GetRowOfLTHead(actcell, dummy))
+		if (tabular->GetRowOfLTHead(sel_row_start, dummyltt))
 			status |= func_status::ToggleOn;
 		else
 			status |= func_status::ToggleOff;
 		break;
 	case LyXTabular::SET_LTFOOT:
-		if (tabular->GetRowOfLTFoot(actcell, dummy))
+		if (tabular->GetRowOfLTFoot(sel_row_start, dummyltt))
 			status |= func_status::ToggleOn;
 		else
 			status |= func_status::ToggleOff;
 		break;
 	case LyXTabular::SET_LTLASTFOOT:
-		if (tabular->GetRowOfLTFoot(actcell, dummy))
+		if (tabular->GetRowOfLTFoot(sel_row_start, dummyltt))
 			status |= func_status::ToggleOn;
 		else
 			status |= func_status::ToggleOff;
 		break;
 	case LyXTabular::SET_LTNEWPAGE:
-		if (tabular->GetLTNewPage(actcell))
+		if (tabular->GetLTNewPage(sel_row_start))
 			status |= func_status::ToggleOn;
 		else
 			status |= func_status::ToggleOff;
@@ -2307,10 +2438,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);
@@ -2321,7 +2452,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;
 }
@@ -2421,19 +2553,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);
+	}
 }
 
 
@@ -2458,6 +2596,14 @@ Paragraph * InsetTabular::firstParagraph() const
 }
 
 
+Paragraph * InsetTabular::getFirstParagraph(int i) const
+{
+	return (i < tabular->GetNumberOfCells())
+		? tabular->GetCellInset(i)->getFirstParagraph(0)
+		: 0;
+}
+
+
 LyXCursor const & InsetTabular::cursor(BufferView * bv) const
 {
 	if (the_locking_inset)
@@ -2472,8 +2618,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;
 		}
@@ -2482,10 +2628,11 @@ Inset * InsetTabular::getInsetFromID(int id_arg) const
 }
 
 
-string const InsetTabular::selectNextWord(BufferView * bv, float & value) const
+string const
+InsetTabular::selectNextWordToSpellcheck(BufferView * bv, float & value) const
 {
 	if (the_locking_inset) {
-		string const str(the_locking_inset->selectNextWord(bv, value));
+		string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value));
 		if (!str.empty())
 			return str;
 		if (tabular->IsLastCell(actcell)) {
@@ -2512,7 +2659,7 @@ string InsetTabular::selectNextWordInt(BufferView * bv, float & value) const
 	// when entering this function the inset should be ALWAYS locked!
 	lyx::Assert(the_locking_inset);
 
-	string const str(the_locking_inset->selectNextWord(bv, value));
+	string const str(the_locking_inset->selectNextWordToSpellcheck(bv, value));
 	if (!str.empty())
 		return str;