enable highdpi display

though mag display and compute needs doing too

Author: jcupitt

src/imagedisplay.c

@@ -79,6 +79,11 @@ struct _Imagedisplay {
 	double scale;
 	double x, y;
 
+	/* The size of physical display pixels in gtk coordinates, eg. for a 200%
+	 * desktop this would be 0.5.
+	 */
+	double pixel_size;
+
 	/* Draw the screen in debug mode.
 	 */
 	gboolean debug;
@@ -126,6 +131,9 @@ enum {
 	 */
 	PROP_DEBUG,
 
+	/* Read out display density with this.
+	 */
+	PROP_PIXEL_SIZE,
 };
 
 enum {
@@ -476,6 +484,8 @@ imagedisplay_set_property(GObject *object,
 {
 	Imagedisplay *imagedisplay = (Imagedisplay *) object;
 
+	double d;
+
 #ifdef DEBUG
 	{
 		g_autofree char *str = g_strdup_value_contents(value);
@@ -573,6 +583,15 @@ imagedisplay_set_property(GObject *object,
 		gtk_widget_queue_draw(GTK_WIDGET(imagedisplay));
 		break;
 
+	case PROP_PIXEL_SIZE:
+		d = g_value_get_double(value);
+		if (imagedisplay->pixel_size != d) {
+			imagedisplay->pixel_size = d;
+			imagedisplay_layout(imagedisplay);
+			gtk_widget_queue_draw(GTK_WIDGET(imagedisplay));
+		}
+		break;
+
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 		break;
@@ -632,6 +651,10 @@ imagedisplay_get_property(GObject *object,
 		g_value_set_boolean(value, imagedisplay->debug);
 		break;
 
+	case PROP_PIXEL_SIZE:
+		g_value_set_double(value, imagedisplay->pixel_size);
+		break;
+
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 		break;
@@ -649,6 +672,15 @@ imagedisplay_snapshot(GtkWidget *widget, GtkSnapshot *snapshot)
 
 	GTK_WIDGET_CLASS(imagedisplay_parent_class)->snapshot(widget, snapshot);
 
+	/* This can change on each repaint as windows are dragged.
+	 */
+	GtkNative *native = gtk_widget_get_native(widget);
+	GdkSurface *surface = gtk_native_get_surface(native);
+	double pixel_size = 1.0 / gdk_surface_get_scale_factor(surface);
+	g_object_set(imagedisplay, "pixel-size", pixel_size, NULL);
+
+	gtk_snapshot_scale(snapshot, pixel_size, pixel_size);
+
 #ifdef HAVE_GTK_SNAPSHOT_SET_SNAP
 	gtk_snapshot_set_snap(snapshot, GSK_RECT_SNAP_ROUND);
 #endif /*HAVE_GTK_SNAPSHOT_SET_SNAP*/
@@ -658,26 +690,21 @@ imagedisplay_snapshot(GtkWidget *widget, GtkSnapshot *snapshot)
 	 */
 	gtk_snapshot_push_clip(snapshot,
 		&GRAPHENE_RECT_INIT(0, 0,
-			gtk_widget_get_width(widget), gtk_widget_get_height(widget)));
+			gtk_widget_get_width(widget) / pixel_size, 
+			gtk_widget_get_height(widget) / pixel_size));
 
 	graphene_rect_t paint;
-	paint.origin.x = imagedisplay->paint_rect.left;
-	paint.origin.y = imagedisplay->paint_rect.top;
-	paint.size.width = imagedisplay->paint_rect.width;
-	paint.size.height = imagedisplay->paint_rect.height;
-
-	/* If there's no gtk snapping, we do our own based on the hardware pixel
-	 * size for the surface this snapshot will be rendered to.
-	 */
-	GtkNative *native = gtk_widget_get_native(widget);
-	GdkSurface *surface = gtk_native_get_surface(native);
-	double pixel_size = 1.0 / gdk_surface_get_scale_factor(surface);
+	paint.origin.x = imagedisplay->paint_rect.left / pixel_size;
+	paint.origin.y = imagedisplay->paint_rect.top / pixel_size;
+	paint.size.width = imagedisplay->paint_rect.width / pixel_size;
+	paint.size.height = imagedisplay->paint_rect.height / pixel_size;
 
 	if (imagedisplay->tilecache &&
 		imagedisplay->tilecache->n_levels > 0)
 		tilecache_snapshot(imagedisplay->tilecache, snapshot,
-			pixel_size,
-			imagedisplay->scale, imagedisplay->x, imagedisplay->y,
+			imagedisplay->scale / pixel_size, 
+			imagedisplay->x / pixel_size, 
+			imagedisplay->y / pixel_size,
 			&paint, imagedisplay->debug);
 
 	// draw any overlays
@@ -828,6 +855,13 @@ imagedisplay_class_init(ImagedisplayClass *class)
 			FALSE,
 			G_PARAM_READWRITE));
 
+	g_object_class_install_property(gobject_class, PROP_PIXEL_SIZE,
+		g_param_spec_double("pixel-size",
+			_("Pixel size"),
+			_("Size of hardware display pixels in gtk coordinates"),
+			0.0, 10.0, 0.0,
+			G_PARAM_READWRITE));
+
 	g_object_class_override_property(gobject_class,
 		PROP_HADJUSTMENT, "hadjustment");
 	g_object_class_override_property(gobject_class,

src/tilecache.c

@@ -841,14 +841,12 @@ tilecache_draw_bounds(GtkSnapshot *snapshot,
  * white lines on tile edges.
  */
 static void
-tilecache_snap_rect_to_boundary(graphene_rect_t *bounds, double pixel_size)
+tilecache_snap_rect_to_boundary(graphene_rect_t *bounds)
 {
-	double left = rint(bounds->origin.x * pixel_size) / pixel_size;
-	double top = rint(bounds->origin.y * pixel_size) / pixel_size;
-	double right = 
-		rint((bounds->origin.x + bounds->size.width) * pixel_size) / pixel_size;
-	double bottom = 
-		rint((bounds->origin.y + bounds->size.height) * pixel_size) / pixel_size;
+	double left = rint(bounds->origin.x);
+	double top = rint(bounds->origin.y);
+	double right = rint(bounds->origin.x + bounds->size.width);
+	double bottom = rint(bounds->origin.y + bounds->size.height);
 
 	bounds->origin.x = left;
 	bounds->origin.y = top;
@@ -860,16 +858,12 @@ tilecache_snap_rect_to_boundary(graphene_rect_t *bounds, double pixel_size)
 /* Scale is how much the level0 image has been scaled, x/y is the position of
  * the top-left corner of @paint in the scaled image.
  *
- * @pixel_scale is gdk_surface_get_scale() for the surface this snapshot will
- * be rendered to.
- *
  * @paint is the pixel area in gtk coordinates that we paint in the widget.
  *
  * Set debug to draw tile boundaries for debugging.
  */
 void
 tilecache_snapshot(Tilecache *tilecache, GtkSnapshot *snapshot,
-	double pixel_size,
 	double scale, double x, double y, graphene_rect_t *paint, gboolean debug)
 {
 	/* In debug mode, scale and offset so we can see tile clipping.
@@ -941,7 +935,7 @@ tilecache_snapshot(Tilecache *tilecache, GtkSnapshot *snapshot,
 	 */
 	graphene_rect_t backdrop = *paint;
 #ifndef HAVE_GTK_SNAPSHOT_SET_SNAP
-	tilecache_snap_rect_to_boundary(&backdrop, pixel_size);
+	tilecache_snap_rect_to_boundary(&backdrop);
 #endif /*!HAVE_GTK_SNAPSHOT_SET_SNAP*/
 	gtk_snapshot_push_repeat(snapshot, &backdrop, NULL);
 
@@ -965,7 +959,7 @@ tilecache_snapshot(Tilecache *tilecache, GtkSnapshot *snapshot,
 			 * blur the image. For zooming out, we want trilinear to get
 			 * mipmaps and antialiasing.
 			 */
-			GskScalingFilter filter = scale >= pixel_size ?
+			GskScalingFilter filter = scale >= 1.0 ?
 				GSK_SCALING_FILTER_NEAREST : GSK_SCALING_FILTER_TRILINEAR;
 
 			graphene_rect_t bounds;
@@ -976,7 +970,7 @@ tilecache_snapshot(Tilecache *tilecache, GtkSnapshot *snapshot,
 			bounds.size.height = tile->bounds0.height * scale;
 
 #ifndef HAVE_GTK_SNAPSHOT_SET_SNAP
-			tilecache_snap_rect_to_boundary(&bounds, pixel_size);
+			tilecache_snap_rect_to_boundary(&bounds);
 #endif /*!HAVE_GTK_SNAPSHOT_SET_SNAP*/
 
 			gtk_snapshot_append_scaled_texture(snapshot,

src/tilecache.h

@@ -110,7 +110,6 @@ Tilecache *tilecache_new();
 /* Render the tiles to a snapshot.
  */
 void tilecache_snapshot(Tilecache *tilecache, GtkSnapshot *snapshot,
-	double pixel_size,
 	double scale, double x, double y, graphene_rect_t *paint, gboolean debug);
 
 #endif /*__TILECACHE_H*/