X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettabular.C;h=202ac6fa44bb8495781e2a56dd4919f2a87029ff;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=5e9e4da802a522491f8b78fa81ed4e902155461b;hpb=12a82dd4f2657e683d4f44fb9168aa177b776e00;p=lyx.git

diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C
index 5e9e4da802..202ac6fa44 100644
--- a/src/insets/insettabular.C
+++ b/src/insets/insettabular.C
@@ -37,28 +37,26 @@
 #include "support/convert.h"
 
 #include "frontends/Alert.h"
-#include "frontends/font_metrics.h"
-#include "frontends/LyXView.h"
 #include "frontends/Clipboard.h"
 #include "frontends/Painter.h"
 #include "frontends/Selection.h"
-#include "frontends/nullpainter.h"
 
 #include <sstream>
 #include <iostream>
 #include <limits>
 
-using lyx::docstring;
 
-using lyx::cap::dirtyTabularStack;
-using lyx::cap::tabularStackDirty;
+namespace lyx {
 
-using lyx::graphics::PreviewLoader;
+using cap::dirtyTabularStack;
+using cap::tabularStackDirty;
 
-using lyx::support::ltrim;
+using graphics::PreviewLoader;
 
-using lyx::frontend::Painter;
-using lyx::frontend::Clipboard;
+using support::ltrim;
+
+using frontend::Painter;
+using frontend::Clipboard;
 
 using boost::shared_ptr;
 
@@ -72,6 +70,8 @@ using std::ostringstream;
 using std::swap;
 using std::vector;
 
+namespace Alert = frontend::Alert;
+
 
 namespace {
 
@@ -95,6 +95,8 @@ TabularFeature tabularFeature[] =
 	{ LyXTabular::APPEND_COLUMN, "append-column" },
 	{ LyXTabular::DELETE_ROW, "delete-row" },
 	{ LyXTabular::DELETE_COLUMN, "delete-column" },
+	{ LyXTabular::COPY_ROW, "copy-row" },
+	{ LyXTabular::COPY_COLUMN, "copy-column" },
 	{ LyXTabular::TOGGLE_LINE_TOP, "toggle-line-top" },
 	{ LyXTabular::TOGGLE_LINE_BOTTOM, "toggle-line-bottom" },
 	{ LyXTabular::TOGGLE_LINE_LEFT, "toggle-line-left" },
@@ -172,12 +174,6 @@ string const featureAsString(LyXTabular::Feature feature)
 }
 
 
-bool InsetTabular::hasPasteBuffer() const
-{
-	return (paste_tabular.get() != 0);
-}
-
-
 InsetTabular::InsetTabular(Buffer const & buf, row_type rows,
 			   col_type columns)
 	: tabular(buf.params(), max(rows, row_type(1)),
@@ -244,7 +240,7 @@ void InsetTabular::read(Buffer const & buf, LyXLex & lex)
 }
 
 
-void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const
+bool InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const
 {
 	//lyxerr << "InsetTabular::metrics: " << mi.base.bv << " width: " <<
 	//	mi.base.textwidth << "\n";
@@ -298,7 +294,9 @@ void InsetTabular::metrics(MetricsInfo & mi, Dimension & dim) const
 	dim.asc = tabular.getAscentOfRow(0);
 	dim.des = tabular.getHeightOfTabular() - dim.asc;
 	dim.wid = tabular.getWidthOfTabular() + 2 * ADD_TO_TABULAR_WIDTH;
+	bool const changed = dim_ != dim;
 	dim_ = dim;
+	return changed;
 }
 
 
@@ -309,10 +307,7 @@ void InsetTabular::draw(PainterInfo & pi, int x, int y) const
 	//lyxerr << "InsetTabular::draw: " << x << " " << y << endl;
 	BufferView * bv = pi.base.bv;
 
-	static lyx::frontend::NullPainter nop;
-	static PainterInfo nullpi(bv, nop);
-
-	//resetPos(bv->cursor());
+	resetPos(bv->cursor());
 
 	x += scx_;
 	x += ADD_TO_TABULAR_WIDTH;
@@ -335,8 +330,10 @@ void InsetTabular::draw(PainterInfo & pi, int x, int y) const
 			    || nx > bv->workWidth()
 			    || y + d < 0
 			    || y - a > bv->workHeight()) {
-				cell(idx)->draw(nullpi, cx, y);
-				drawCellLines(nop, nx, y, i, idx, pi.erased_);
+				pi.pain.setDrawingEnabled(false);
+				cell(idx)->draw(pi, cx, y);
+				drawCellLines(pi.pain, nx, y, i, idx, pi.erased_);
+				pi.pain.setDrawingEnabled(true);
 			} else {
 				cell(idx)->draw(pi, cx, y);
 				drawCellLines(pi.pain, nx, y, i, idx, pi.erased_);
@@ -474,7 +471,7 @@ void InsetTabular::edit(LCursor & cur, bool left)
 		cur.pit() = 0;
 		cur.pos() = cur.lastpos(); // FIXME crude guess
 	}
-	// this accesses the position cache before it is initialized
+	// FIXME: this accesses the position cache before it is initialized
 	//resetPos(cur);
 	//cur.bv().fitCursor();
 }
@@ -492,17 +489,29 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 	case LFUN_MOUSE_PRESS:
 		//lyxerr << "# InsetTabular::MousePress\n" << cur.bv().cursor() << endl;
 
-		if (cmd.button() == mouse_button::button1
-		    || cmd.button() == mouse_button::button3) {
+		if (cmd.button() == mouse_button::button1 
+		    || (cmd.button() == mouse_button::button3 
+			&& (&bvcur.selBegin().inset() != this || !tablemode(bvcur)))) {
+			if (!bvcur.selection() && !cur.bv().mouseSetCursor(cur))
+				cur.noUpdate();
 			cur.selection() = false;
 			setCursorFromCoordinates(cur, cmd.x, cmd.y);
-			cur.resetAnchor();
-			bvcur = cur;
+			cur.bv().mouseSetCursor(cur);
 			break;
 		}
 
 		if (cmd.button() == mouse_button::button2) {
-			cmd = FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph");
+			if (bvcur.selection()) {
+				// See comment in LyXText::dispatch why we
+				// do this
+				// FIXME This does not use paste_tabular,
+				// another reason why paste_tabular should go.
+				cap::copySelectionToStack(bvcur);
+				cmd = FuncRequest(LFUN_PASTE, "0");
+			} else {
+				cmd = FuncRequest(LFUN_PRIMARY_SELECTION_PASTE,
+				                  "paragraph");
+			}
 			doDispatch(cur, cmd);
 		}
 		break;
@@ -512,6 +521,10 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 		if (cmd.button() == mouse_button::button1) {
 			// only accept motions to places not deeper nested than the real anchor
 			if (bvcur.anchor_.hasPart(cur)) {
+				// only update if selection changes
+				if (bvcur.idx() == cur.idx() &&
+					!(bvcur.anchor_.idx() == cur.idx() && bvcur.pos() != cur.pos()))
+					cur.noUpdate();
 				setCursorFromCoordinates(cur, cmd.x, cmd.y);
 				bvcur.setCursor(cur);
 				bvcur.selection() = true;
@@ -522,7 +535,10 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 
 	case LFUN_MOUSE_RELEASE:
 		//lyxerr << "# InsetTabular::MouseRelease\n" << bvcur << endl;
-		if (cmd.button() == mouse_button::button3)
+		if (cmd.button() == mouse_button::button1) {
+			if (bvcur.selection())
+				theSelection().haveSelection(true);
+		} else if (cmd.button() == mouse_button::button3)
 			InsetTabularMailer(*this).showDialog(&cur.bv());
 		break;
 
@@ -541,6 +557,8 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 		cell(cur.idx())->dispatch(cur, cmd);
 		if (!cur.result().dispatched()) {
 			isRightToLeft(cur) ? movePrevCell(cur) : moveNextCell(cur);
+			if (cmd.action == LFUN_CHAR_FORWARD_SELECT)
+				theSelection().haveSelection(cur.selection());
 			if (sl == cur.top())
 				cmd = FuncRequest(LFUN_FINISHED_RIGHT);
 			else
@@ -553,6 +571,8 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 		cell(cur.idx())->dispatch(cur, cmd);
 		if (!cur.result().dispatched()) {
 			isRightToLeft(cur) ? moveNextCell(cur) : movePrevCell(cur);
+			if (cmd.action == LFUN_CHAR_BACKWARD_SELECT)
+				theSelection().haveSelection(cur.selection());
 			if (sl == cur.top())
 				cmd = FuncRequest(LFUN_FINISHED_LEFT);
 			else
@@ -571,8 +591,11 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 			if (tabular.row_of_cell(cur.idx()) != tabular.rows() - 1) {
 				cur.idx() = tabular.getCellBelow(cur.idx());
 				cur.pit() = 0;
-				cur.pos() = cell(cur.idx())->getText(0)->x2pos(
-					cur.pit(), 0, cur.targetX());
+				TextMetrics const & tm =
+					cur.bv().textMetrics(cell(cur.idx())->getText(0));
+				cur.pos() = tm.x2pos(cur.pit(), 0, cur.targetX());
+				if (cmd.action == LFUN_DOWN_SELECT)
+					theSelection().haveSelection(cur.selection());
 			}
 		if (sl == cur.top()) {
 			// we trick it to go to the RIGHT after leaving the
@@ -594,10 +617,12 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 				cur.idx() = tabular.getCellAbove(cur.idx());
 				cur.pit() = cur.lastpit();
 				LyXText const * text = cell(cur.idx())->getText(0);
-				cur.pos() = text->x2pos(
-					cur.pit(),
-					text->paragraphs().back().rows().size()-1,
-					cur.targetX());
+				TextMetrics const & tm = cur.bv().textMetrics(text);
+				ParagraphMetrics const & pm =
+					tm.parMetrics(cur.lastpit());
+				cur.pos() = tm.x2pos(cur.pit(), pm.rows().size()-1, cur.targetX());
+				if (cmd.action == LFUN_UP_SELECT)
+					theSelection().haveSelection(cur.selection());
 			}
 		if (sl == cur.top()) {
 			cmd = FuncRequest(LFUN_FINISHED_UP);
@@ -649,17 +674,17 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 		break;
 
 	case LFUN_TABULAR_FEATURE:
-		if (!tabularFeatures(cur, lyx::to_utf8(cmd.argument())))
+		if (!tabularFeatures(cur, to_utf8(cmd.argument())))
 			cur.undispatched();
 		break;
 
 	// insert file functions
-	case LFUN_FILE_INSERT_ASCII_PARA:
-	case LFUN_FILE_INSERT_ASCII: {
-		// FIXME: We don't know the encoding of filenames
-		string const tmpstr = getContentsOfAsciiFile(&cur.bv(), lyx::to_utf8(cmd.argument()), false);
+	case LFUN_FILE_INSERT_PLAINTEXT_PARA:
+	case LFUN_FILE_INSERT_PLAINTEXT: {
+		// FIXME UNICODE
+		string const tmpstr = getContentsOfPlaintextFile(&cur.bv(), to_utf8(cmd.argument()), false);
 		// FIXME: We don't know the encoding of the file
-		if (!tmpstr.empty() && !insertAsciiString(cur.bv(), lyx::from_utf8(tmpstr), false))
+		if (!tmpstr.empty() && !insertPlaintextString(cur.bv(), from_utf8(tmpstr), false))
 			cur.undispatched();
 		break;
 	}
@@ -698,32 +723,28 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 	case LFUN_CLIPBOARD_PASTE:
 	case LFUN_PRIMARY_SELECTION_PASTE: {
 		docstring const clip = (cmd.action == LFUN_CLIPBOARD_PASTE) ?
-			theApp->clipboard().get() :
-			theApp->selection().get();
+			theClipboard().getAsText() :
+			theSelection().get();
 		if (clip.empty())
 			break;
-		// pass to InsertAsciiString, but
+		// pass to InsertPlaintextString, but
 		// only if we have multi-cell content
-		if (clip.find_first_of(lyx::from_ascii("\t\n")) != docstring::npos) {
-			if (insertAsciiString(cur.bv(), clip, false)) {
+		if (clip.find_first_of(from_ascii("\t\n")) != docstring::npos) {
+			if (insertPlaintextString(cur.bv(), clip, false)) {
 				// content has been replaced,
 				// so cursor might be invalid
 				cur.pos() = cur.lastpos();
 				bvcur.setCursor(cur);
 				break;
 			}
-		} else {
-			// so that the clipboard is used and it goes on
-			// to default
-			// and executes LFUN_PRIMARY_SELECTION_PASTE in insettext!
-			paste_tabular.reset();
-			dirtyTabularStack(false);
 		}
-		// fall through
+		// Let the cell handle normal text
+		cell(cur.idx())->dispatch(cur, cmd);
+		break;
 	}
 
 	case LFUN_PASTE:
-		if (hasPasteBuffer() && tabularStackDirty()) {
+		if (tabularStackDirty() && theClipboard().isInternal()) {
 			recordUndoInset(cur, Undo::INSERT);
 			pasteSelection(cur);
 			break;
@@ -779,7 +800,8 @@ void InsetTabular::doDispatch(LCursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	resetPos(cur);
+	// FIXME: this accesses the position cache before it is initialized
+	//resetPos(cur);
 	InsetTabularMailer(*this).updateDialog(&cur.bv());
 }
 
@@ -795,7 +817,7 @@ bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd,
 		int i = 0;
 		for (; tabularFeature[i].action != LyXTabular::LAST_ACTION; ++i) {
 			string const tmp = tabularFeature[i].feature;
-			if (tmp == lyx::to_utf8(cmd.argument()).substr(0, tmp.length())) {
+			if (tmp == to_utf8(cmd.argument()).substr(0, tmp.length())) {
 				action = tabularFeature[i].action;
 				break;
 			}
@@ -807,7 +829,7 @@ bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd,
 		}
 
 		string const argument
-			= ltrim(lyx::to_utf8(cmd.argument()).substr(tabularFeature[i].feature.length()));
+			= ltrim(to_utf8(cmd.argument()).substr(tabularFeature[i].feature.length()));
 
 		row_type sel_row_start = 0;
 		row_type sel_row_end = 0;
@@ -826,6 +848,8 @@ bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd,
 		case LyXTabular::APPEND_COLUMN:
 		case LyXTabular::DELETE_ROW:
 		case LyXTabular::DELETE_COLUMN:
+		case LyXTabular::COPY_ROW:
+		case LyXTabular::COPY_COLUMN:
 		case LyXTabular::SET_ALL_LINES:
 		case LyXTabular::UNSET_ALL_LINES:
 		case LyXTabular::SET_TOP_SPACE:
@@ -1030,10 +1054,11 @@ bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd,
 	}
 
 	case LFUN_PASTE:
-		if (tabularStackDirty()) {
+		if (tabularStackDirty() && theClipboard().isInternal()) {
 			status.enabled(true);
 			return true;
-		}
+		} else
+			return cell(cur.idx())->getStatus(cur, cmd, status);
 
 	case LFUN_INSET_MODIFY:
 		if (translate(cmd.getArg(0)) == TABULAR_CODE) {
@@ -1049,14 +1074,14 @@ bool InsetTabular::getStatus(LCursor & cur, FuncRequest const & cmd,
 }
 
 
-int InsetTabular::latex(Buffer const & buf, ostream & os,
+int InsetTabular::latex(Buffer const & buf, odocstream & os,
 			OutputParams const & runparams) const
 {
 	return tabular.latex(buf, os, runparams);
 }
 
 
-int InsetTabular::plaintext(Buffer const & buf, ostream & os,
+int InsetTabular::plaintext(Buffer const & buf, odocstream & os,
 			OutputParams const & runparams) const
 {
 	int const dp = runparams.linelen ? runparams.depth : 0;
@@ -1064,7 +1089,7 @@ int InsetTabular::plaintext(Buffer const & buf, ostream & os,
 }
 
 
-int InsetTabular::docbook(Buffer const & buf, ostream & os,
+int InsetTabular::docbook(Buffer const & buf, odocstream & os,
 			  OutputParams const & runparams) const
 {
 	int ret = 0;
@@ -1112,10 +1137,10 @@ shared_ptr<InsetText> InsetTabular::cell(idx_type idx)
 }
 
 
-void InsetTabular::cursorPos
-	(CursorSlice const & sl, bool boundary, int & x, int & y) const
+void InsetTabular::cursorPos(BufferView const & bv,
+		CursorSlice const & sl, bool boundary, int & x, int & y) const
 {
-	cell(sl.idx())->cursorPos(sl, boundary, x, y);
+	cell(sl.idx())->cursorPos(bv, sl, boundary, x, y);
 
 	// y offset	correction
 	int const row = tabular.row_of_cell(sl.idx());
@@ -1143,12 +1168,12 @@ void InsetTabular::cursorPos
 }
 
 
-int InsetTabular::dist(idx_type const cell, int x, int y) const
+int InsetTabular::dist(BufferView & bv, idx_type const cell, int x, int y) const
 {
 	int xx = 0;
 	int yy = 0;
 	InsetBase const & inset = *tabular.getCellInset(cell);
-	Point o = theCoords.getInsets().xy(&inset);
+	Point o = bv.coordCache().getInsets().xy(&inset);
 	int const xbeg = o.x_ - tabular.getBeginningOfTextInCell(cell);
 	int const xend = xbeg + tabular.getWidthOfColumn(cell);
 	row_type const row = tabular.row_of_cell(cell);
@@ -1179,7 +1204,7 @@ InsetBase * InsetTabular::editXY(LCursor & cur, int x, int y)
 	//lyxerr << "InsetTabular::editXY: " << this << endl;
 	cur.selection() = false;
 	cur.push(*this);
-	cur.idx() = getNearestCell(x, y);
+	cur.idx() = getNearestCell(cur.bv(), x, y);
 	resetPos(cur);
 	return cell(cur.idx())->text_.editXY(cur, x, y);
 }
@@ -1187,18 +1212,18 @@ InsetBase * InsetTabular::editXY(LCursor & cur, int x, int y)
 
 void InsetTabular::setCursorFromCoordinates(LCursor & cur, int x, int y) const
 {
-	cur.idx() = getNearestCell(x, y);
+	cur.idx() = getNearestCell(cur.bv(), x, y);
 	cell(cur.idx())->text_.setCursorFromCoordinates(cur, x, y);
 }
 
 
-InsetTabular::idx_type InsetTabular::getNearestCell(int x, int y) const
+InsetTabular::idx_type InsetTabular::getNearestCell(BufferView & bv, int x, int y) const
 {
 	idx_type idx_min = 0;
 	int dist_min = std::numeric_limits<int>::max();
 	for (idx_type i = 0, n = nargs(); i != n; ++i) {
-		if (theCoords.getInsets().has(tabular.getCellInset(i).get())) {
-			int const d = dist(i, x, y);
+		if (bv.coordCache().getInsets().has(tabular.getCellInset(i).get())) {
+			int const d = dist(bv, i, x, y);
 			if (d < dist_min) {
 				dist_min = d;
 				idx_min = i;
@@ -1234,7 +1259,7 @@ void InsetTabular::resetPos(LCursor & cur) const
 		int const X1 = 0;
 		int const X2 = maxwidth;
 		int const offset = ADD_TO_TABULAR_WIDTH + 2;
-		int const x1 = xo() + getCellXPos(cur.idx()) + offset;
+		int const x1 = xo(cur.bv()) + getCellXPos(cur.idx()) + offset;
 		int const x2 = x1 + tabular.getWidthOfColumn(cur.idx());
 
 		if (x1 < X1)
@@ -1245,9 +1270,7 @@ void InsetTabular::resetPos(LCursor & cur) const
 			scx_ = 0;
 	}
 
-	cur.needsUpdate();
-
-	InsetTabularMailer(*this).updateDialog(&bv);
+	cur.updateFlags(Update::Force | Update::FitCursor);
 }
 
 
@@ -1296,7 +1319,9 @@ void InsetTabular::movePrevCell(LCursor & cur)
 	}
 	cur.pit() = cur.lastpit();
 	cur.pos() = cur.lastpos();
-	resetPos(cur);
+
+	// FIXME: this accesses the position cache before it is initialized
+	//resetPos(cur);
 }
 
 
@@ -1425,7 +1450,7 @@ void InsetTabular::tabularFeatures(LCursor & cur,
 
 	case LyXTabular::SET_SPECIAL_COLUMN:
 	case LyXTabular::SET_SPECIAL_MULTI:
-		tabular.setAlignSpecial(cur.idx(),value,feature);
+		tabular.setAlignSpecial(cur.idx(), from_utf8(value), feature);
 		break;
 
 	case LyXTabular::APPEND_ROW:
@@ -1461,6 +1486,15 @@ void InsetTabular::tabularFeatures(LCursor & cur,
 		cur.selection() = false;
 		break;
 
+	case LyXTabular::COPY_ROW:
+		tabular.copyRow(bv.buffer()->params(), row);
+		break;
+
+	case LyXTabular::COPY_COLUMN:
+		tabular.copyColumn(bv.buffer()->params(), column);
+		cur.idx() = tabular.getCellNumber(row, column);
+		break;
+
 	case LyXTabular::M_TOGGLE_LINE_TOP:
 		flag = false;
 	case LyXTabular::TOGGLE_LINE_TOP: {
@@ -1724,8 +1758,6 @@ void InsetTabular::tabularFeatures(LCursor & cur,
 	case LyXTabular::LAST_ACTION:
 		break;
 	}
-
-	InsetTabularMailer(*this).updateDialog(&bv);
 }
 
 
@@ -1775,14 +1807,17 @@ bool InsetTabular::copySelection(LCursor & cur)
 	paste_tabular->setRightLine(paste_tabular->getLastCellInRow(0),
 				    true, true);
 
-	ostringstream os;
+	odocstringstream os;
 	OutputParams const runparams;
 	paste_tabular->plaintext(cur.buffer(), os, runparams, 0, true, '\t');
-	theApp->clipboard().put(lyx::from_utf8(os.str()));
+	// Needed for the "Edit->Paste recent" menu and the system clipboard.
+	cap::copySelection(cur, os.str());
+
 	// mark tabular stack dirty
 	// FIXME: this is a workaround for bug 1919. Should be removed for 1.5,
 	// when we (hopefully) have a one-for-all paste mechanism.
-	lyx::cap::dirtyTabularStack(true);
+	// This must be called after cap::copySelection.
+	dirtyTabularStack(true);
 
 	return true;
 }
@@ -1814,7 +1849,9 @@ bool InsetTabular::pasteSelection(LCursor & cur)
 			shared_ptr<InsetText> inset(
 				new InsetText(*paste_tabular->getCellInset(r1, c1)));
 			tabular.setCellInset(r2, c2, inset);
-			inset->markNew();
+			// FIXME: change tracking (MG)
+			inset->setChange(Change(cur.buffer().params().trackChanges ?
+			                        Change::INSERTED : Change::UNCHANGED));
 			cur.pos() = 0;
 		}
 	}
@@ -1834,8 +1871,9 @@ void InsetTabular::cutSelection(LCursor & cur)
 		for (col_type j = cs; j <= ce; ++j) {
 			shared_ptr<InsetText> t
 				= cell(tabular.getCellNumber(i, j));
-			if (cur.buffer().params().tracking_changes)
-				t->markErased(true);
+			if (cur.buffer().params().trackChanges)
+				// FIXME: Change tracking (MG)
+				t->setChange(Change(Change::DELETED));
 			else
 				t->clear();
 		}
@@ -1847,6 +1885,7 @@ void InsetTabular::cutSelection(LCursor & cur)
 	if (cur.pos() > cur.lastpos())
 		cur.pos() = cur.lastpos();
 	cur.clearSelection();
+	theSelection().haveSelection(false);
 }
 
 
@@ -1854,7 +1893,7 @@ bool InsetTabular::isRightToLeft(LCursor & cur) const
 {
 	BOOST_ASSERT(cur.depth() > 1);
 	Paragraph const & parentpar = cur[cur.depth() - 2].paragraph();
-	LCursor::pos_type const parentpos = cur[cur.depth() - 2].pos();
+	pos_type const parentpos = cur[cur.depth() - 2].pos();
 	return parentpar.getFontSettings(cur.bv().buffer()->params(),
 					 parentpos).language()->rightToLeft();
 }
@@ -1887,10 +1926,24 @@ LyXText * InsetTabular::getText(int idx) const
 }
 
 
-void InsetTabular::markErased(bool erased)
+void InsetTabular::setChange(Change const & change)
+{
+	for (idx_type idx = 0; idx < nargs(); ++idx)
+		cell(idx)->setChange(change);
+}
+
+
+void InsetTabular::acceptChanges()
 {
 	for (idx_type idx = 0; idx < nargs(); ++idx)
-		cell(idx)->markErased(erased);
+		cell(idx)->acceptChanges();
+}
+
+
+void InsetTabular::rejectChanges()
+{
+	for (idx_type idx = 0; idx < nargs(); ++idx)
+		cell(idx)->rejectChanges();
 }
 
 
@@ -1900,12 +1953,14 @@ bool InsetTabular::forceDefaultParagraphs(idx_type cell) const
 }
 
 
-bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
+bool InsetTabular::insertPlaintextString(BufferView & bv, docstring const & buf,
 				     bool usePaste)
 {
 	if (buf.length() <= 0)
 		return true;
 
+	Buffer const & buffer = *bv.buffer();
+
 	col_type cols = 1;
 	row_type rows = 1;
 	col_type maxCols = 1;
@@ -1913,7 +1968,7 @@ bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
 	docstring::size_type p = 0;
 
 	while (p < len &&
-	       (p = buf.find_first_of(lyx::from_ascii("\t\n"), p)) != docstring::npos) {
+	       (p = buf.find_first_of(from_ascii("\t\n"), p)) != docstring::npos) {
 		switch (buf[p]) {
 		case '\t':
 			++cols;
@@ -1934,7 +1989,7 @@ bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
 	row_type row = 0;
 	if (usePaste) {
 		paste_tabular.reset(
-			new LyXTabular(bv.buffer()->params(), rows, maxCols));
+			new LyXTabular(buffer.params(), rows, maxCols));
 		loctab = paste_tabular.get();
 		cols = 0;
 		dirtyTabularStack(true);
@@ -1953,7 +2008,7 @@ bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
 	col_type const columns = loctab->columns();
 
 	while (cell < cells && p < len && row < rows &&
-	       (p = buf.find_first_of(lyx::from_ascii("\t\n"), p)) != docstring::npos)
+	       (p = buf.find_first_of(from_ascii("\t\n"), p)) != docstring::npos)
 	{
 		if (p >= len)
 			break;
@@ -1962,10 +2017,10 @@ bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
 			// we can only set this if we are not too far right
 			if (cols < columns) {
 				shared_ptr<InsetText> inset = loctab->getCellInset(cell);
-				inset->setViewCache(&bv);
 				Paragraph & par = inset->text_.getPar(0);
-				LyXFont const font = inset->text_.getFont(par, 0);
-				inset->setText(buf.substr(op, p - op), font);
+				LyXFont const font = inset->text_.getFont(buffer, par, 0);
+				inset->setText(buf.substr(op, p - op), font,
+				               buffer.params().trackChanges);
 				++cols;
 				++cell;
 			}
@@ -1974,10 +2029,10 @@ bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
 			// we can only set this if we are not too far right
 			if (cols < columns) {
 				shared_ptr<InsetText> inset = tabular.getCellInset(cell);
-				inset->setViewCache(&bv);
 				Paragraph & par = inset->text_.getPar(0);
-				LyXFont const font = inset->text_.getFont(par, 0);
-				inset->setText(buf.substr(op, p - op), font);
+				LyXFont const font = inset->text_.getFont(buffer, par, 0);
+				inset->setText(buf.substr(op, p - op), font,
+				               buffer.params().trackChanges);
 			}
 			cols = ocol;
 			++row;
@@ -1991,10 +2046,10 @@ bool InsetTabular::insertAsciiString(BufferView & bv, docstring const & buf,
 	// check for the last cell if there is no trailing '\n'
 	if (cell < cells && op < len) {
 		shared_ptr<InsetText> inset = loctab->getCellInset(cell);
-		inset->setViewCache(&bv);
 		Paragraph & par = inset->text_.getPar(0);
-		LyXFont const font = inset->text_.getFont(par, 0);
-		inset->setText(buf.substr(op, len - op), font);
+		LyXFont const font = inset->text_.getFont(buffer, par, 0);
+		inset->setText(buf.substr(op, len - op), font,
+			buffer.params().trackChanges);
 	}
 	return true;
 }
@@ -2068,3 +2123,6 @@ string const InsetTabularMailer::params2string(InsetTabular const & inset)
 	data << "\\end_inset\n";
 	return data.str();
 }
+
+
+} // namespace lyx