X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FCoordCache.h;h=a666a4ecb025bb291b1eecc6ec8d3f5b5c279107;hb=e4f2484cb5899da6d98e0be6db465ca011989e04;hp=296de324e94b61b74a877f054913f69be11ec90a;hpb=26f336769af8dd5c48c2c0241cd3fbfc50a3c65e;p=lyx.git

diff --git a/src/CoordCache.h b/src/CoordCache.h
index 296de324e9..a666a4ecb0 100644
--- a/src/CoordCache.h
+++ b/src/CoordCache.h
@@ -3,7 +3,7 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author André Pönitz
+ * \author André Pönitz
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -14,6 +14,8 @@
 // It seems that MacOSX define the check macro.
 #undef check
 
+#include "Dimension.h"
+
 #include "support/types.h"
 
 #include <map>
@@ -27,17 +29,39 @@ class Paragraph;
 
 void lyxbreaker(void const * data, const char * hint, int size);
 
-class Point {
-public:
-	Point()
-		: x_(0), y_(0)
-	{}
+struct Geometry {
+	Point pos;
+	Dimension dim;
+
+	bool covers(int x, int y) const
+	{
+		return x >= pos.x_
+			&& x <= pos.x_ + dim.wid
+			&& y >= pos.y_ - dim.asc
+			&& y <= pos.y_ + dim.des;
+	}
+
+	int squareDistance(int x, int y) const
+	{
+		int xx = 0;
+		int yy = 0;
+
+		if (x < pos.x_)
+			xx = pos.x_ - x;
+		else if (x > pos.x_ + dim.wid)
+			xx = x - pos.x_ - dim.wid;
 
-	Point(int x, int y);
+		if (y < pos.y_ - dim.asc)
+			yy = pos.y_ - dim.asc - y;
+		else if (y > pos.y_ + dim.des)
+			yy = y - pos.y_ - dim.des;
 
-	int x_, y_;
+		// Optimisation: We avoid to compute the sqrt on purpose.
+		return xx*xx + yy*yy;
+	}
 };
 
+
 template <class T> class CoordCacheBase {
 public:
 	void clear()
@@ -52,25 +76,42 @@ public:
 
 	void add(T const * thing, int x, int y)
 	{
-		data_[thing] = Point(x, y);
+		data_[thing].pos = Point(x, y);
+	}
+
+	void add(T const * thing, Dimension const & dim)
+	{
+		data_[thing].dim = dim;
+	}
+
+	Geometry const & geometry(T const * thing) const
+	{
+		check(thing, "geometry");
+		return data_.find(thing)->second;
+	}
+
+	Dimension const & dim(T const * thing) const
+	{
+		check(thing, "dim");
+		return data_.find(thing)->second.dim;
 	}
 
 	int x(T const * thing) const
 	{
 		check(thing, "x");
-		return data_.find(thing)->second.x_;
+		return data_.find(thing)->second.pos.x_;
 	}
 
 	int y(T const * thing) const
 	{
 		check(thing, "y");
-		return data_.find(thing)->second.y_;
+		return data_.find(thing)->second.pos.y_;
 	}
 
 	Point xy(T const * thing) const
 	{
 		check(thing, "xy");
-		return data_.find(thing)->second;
+		return data_.find(thing)->second.pos;
 	}
 
 	bool has(T const * thing) const
@@ -78,11 +119,19 @@ public:
 		return data_.find(thing) != data_.end();
 	}
 
-//	T * find(int x, int y) const
-//	{
-//		T *
-//		cache_type iter
-//	}
+	bool covers(T const * thing, int x, int y) const
+	{
+		typename cache_type::const_iterator it = data_.find(thing);
+		return it != data_.end() && it->second.covers(x, y);
+	}
+
+	int squareDistance(T const * thing, int x, int y) const
+	{
+		typename cache_type::const_iterator it = data_.find(thing);
+		if (it == data_.end())
+			return 1000000;
+		return it->second.squareDistance(x, y);
+	}
 
 private:
 	friend class CoordCache;
@@ -93,7 +142,7 @@ private:
 			lyxbreaker(thing, hint, data_.size());
 	}
 
-	typedef std::map<T const *, Point> cache_type;
+	typedef std::map<T const *, Geometry> cache_type;
 	cache_type data_;
 
 public:
@@ -101,39 +150,31 @@ public:
 };
 
 /**
- * A global cache that allows us to come from a paragraph in a document
- * to a position point on the screen.
+ * A BufferView dependent cache that allows us to come from an inset in
+ * a document to a position point and dimension on the screen.
  * All points cached in this cache are only valid between subsequent
  * updates. (x,y) == (0,0) is the upper left screen corner, x increases
  * to the right, y increases downwords.
- * The cache is built in BufferView::updateMetrics which is called
- * from BufferView::update. The individual points are added
- * while we paint them. See for instance paintPar in RowPainter.C.
+ * The dimension part is built in BufferView::updateMetrics() and the 
+ * diverse Inset::metrics() calls.
+ * The individual points are added at drawing time in
+ * BufferView::updateMetrics(). The math inset position are cached in
+ * the diverse InsetMathXXX::draw() calls and the in-text inset position
+ * are cached in RowPainter::paintInset().
+ * FIXME: For mathed, it would be nice if the insets did not saves their
+ * position themselves. That should be the duty of the containing math
+ * array.
  */
 class CoordCache {
 public:
 	void clear();
 
-	/// A map from paragraph index number to screen point
-	typedef std::map<pit_type, Point> InnerParPosCache;
-	/// A map from a CursorSlice to screen points
-	typedef std::map<Text const *, InnerParPosCache> SliceCache;
-
 	/// A map from MathData to position on the screen
 	CoordCacheBase<MathData> & arrays() { return arrays_; }
 	CoordCacheBase<MathData> const & getArrays() const { return arrays_; }
 	/// A map from insets to positions on the screen
 	CoordCacheBase<Inset> & insets() { return insets_; }
 	CoordCacheBase<Inset> const & getInsets() const { return insets_; }
-	///
-	SliceCache & slice(bool boundary)
-	{
-		return boundary ? slices1_ : slices0_;
-	}
-	SliceCache const & getSlice(bool boundary) const
-	{
-		return boundary ? slices1_ : slices0_;
-	}
 
 	/// Dump the contents of the cache to lyxerr in debugging form
 	void dump() const;
@@ -142,10 +183,6 @@ private:
 	CoordCacheBase<MathData> arrays_;
 	// All insets
 	CoordCacheBase<Inset> insets_;
-	/// Used with boundary == 0
-	SliceCache slices0_;
-	/// Used with boundary == 1
-	SliceCache slices1_;
 };
 
 } // namespace lyx