AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
91f989006c
gtk2/gtk/gtkmagnifier.c

491 lines
13 KiB
C
Raw Normal View History

Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
/* GTK - The GIMP Toolkit
* Copyright © 2013 Carlos Garnacho <carlosg@gnome.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gtk/gtk.h"
#include "gtkmagnifierprivate.h"
#include "gtkintl.h"
enum {
PROP_INSPECTED = 1,
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
PROP_RESIZE,
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
PROP_MAGNIFICATION
};
typedef struct _GtkMagnifierPrivate GtkMagnifierPrivate;
struct _GtkMagnifierPrivate
{
GtkWidget *inspected;
gdouble magnification;
gint x;
gint y;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
gboolean resize;
gulong draw_handler;
gulong resize_handler;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
};
G_DEFINE_TYPE_WITH_PRIVATE (GtkMagnifier, _gtk_magnifier,
GTK_TYPE_WIDGET)
static void
_gtk_magnifier_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
switch (param_id)
{
case PROP_INSPECTED:
_gtk_magnifier_set_inspected (GTK_MAGNIFIER (object),
g_value_get_object (value));
break;
case PROP_MAGNIFICATION:
_gtk_magnifier_set_magnification (GTK_MAGNIFIER (object),
g_value_get_double (value));
break;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
case PROP_RESIZE:
_gtk_magnifier_set_resize (GTK_MAGNIFIER (object),
g_value_get_boolean (value));
break;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
}
}
static void
_gtk_magnifier_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GtkMagnifier *magnifier;
GtkMagnifierPrivate *priv;
magnifier = GTK_MAGNIFIER (object);
priv = _gtk_magnifier_get_instance_private (magnifier);
switch (param_id)
{
case PROP_INSPECTED:
g_value_set_object (value, priv->inspected);
break;
case PROP_MAGNIFICATION:
g_value_set_double (value, priv->magnification);
break;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
case PROP_RESIZE:
g_value_set_boolean (value, priv->resize);
break;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
}
}
static gboolean
_gtk_magnifier_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkAllocation allocation, inspected_alloc;
GtkMagnifier *magnifier;
GtkMagnifierPrivate *priv;
gdouble x, y;
magnifier = GTK_MAGNIFIER (widget);
priv = _gtk_magnifier_get_instance_private (magnifier);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
if (priv->inspected == NULL)
return FALSE;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
if (!gtk_widget_is_visible (priv->inspected))
return FALSE;
gtk_widget_get_allocation (widget, &allocation);
gtk_widget_get_allocation (priv->inspected, &inspected_alloc);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
if (!priv->resize)
cairo_translate (cr, allocation.width / 2, allocation.height / 2);
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
x = CLAMP (priv->x, 0, inspected_alloc.width);
y = CLAMP (priv->y, 0, inspected_alloc.height);
cairo_save (cr);
cairo_scale (cr, priv->magnification, priv->magnification);
cairo_translate (cr, -x, -y);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
g_signal_handler_block (priv->inspected, priv->draw_handler);
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
gtk_widget_draw (priv->inspected, cr);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
g_signal_handler_unblock (priv->inspected, priv->draw_handler);
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
cairo_restore (cr);
return TRUE;
}
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
static void
gtk_magnifier_get_preferred_width (GtkWidget *widget,
gint *minimum_width,
gint *natural_width)
{
GtkMagnifier *magnifier;
GtkMagnifierPrivate *priv;
gint width;
magnifier = GTK_MAGNIFIER (widget);
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->resize && priv->inspected)
width = priv->magnification * gtk_widget_get_allocated_width (priv->inspected);
else
width = 0;
*minimum_width = width;
*natural_width = width;
}
static void
gtk_magnifier_get_preferred_height (GtkWidget *widget,
gint *minimum_height,
gint *natural_height)
{
GtkMagnifier *magnifier;
GtkMagnifierPrivate *priv;
gint height;
magnifier = GTK_MAGNIFIER (widget);
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->resize && priv->inspected)
height = priv->magnification * gtk_widget_get_allocated_height (priv->inspected);
else
height = 0;
*minimum_height = height;
*natural_height = height;
}
static void
resize_handler (GtkWidget *widget,
GtkAllocation *alloc,
GtkWidget *magnifier)
{
gtk_widget_queue_resize (magnifier);
}
static void
connect_resize_handler (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->inspected && priv->resize)
priv->resize_handler = g_signal_connect (priv->inspected, "size-allocate",
G_CALLBACK (resize_handler), magnifier);
}
static void
disconnect_resize_handler (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->resize_handler)
{
gtkmagnifier: Avoid a crash if the inspected widget is finalized If the inspected widget is finalized and we then try to disconnect from its signals we'll crash. https://bugzilla.gnome.org/show_bug.cgi?id=761775
2016-02-09 14:30:00 +00:00
if (priv->inspected)
g_signal_handler_disconnect (priv->inspected, priv->resize_handler);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
priv->resize_handler = 0;
}
}
static gboolean
draw_handler (GtkWidget *widget,
cairo_t *cr,
GtkWidget *magnifier)
{
gtk_widget_queue_draw (magnifier);
return FALSE;
}
static void
connect_draw_handler (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
priv = _gtk_magnifier_get_instance_private (magnifier);
magnifier: Only connect to ::draw when needed This making us take the slow path in ::draw handling, so we want to avoid it if we can. https://bugzilla.gnome.org/show_bug.cgi?id=765238
2016-04-19 19:27:08 +00:00
if (!priv->draw_handler)
{
if (priv->inspected)
priv->draw_handler = g_signal_connect (priv->inspected, "draw",
G_CALLBACK (draw_handler), magnifier);
}
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
}
static void
disconnect_draw_handler (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->draw_handler)
{
gtkmagnifier: Avoid a crash if the inspected widget is finalized If the inspected widget is finalized and we then try to disconnect from its signals we'll crash. https://bugzilla.gnome.org/show_bug.cgi?id=761775
2016-02-09 14:30:00 +00:00
if (priv->inspected)
g_signal_handler_disconnect (priv->inspected, priv->draw_handler);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
priv->draw_handler = 0;
}
}
static void
_gtk_magnifier_destroy (GtkWidget *widget)
{
_gtk_magnifier_set_inspected (GTK_MAGNIFIER (widget), NULL);
GTK_WIDGET_CLASS (_gtk_magnifier_parent_class)->destroy (widget);
}
magnifier: Only connect to ::draw when needed This making us take the slow path in ::draw handling, so we want to avoid it if we can. https://bugzilla.gnome.org/show_bug.cgi?id=765238
2016-04-19 19:27:08 +00:00
static void
gtk_magnifier_map (GtkWidget *widget)
{
connect_draw_handler (GTK_MAGNIFIER (widget));
GTK_WIDGET_CLASS (_gtk_magnifier_parent_class)->map (widget);
}
static void
gtk_magnifier_unmap (GtkWidget *widget)
{
GTK_WIDGET_CLASS (_gtk_magnifier_parent_class)->unmap (widget);
disconnect_draw_handler (GTK_MAGNIFIER (widget));
}
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
static void
_gtk_magnifier_class_init (GtkMagnifierClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class->set_property = _gtk_magnifier_set_property;
object_class->get_property = _gtk_magnifier_get_property;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
widget_class->destroy = _gtk_magnifier_destroy;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
widget_class->draw = _gtk_magnifier_draw;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
widget_class->get_preferred_width = gtk_magnifier_get_preferred_width;
widget_class->get_preferred_height = gtk_magnifier_get_preferred_height;
magnifier: Only connect to ::draw when needed This making us take the slow path in ::draw handling, so we want to avoid it if we can. https://bugzilla.gnome.org/show_bug.cgi?id=765238
2016-04-19 19:27:08 +00:00
widget_class->map = gtk_magnifier_map;
widget_class->unmap = gtk_magnifier_unmap;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
g_object_class_install_property (object_class,
PROP_INSPECTED,
gtkmagnifier: do not use P_() macro for property names
2014-02-07 07:17:11 +00:00
g_param_spec_object ("inspected",
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
P_("Inspected"),
P_("Inspected widget"),
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MAGNIFICATION,
gtkmagnifier: do not use P_() macro for property names
2014-02-07 07:17:11 +00:00
g_param_spec_double ("magnification",
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
P_("magnification"),
P_("magnification"),
1, G_MAXDOUBLE, 1,
G_PARAM_READWRITE));
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
g_object_class_install_property (object_class,
PROP_RESIZE,
g_param_spec_boolean ("resize",
P_("resize"),
P_("resize"),
FALSE,
G_PARAM_READWRITE));
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
}
static void
_gtk_magnifier_init (GtkMagnifier *magnifier)
{
GtkWidget *widget = GTK_WIDGET (magnifier);
GtkMagnifierPrivate *priv;
priv = _gtk_magnifier_get_instance_private (magnifier);
gtk_widget_set_events (widget,
gtk: Stop setting GDK_EXPOSURE_MASK on random widgets These days exposure happens only on the native windows (generally the toplevel window) and is propagated down recursively. The expose event is only useful for backwards compat, and in fact, for double buffered widgets we totally ignore the event (and non-double buffering breaks on wayland). So, by not setting the mask we avoid emitting these events and then later ignoring them. We still keep it on eventbox, fixed and layout as these are used in weird ways that want backwards compat.
2015-09-14 08:56:13 +00:00
gtk_widget_get_events (widget));
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
gtk_widget_set_has_window (widget, FALSE);
priv->magnification = 1;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
priv->resize = FALSE;
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
}
GtkWidget *
_gtk_magnifier_new (GtkWidget *inspected)
{
g_return_val_if_fail (GTK_IS_WIDGET (inspected), NULL);
return g_object_new (GTK_TYPE_MAGNIFIER,
"inspected", inspected,
NULL);
}
GtkWidget *
_gtk_magnifier_get_inspected (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
g_return_val_if_fail (GTK_IS_MAGNIFIER (magnifier), NULL);
priv = _gtk_magnifier_get_instance_private (magnifier);
return priv->inspected;
}
void
_gtk_magnifier_set_inspected (GtkMagnifier *magnifier,
GtkWidget *inspected)
{
GtkMagnifierPrivate *priv;
magnifier: Fix compiler warning
2014-01-22 19:48:51 +00:00
g_return_if_fail (GTK_IS_MAGNIFIER (magnifier));
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->inspected == inspected)
return;
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
disconnect_draw_handler (magnifier);
disconnect_resize_handler (magnifier);
gtkmagnifier: Avoid a crash if the inspected widget is finalized If the inspected widget is finalized and we then try to disconnect from its signals we'll crash. https://bugzilla.gnome.org/show_bug.cgi?id=761775
2016-02-09 14:30:00 +00:00
if (priv->inspected)
g_object_remove_weak_pointer (G_OBJECT (priv->inspected),
(gpointer *) &priv->inspected);
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
priv->inspected = inspected;
gtkmagnifier: Avoid a crash if the inspected widget is finalized If the inspected widget is finalized and we then try to disconnect from its signals we'll crash. https://bugzilla.gnome.org/show_bug.cgi?id=761775
2016-02-09 14:30:00 +00:00
if (priv->inspected)
g_object_add_weak_pointer (G_OBJECT (priv->inspected),
(gpointer *) &priv->inspected);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
magnifier: Only connect to ::draw when needed This making us take the slow path in ::draw handling, so we want to avoid it if we can. https://bugzilla.gnome.org/show_bug.cgi?id=765238
2016-04-19 19:27:08 +00:00
if (gtk_widget_get_mapped (GTK_WIDGET (magnifier)))
connect_draw_handler (magnifier);
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
connect_resize_handler (magnifier);
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
g_object_notify (G_OBJECT (magnifier), "inspected");
}
void
_gtk_magnifier_set_coords (GtkMagnifier *magnifier,
gdouble x,
gdouble y)
{
GtkMagnifierPrivate *priv;
g_return_if_fail (GTK_IS_MAGNIFIER (magnifier));
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->x == x && priv->y == y)
return;
priv->x = x;
priv->y = y;
if (gtk_widget_is_visible (GTK_WIDGET (magnifier)))
gtk_widget_queue_draw (GTK_WIDGET (magnifier));
}
void
_gtk_magnifier_get_coords (GtkMagnifier *magnifier,
gdouble *x,
gdouble *y)
{
GtkMagnifierPrivate *priv;
g_return_if_fail (GTK_IS_MAGNIFIER (magnifier));
priv = _gtk_magnifier_get_instance_private (magnifier);
if (x)
*x = priv->x;
if (y)
*y = priv->y;
}
void
_gtk_magnifier_set_magnification (GtkMagnifier *magnifier,
gdouble magnification)
{
GtkMagnifierPrivate *priv;
g_return_if_fail (GTK_IS_MAGNIFIER (magnifier));
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->magnification == magnification)
return;
priv->magnification = magnification;
g_object_notify (G_OBJECT (magnifier), "magnification");
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
if (priv->resize)
gtk_widget_queue_resize (GTK_WIDGET (magnifier));
Add GtkMagnifier This is a private widget that takes another widget on construction, and is able to render parts of it, possibly at a different magnification level.
2013-12-11 14:42:10 +00:00
if (gtk_widget_is_visible (GTK_WIDGET (magnifier)))
gtk_widget_queue_draw (GTK_WIDGET (magnifier));
}
gdouble
_gtk_magnifier_get_magnification (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
g_return_val_if_fail (GTK_IS_MAGNIFIER (magnifier), 1);
priv = _gtk_magnifier_get_instance_private (magnifier);
return priv->magnification;
}
GtkMagnifier: Add a resizing mode In addition to the fixed-size mode that is used by the text view, add a mode in which the magnifier requests enough size to render the entire inspected widget at the current magnification. In this mode, the magnifier will update its size when the size of the inspected widget changes. Also, make the magnifier redraw on its own whenever the inspected widget draws.
2014-12-21 00:16:46 +00:00
void
_gtk_magnifier_set_resize (GtkMagnifier *magnifier,
gboolean resize)
{
GtkMagnifierPrivate *priv;
g_return_if_fail (GTK_IS_MAGNIFIER (magnifier));
priv = _gtk_magnifier_get_instance_private (magnifier);
if (priv->resize == resize)
return;
priv->resize = resize;
gtk_widget_queue_resize (GTK_WIDGET (magnifier));
if (resize)
connect_resize_handler (magnifier);
else
disconnect_resize_handler (magnifier);
}
gboolean
_gtk_magnifier_get_resize (GtkMagnifier *magnifier)
{
GtkMagnifierPrivate *priv;
g_return_val_if_fail (GTK_IS_MAGNIFIER (magnifier), FALSE);
priv = _gtk_magnifier_get_instance_private (magnifier);
return priv->resize;
}
Reference in New Issue Copy Permalink