diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:30:19 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:30:19 +0000 |
commit | 5c1676dfe6d2f3c837a5e074117b45613fd29a72 (patch) | |
tree | cbffb45144febf451e54061db2b21395faf94bfe /libgimpwidgets/gimppreview.c | |
parent | Initial commit. (diff) | |
download | gimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.tar.xz gimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.zip |
Adding upstream version 2.10.34.upstream/2.10.34upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | libgimpwidgets/gimppreview.c | 851 |
1 files changed, 851 insertions, 0 deletions
diff --git a/libgimpwidgets/gimppreview.c b/libgimpwidgets/gimppreview.c new file mode 100644 index 0000000..75b38ea --- /dev/null +++ b/libgimpwidgets/gimppreview.c @@ -0,0 +1,851 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball + * + * gimppreview.c + * + * 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 3 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 + * <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gegl.h> +#include <gtk/gtk.h> + +#include "libgimpmath/gimpmath.h" + +#include "gimpwidgets.h" + +#include "gimppreview.h" + +#include "libgimp/libgimp-intl.h" + + +/** + * SECTION: gimppreview + * @title: GimpPreview + * @short_description: A widget providing a #GimpPreviewArea plus + * framework to update the preview. + * + * A widget providing a #GimpPreviewArea plus framework to update the + * preview. + **/ + + +#define DEFAULT_SIZE 200 +#define PREVIEW_TIMEOUT 200 + + +enum +{ + INVALIDATED, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_UPDATE +}; + +typedef struct +{ + GtkWidget *controls; +} GimpPreviewPrivate; + +#define GIMP_PREVIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIMP_TYPE_PREVIEW, GimpPreviewPrivate)) + + +static void gimp_preview_class_init (GimpPreviewClass *klass); +static void gimp_preview_init (GimpPreview *preview); +static void gimp_preview_dispose (GObject *object); +static void gimp_preview_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); +static void gimp_preview_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); + +static void gimp_preview_direction_changed (GtkWidget *widget, + GtkTextDirection prev_dir); +static gboolean gimp_preview_popup_menu (GtkWidget *widget); + +static void gimp_preview_area_realize (GtkWidget *widget, + GimpPreview *preview); +static void gimp_preview_area_unrealize (GtkWidget *widget, + GimpPreview *preview); +static void gimp_preview_area_size_allocate (GtkWidget *widget, + GtkAllocation *allocation, + GimpPreview *preview); +static void gimp_preview_area_set_cursor (GimpPreview *preview); +static gboolean gimp_preview_area_event (GtkWidget *area, + GdkEvent *event, + GimpPreview *preview); + +static void gimp_preview_toggle_callback (GtkWidget *toggle, + GimpPreview *preview); + +static void gimp_preview_notify_checks (GimpPreview *preview); + +static gboolean gimp_preview_invalidate_now (GimpPreview *preview); +static void gimp_preview_real_set_cursor (GimpPreview *preview); +static void gimp_preview_real_transform (GimpPreview *preview, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y); +static void gimp_preview_real_untransform (GimpPreview *preview, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y); + + +static guint preview_signals[LAST_SIGNAL] = { 0 }; + +static GtkBoxClass *parent_class = NULL; + + +GType +gimp_preview_get_type (void) +{ + static GType preview_type = 0; + + if (! preview_type) + { + const GTypeInfo preview_info = + { + sizeof (GimpPreviewClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gimp_preview_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GimpPreview), + 0, /* n_preallocs */ + (GInstanceInitFunc) gimp_preview_init, + }; + + preview_type = g_type_register_static (GTK_TYPE_BOX, + "GimpPreview", + &preview_info, + G_TYPE_FLAG_ABSTRACT); + } + + return preview_type; +} + +static void +gimp_preview_class_init (GimpPreviewClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + preview_signals[INVALIDATED] = + g_signal_new ("invalidated", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpPreviewClass, invalidated), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + object_class->dispose = gimp_preview_dispose; + object_class->get_property = gimp_preview_get_property; + object_class->set_property = gimp_preview_set_property; + + widget_class->direction_changed = gimp_preview_direction_changed; + widget_class->popup_menu = gimp_preview_popup_menu; + + klass->draw = NULL; + klass->draw_thumb = NULL; + klass->draw_buffer = NULL; + klass->set_cursor = gimp_preview_real_set_cursor; + klass->transform = gimp_preview_real_transform; + klass->untransform = gimp_preview_real_untransform; + + g_type_class_add_private (object_class, sizeof (GimpPreviewPrivate)); + + g_object_class_install_property (object_class, + PROP_UPDATE, + g_param_spec_boolean ("update", + "Update", + "Whether the preview should update automatically", + TRUE, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); + + gtk_widget_class_install_style_property (widget_class, + g_param_spec_int ("size", + "Size", + "The preview's size", + 1, 1024, + DEFAULT_SIZE, + GIMP_PARAM_READABLE)); +} + +static void +gimp_preview_init (GimpPreview *preview) +{ + GimpPreviewPrivate *priv = GIMP_PREVIEW_GET_PRIVATE (preview); + GtkWidget *frame; + gdouble xalign = 0.0; + + gtk_orientable_set_orientation (GTK_ORIENTABLE (preview), + GTK_ORIENTATION_VERTICAL); + + gtk_box_set_homogeneous (GTK_BOX (preview), FALSE); + gtk_box_set_spacing (GTK_BOX (preview), 6); + + if (gtk_widget_get_direction (GTK_WIDGET (preview)) == GTK_TEXT_DIR_RTL) + xalign = 1.0; + + preview->frame = gtk_aspect_frame_new (NULL, xalign, 0.0, 1.0, TRUE); + gtk_frame_set_shadow_type (GTK_FRAME (preview->frame), GTK_SHADOW_NONE); + gtk_box_pack_start (GTK_BOX (preview), preview->frame, TRUE, TRUE, 0); + gtk_widget_show (preview->frame); + + preview->table = gtk_table_new (3, 2, FALSE); + gtk_table_set_row_spacing (GTK_TABLE (preview->table), 1, 3); + gtk_container_add (GTK_CONTAINER (preview->frame), preview->table); + gtk_widget_show (preview->table); + + preview->timeout_id = 0; + + preview->xmin = preview->ymin = 0; + preview->xmax = preview->ymax = 1; + preview->width = preview->xmax - preview->xmin; + preview->height = preview->ymax - preview->ymin; + + preview->xoff = 0; + preview->yoff = 0; + + preview->default_cursor = NULL; + + /* preview area */ + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); + gtk_table_attach (GTK_TABLE (preview->table), frame, 0, 1, 0, 1, + GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); + gtk_widget_show (frame); + + preview->area = gimp_preview_area_new (); + gtk_container_add (GTK_CONTAINER (frame), preview->area); + gtk_widget_show (preview->area); + + g_signal_connect_swapped (preview->area, "notify::check-size", + G_CALLBACK (gimp_preview_notify_checks), + preview); + g_signal_connect_swapped (preview->area, "notify::check-type", + G_CALLBACK (gimp_preview_notify_checks), + preview); + + gtk_widget_add_events (preview->area, + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_HINT_MASK | + GDK_BUTTON_MOTION_MASK); + + g_signal_connect (preview->area, "event", + G_CALLBACK (gimp_preview_area_event), + preview); + + g_signal_connect (preview->area, "realize", + G_CALLBACK (gimp_preview_area_realize), + preview); + g_signal_connect (preview->area, "unrealize", + G_CALLBACK (gimp_preview_area_unrealize), + preview); + + g_signal_connect_data (preview->area, "realize", + G_CALLBACK (gimp_preview_area_set_cursor), + preview, NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED); + + g_signal_connect (preview->area, "size-allocate", + G_CALLBACK (gimp_preview_area_size_allocate), + preview); + + g_signal_connect_data (preview->area, "size-allocate", + G_CALLBACK (gimp_preview_area_set_cursor), + preview, NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED); + + priv->controls = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_table_attach (GTK_TABLE (preview->table), priv->controls, 0, 2, 2, 3, + GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); + gtk_widget_show (priv->controls); + + /* toggle button to (de)activate the instant preview */ + preview->toggle = gtk_check_button_new_with_mnemonic (_("_Preview")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (preview->toggle), + preview->update_preview); + gtk_box_pack_start (GTK_BOX (priv->controls), preview->toggle, TRUE, TRUE, 0); + gtk_widget_show (preview->toggle); + + g_signal_connect (preview->toggle, "toggled", + G_CALLBACK (gimp_preview_toggle_callback), + preview); +} + +static void +gimp_preview_dispose (GObject *object) +{ + GimpPreview *preview = GIMP_PREVIEW (object); + + if (preview->timeout_id) + { + g_source_remove (preview->timeout_id); + preview->timeout_id = 0; + } + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static void +gimp_preview_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpPreview *preview = GIMP_PREVIEW (object); + + switch (property_id) + { + case PROP_UPDATE: + g_value_set_boolean (value, preview->update_preview); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_preview_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpPreview *preview = GIMP_PREVIEW (object); + + switch (property_id) + { + case PROP_UPDATE: + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (preview->toggle), + g_value_get_boolean (value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_preview_direction_changed (GtkWidget *widget, + GtkTextDirection prev_dir) +{ + GimpPreview *preview = GIMP_PREVIEW (widget); + gdouble xalign = 0.0; + + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + xalign = 1.0; + + gtk_aspect_frame_set (GTK_ASPECT_FRAME (preview->frame), + xalign, 0.0, 1.0, TRUE); +} + +static gboolean +gimp_preview_popup_menu (GtkWidget *widget) +{ + GimpPreview *preview = GIMP_PREVIEW (widget); + + gimp_preview_area_menu_popup (GIMP_PREVIEW_AREA (preview->area), NULL); + + return TRUE; +} + +static void +gimp_preview_area_realize (GtkWidget *widget, + GimpPreview *preview) +{ + GdkDisplay *display = gtk_widget_get_display (widget); + + g_return_if_fail (preview->cursor_busy == NULL); + + preview->cursor_busy = gdk_cursor_new_for_display (display, GDK_WATCH); + +} + +static void +gimp_preview_area_unrealize (GtkWidget *widget, + GimpPreview *preview) +{ + if (preview->cursor_busy) + { + gdk_cursor_unref (preview->cursor_busy); + preview->cursor_busy = NULL; + } +} + +static void +gimp_preview_area_size_allocate (GtkWidget *widget, + GtkAllocation *allocation, + GimpPreview *preview) +{ + gint width = preview->xmax - preview->xmin; + gint height = preview->ymax - preview->ymin; + + preview->width = MIN (width, allocation->width); + preview->height = MIN (height, allocation->height); + + gimp_preview_draw (preview); + gimp_preview_invalidate (preview); +} + +static void +gimp_preview_area_set_cursor (GimpPreview *preview) +{ + GIMP_PREVIEW_GET_CLASS (preview)->set_cursor (preview); +} + +static gboolean +gimp_preview_area_event (GtkWidget *area, + GdkEvent *event, + GimpPreview *preview) +{ + GdkEventButton *button_event = (GdkEventButton *) event; + + switch (event->type) + { + case GDK_BUTTON_PRESS: + switch (button_event->button) + { + case 3: + gimp_preview_area_menu_popup (GIMP_PREVIEW_AREA (area), button_event); + return TRUE; + } + break; + + default: + break; + } + + return FALSE; +} + +static void +gimp_preview_toggle_callback (GtkWidget *toggle, + GimpPreview *preview) +{ + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle))) + { + preview->update_preview = TRUE; + + g_object_notify (G_OBJECT (preview), "update"); + + if (preview->timeout_id) + g_source_remove (preview->timeout_id); + + gimp_preview_invalidate_now (preview); + } + else + { + preview->update_preview = FALSE; + + g_object_notify (G_OBJECT (preview), "update"); + + gimp_preview_draw (preview); + } +} + +static void +gimp_preview_notify_checks (GimpPreview *preview) +{ + gimp_preview_draw (preview); + gimp_preview_invalidate (preview); +} + +static gboolean +gimp_preview_invalidate_now (GimpPreview *preview) +{ + GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (preview)); + GimpPreviewClass *class = GIMP_PREVIEW_GET_CLASS (preview); + + gimp_preview_draw (preview); + + preview->timeout_id = 0; + + if (toplevel && gtk_widget_get_realized (toplevel)) + { + gdk_window_set_cursor (gtk_widget_get_window (toplevel), + preview->cursor_busy); + gdk_window_set_cursor (gtk_widget_get_window (preview->area), + preview->cursor_busy); + + gdk_flush (); + + g_signal_emit (preview, preview_signals[INVALIDATED], 0); + + class->set_cursor (preview); + gdk_window_set_cursor (gtk_widget_get_window (toplevel), NULL); + } + else + { + g_signal_emit (preview, preview_signals[INVALIDATED], 0); + } + + return FALSE; +} + +static void +gimp_preview_real_set_cursor (GimpPreview *preview) +{ + if (gtk_widget_get_realized (preview->area)) + gdk_window_set_cursor (gtk_widget_get_window (preview->area), + preview->default_cursor); +} + +static void +gimp_preview_real_transform (GimpPreview *preview, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y) +{ + *dest_x = src_x - preview->xoff - preview->xmin; + *dest_y = src_y - preview->yoff - preview->ymin; +} + +static void +gimp_preview_real_untransform (GimpPreview *preview, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y) +{ + *dest_x = src_x + preview->xoff + preview->xmin; + *dest_y = src_y + preview->yoff + preview->ymin; +} + +/** + * gimp_preview_set_update: + * @preview: a #GimpPreview widget + * @update: %TRUE if the preview should invalidate itself when being + * scrolled or when gimp_preview_invalidate() is being called + * + * Sets the state of the "Preview" check button. + * + * Since: 2.2 + **/ +void +gimp_preview_set_update (GimpPreview *preview, + gboolean update) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + + g_object_set (preview, + "update", update, + NULL); +} + +/** + * gimp_preview_get_update: + * @preview: a #GimpPreview widget + * + * Return value: the state of the "Preview" check button. + * + * Since: 2.2 + **/ +gboolean +gimp_preview_get_update (GimpPreview *preview) +{ + g_return_val_if_fail (GIMP_IS_PREVIEW (preview), FALSE); + + return preview->update_preview; +} + +/** + * gimp_preview_set_bounds: + * @preview: a #GimpPreview widget + * @xmin: the minimum X value + * @ymin: the minimum Y value + * @xmax: the maximum X value + * @ymax: the maximum Y value + * + * Sets the lower and upper limits for the previewed area. The + * difference between the upper and lower value is used to set the + * maximum size of the #GimpPreviewArea used in the @preview. + * + * Since: 2.2 + **/ +void +gimp_preview_set_bounds (GimpPreview *preview, + gint xmin, + gint ymin, + gint xmax, + gint ymax) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (xmax > xmin); + g_return_if_fail (ymax > ymin); + + preview->xmin = xmin; + preview->ymin = ymin; + preview->xmax = xmax; + preview->ymax = ymax; + + gimp_preview_area_set_max_size (GIMP_PREVIEW_AREA (preview->area), + xmax - xmin, + ymax - ymin); +} + +/** + * gimp_preview_get_size: + * @preview: a #GimpPreview widget + * @width: return location for the preview area width + * @height: return location for the preview area height + * + * Since: 2.2 + **/ +void +gimp_preview_get_size (GimpPreview *preview, + gint *width, + gint *height) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + + if (width) + *width = preview->width; + + if (height) + *height = preview->height; +} + +/** + * gimp_preview_get_position: + * @preview: a #GimpPreview widget + * @x: return location for the horizontal offset + * @y: return location for the vertical offset + * + * Since: 2.2 + **/ +void +gimp_preview_get_position (GimpPreview *preview, + gint *x, + gint *y) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + + if (x) + *x = preview->xoff + preview->xmin; + + if (y) + *y = preview->yoff + preview->ymin; +} + +/** + * gimp_preview_transform: + * @preview: a #GimpPreview widget + * @src_x: horizontal position on the previewed image + * @src_y: vertical position on the previewed image + * @dest_x: returns the transformed horizontal position + * @dest_y: returns the transformed vertical position + * + * Transforms from image to widget coordinates. + * + * Since: 2.4 + **/ +void +gimp_preview_transform (GimpPreview *preview, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (dest_x != NULL && dest_y != NULL); + + GIMP_PREVIEW_GET_CLASS (preview)->transform (preview, + src_x, src_y, dest_x, dest_y); +} + +/** + * gimp_preview_untransform: + * @preview: a #GimpPreview widget + * @src_x: horizontal position relative to the preview area's origin + * @src_y: vertical position relative to preview area's origin + * @dest_x: returns the untransformed horizontal position + * @dest_y: returns the untransformed vertical position + * + * Transforms from widget to image coordinates. + * + * Since: 2.4 + **/ +void +gimp_preview_untransform (GimpPreview *preview, + gint src_x, + gint src_y, + gint *dest_x, + gint *dest_y) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + g_return_if_fail (dest_x != NULL && dest_y != NULL); + + GIMP_PREVIEW_GET_CLASS (preview)->untransform (preview, + src_x, src_y, dest_x, dest_y); +} + +/** + * gimp_preview_get_area: + * @preview: a #GimpPreview widget + * + * In most cases, you shouldn't need to access the #GimpPreviewArea + * that is being used in the @preview. Sometimes however, you need to. + * For example if you want to receive mouse events from the area. In + * such cases, use gimp_preview_get_area(). + * + * Return value: a pointer to the #GimpPreviewArea used in the @preview. + * + * Since: 2.4 + **/ +GtkWidget * +gimp_preview_get_area (GimpPreview *preview) +{ + g_return_val_if_fail (GIMP_IS_PREVIEW (preview), NULL); + + return preview->area; +} + +/** + * gimp_preview_draw: + * @preview: a #GimpPreview widget + * + * Calls the GimpPreview::draw method. GimpPreview itself doesn't + * implement a default draw method so the behaviour is determined by + * the derived class implementing this method. + * + * #GimpDrawablePreview implements gimp_preview_draw() by drawing the + * original, unmodified drawable to the @preview. + * + * Since: 2.2 + **/ +void +gimp_preview_draw (GimpPreview *preview) +{ + GimpPreviewClass *class = GIMP_PREVIEW_GET_CLASS (preview); + + if (class->draw) + class->draw (preview); +} + +/** + * gimp_preview_draw_buffer: + * @preview: a #GimpPreview widget + * @buffer: a pixel buffer the size of the preview + * @rowstride: the @buffer's rowstride + * + * Calls the GimpPreview::draw_buffer method. GimpPreview itself + * doesn't implement this method so the behaviour is determined by the + * derived class implementing this method. + * + * Since: 2.2 + **/ +void +gimp_preview_draw_buffer (GimpPreview *preview, + const guchar *buffer, + gint rowstride) +{ + GimpPreviewClass *class = GIMP_PREVIEW_GET_CLASS (preview); + + if (class->draw_buffer) + class->draw_buffer (preview, buffer, rowstride); +} + +/** + * gimp_preview_invalidate: + * @preview: a #GimpPreview widget + * + * This function starts or renews a short low-priority timeout. When + * the timeout expires, the GimpPreview::invalidated signal is emitted + * which will usually cause the @preview to be updated. + * + * This function does nothing unless the "Preview" button is checked. + * + * During the emission of the signal a busy cursor is set on the + * toplevel window containing the @preview and on the preview area + * itself. + * + * Since: 2.2 + **/ +void +gimp_preview_invalidate (GimpPreview *preview) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + + if (preview->update_preview) + { + if (preview->timeout_id) + g_source_remove (preview->timeout_id); + + preview->timeout_id = + g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE, PREVIEW_TIMEOUT, + (GSourceFunc) gimp_preview_invalidate_now, + preview, NULL); + } +} + +/** + * gimp_preview_set_default_cursor: + * @preview: a #GimpPreview widget + * @cursor: a #GdkCursor or %NULL + * + * Sets the default mouse cursor for the preview. Note that this will + * be overridden by a %GDK_FLEUR if the preview has scrollbars, or by a + * %GDK_WATCH when the preview is invalidated. + * + * Since: 2.2 + **/ +void +gimp_preview_set_default_cursor (GimpPreview *preview, + GdkCursor *cursor) +{ + g_return_if_fail (GIMP_IS_PREVIEW (preview)); + + g_set_object (&preview->default_cursor, cursor); +} + +/** + * gimp_preview_get_controls: + * @preview: a #GimpPreview widget + * + * Gives access to the #GtkHBox at the bottom of the preview that + * contains the update toggle. Derived widgets can use this function + * if they need to add controls to this area. + * + * Return value: the #GtkHBox at the bottom of the preview. + * + * Since: 2.4 + **/ +GtkWidget * +gimp_preview_get_controls (GimpPreview *preview) +{ + g_return_val_if_fail (GIMP_IS_PREVIEW (preview), NULL); + + return GIMP_PREVIEW_GET_PRIVATE (preview)->controls; +} |