X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Finsets%2Finsettabular.C;h=fd5c283bf5ec97c75b41791d0ca0e9d53f7248d0;hb=4acce5c117e0d6101113f38e2e058d284b866de9;hp=2ee3c69ddd61343c7b9197fb088bf1b7393532b8;hpb=b634b3eb3b5cc1c47fd3bc63294e16536d4f7664;p=lyx.git

diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C
index 2ee3c69ddd..fd5c283bf5 100644
--- a/src/insets/insettabular.C
+++ b/src/insets/insettabular.C
@@ -37,8 +37,7 @@
 #include "frontends/LyXView.h"
 #include "frontends/Painter.h"
 
-#include "support/std_sstream.h"
-
+#include <sstream>
 #include <iostream>
 
 using lyx::graphics::PreviewLoader;
@@ -156,17 +155,13 @@ bool InsetTabular::hasPasteBuffer() const
 InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
 	: tabular(buf.params(), max(rows, 1), max(columns, 1)),
 	  buffer_(&buf), cursorx_(0)
-{
-	tabular.setOwner(this);
-}
+{}
 
 
 InsetTabular::InsetTabular(InsetTabular const & tab)
 	: UpdatableInset(tab), tabular(tab.tabular),
 		buffer_(tab.buffer_), cursorx_(0)
-{
-	tabular.setOwner(this);
-}
+{}
 
 
 InsetTabular::~InsetTabular()
@@ -187,7 +182,7 @@ Buffer const & InsetTabular::buffer() const
 }
 
 
-void InsetTabular::buffer(Buffer * b)
+void InsetTabular::buffer(Buffer const * b)
 {
 	buffer_ = b;
 }
@@ -209,10 +204,10 @@ void InsetTabular::read(Buffer const & buf, LyXLex & lex)
 	if (old_format)
 		return;
 
-	lex.nextToken();
+	lex.next();
 	string token = lex.getString();
 	while (lex.isOK() && (token != "\\end_inset")) {
-		lex.nextToken();
+		lex.next();
 		token = lex.getString();
 	}
 	if (token != "\\end_inset") {
@@ -240,8 +235,10 @@ void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const
 			++cell;
 			Dimension dim;
 			MetricsInfo m = mi;
-			m.base.textwidth =
-				tabular.column_info[j].p_width.inPixels(mi.base.textwidth);
+			LyXLength p_width = tabular.column_info[j].p_width;
+			if (!p_width.zero()) {
+				m.base.textwidth = p_width.inPixels(mi.base.textwidth);
+			}
 			tabular.getCellInset(cell).metrics(m, dim);
 			maxAsc  = max(maxAsc, dim.asc);
 			maxDesc = max(maxDesc, dim.des);
@@ -265,9 +262,7 @@ void InsetTabular::draw(PainterInfo & pi, int x, int y) const
 	BufferView * bv = pi.base.bv;
 	setPosCache(pi, x, y);
 
-	if (!owner())
-		x += scroll();
-
+	x += scroll();
 	x += ADD_TO_TABULAR_WIDTH;
 
 	int idx = 0;
@@ -275,12 +270,11 @@ void InsetTabular::draw(PainterInfo & pi, int x, int y) const
 	for (int i = 0; i < tabular.rows(); ++i) {
 		int nx = x;
 		idx = tabular.getCellNumber(i, 0);
-		if (y + tabular.getDescentOfRow(i) <= 0 &&
-			  y - tabular.getAscentOfRow(i) < pi.pain.paperHeight())
-		{
-			y += tabular.getDescentOfRow(i) +
-					tabular.getAscentOfRow(i + 1) +
-					tabular.getAdditionalHeight(i + 1);
+		if (y + tabular.getDescentOfRow(i) <= 0
+		    && y - tabular.getAscentOfRow(i) < pi.pain.paperHeight()) {
+			y += tabular.getDescentOfRow(i)
+				+ tabular.getAscentOfRow(i + 1)
+				+ tabular.getAdditionalHeight(i + 1);
 			continue;
 		}
 		for (int j = 0; j < tabular.columns(); ++j) {
@@ -382,6 +376,7 @@ void InsetTabular::edit(LCursor & cur, bool left)
 	lyxerr << "InsetTabular::edit: " << this << endl;
 	finishUndo();
 	int cell;
+	cur.push(*this);
 	if (left) {
 		if (isRightToLeft(cur))
 			cell = tabular.getLastCellInRow(0);
@@ -394,20 +389,20 @@ void InsetTabular::edit(LCursor & cur, bool left)
 			cell = tabular.getNumberOfCells() - 1;
 	}
 	cur.selection() = false;
-	resetPos(cur);
-	cur.bv().fitCursor();
-	cur.push(*this);
+	// this accesses the position cache before it is initialized
+	//resetPos(cur);
+	//cur.bv().fitCursor();
 	cur.idx() = cell;
 }
 
 
-InsetBase * InsetTabular::editXY(LCursor & cur, int x, int y)
+InsetBase * InsetTabular::editXY(LCursor & cur, int x, int y) const
 {
 	//lyxerr << "InsetTabular::editXY: " << this << endl;
 	cur.selection() = false;
-	cur.push(*this);
+	cur.push(const_cast<InsetTabular&>(*this));
 	return setPos(cur, x, y);
-	//int xx = cursorx_ - xo_ + tabular.getBeginningOfTextInCell(actcell);
+	//int xx = cursorx_ - xo() + tabular.getBeginningOfTextInCell(actcell);
 }
 
 
@@ -416,32 +411,43 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 	lyxerr << "# InsetTabular::dispatch: cmd: " << cmd << endl;
 	//lyxerr << "  cur:\n" << cur << endl;
 	CursorSlice sl = cur.top();
+	LCursor & bvcur = cur.bv().cursor();
 
 	switch (cmd.action) {
 
 	case LFUN_MOUSE_PRESS:
-		// we'll pop up the table dialog on release
-		if (cmd.button() == mouse_button::button3)
+		lyxerr << "# InsetTabular::MousePress\n" << cur.bv().cursor() << endl;
+
+		if (cmd.button() == mouse_button::button1) {
+			cur.selection() = false;
+			setPos(cur, cmd.x, cmd.y);
+			cur.resetAnchor();
+			bvcur = cur;
 			break;
-		cur.selection() = false;
-		setPos(cur, cmd.x, cmd.y);
-		cur.resetAnchor();
-		cur.bv().cursor().setCursor(cur, false);
+		}
+
 		//if (cmd.button() == mouse_button::button2)
 		//	dispatch(cur, FuncRequest(LFUN_PASTESELECTION, "paragraph"));
-		//lyxerr << "# InsetTabular::MousePress\n" << cur.bv().cursor() << endl;
+
+		// we'll pop up the table dialog on release
+		if (cmd.button() == mouse_button::button3)
+			break;
 		break;
 
 	case LFUN_MOUSE_MOTION:
-		if (cmd.button() != mouse_button::button1)
-			break;
-		setPos(cur, cmd.x, cmd.y);
-		cur.bv().cursor().setCursor(cur, true);
-		//lyxerr << "# InsetTabular::MouseMotion\n" << cur.bv().cursor() << endl;
+		lyxerr << "# InsetTabular::MouseMotion\n" << bvcur << endl;
+		if (cmd.button() == mouse_button::button1) {
+			// only accept motions to places not deeper nested than the real anchor
+			if (bvcur.anchor_.hasPart(cur)) {
+				setPos(cur, cmd.x, cmd.y);
+				bvcur.setCursor(cur);
+				bvcur.selection() = true;
+			}
+		}
 		break;
 
 	case LFUN_MOUSE_RELEASE:
-		//lyxerr << "# InsetTabular::MouseRelease\n" << cur.bv().cursor() << endl;
+		lyxerr << "# InsetTabular::MouseRelease\n" << bvcur << endl;
 		if (cmd.button() == mouse_button::button3)
 			InsetTabularMailer(*this).showDialog(&cur.bv());
 		break;
@@ -463,12 +469,12 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 			scroll(cur.bv(), static_cast<float>(strToDbl(cmd.argument)));
 		else
 			scroll(cur.bv(), strToInt(cmd.argument));
-		cur.update();
 		break;
 
 	case LFUN_RIGHTSEL:
 	case LFUN_RIGHT:
 		cell(cur.idx()).dispatch(cur, cmd);
+		cur.dispatched(); // override the cell's decision
 		if (sl == cur.top())
 			isRightToLeft(cur) ? movePrevCell(cur) : moveNextCell(cur);
 		if (sl == cur.top()) {
@@ -477,9 +483,10 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 		}
 		break;
 
-	case LFUN_LEFTSEL: 
+	case LFUN_LEFTSEL:
 	case LFUN_LEFT:
 		cell(cur.idx()).dispatch(cur, cmd);
+		cur.dispatched(); // override the cell's decision
 		if (sl == cur.top())
 			isRightToLeft(cur) ? moveNextCell(cur) : movePrevCell(cur);
 		if (sl == cur.top()) {
@@ -491,6 +498,7 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 	case LFUN_DOWNSEL:
 	case LFUN_DOWN:
 		cell(cur.idx()).dispatch(cur, cmd);
+		cur.dispatched(); // override the cell's decision
 		if (sl == cur.top())
 			if (tabular.row_of_cell(cur.idx()) != tabular.rows() - 1) {
 				cur.idx() = tabular.getCellBelow(cur.idx());
@@ -507,6 +515,7 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 	case LFUN_UPSEL:
 	case LFUN_UP:
 		cell(cur.idx()).dispatch(cur, cmd);
+		cur.dispatched(); // override the cell's decision
 		if (sl == cur.top())
 			if (tabular.row_of_cell(cur.idx()) != 0) {
 				cur.idx() = tabular.getCellAbove(cur.idx());
@@ -527,7 +536,7 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 		int actcol = tabular.column_of_cell(actcell);
 		int column = actcol;
 		if (cur.bv().top_y() + cur.bv().painter().paperHeight()
-				< yo_ + tabular.getHeightOfTabular())
+				< yo() + tabular.getHeightOfTabular())
 		{
 			cur.bv().scrollDocView(
 				cur.bv().top_y() + cur.bv().painter().paperHeight());
@@ -543,10 +552,10 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 		//if (hasSelection())
 		//	cur.selection() = false;
 		int column = tabular.column_of_cell(cur.idx());
-		if (yo_ < 0) {
+		if (yo() < 0) {
 			cur.bv().scrollDocView(
 				cur.bv().top_y() - cur.bv().painter().paperHeight());
-			if (yo_ > 0)
+			if (yo() > 0)
 				cur.idx() = column;
 			else
 				cur.idx() = tabular.getCellBelow(first_visible_cell) + column;
@@ -579,19 +588,6 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	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:
-		lyxerr << "font changes not re-implemented for tables after LOCK" << endl;
-		break;
-
 	case LFUN_CUT:
 		if (copySelection(cur)) {
 			recordUndo(cur, Undo::DELETE);
@@ -643,7 +639,7 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 			maxCols = max(cols, maxCols);
 
 			paste_tabular.reset(
-				new LyXTabular(cur.bv().buffer()->params(), rows, maxCols));
+				new LyXTabular(cur.buffer().params(), rows, maxCols));
 
 			string::size_type op = 0;
 			int cell = 0;
@@ -703,75 +699,185 @@ void InsetTabular::priv_dispatch(LCursor & cur, FuncRequest & cmd)
 }
 
 
+// function sets an object as defined in func_status.h:
+// states OK, Unknown, Disabled, On, Off.
 bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd,
-	FuncStatus & flag) const
+	FuncStatus & status) const
 {
 	switch (cmd.action) {
-	case LFUN_TABULAR_FEATURE:
-#if 0
-		if (cur.inMathed()) {
-			// FIXME: check temporarily disabled
-			// valign code
-			char align = mathcursor::valign();
-			if (align == '\0') {
-				enable = false;
-				break;
-			}
-			if (cmd.argument.empty()) {
-				flag.clear();
-				break;
-			}
-			if (!contains("tcb", cmd.argument[0])) {
-				enable = false;
+	case LFUN_TABULAR_FEATURE: {
+		int actcell = cur.idx();
+		int action = LyXTabular::LAST_ACTION;
+		int i = 0;
+		for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) {
+			string const tmp = tabularFeature[i].feature;
+			if (tmp == cmd.argument.substr(0, tmp.length())) {
+				action = tabularFeature[i].action;
 				break;
 			}
-			flag.setOnOff(cmd.argument[0] == align);
-		} else {
-			enable = false;
+		}
+		if (action == LyXTabular::LAST_ACTION) {
+			status.clear();
+			status.unknown(true);
+			return true;
+		}
 
-			char const align = mathcursor::halign();
-			if (align == '\0') {
-				enable = false;
-				break;
-			}
-			if (cmd.argument.empty()) {
-				flag.clear();
-				break;
-			}
-			if (!contains("lcr", cmd.argument[0])) {
-				enable = false;
-				break;
-			}
-			flag.setOnOff(cmd.argument[0] == align);
+		string const argument
+			= ltrim(cmd.argument.substr(tabularFeature[i].feature.length()));
+
+		int sel_row_start = 0;
+		int sel_row_end = 0;
+		int dummy;
+		LyXTabular::ltType dummyltt;
+		bool flag = true;
+
+		getSelection(cur, sel_row_start, sel_row_end, dummy, dummy);
+
+		switch (action) {
+		case LyXTabular::SET_PWIDTH:
+		case LyXTabular::SET_MPWIDTH:
+		case LyXTabular::SET_SPECIAL_COLUMN:
+		case LyXTabular::SET_SPECIAL_MULTI:
+		case LyXTabular::APPEND_ROW:
+		case LyXTabular::APPEND_COLUMN:
+		case LyXTabular::DELETE_ROW:
+		case LyXTabular::DELETE_COLUMN:
+		case LyXTabular::SET_ALL_LINES:
+		case LyXTabular::UNSET_ALL_LINES:
+			status.clear();
+			return true;
+
+		case LyXTabular::MULTICOLUMN:
+			status.setOnOff(tabular.isMultiColumn(actcell));
+			break;
 
-			disable = !mathcursor::halign();
+		case LyXTabular::M_TOGGLE_LINE_TOP:
+			flag = false;
+		case LyXTabular::TOGGLE_LINE_TOP:
+			status.setOnOff(tabular.topLine(actcell, flag));
 			break;
-		}
 
-			FuncStatus ret;
-			//ret.disabled(true);
-			InsetTabular * tab = static_cast<InsetTabular *>
-				(cur.innerInsetOfType(InsetBase::TABULAR_CODE));
-			if (tab) {
-				ret = tab->getStatus(cmd.argument);
-				flag |= ret;
-				enable = true;
-			} else {
-				enable = false;
-			}
-		} else {
-			static InsetTabular inset(*buf, 1, 1);
-			enable = false;
-			FuncStatus ret = inset.getStatus(cmd.argument);
-			if (ret.onoff(true) || ret.onoff(false))
-				flag.setOnOff(false);
+		case LyXTabular::M_TOGGLE_LINE_BOTTOM:
+			flag = false;
+		case LyXTabular::TOGGLE_LINE_BOTTOM:
+			status.setOnOff(tabular.bottomLine(actcell, flag));
+			break;
+
+		case LyXTabular::M_TOGGLE_LINE_LEFT:
+			flag = false;
+		case LyXTabular::TOGGLE_LINE_LEFT:
+			status.setOnOff(tabular.leftLine(actcell, flag));
+			break;
+
+		case LyXTabular::M_TOGGLE_LINE_RIGHT:
+			flag = false;
+		case LyXTabular::TOGGLE_LINE_RIGHT:
+			status.setOnOff(tabular.rightLine(actcell, flag));
+			break;
+
+		case LyXTabular::M_ALIGN_LEFT:
+			flag = false;
+		case LyXTabular::ALIGN_LEFT:
+			status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_LEFT);
+			break;
+
+		case LyXTabular::M_ALIGN_RIGHT:
+			flag = false;
+		case LyXTabular::ALIGN_RIGHT:
+			status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_RIGHT);
+			break;
+
+		case LyXTabular::M_ALIGN_CENTER:
+			flag = false;
+		case LyXTabular::ALIGN_CENTER:
+			status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_CENTER);
+			break;
+
+		case LyXTabular::ALIGN_BLOCK:
+			status.enabled(!tabular.getPWidth(actcell).zero());
+			status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_BLOCK);
+			break;
+
+		case LyXTabular::M_VALIGN_TOP:
+			flag = false;
+		case LyXTabular::VALIGN_TOP:
+			status.setOnOff(
+				tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP);
+			break;
+
+		case LyXTabular::M_VALIGN_BOTTOM:
+			flag = false;
+		case LyXTabular::VALIGN_BOTTOM:
+			status.setOnOff(
+				tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM);
+			break;
+
+		case LyXTabular::M_VALIGN_MIDDLE:
+			flag = false;
+		case LyXTabular::VALIGN_MIDDLE:
+			status.setOnOff(
+				tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_MIDDLE);
+			break;
+
+		case LyXTabular::SET_LONGTABULAR:
+			status.setOnOff(tabular.isLongTabular());
+			break;
+
+		case LyXTabular::UNSET_LONGTABULAR:
+			status.setOnOff(!tabular.isLongTabular());
+			break;
+
+		case LyXTabular::SET_ROTATE_TABULAR:
+			status.setOnOff(tabular.getRotateTabular());
+			break;
+
+		case LyXTabular::UNSET_ROTATE_TABULAR:
+			status.setOnOff(!tabular.getRotateTabular());
+			break;
+
+		case LyXTabular::SET_ROTATE_CELL:
+			status.setOnOff(tabular.getRotateCell(actcell));
+			break;
+
+		case LyXTabular::UNSET_ROTATE_CELL:
+			status.setOnOff(!tabular.getRotateCell(actcell));
+			break;
+
+		case LyXTabular::SET_USEBOX:
+			status.setOnOff(strToInt(argument) == tabular.getUsebox(actcell));
+			break;
+
+		case LyXTabular::SET_LTFIRSTHEAD:
+			status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt));
+			break;
+
+		case LyXTabular::SET_LTHEAD:
+			status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt));
+			break;
+
+		case LyXTabular::SET_LTFOOT:
+			status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt));
+			break;
+
+		case LyXTabular::SET_LTLASTFOOT:
+			status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt));
+			break;
+
+		case LyXTabular::SET_LTNEWPAGE:
+			status.setOnOff(tabular.getLTNewPage(sel_row_start));
+			break;
+
+		default:
+			status.clear();
+			status.enabled(false);
+			break;
 		}
-#endif
 		return true;
+	}
 
 	default:
 		// we try to handle this event in the insets dispatch function.
-		return cell(cur.idx()).getStatus(cur, cmd, flag);
+		return cell(cur.idx()).getStatus(cur, cmd, status);
 	}
 }
 
@@ -786,7 +892,7 @@ int InsetTabular::latex(Buffer const & buf, ostream & os,
 int InsetTabular::plaintext(Buffer const & buf, ostream & os,
 			OutputParams const & runparams) const
 {
-	int dp = runparams.linelen ? ownerPar(buf, this).params().depth() : 0;
+	int dp = runparams.linelen ? runparams.depth : 0;
 	return tabular.plaintext(buf, os, runparams, dp, false, 0);
 }
 
@@ -802,13 +908,18 @@ int InsetTabular::docbook(Buffer const & buf, ostream & os,
 			  OutputParams const & runparams) const
 {
 	int ret = 0;
-	InsetOld * master;
+	InsetOld * master = 0;
 
+#ifdef WITH_WARNINGS
+#warning Why not pass a proper DocIterator here?
+#endif
+#if 0
 	// if the table is inside a float it doesn't need the informaltable
 	// wrapper. Search for it.
 	for (master = owner(); master; master = master->owner())
 		if (master->lyxCode() == InsetOld::FLOAT_CODE)
 			break;
+#endif
 
 	if (!master) {
 		os << "<informaltable>";
@@ -845,7 +956,7 @@ InsetText & InsetTabular::cell(int idx)
 }
 
 
-void InsetTabular::getCursorPos(CursorSlice const & cur, int & x, int & y) const
+void InsetTabular::getCursorPos(LCursor const & cur, int & x, int & y) const
 {
 	cell(cur.idx()).getCursorPos(cur, x, y);
 }
@@ -853,6 +964,7 @@ void InsetTabular::getCursorPos(CursorSlice const & cur, int & x, int & y) const
 
 InsetBase * InsetTabular::setPos(LCursor & cur, int x, int y) const
 {
+	lyxerr << "# InsetTabular::setPos()  x=" << x << " y=" << y << endl;
 	int idx_min = 0;
 	int dist_min = 1000000;
 	for (idx_type i = 0; i < nargs(); ++i) {
@@ -879,7 +991,7 @@ int InsetTabular::getCellXPos(int cell) const
 	for (; c < cell; ++c)
 		lx += tabular.getWidthOfColumn(c);
 
-	return lx - tabular.getWidthOfColumn(cell) + xo_;
+	return lx - tabular.getWidthOfColumn(cell) + xo();
 }
 
 
@@ -904,8 +1016,8 @@ void InsetTabular::resetPos(LCursor & cur) const
 		scroll(bv, - tabular.getWidthOfColumn(actcell) - 20);
 	} else if (cursorx_ - offset < 20) {
 		scroll(bv, 20 - cursorx_ + offset);
-	} else if (scroll() && xo_ > 20 &&
-		   xo_ + tabular.getWidthOfTabular() > bv.workWidth() - 20) {
+	} else if (scroll() && xo() > 20 &&
+		   xo() + tabular.getWidthOfTabular() > bv.workWidth() - 20) {
 		scroll(bv, old_x - cursorx_);
 	}
 
@@ -915,8 +1027,9 @@ void InsetTabular::resetPos(LCursor & cur) const
 
 void InsetTabular::moveNextCell(LCursor & cur)
 {
-	lyxerr << "InsetTabular::moveNextCell 1 cur: " << cur << endl;
+	lyxerr << "InsetTabular::moveNextCell 1 cur: " << cur.top() << endl;
 	if (isRightToLeft(cur)) {
+		lyxerr << "InsetTabular::moveNextCell A cur: " << endl;
 		if (tabular.isFirstCellInRow(cur.idx())) {
 			int row = tabular.row_of_cell(cur.idx());
 			if (row == tabular.rows() - 1)
@@ -929,13 +1042,14 @@ void InsetTabular::moveNextCell(LCursor & cur)
 			--cur.idx();
 		}
 	} else {
+		lyxerr << "InsetTabular::moveNextCell B cur: " << endl;
 		if (tabular.isLastCell(cur.idx()))
 			return;
 		++cur.idx();
 	}
 	cur.par() = 0;
 	cur.pos() = 0;
-	lyxerr << "InsetTabular::moveNextCell 2 cur: " << cur << endl;
+	lyxerr << "InsetTabular::moveNextCell 2 cur: " << cur.top() << endl;
 	resetPos(cur);
 }
 
@@ -1100,13 +1214,11 @@ void InsetTabular::tabularFeatures(LCursor & cur,
 	case LyXTabular::APPEND_ROW:
 		// append the row into the tabular
 		tabular.appendRow(bv.buffer()->params(), actcell);
-		tabular.setOwner(this);
 		break;
 
 	case LyXTabular::APPEND_COLUMN:
 		// append the column into the tabular
 		tabular.appendColumn(bv.buffer()->params(), actcell);
-		tabular.setOwner(this);
 		actcell = tabular.getCellNumber(row, column);
 		break;
 
@@ -1221,7 +1333,7 @@ void InsetTabular::tabularFeatures(LCursor & cur,
 #if 0
 		// just multicol for one Single Cell
 		if (!hasSelection()) {
-			// check wether we are completly in a multicol
+			// check whether we are completly in a multicol
 			if (tabular.isMultiColumn(actcell))
 				tabular.unsetMultiColumn(actcell);
 			else
@@ -1356,187 +1468,6 @@ void InsetTabular::openLayoutDialog(BufferView * bv) const
 }
 
 
-//
-// function returns an object as defined in func_status.h:
-// states OK, Unknown, Disabled, On, Off.
-//
-FuncStatus InsetTabular::getStatus(BufferView & bv,
-	string const & what, int actcell) const
-{
-	FuncStatus status;
-	int action = LyXTabular::LAST_ACTION;	
-	LCursor & cur = bv.cursor();
-
-	int i = 0;
-	for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) {
-		string const tmp = tabularFeature[i].feature;
-		if (tmp == what.substr(0, tmp.length())) {
-			//if (!compare(tabularFeatures[i].feature.c_str(), what.c_str(),
-			//   tabularFeatures[i].feature.length()))
-			action = tabularFeature[i].action;
-			break;
-		}
-	}
-	if (action == LyXTabular::LAST_ACTION) {
-		status.clear();
-		status.unknown(true);
-		return status;
-	}
-
-	string const argument
-		= ltrim(what.substr(tabularFeature[i].feature.length()));
-
-	int sel_row_start = 0;
-	int sel_row_end = 0;
-	int dummy;
-	LyXTabular::ltType dummyltt;
-	bool flag = true;
-
-	getSelection(cur, sel_row_start, sel_row_end, dummy, dummy);
-
-	switch (action) {
-	case LyXTabular::SET_PWIDTH:
-	case LyXTabular::SET_MPWIDTH:
-	case LyXTabular::SET_SPECIAL_COLUMN:
-	case LyXTabular::SET_SPECIAL_MULTI:
-	case LyXTabular::APPEND_ROW:
-	case LyXTabular::APPEND_COLUMN:
-	case LyXTabular::DELETE_ROW:
-	case LyXTabular::DELETE_COLUMN:
-	case LyXTabular::SET_ALL_LINES:
-	case LyXTabular::UNSET_ALL_LINES:
-		status.clear();
-		return status;
-
-	case LyXTabular::MULTICOLUMN:
-		status.setOnOff(tabular.isMultiColumn(actcell));
-		break;
-
-	case LyXTabular::M_TOGGLE_LINE_TOP:
-		flag = false;
-	case LyXTabular::TOGGLE_LINE_TOP:
-		status.setOnOff(tabular.topLine(actcell, flag));
-		break;
-
-	case LyXTabular::M_TOGGLE_LINE_BOTTOM:
-		flag = false;
-	case LyXTabular::TOGGLE_LINE_BOTTOM:
-		status.setOnOff(tabular.bottomLine(actcell, flag));
-		break;
-
-	case LyXTabular::M_TOGGLE_LINE_LEFT:
-		flag = false;
-	case LyXTabular::TOGGLE_LINE_LEFT:
-		status.setOnOff(tabular.leftLine(actcell, flag));
-		break;
-
-	case LyXTabular::M_TOGGLE_LINE_RIGHT:
-		flag = false;
-	case LyXTabular::TOGGLE_LINE_RIGHT:
-		status.setOnOff(tabular.rightLine(actcell, flag));
-		break;
-
-	case LyXTabular::M_ALIGN_LEFT:
-		flag = false;
-	case LyXTabular::ALIGN_LEFT:
-		status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_LEFT);
-		break;
-
-	case LyXTabular::M_ALIGN_RIGHT:
-		flag = false;
-	case LyXTabular::ALIGN_RIGHT:
-		status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_RIGHT);
-		break;
-
-	case LyXTabular::M_ALIGN_CENTER:
-		flag = false;
-	case LyXTabular::ALIGN_CENTER:
-		status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_CENTER);
-		break;
-
-	case LyXTabular::ALIGN_BLOCK:
-		status.enabled(!tabular.getPWidth(actcell).zero());
-		status.setOnOff(tabular.getAlignment(actcell, flag) == LYX_ALIGN_BLOCK);
-		break;
-
-	case LyXTabular::M_VALIGN_TOP:
-		flag = false;
-	case LyXTabular::VALIGN_TOP:
-		status.setOnOff(
-			tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP);
-		break;
-
-	case LyXTabular::M_VALIGN_BOTTOM:
-		flag = false;
-	case LyXTabular::VALIGN_BOTTOM:
-		status.setOnOff(
-			tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM);
-		break;
-
-	case LyXTabular::M_VALIGN_MIDDLE:
-		flag = false;
-	case LyXTabular::VALIGN_MIDDLE:
-		status.setOnOff(
-			tabular.getVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_MIDDLE);
-		break;
-
-	case LyXTabular::SET_LONGTABULAR:
-		status.setOnOff(tabular.isLongTabular());
-		break;
-
-	case LyXTabular::UNSET_LONGTABULAR:
-		status.setOnOff(!tabular.isLongTabular());
-		break;
-
-	case LyXTabular::SET_ROTATE_TABULAR:
-		status.setOnOff(tabular.getRotateTabular());
-		break;
-
-	case LyXTabular::UNSET_ROTATE_TABULAR:
-		status.setOnOff(!tabular.getRotateTabular());
-		break;
-
-	case LyXTabular::SET_ROTATE_CELL:
-		status.setOnOff(tabular.getRotateCell(actcell));
-		break;
-
-	case LyXTabular::UNSET_ROTATE_CELL:
-		status.setOnOff(!tabular.getRotateCell(actcell));
-		break;
-
-	case LyXTabular::SET_USEBOX:
-		status.setOnOff(strToInt(argument) == tabular.getUsebox(actcell));
-		break;
-
-	case LyXTabular::SET_LTFIRSTHEAD:
-		status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt));
-		break;
-
-	case LyXTabular::SET_LTHEAD:
-		status.setOnOff(tabular.getRowOfLTHead(sel_row_start, dummyltt));
-		break;
-
-	case LyXTabular::SET_LTFOOT:
-		status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt));
-		break;
-
-	case LyXTabular::SET_LTLASTFOOT:
-		status.setOnOff(tabular.getRowOfLTFoot(sel_row_start, dummyltt));
-		break;
-
-	case LyXTabular::SET_LTNEWPAGE:
-		status.setOnOff(tabular.getLTNewPage(sel_row_start));
-		break;
-
-	default:
-		status.clear();
-		status.enabled(false);
-		break;
-	}
-	return status;
-}
-
-
 void InsetTabular::getLabelList(Buffer const & buffer,
 				vector<string> & list) const
 {
@@ -1553,7 +1484,6 @@ bool InsetTabular::copySelection(LCursor & cur)
 	getSelection(cur, rs, re, cs, ce);
 
 	paste_tabular.reset(new LyXTabular(tabular));
-	paste_tabular->setOwner(this);
 
 	for (int i = 0; i < rs; ++i)
 		paste_tabular->deleteRow(0);
@@ -1579,7 +1509,7 @@ bool InsetTabular::copySelection(LCursor & cur)
 
 	ostringstream os;
 	OutputParams const runparams;
-	paste_tabular->plaintext(*cur.bv().buffer(), os, runparams, 0, true, '\t');
+	paste_tabular->plaintext(cur.buffer(), os, runparams, 0, true, '\t');
 	cur.bv().stuffClipboard(os.str());
 	return true;
 }
@@ -1611,7 +1541,6 @@ bool InsetTabular::pasteSelection(LCursor & cur)
 			}
 			InsetText & inset = tabular.getCellInset(r2, c2);
 			inset = paste_tabular->getCellInset(r1, c1);
-			inset.setOwner(this);
 			inset.markNew();
 		}
 	}
@@ -1624,26 +1553,30 @@ void InsetTabular::cutSelection(LCursor & cur)
 	if (!cur.selection())
 		return;
 
-	bool const track = cur.bv().buffer()->params().tracking_changes;
+	bool const track = cur.buffer().params().tracking_changes;
 	int rs, re, cs, ce;
-	getSelection(cur, rs, re, cs, ce); 
+	getSelection(cur, rs, re, cs, ce);
 	for (int i = rs; i <= re; ++i)
 		for (int j = cs; j <= ce; ++j)
 			cell(tabular.getCellNumber(i, j)).clear(track);
 }
 
 
-bool InsetTabular::isRightToLeft(LCursor & cur)
+bool InsetTabular::isRightToLeft(LCursor & cur) const
 {
-	return cur.bv().getParentLanguage(this)->RightToLeft();
+	BOOST_ASSERT(cur.size() > 1);
+	Paragraph const & parentpar = cur[cur.size() - 2].paragraph();
+	LCursor::pos_type const parentpos = cur[cur.size() - 2].pos();
+	return parentpar.getFontSettings(cur.bv().buffer()->params(),
+					 parentpos).language()->RightToLeft();
 }
 
 
 void InsetTabular::getSelection(LCursor & cur,
 	int & rs, int & re, int & cs, int & ce) const
 {
-	CursorSlice & beg = cur.selBegin();
-	CursorSlice & end = cur.selEnd();
+	CursorSlice const & beg = cur.selBegin();
+	CursorSlice const & end = cur.selEnd();
 	cs = tabular.column_of_cell(beg.idx());
 	ce = tabular.column_of_cell(end.idx());
 	if (cs > ce) {
@@ -1738,7 +1671,6 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
 	if (usePaste) {
 		paste_tabular.reset(
 			new LyXTabular(bv.buffer()->params(), rows, maxCols));
-		paste_tabular->setOwner(this);
 		loctab = paste_tabular.get();
 		cols = 0;
 	} else {
@@ -1765,8 +1697,8 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
 			// we can only set this if we are not too far right
 			if (cols < columns) {
 				InsetText & inset = loctab->getCellInset(cell);
-				LyXFont const font = inset.text_.
-					getFont(inset.paragraphs().begin(), 0);
+				Paragraph & par = inset.text_.getPar(0);
+				LyXFont const font = inset.text_.getFont(par, 0);
 				inset.setText(buf.substr(op, p - op), font);
 				++cols;
 				++cell;
@@ -1776,8 +1708,8 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
 			// we can only set this if we are not too far right
 			if (cols < columns) {
 				InsetText & inset = tabular.getCellInset(cell);
-				LyXFont const font = inset.text_.
-					getFont(inset.paragraphs().begin(), 0);
+				Paragraph & par = inset.text_.getPar(0);
+				LyXFont const font = inset.text_.getFont(par, 0);
 				inset.setText(buf.substr(op, p - op), font);
 			}
 			cols = ocol;
@@ -1792,7 +1724,8 @@ bool InsetTabular::insertAsciiString(BufferView & bv, string const & buf,
 	// check for the last cell if there is no trailing '\n'
 	if (cell < cells && op < len) {
 		InsetText & inset = loctab->getCellInset(cell);
-		LyXFont const font = inset.text_.getFont(inset.paragraphs().begin(), 0);
+		Paragraph & par = inset.text_.getPar(0);
+		LyXFont const font = inset.text_.getFont(par, 0);
 		inset.setText(buf.substr(op, len - op), font);
 	}
 	return true;
@@ -1812,7 +1745,7 @@ void InsetTabular::addPreview(PreviewLoader & loader) const
 
 bool InsetTabular::tablemode(LCursor & cur) const
 {
-	return cur.selBegin().idx() != cur.selEnd().idx();
+	return cur.selection() && cur.selBegin().idx() != cur.selEnd().idx();
 }
 
 
@@ -1838,7 +1771,9 @@ int InsetTabularMailer::string2params(string const & in, InsetTabular & inset)
 	LyXLex lex(0,0);
 	lex.setStream(data);
 
+#ifdef WITH_WARNINGS
 #warning CHECK verify that this is a sane value to return.
+#endif
 	if (in.empty())
 		return -1;
 
@@ -1883,11 +1818,12 @@ int InsetTabularMailer::string2params(string const & in, InsetTabular & inset)
 string const InsetTabularMailer::params2string(InsetTabular const & inset)
 {
 	ostringstream data;
+#ifdef WITH_WARNINGS
 #warning wrong!
+#endif
 	//data << name_ << " \\active_cell " << inset.getActCell() << '\n';
 	data << name_ << " \\active_cell " << 0 << '\n';
 	inset.write(inset.buffer(), data);
 	data << "\\end_inset\n";
 	return data.str();
 }
-