X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=588dea74b47ea7aecb18c6bda57c232bb2d3148c;hb=00ec2dd10648ba3220ce97c7502897520bb85ac6;hp=68ba3d7475f52209f46d84ef366e658555fbd957;hpb=410605385f1f40d3381fc7236dfb468d100d94f8;p=lyx.git

diff --git a/src/BufferView.cpp b/src/BufferView.cpp
index 68ba3d7475..588dea74b4 100644
--- a/src/BufferView.cpp
+++ b/src/BufferView.cpp
@@ -65,6 +65,7 @@
 #include "insets/InsetText.h"
 
 #include "mathed/MathData.h"
+#include "mathed/InsetMathNest.h"
 
 #include "frontends/alert.h"
 #include "frontends/Application.h"
@@ -228,14 +229,17 @@ enum ScreenUpdateStrategy {
 
 struct BufferView::Private
 {
-	Private(BufferView & bv) : update_strategy_(NoScreenUpdate),
+	Private(BufferView & bv) :
+		update_strategy_(FullScreenUpdate),
+		update_flags_(Update::Force),
 		wh_(0), cursor_(bv),
 		anchor_pit_(0), anchor_ypos_(0),
 		inlineCompletionUniqueChars_(0),
 		last_inset_(0), clickable_inset_(false),
 		mouse_position_cache_(),
 		bookmark_edit_position_(-1), gui_(0),
-		horiz_scroll_offset_(0), repaint_caret_row_(false)
+		horiz_scroll_offset_(0),
+		caret_ascent_(0), caret_descent_(0)
 	{
 		xsel_cache_.set = false;
 	}
@@ -245,6 +249,8 @@ struct BufferView::Private
 	///
 	ScreenUpdateStrategy update_strategy_;
 	///
+	Update::flags update_flags_;
+	///
 	CoordCache coord_cache_;
 
 	/// Estimated average par height for scrollbar.
@@ -313,11 +319,11 @@ struct BufferView::Private
 	/// at previous draw event
 	CursorSlice last_row_slice_;
 
-	/// a slice pointing to where the cursor has been drawn after the current
-	/// draw() call.
-	CursorSlice caret_slice_;
-	/// indicates whether the caret slice needs to be repainted in this draw() run.
-	bool repaint_caret_row_;
+	// The vertical size of the blinking caret. Only used for math
+	// Using it for text could be bad when undo restores the cursor
+	// current font, since the caret size could become wrong.
+	int caret_ascent_;
+	int caret_descent_;
 };
 
 
@@ -445,79 +451,88 @@ bool BufferView::needsFitCursor() const
 }
 
 
-void BufferView::processUpdateFlags(Update::flags flags)
+namespace {
+
+// this is for debugging only.
+string flagsAsString(Update::flags flags)
 {
-	// This is close to a hot-path.
-	LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags()"
-		<< "[fitcursor = " << (flags & Update::FitCursor)
-		<< ", forceupdate = " << (flags & Update::Force)
-		<< ", singlepar = " << (flags & Update::SinglePar)
-		<< "]  buffer: " << &buffer_);
+	if (flags == Update::None)
+		return "None ";
+	return string((flags & Update::FitCursor) ? "FitCursor " : "")
+		+ ((flags & Update::Force) ? "Force " : "")
+		+ ((flags & Update::ForceDraw) ? "ForceDraw " : "")
+		+ ((flags & Update::SinglePar) ? "SinglePar " : "")
+		+ ((flags & Update::Decoration) ? "Decoration " : "");
+}
 
-	// FIXME Does this really need doing here? It's done in updateBuffer, and
-	// if the Buffer doesn't need updating, then do the macros?
-	buffer_.updateMacros();
+}
 
-	// Now do the first drawing step if needed. This consists on updating
-	// the CoordCache in updateMetrics().
-	// The second drawing step is done in WorkArea::redraw() if needed.
-	// FIXME: is this still true now that Buffer::changed() is used all over?
+void BufferView::processUpdateFlags(Update::flags flags)
+{
+	LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags( "
+		   << flagsAsString(flags) << ")  buffer: " << &buffer_);
 
 	// Case when no explicit update is requested.
-	if (!flags) {
-		// no need to redraw anything.
-		d->update_strategy_ = NoScreenUpdate;
+	if (flags == Update::None)
 		return;
+
+	// SinglePar is ignored for now (this should probably change). We
+	// set it ourselves below, at the price of always rebreaking the
+	// paragraph at cursor. This can be expensive for large tables.
+	flags = flags & ~Update::SinglePar;
+
+	// First check whether the metrics and inset positions should be updated
+	if (flags & Update::Force) {
+		// This will update the CoordCache items and replace Force
+		// with ForceDraw in flags.
+		updateMetrics(flags);
 	}
 
-	if (flags == Update::Decoration) {
-		d->update_strategy_ = DecorationUpdate;
-		buffer_.changed(false);
-		return;
+	// Detect whether we can only repaint a single paragraph.
+	// We handle this before FitCursor because the later will require
+	// correct metrics at cursor position.
+	if (!(flags & Update::ForceDraw)) {
+		if (singleParUpdate())
+			flags = flags | Update::SinglePar;
+		else
+			updateMetrics(flags);
 	}
 
-	if (flags == Update::FitCursor
-		|| flags == (Update::Decoration | Update::FitCursor)) {
-		// tell the frontend to update the screen if needed.
+	// Then make sure that the screen contains the cursor if needed
+	if (flags & Update::FitCursor) {
 		if (needsFitCursor()) {
-			showCursor();
-			return;
-		}
-		if (flags & Update::Decoration) {
-			d->update_strategy_ = DecorationUpdate;
-			buffer_.changed(false);
-			return;
+			scrollToCursor(d->cursor_, false);
+			// Metrics have to be recomputed (maybe again)
+			updateMetrics(flags);
 		}
-		// no screen update is needed in principle, but this
-		// could change if cursor row needs horizontal scrolling.
-		d->update_strategy_ = NoScreenUpdate;
-		buffer_.changed(false);
-		return;
+		flags = flags & ~Update::FitCursor;
 	}
 
-	bool const full_metrics = flags & Update::Force || !singleParUpdate();
+	// Add flags to the the update flags. These will be reset to None
+	// after the redraw is actually done
+	d->update_flags_ = d->update_flags_ | flags;
+	LYXERR(Debug::PAINTING, "Cumulative flags: " << flagsAsString(flags));
 
-	if (full_metrics)
-		// We have to update the full screen metrics.
-		updateMetrics();
+	// Now compute the update strategy
+	// Possibly values in flag are None, Decoration, ForceDraw
+	LATTEST((d->update_flags_ & ~(Update::None | Update::SinglePar
+	                              | Update::Decoration | Update::ForceDraw)) == 0);
 
-	if (!(flags & Update::FitCursor)) {
-		// Nothing to do anymore. Trigger a redraw and return
-		buffer_.changed(false);
-		return;
-	}
-
-	// updateMetrics() does not update paragraph position
-	// This is done at draw() time. So we need a redraw!
-	buffer_.changed(false);
-
-	if (needsFitCursor()) {
-		// The cursor is off screen so ensure it is visible.
-		// refresh it:
-		showCursor();
+	if (d->update_flags_ & Update::ForceDraw)
+		d->update_strategy_ = FullScreenUpdate;
+	else if (d->update_flags_ & Update::Decoration)
+		d->update_strategy_ = DecorationUpdate;
+	else if (d->update_flags_ & Update::SinglePar)
+		d->update_strategy_ = SingleParUpdate;
+	else {
+		// no need to redraw anything.
+		d->update_strategy_ = NoScreenUpdate;
 	}
 
 	updateHoveredInset();
+
+	// Trigger a redraw.
+	buffer_.changed(false);
 }
 
 
@@ -632,8 +647,7 @@ void BufferView::scrollDocView(int const value, bool update)
 	// If the offset is less than 2 screen height, prefer to scroll instead.
 	if (abs(value) <= 2 * height_) {
 		d->anchor_ypos_ -= value;
-		buffer_.changed(true);
-		updateHoveredInset();
+		processUpdateFlags(Update::Force);
 		return;
 	}
 
@@ -830,12 +844,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 		d->cursor_.setCurrentFont();
 		// Do not forget to reset the anchor (see #9912)
 		d->cursor_.resetAnchor();
-		// To center the screen on this new position we need the
-		// paragraph position which is computed at draw() time.
-		// So we need a redraw!
-		buffer_.changed(false);
-		if (needsFitCursor())
-			showCursor();
+		processUpdateFlags(Update::FitCursor);
 	}
 
 	return success;
@@ -877,19 +886,15 @@ void BufferView::showCursor()
 void BufferView::showCursor(DocIterator const & dit,
 	bool recenter, bool update)
 {
-	if (scrollToCursor(dit, recenter) && update) {
-		buffer_.changed(true);
-		updateHoveredInset();
-	}
+	if (scrollToCursor(dit, recenter) && update)
+		processUpdateFlags(Update::Force);
 }
 
 
 void BufferView::scrollToCursor()
 {
-	if (scrollToCursor(d->cursor_, false)) {
-		buffer_.changed(true);
-		updateHoveredInset();
-	}
+	if (scrollToCursor(d->cursor_, false))
+		processUpdateFlags(Update::Force);
 }
 
 
@@ -1135,6 +1140,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		flag.setEnabled(true);
 		break;
 
+	case LFUN_GRAPHICS_UNIFY:
+		flag.setEnabled(cur.selection());
+		break;
+
 	case LFUN_WORD_FINDADV: {
 		FindAndReplaceOptions opt;
 		istringstream iss(to_utf8(cmd.argument()));
@@ -1364,25 +1373,45 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		break;
 	}
 
-	case LFUN_UNDO:
+	case LFUN_UNDO: {
 		dr.setMessage(_("Undo"));
 		cur.clearSelection();
+		// We need to find out if the bibliography information
+		// has changed. See bug #11055.
+		// So these should not be references...
+		LayoutModuleList const engines = buffer().params().citeEngine();
+		CiteEngineType const enginetype = buffer().params().citeEngineType();
 		if (!cur.textUndo())
 			dr.setMessage(_("No further undo information"));
-		else
+		else {
 			dr.screenUpdate(Update::Force | Update::FitCursor);
-		dr.forceBufferUpdate();
+			dr.forceBufferUpdate();
+			if (buffer().params().citeEngine() != engines ||
+			    buffer().params().citeEngineType() != enginetype)
+				buffer().invalidateCiteLabels();
+		}
 		break;
+	}
 
-	case LFUN_REDO:
+	case LFUN_REDO: {
 		dr.setMessage(_("Redo"));
 		cur.clearSelection();
+		// We need to find out if the bibliography information
+		// has changed. See bug #11055.
+		// So these should not be references...
+		LayoutModuleList const engines = buffer().params().citeEngine();
+		CiteEngineType const enginetype = buffer().params().citeEngineType();
 		if (!cur.textRedo())
 			dr.setMessage(_("No further redo information"));
-		else
+		else {
 			dr.screenUpdate(Update::Force | Update::FitCursor);
-		dr.forceBufferUpdate();
+			dr.forceBufferUpdate();
+			if (buffer().params().citeEngine() != engines ||
+			    buffer().params().citeEngineType() != enginetype)
+				buffer().invalidateCiteLabels();
+		}
 		break;
+	}
 
 	case LFUN_FONT_STATE:
 		dr.setMessage(cur.currentState(false));
@@ -1634,10 +1663,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
 						BIBTEX_CODE);
 		if (inset) {
-			if (inset->addDatabase(cmd.argument())) {
-				buffer_.invalidateBibfileCache();
+			if (inset->addDatabase(cmd.argument()))
 				dr.forceBufferUpdate();
-			}
 		}
 		break;
 	}
@@ -1648,11 +1675,48 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
 						BIBTEX_CODE);
 		if (inset) {
-			if (inset->delDatabase(cmd.argument())) {
-				buffer_.invalidateBibfileCache();
+			if (inset->delDatabase(cmd.argument()))
 				dr.forceBufferUpdate();
+		}
+		break;
+	}
+
+	case LFUN_GRAPHICS_UNIFY: {
+
+		cur.recordUndoFullBuffer();
+
+		DocIterator from, to;
+		from = cur.selectionBegin();
+		to = cur.selectionEnd();
+
+		string const newId = cmd.getArg(0);
+		bool fetchId = newId.empty(); //if we wait for groupId from first graphics inset
+
+		InsetGraphicsParams grp_par;
+		if (!fetchId)
+			InsetGraphics::string2params(graphics::getGroupParams(buffer_, newId), buffer_, grp_par);
+
+		if (!from.nextInset())	//move to closest inset
+			from.forwardInset();
+
+		while (!from.empty() && from < to) {
+			Inset * inset = from.nextInset();
+			if (!inset)
+				break;
+			if (inset->lyxCode() == GRAPHICS_CODE) {
+			InsetGraphics & ig = static_cast<InsetGraphics &>(*inset);
+				InsetGraphicsParams inspar = ig.getParams();
+				if (fetchId) {
+				        grp_par = inspar;
+					fetchId = false;
+				} else {
+					grp_par.filename = inspar.filename;
+					ig.setParams(grp_par);
+				}
 			}
+			from.forwardInset();
 		}
+		dr.screenUpdate(Update::Force); //needed if triggered from context menu
 		break;
 	}
 
@@ -1715,8 +1779,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		bool const in_texted = cur.inTexted();
 		cur.setCursor(doc_iterator_begin(cur.buffer()));
 		cur.selHandle(false);
-		buffer_.changed(true);
-		updateHoveredInset();
+		// Force an immediate computation of metrics because we need it below
+		processUpdateFlags(Update::Force);
 
 		d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
 			true, act == LFUN_SCREEN_UP);
@@ -1750,8 +1814,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			if (scroll_value)
 				scroll(scroll_step * scroll_value);
 		}
-		buffer_.changed(true);
-		updateHoveredInset();
+		dr.screenUpdate(Update::ForceDraw);
 		dr.forceBufferUpdate();
 		break;
 	}
@@ -1834,6 +1897,33 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 
 
+	case LFUN_UNICODE_INSERT: {
+		if (cmd.argument().empty())
+			break;
+
+		FuncCode code = cur.inset().currentMode() == Inset::MATH_MODE ?
+			LFUN_MATH_INSERT : LFUN_SELF_INSERT;
+		int i = 0;
+		while (true) {
+			docstring const arg = from_utf8(cmd.getArg(i));
+			if (arg.empty())
+				break;
+			if (!isHex(arg)) {
+				LYXERR0("Not a hexstring: " << arg);
+				++i;
+				continue;
+			}
+			char_type c = hexToInt(arg);
+			if (c >= 32 && c < 0x10ffff) {
+				LYXERR(Debug::KEY, "Inserting c: " << c);
+				lyx::dispatch(FuncRequest(code, docstring(1, c)));
+			}
+			++i;
+		}
+		break;
+	}
+
+
 	// This would be in Buffer class if only Cursor did not
 	// require a bufferview
 	case LFUN_INSET_FORALL: {
@@ -1981,6 +2071,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		icp["key"] = from_utf8(arg);
 		if (!opt1.empty())
 			icp["before"] = from_utf8(opt1);
+		icp["literal"] = 
+			from_ascii(InsetCitation::last_literal ? "true" : "false");
 		string icstr = InsetCommand::params2string(icp);
 		FuncRequest fr(LFUN_INSET_INSERT, icstr);
 		lyx::dispatch(fr);
@@ -2645,7 +2737,7 @@ bool BufferView::singleParUpdate()
 		// the singlePar optimisation.
 		return false;
 
-	d->update_strategy_ = SingleParUpdate;
+	tm.updatePosCache(bottom_pit);
 
 	LYXERR(Debug::PAINTING, "\ny1: " << pm.position() - pm.ascent()
 		<< " y2: " << pm.position() + pm.descent()
@@ -2656,6 +2748,13 @@ bool BufferView::singleParUpdate()
 
 
 void BufferView::updateMetrics()
+{
+	updateMetrics(d->update_flags_);
+	d->update_strategy_ = FullScreenUpdate;
+}
+
+
+void BufferView::updateMetrics(Update::flags & update_flags)
 {
 	if (height_ == 0 || width_ == 0)
 		return;
@@ -2698,6 +2797,7 @@ void BufferView::updateMetrics()
 		}
 	}
 	anchor_pm.setPosition(d->anchor_ypos_);
+	tm.updatePosCache(d->anchor_pit_);
 
 	LYXERR(Debug::PAINTING, "metrics: "
 		<< " anchor pit = " << d->anchor_pit_
@@ -2713,6 +2813,7 @@ void BufferView::updateMetrics()
 		y1 -= pm.descent();
 		// Save the paragraph position in the cache.
 		pm.setPosition(y1);
+		tm.updatePosCache(pit1);
 		y1 -= pm.ascent();
 	}
 
@@ -2726,6 +2827,7 @@ void BufferView::updateMetrics()
 		y2 += pm.ascent();
 		// Save the paragraph position in the cache.
 		pm.setPosition(y2);
+		tm.updatePosCache(pit2);
 		y2 += pm.descent();
 	}
 
@@ -2737,7 +2839,8 @@ void BufferView::updateMetrics()
 		<< " pit1 = " << pit1
 		<< " pit2 = " << pit2);
 
-	d->update_strategy_ = FullScreenUpdate;
+	// metrics is done, full drawing is necessary now
+	update_flags = (update_flags & ~Update::Force) | Update::ForceDraw;
 
 	// Now update the positions of insets in the cache.
 	updatePosCache();
@@ -2892,13 +2995,26 @@ bool BufferView::paragraphVisible(DocIterator const & dit) const
 }
 
 
-void BufferView::cursorPosAndHeight(Point & p, int & h) const
+void BufferView::setCaretAscentDescent(int asc, int des)
+{
+	d->caret_ascent_ = asc;
+	d->caret_descent_ = des;
+}
+
+
+void BufferView::caretPosAndHeight(Point & p, int & h) const
 {
+	int asc, des;
 	Cursor const & cur = cursor();
-	Font const font = cur.real_current_font;
-	frontend::FontMetrics const & fm = theFontMetrics(font);
-	int const asc = fm.maxAscent();
-	int const des = fm.maxDescent();
+	if (cur.inMathed()) {
+		asc = d->caret_ascent_;
+		des = d->caret_descent_;
+	} else {
+		Font const font = cur.real_current_font;
+		frontend::FontMetrics const & fm = theFontMetrics(font);
+		asc = fm.maxAscent();
+		des = fm.maxDescent();
+	}
 	h = asc + des;
 	p = getPos(cur);
 	p.y_ -= asc;
@@ -2965,23 +3081,6 @@ void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice)
 }
 
 
-namespace {
-
-bool sliceInRow(CursorSlice const & cs, Text const * text, Row const & row)
-{
-	return !cs.empty() && cs.text() == text && cs.pit() == row.pit()
-		&& row.pos() <= cs.pos() && cs.pos() <= row.endpos();
-}
-
-}
-
-
-bool BufferView::needRepaint(Text const * text, Row const & row) const
-{
-	return d->repaint_caret_row_ && sliceInRow(d->caret_slice_, text, row);
-}
-
-
 void BufferView::checkCursorScrollOffset()
 {
 	CursorSlice rowSlice = d->cursor_.bottom();
@@ -3046,23 +3145,13 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret)
 {
 	if (height_ == 0 || width_ == 0)
 		return;
-	LYXERR(Debug::PAINTING, "\t\t*** START DRAWING ***");
-
+	LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t--- START NODRAW ---"
+	                         : "\t\t*** START DRAWING ***"));
 	Text & text = buffer_.text();
 	TextMetrics const & tm = d->text_metrics_[&text];
 	int const y = tm.first().second->position();
 	PainterInfo pi(this, pain);
 
-	CursorSlice const & bottomSlice = d->cursor_.bottom();
-	/**  A repaint of the previous cursor row is needed if
-	 * 1/ the caret will be painted and is is not the same than the
-	 *    already painted one;
-	 * 2/ the caret will not be painted, but there is already one on
-	 * screen.
-	 */
-	d->repaint_caret_row_ = (paint_caret && bottomSlice != d->caret_slice_)
-		|| (! paint_caret && !d->caret_slice_.empty());
-
 	// Check whether the row where the cursor lives needs to be scrolled.
 	// Update the drawing strategy if needed.
 	checkCursorScrollOffset();
@@ -3078,7 +3167,7 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret)
 		if (pain.isNull()) {
 			pi.full_repaint = true;
 			tm.draw(pi, 0, y);
-		} else if (d->repaint_caret_row_) {
+		} else {
 			pi.full_repaint = false;
 			tm.draw(pi, 0, y);
 		}
@@ -3126,7 +3215,8 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret)
 		}
 		break;
 	}
-	LYXERR(Debug::PAINTING, "\n\t\t*** END DRAWING  ***");
+	LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t --- END NODRAW ---"
+	                        : "\t\t *** END DRAWING ***"));
 
 	// The scrollbar needs an update.
 	updateScrollbar();
@@ -3137,19 +3227,29 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret)
 	for (pit_type pit = firstpm.first; pit <= lastpm.first; ++pit) {
 		ParagraphMetrics const & pm = tm.parMetrics(pit);
 		if (pm.position() + pm.descent() > 0) {
+			if (d->anchor_pit_ != pit
+			    || d->anchor_ypos_ != pm.position())
+				LYXERR(Debug::PAINTING, "Found new anchor pit = " << d->anchor_pit_
+				       << "  anchor ypos = " << d->anchor_ypos_);
 			d->anchor_pit_ = pit;
 			d->anchor_ypos_ = pm.position();
 			break;
 		}
 	}
-	LYXERR(Debug::PAINTING, "Found new anchor pit = " << d->anchor_pit_
-		<< "  anchor ypos = " << d->anchor_ypos_);
+	if (!pain.isNull()) {
+		// reset the update flags, everything has been done
+		d->update_flags_ = Update::None;
+	}
 
-	// Remember what has just been done for the next draw() step
-	if (paint_caret)
-		d->caret_slice_ = bottomSlice;
-	else
-		d->caret_slice_ = CursorSlice();
+	// If a caret has to be painted, mark its text row as dirty to
+	//make sure that it will be repainted on next redraw.
+	/* FIXME: investigate whether this can be avoided when the cursor did not
+	 * move at all
+	 */
+	if (paint_caret) {
+		Row const & caret_row = d->cursor_.textRow();
+		caret_row.changed(true);
+	}
 }