diff options
Diffstat (limited to '')
| -rw-r--r-- | libgimpwidgets/gimpscrolledpreview.c | 917 |
1 files changed, 917 insertions, 0 deletions
diff --git a/libgimpwidgets/gimpscrolledpreview.c b/libgimpwidgets/gimpscrolledpreview.c new file mode 100644 index 0000000..db2426e --- /dev/null +++ b/libgimpwidgets/gimpscrolledpreview.c @@ -0,0 +1,917 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball + * + * gimpscrolledpreview.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 <gtk/gtk.h> + +#include "libgimpmath/gimpmath.h" + +#include "gimpwidgetstypes.h" + +#include "gimpicons.h" +#include "gimppreviewarea.h" +#include "gimpscrolledpreview.h" +#include "gimp3migration.h" + +#include "libgimp/libgimp-intl.h" + + +/** + * SECTION: gimpscrolledpreview + * @title: GimpScrolledPreview + * @short_description: A widget providing a #GimpPreview enhanced by + * scrolling capabilities. + * + * A widget providing a #GimpPreview enhanced by scrolling capabilities. + **/ + + +#define POPUP_SIZE 100 + + +typedef struct +{ + GtkPolicyType hscr_policy; + GtkPolicyType vscr_policy; + gint drag_x; + gint drag_y; + gint drag_xoff; + gint drag_yoff; + gboolean in_drag; + gint frozen; +} GimpScrolledPreviewPrivate; + +#define GIMP_SCROLLED_PREVIEW_GET_PRIVATE(obj) \ + ((GimpScrolledPreviewPrivate *) ((GimpScrolledPreview *) (obj))->priv) + + +static void gimp_scrolled_preview_class_init (GimpScrolledPreviewClass *klass); +static void gimp_scrolled_preview_init (GimpScrolledPreview *preview); +static void gimp_scrolled_preview_dispose (GObject *object); + +static void gimp_scrolled_preview_area_realize (GtkWidget *widget, + GimpScrolledPreview *preview); +static void gimp_scrolled_preview_area_unrealize (GtkWidget *widget, + GimpScrolledPreview *preview); +static void gimp_scrolled_preview_area_size_allocate (GtkWidget *widget, + GtkAllocation *allocation, + GimpScrolledPreview *preview); +static gboolean gimp_scrolled_preview_area_event (GtkWidget *area, + GdkEvent *event, + GimpScrolledPreview *preview); + +static void gimp_scrolled_preview_h_scroll (GtkAdjustment *hadj, + GimpPreview *preview); +static void gimp_scrolled_preview_v_scroll (GtkAdjustment *vadj, + GimpPreview *preview); + +static gboolean gimp_scrolled_preview_nav_button_press (GtkWidget *widget, + GdkEventButton *event, + GimpScrolledPreview *preview); + +static gboolean gimp_scrolled_preview_nav_popup_event (GtkWidget *widget, + GdkEvent *event, + GimpScrolledPreview *preview); +static gboolean gimp_scrolled_preview_nav_popup_expose (GtkWidget *widget, + GdkEventExpose *event, + GimpScrolledPreview *preview); + +static void gimp_scrolled_preview_set_cursor (GimpPreview *preview); + + +static GimpPreviewClass *parent_class = NULL; + + +GType +gimp_scrolled_preview_get_type (void) +{ + static GType preview_type = 0; + + if (! preview_type) + { + const GTypeInfo preview_info = + { + sizeof (GimpScrolledPreviewClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gimp_scrolled_preview_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GimpScrolledPreview), + 0, /* n_preallocs */ + (GInstanceInitFunc) gimp_scrolled_preview_init, + }; + + preview_type = g_type_register_static (GIMP_TYPE_PREVIEW, + "GimpScrolledPreview", + &preview_info, + G_TYPE_FLAG_ABSTRACT); + } + + return preview_type; +} + +static void +gimp_scrolled_preview_class_init (GimpScrolledPreviewClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpPreviewClass *preview_class = GIMP_PREVIEW_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->dispose = gimp_scrolled_preview_dispose; + + preview_class->set_cursor = gimp_scrolled_preview_set_cursor; + + g_type_class_add_private (object_class, sizeof (GimpScrolledPreviewPrivate)); +} + +static void +gimp_scrolled_preview_init (GimpScrolledPreview *preview) +{ + GimpScrolledPreviewPrivate *priv; + GtkWidget *image; + GtkAdjustment *adj; + + preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview, + GIMP_TYPE_SCROLLED_PREVIEW, + GimpScrolledPreviewPrivate); + + priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + preview->nav_popup = NULL; + + priv->hscr_policy = GTK_POLICY_AUTOMATIC; + priv->vscr_policy = GTK_POLICY_AUTOMATIC; + + priv->in_drag = FALSE; + priv->frozen = 1; /* we are frozen during init */ + + /* scrollbars */ + adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, GIMP_PREVIEW (preview)->width - 1, 1.0, + GIMP_PREVIEW (preview)->width, + GIMP_PREVIEW (preview)->width)); + + g_signal_connect (adj, "value-changed", + G_CALLBACK (gimp_scrolled_preview_h_scroll), + preview); + + preview->hscr = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, adj); + gtk_table_attach (GTK_TABLE (GIMP_PREVIEW (preview)->table), + preview->hscr, 0, 1, 1, 2, + GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); + + adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, GIMP_PREVIEW (preview)->height - 1, 1.0, + GIMP_PREVIEW (preview)->height, + GIMP_PREVIEW (preview)->height)); + + g_signal_connect (adj, "value-changed", + G_CALLBACK (gimp_scrolled_preview_v_scroll), + preview); + + preview->vscr = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adj); + gtk_table_attach (GTK_TABLE (GIMP_PREVIEW (preview)->table), + preview->vscr, 1, 2, 0, 1, + GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + + /* Connect after here so that plug-ins get a chance to override the + * default behavior. See bug #364432. + */ + g_signal_connect_after (GIMP_PREVIEW (preview)->area, "event", + G_CALLBACK (gimp_scrolled_preview_area_event), + preview); + + g_signal_connect (GIMP_PREVIEW (preview)->area, "realize", + G_CALLBACK (gimp_scrolled_preview_area_realize), + preview); + g_signal_connect (GIMP_PREVIEW (preview)->area, "unrealize", + G_CALLBACK (gimp_scrolled_preview_area_unrealize), + preview); + + g_signal_connect (GIMP_PREVIEW (preview)->area, "size-allocate", + G_CALLBACK (gimp_scrolled_preview_area_size_allocate), + preview); + + /* navigation icon */ + preview->nav_icon = gtk_event_box_new (); + gtk_table_attach (GTK_TABLE (GIMP_PREVIEW(preview)->table), + preview->nav_icon, 1,2, 1,2, + GTK_SHRINK, GTK_SHRINK, 0, 0); + + image = gtk_image_new_from_icon_name (GIMP_ICON_DIALOG_NAVIGATION, + GTK_ICON_SIZE_MENU); + gtk_container_add (GTK_CONTAINER (preview->nav_icon), image); + gtk_widget_show (image); + + g_signal_connect (preview->nav_icon, "button-press-event", + G_CALLBACK (gimp_scrolled_preview_nav_button_press), + preview); + + priv->frozen = 0; /* thaw without actually calling draw/invalidate */ +} + +static void +gimp_scrolled_preview_dispose (GObject *object) +{ + GimpScrolledPreview *preview = GIMP_SCROLLED_PREVIEW (object); + + if (preview->nav_popup) + { + gtk_widget_destroy (preview->nav_popup); + preview->nav_popup = NULL; + } + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static void +gimp_scrolled_preview_area_realize (GtkWidget *widget, + GimpScrolledPreview *preview) +{ + GdkDisplay *display = gtk_widget_get_display (widget); + + g_return_if_fail (preview->cursor_move == NULL); + + preview->cursor_move = gdk_cursor_new_for_display (display, GDK_HAND1); +} + +static void +gimp_scrolled_preview_area_unrealize (GtkWidget *widget, + GimpScrolledPreview *preview) +{ + if (preview->cursor_move) + { + gdk_cursor_unref (preview->cursor_move); + preview->cursor_move = NULL; + } +} + +static void +gimp_scrolled_preview_hscr_update (GimpScrolledPreview *preview) +{ + GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + gint width; + + width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin; + + gtk_adjustment_configure (adj, + gtk_adjustment_get_value (adj), + 0, width, + 1.0, + MAX (GIMP_PREVIEW (preview)->width / 2.0, 1.0), + GIMP_PREVIEW (preview)->width); +} + +static void +gimp_scrolled_preview_vscr_update (GimpScrolledPreview *preview) +{ + GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + gint height; + + height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin; + + gtk_adjustment_configure (adj, + gtk_adjustment_get_value (adj), + 0, height, + 1.0, + MAX (GIMP_PREVIEW (preview)->height / 2.0, 1.0), + GIMP_PREVIEW (preview)->height); +} + +static void +gimp_scrolled_preview_area_size_allocate (GtkWidget *widget, + GtkAllocation *allocation, + GimpScrolledPreview *preview) +{ + GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + gint width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin; + gint height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin; + + gimp_scrolled_preview_freeze (preview); + + GIMP_PREVIEW (preview)->width = MIN (width, allocation->width); + GIMP_PREVIEW (preview)->height = MIN (height, allocation->height); + + gimp_scrolled_preview_hscr_update (preview); + + switch (priv->hscr_policy) + { + case GTK_POLICY_AUTOMATIC: + gtk_widget_set_visible (preview->hscr, + width > GIMP_PREVIEW (preview)->width); + break; + + case GTK_POLICY_ALWAYS: + gtk_widget_show (preview->hscr); + break; + + case GTK_POLICY_NEVER: + gtk_widget_hide (preview->hscr); + break; + } + + gimp_scrolled_preview_vscr_update (preview); + + switch (priv->vscr_policy) + { + case GTK_POLICY_AUTOMATIC: + gtk_widget_set_visible (preview->vscr, + height > GIMP_PREVIEW (preview)->height); + break; + + case GTK_POLICY_ALWAYS: + gtk_widget_show (preview->vscr); + break; + + case GTK_POLICY_NEVER: + gtk_widget_hide (preview->vscr); + break; + } + + gtk_widget_set_visible (preview->nav_icon, + gtk_widget_get_visible (preview->vscr) && + gtk_widget_get_visible (preview->hscr) && + GIMP_PREVIEW_GET_CLASS (preview)->draw_thumb); + + gimp_scrolled_preview_thaw (preview); +} + +static gboolean +gimp_scrolled_preview_area_event (GtkWidget *area, + GdkEvent *event, + GimpScrolledPreview *preview) +{ + GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + GdkEventButton *button_event = (GdkEventButton *) event; + GdkCursor *cursor; + + switch (event->type) + { + case GDK_BUTTON_PRESS: + switch (button_event->button) + { + case 1: + case 2: + cursor = gdk_cursor_new_for_display (gtk_widget_get_display (area), + GDK_FLEUR); + + if (gdk_pointer_grab (gtk_widget_get_window (area), TRUE, + GDK_BUTTON_RELEASE_MASK | + GDK_BUTTON_MOTION_MASK | + GDK_POINTER_MOTION_HINT_MASK, + NULL, cursor, + gdk_event_get_time (event)) == GDK_GRAB_SUCCESS) + { + gtk_widget_get_pointer (area, &priv->drag_x, &priv->drag_y); + + priv->drag_xoff = GIMP_PREVIEW (preview)->xoff; + priv->drag_yoff = GIMP_PREVIEW (preview)->yoff; + priv->in_drag = TRUE; + gtk_grab_add (area); + } + + gdk_cursor_unref (cursor); + + break; + + case 3: + return TRUE; + } + break; + + case GDK_BUTTON_RELEASE: + if (priv->in_drag && + (button_event->button == 1 || button_event->button == 2)) + { + gdk_display_pointer_ungrab (gtk_widget_get_display (area), + gdk_event_get_time (event)); + + gtk_grab_remove (area); + priv->in_drag = FALSE; + } + break; + + case GDK_MOTION_NOTIFY: + if (priv->in_drag) + { + GdkEventMotion *mevent = (GdkEventMotion *) event; + GtkAdjustment *hadj; + GtkAdjustment *vadj; + gint x, y; + + hadj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + vadj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + + gtk_widget_get_pointer (area, &x, &y); + + x = priv->drag_xoff - (x - priv->drag_x); + y = priv->drag_yoff - (y - priv->drag_y); + + x = CLAMP (x, + gtk_adjustment_get_lower (hadj), + gtk_adjustment_get_upper (hadj) - + gtk_adjustment_get_page_size (hadj)); + y = CLAMP (y, + gtk_adjustment_get_lower (vadj), + gtk_adjustment_get_upper (vadj) - + gtk_adjustment_get_page_size (vadj)); + + if (GIMP_PREVIEW (preview)->xoff != x || + GIMP_PREVIEW (preview)->yoff != y) + { + gtk_adjustment_set_value (hadj, x); + gtk_adjustment_set_value (vadj, y); + + gimp_preview_draw (GIMP_PREVIEW (preview)); + gimp_preview_invalidate (GIMP_PREVIEW (preview)); + } + + gdk_event_request_motions (mevent); + } + break; + + case GDK_SCROLL: + { + GdkEventScroll *sevent = (GdkEventScroll *) event; + GdkScrollDirection direction = sevent->direction; + GtkAdjustment *adj; + gfloat value; + + /* Ctrl-Scroll is reserved for zooming */ + if (sevent->state & GDK_CONTROL_MASK) + return FALSE; + + if (sevent->state & GDK_SHIFT_MASK) + switch (direction) + { + case GDK_SCROLL_UP: direction = GDK_SCROLL_LEFT; break; + case GDK_SCROLL_DOWN: direction = GDK_SCROLL_RIGHT; break; + case GDK_SCROLL_LEFT: direction = GDK_SCROLL_UP; break; + case GDK_SCROLL_RIGHT: direction = GDK_SCROLL_DOWN; break; + } + + switch (direction) + { + case GDK_SCROLL_UP: + case GDK_SCROLL_DOWN: + default: + adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + break; + + case GDK_SCROLL_RIGHT: + case GDK_SCROLL_LEFT: + adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + break; + } + + value = gtk_adjustment_get_value (adj); + + switch (direction) + { + case GDK_SCROLL_UP: + case GDK_SCROLL_LEFT: + value -= gtk_adjustment_get_page_increment (adj) / 2; + break; + + case GDK_SCROLL_DOWN: + case GDK_SCROLL_RIGHT: + value += gtk_adjustment_get_page_increment (adj) / 2; + break; + } + + gtk_adjustment_set_value (adj, + CLAMP (value, + gtk_adjustment_get_lower (adj), + gtk_adjustment_get_upper (adj) - + gtk_adjustment_get_page_size (adj))); + } + break; + + default: + break; + } + + return FALSE; +} + +static void +gimp_scrolled_preview_h_scroll (GtkAdjustment *hadj, + GimpPreview *preview) +{ + GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + preview->xoff = gtk_adjustment_get_value (hadj); + + gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (preview->area), + preview->xoff, preview->yoff); + + if (! (priv->in_drag || priv->frozen)) + { + gimp_preview_draw (preview); + gimp_preview_invalidate (preview); + } +} + +static void +gimp_scrolled_preview_v_scroll (GtkAdjustment *vadj, + GimpPreview *preview) +{ + GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + preview->yoff = gtk_adjustment_get_value (vadj); + + gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (preview->area), + preview->xoff, preview->yoff); + + if (! (priv->in_drag || priv->frozen)) + { + gimp_preview_draw (preview); + gimp_preview_invalidate (preview); + } +} + +static gboolean +gimp_scrolled_preview_nav_button_press (GtkWidget *widget, + GdkEventButton *event, + GimpScrolledPreview *preview) +{ + GimpPreview *gimp_preview = GIMP_PREVIEW (preview); + GtkAdjustment *adj; + + if (preview->nav_popup) + return TRUE; + + if (event->type == GDK_BUTTON_PRESS && event->button == 1) + { + GtkStyle *style = gtk_widget_get_style (widget); + GtkWidget *outer; + GtkWidget *inner; + GtkWidget *area; + GdkCursor *cursor; + gint x, y; + gdouble h, v; + + preview->nav_popup = gtk_window_new (GTK_WINDOW_POPUP); + + gtk_window_set_screen (GTK_WINDOW (preview->nav_popup), + gtk_widget_get_screen (widget)); + + outer = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (outer), GTK_SHADOW_OUT); + gtk_container_add (GTK_CONTAINER (preview->nav_popup), outer); + gtk_widget_show (outer); + + inner = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (inner), GTK_SHADOW_IN); + gtk_container_add (GTK_CONTAINER (outer), inner); + gtk_widget_show (inner); + + area = g_object_new (GIMP_TYPE_PREVIEW_AREA, + "check-size", GIMP_CHECK_SIZE_SMALL_CHECKS, + "check-type", GIMP_PREVIEW_AREA (gimp_preview->area)->check_type, + NULL); + + gtk_container_add (GTK_CONTAINER (inner), area); + + g_signal_connect (area, "event", + G_CALLBACK (gimp_scrolled_preview_nav_popup_event), + preview); + g_signal_connect_after (area, "expose-event", + G_CALLBACK (gimp_scrolled_preview_nav_popup_expose), + preview); + + GIMP_PREVIEW_GET_CLASS (preview)->draw_thumb (gimp_preview, + GIMP_PREVIEW_AREA (area), + POPUP_SIZE, POPUP_SIZE); + gtk_widget_realize (area); + gtk_widget_show (area); + + gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y); + + adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + h = ((gtk_adjustment_get_value (adj) / + gtk_adjustment_get_upper (adj)) + + (gtk_adjustment_get_page_size (adj) / + gtk_adjustment_get_upper (adj)) / 2.0); + + adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + v = ((gtk_adjustment_get_value (adj) / + gtk_adjustment_get_upper (adj)) + + (gtk_adjustment_get_page_size (adj) / + gtk_adjustment_get_upper (adj)) / 2.0); + + x += event->x - h * (gdouble) GIMP_PREVIEW_AREA (area)->width; + y += event->y - v * (gdouble) GIMP_PREVIEW_AREA (area)->height; + + gtk_window_move (GTK_WINDOW (preview->nav_popup), + x - 2 * style->xthickness, + y - 2 * style->ythickness); + + gtk_widget_show (preview->nav_popup); + + gtk_grab_add (area); + + cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), + GDK_FLEUR); + + gdk_pointer_grab (gtk_widget_get_window (area), TRUE, + GDK_BUTTON_RELEASE_MASK | + GDK_BUTTON_MOTION_MASK | + GDK_POINTER_MOTION_HINT_MASK, + gtk_widget_get_window (area), cursor, + event->time); + + gdk_cursor_unref (cursor); + } + + return TRUE; +} + +static gboolean +gimp_scrolled_preview_nav_popup_event (GtkWidget *widget, + GdkEvent *event, + GimpScrolledPreview *preview) +{ + switch (event->type) + { + case GDK_BUTTON_RELEASE: + { + GdkEventButton *button_event = (GdkEventButton *) event; + + if (button_event->button == 1) + { + gtk_grab_remove (widget); + gdk_display_pointer_ungrab (gtk_widget_get_display (widget), + button_event->time); + + gtk_widget_destroy (preview->nav_popup); + preview->nav_popup = NULL; + } + } + break; + + case GDK_MOTION_NOTIFY: + { + GdkEventMotion *mevent = (GdkEventMotion *) event; + GtkAdjustment *hadj; + GtkAdjustment *vadj; + GtkAllocation allocation; + gint cx, cy; + gdouble x, y; + + hadj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + vadj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + + gtk_widget_get_allocation (widget, &allocation); + + gtk_widget_get_pointer (widget, &cx, &cy); + + x = cx * (gtk_adjustment_get_upper (hadj) - + gtk_adjustment_get_lower (hadj)) / allocation.width; + y = cy * (gtk_adjustment_get_upper (vadj) - + gtk_adjustment_get_lower (vadj)) / allocation.height; + + x += (gtk_adjustment_get_lower (hadj) - + gtk_adjustment_get_page_size (hadj) / 2); + y += (gtk_adjustment_get_lower (vadj) - + gtk_adjustment_get_page_size (vadj) / 2); + + gtk_adjustment_set_value (hadj, + CLAMP (x, + gtk_adjustment_get_lower (hadj), + gtk_adjustment_get_upper (hadj) - + gtk_adjustment_get_page_size (hadj))); + gtk_adjustment_set_value (vadj, + CLAMP (y, + gtk_adjustment_get_lower (vadj), + gtk_adjustment_get_upper (vadj) - + gtk_adjustment_get_page_size (vadj))); + + gtk_widget_queue_draw (widget); + gdk_window_process_updates (gtk_widget_get_window (widget), FALSE); + + gdk_event_request_motions (mevent); + } + break; + + default: + break; + } + + return FALSE; +} + +static gboolean +gimp_scrolled_preview_nav_popup_expose (GtkWidget *widget, + GdkEventExpose *event, + GimpScrolledPreview *preview) +{ + GtkAdjustment *adj; + GtkAllocation allocation; + cairo_t *cr; + gdouble x, y; + gdouble w, h; + + adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + + gtk_widget_get_allocation (widget, &allocation); + + x = (gtk_adjustment_get_value (adj) / + (gtk_adjustment_get_upper (adj) - + gtk_adjustment_get_lower (adj))); + w = (gtk_adjustment_get_page_size (adj) / + (gtk_adjustment_get_upper (adj) - + gtk_adjustment_get_lower (adj))); + + adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + + y = (gtk_adjustment_get_value (adj) / + (gtk_adjustment_get_upper (adj) - + gtk_adjustment_get_lower (adj))); + h = (gtk_adjustment_get_page_size (adj) / + (gtk_adjustment_get_upper (adj) - + gtk_adjustment_get_lower (adj))); + + if (w >= 1.0 && h >= 1.0) + return FALSE; + + x = floor (x * (gdouble) allocation.width); + y = floor (y * (gdouble) allocation.height); + w = MAX (1, ceil (w * (gdouble) allocation.width)); + h = MAX (1, ceil (h * (gdouble) allocation.height)); + + cr = gdk_cairo_create (gtk_widget_get_window (widget)); + + gdk_cairo_region (cr, event->region); + cairo_clip (cr); + + cairo_rectangle (cr, + 0, 0, allocation.width, allocation.height); + + cairo_rectangle (cr, x, y, w, h); + + cairo_set_source_rgba (cr, 0, 0, 0, 0.5); + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); + cairo_fill (cr); + + cairo_rectangle (cr, x, y, w, h); + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_set_line_width (cr, 2); + cairo_stroke (cr); + + cairo_destroy (cr); + + return FALSE; +} + +static void +gimp_scrolled_preview_set_cursor (GimpPreview *preview) +{ + if (! gtk_widget_get_realized (preview->area)) + return; + + if (preview->xmax - preview->xmin > preview->width || + preview->ymax - preview->ymin > preview->height) + { + gdk_window_set_cursor (gtk_widget_get_window (preview->area), + GIMP_SCROLLED_PREVIEW (preview)->cursor_move); + } + else + { + gdk_window_set_cursor (gtk_widget_get_window (preview->area), + preview->default_cursor); + } +} + +/** + * gimp_scrolled_preview_set_position: + * @preview: a #GimpScrolledPreview + * @x: horizontal scroll offset + * @y: vertical scroll offset + * + * Since: 2.4 + **/ +void +gimp_scrolled_preview_set_position (GimpScrolledPreview *preview, + gint x, + gint y) +{ + GtkAdjustment *adj; + + g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview)); + + gimp_scrolled_preview_freeze (preview); + + gimp_scrolled_preview_hscr_update (preview); + gimp_scrolled_preview_vscr_update (preview); + + adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr)); + gtk_adjustment_set_value (adj, x - GIMP_PREVIEW (preview)->xmin); + + adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr)); + gtk_adjustment_set_value (adj, y - GIMP_PREVIEW (preview)->ymin); + + gimp_scrolled_preview_thaw (preview); +} + +/** + * gimp_scrolled_preview_set_policy + * @preview: a #GimpScrolledPreview + * @hscrollbar_policy: policy for horizontal scrollbar + * @vscrollbar_policy: policy for vertical scrollbar + * + * Since: 2.4 + **/ +void +gimp_scrolled_preview_set_policy (GimpScrolledPreview *preview, + GtkPolicyType hscrollbar_policy, + GtkPolicyType vscrollbar_policy) +{ + GimpScrolledPreviewPrivate *priv; + + g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview)); + + priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + priv->hscr_policy = hscrollbar_policy; + priv->vscr_policy = vscrollbar_policy; + + gtk_widget_queue_resize (GIMP_PREVIEW (preview)->area); +} + + +/** + * gimp_scrolled_preview_freeze: + * @preview: a #GimpScrolledPreview + * + * While the @preview is frozen, it is not going to redraw itself in + * response to scroll events. + * + * This function should only be used to implement widgets derived from + * #GimpScrolledPreview. There is no point in calling this from a plug-in. + * + * Since: 2.4 + **/ +void +gimp_scrolled_preview_freeze (GimpScrolledPreview *preview) +{ + GimpScrolledPreviewPrivate *priv; + + g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview)); + + priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + priv->frozen++; +} + +/** + * gimp_scrolled_preview_thaw: + * @preview: a #GimpScrolledPreview + * + * While the @preview is frozen, it is not going to redraw itself in + * response to scroll events. + * + * This function should only be used to implement widgets derived from + * #GimpScrolledPreview. There is no point in calling this from a plug-in. + * + * Since: 2.4 + **/ +void +gimp_scrolled_preview_thaw (GimpScrolledPreview *preview) +{ + GimpScrolledPreviewPrivate *priv; + + g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview)); + + priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview); + + g_return_if_fail (priv->frozen > 0); + + priv->frozen--; + + if (! priv->frozen) + { + gimp_preview_draw (GIMP_PREVIEW (preview)); + gimp_preview_invalidate (GIMP_PREVIEW (preview)); + } +} |