dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

libgimpwidgets: move all GimpPreview members to private 

and add tons of API so subclasses can still do their thing, probably
subject to change/fix.
This commit is contained in:
Michael Natterer 2018-05-04 09:46:37 +02:00
parent 9cb67fa992
commit d87eddb1c4
7 changed files with 527 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
libgimp/gimpaspectpreview.c
View File

@ -145,7 +145,7 @@ gimp_aspect_preview_init (GimpAspectPreview *preview)
GIMP_TYPE_ASPECT_PREVIEW,
GimpAspectPreviewPrivate);
g_object_set (GIMP_PREVIEW (preview)->area,
g_object_set (gimp_preview_get_area (GIMP_PREVIEW (preview)),
"check-size", gimp_check_size (),
"check-type", gimp_check_type (),
NULL);
@ -237,14 +237,17 @@ static void
gimp_aspect_preview_style_updated (GtkWidget *widget)
{
GimpPreview *preview = GIMP_PREVIEW (widget);
GtkWidget *area = gimp_preview_get_area (preview);
GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
if (preview->area)
if (area)
{
GimpAspectPreviewPrivate *priv = GET_PRIVATE (preview);
gint width;
gint height;
gint preview_width;
gint preview_height;
gint size;
width = gimp_drawable_width (priv->drawable_ID);
@ -256,29 +259,31 @@ gimp_aspect_preview_style_updated (GtkWidget *widget)
if (width > height)
{
preview->width = MIN (width, size);
preview->height = (height * preview->width) / width;
preview_width = MIN (width, size);
preview_height = (height * preview_width) / width;
}
else
{
preview->height = MIN (height, size);
preview->width = (width * preview->height) / height;
preview_height = MIN (height, size);
preview_width = (width * preview_height) / height;
}
gtk_widget_set_size_request (preview->area,
preview->width, preview->height);
gimp_preview_set_size (preview, preview_width, preview_height);
}
}
static void
gimp_aspect_preview_draw (GimpPreview *preview)
{
g_return_if_fail (GIMP_IS_ASPECT_PREVIEW (preview));
GtkWidget *area = gimp_preview_get_area (preview);
gint width;
gint height;
gimp_preview_area_fill (GIMP_PREVIEW_AREA (preview->area),
gimp_preview_get_size (preview, &width, &height);
gimp_preview_area_fill (GIMP_PREVIEW_AREA (area),
0, 0,
preview->width,
preview->height,
width, height,
0, 0, 0);
}
@ -288,15 +293,20 @@ gimp_aspect_preview_draw_buffer (GimpPreview *preview,
gint rowstride)
{
GimpAspectPreviewPrivate *priv = GET_PRIVATE (preview);
GtkWidget *area = gimp_preview_get_area (preview);
gint width;
gint height;
gint32 image_ID;
gimp_preview_get_size (preview, &width, &height);
image_ID = gimp_item_get_image (priv->drawable_ID);
if (gimp_selection_is_empty (image_ID))
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
gimp_preview_area_draw (GIMP_PREVIEW_AREA (area),
0, 0,
preview->width, preview->height,
width, height,
gimp_drawable_type (priv->drawable_ID),
buffer,
rowstride);
@ -306,21 +316,21 @@ gimp_aspect_preview_draw_buffer (GimpPreview *preview,
guchar *sel;
guchar *src;
gint selection_ID;
gint width, height;
gint w, h;
gint bpp;
selection_ID = gimp_image_get_selection (image_ID);
width = preview->width;
height = preview->height;
w = width;
h = height;
src = gimp_drawable_get_thumbnail_data (priv->drawable_ID,
&width, &height, &bpp);
&w, &h, &bpp);
sel = gimp_drawable_get_thumbnail_data (selection_ID,
&width, &height, &bpp);
&w, &h, &bpp);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (preview->area),
0, 0, preview->width, preview->height,
gimp_preview_area_mask (GIMP_PREVIEW_AREA (area),
0, 0, width, height,
gimp_drawable_type (priv->drawable_ID),
src, width * gimp_drawable_bpp (priv->drawable_ID),
buffer, rowstride,
@ -339,9 +349,13 @@ gimp_aspect_preview_transform (GimpPreview *preview,
gint *dest_y)
{
GimpAspectPreviewPrivate *priv = GET_PRIVATE (preview);
gint width;
gint height;
*dest_x = (gdouble) src_x * preview->width / gimp_drawable_width (priv->drawable_ID);
*dest_y = (gdouble) src_y * preview->height / gimp_drawable_height (priv->drawable_ID);
gimp_preview_get_size (preview, &width, &height);
*dest_x = (gdouble) src_x * width / gimp_drawable_width (priv->drawable_ID);
*dest_y = (gdouble) src_y * height / gimp_drawable_height (priv->drawable_ID);
}
static void
@ -352,9 +366,13 @@ gimp_aspect_preview_untransform (GimpPreview *preview,
gint *dest_y)
{
GimpAspectPreviewPrivate *priv = GET_PRIVATE (preview);
gint width;
gint height;
*dest_x = (gdouble) src_x * gimp_drawable_width (priv->drawable_ID) / preview->width;
*dest_y = (gdouble) src_y * gimp_drawable_height (priv->drawable_ID) / preview->height;
gimp_preview_get_size (preview, &width, &height);
*dest_x = (gdouble) src_x * gimp_drawable_width (priv->drawable_ID) / width;
*dest_y = (gdouble) src_y * gimp_drawable_height (priv->drawable_ID) / height;
}
static void
@ -388,7 +406,7 @@ gimp_aspect_preview_set_drawable_id (GimpAspectPreview *preview,
gimp_preview_set_bounds (GIMP_PREVIEW (preview), 0, 0, width, height);
if (height > 0)
g_object_set (GIMP_PREVIEW (preview)->frame,
g_object_set (gimp_preview_get_frame (GIMP_PREVIEW (preview)),
"ratio",
(gdouble) d_width / (gdouble) d_height,
NULL);

82
libgimp/gimpdrawablepreview.c
View File

@ -144,7 +144,7 @@ gimp_drawable_preview_init (GimpDrawablePreview *preview)
GIMP_TYPE_DRAWABLE_PREVIEW,
GimpDrawablePreviewPrivate);
g_object_set (GIMP_PREVIEW (preview)->area,
g_object_set (gimp_preview_get_area (GIMP_PREVIEW (preview)),
"check-size", gimp_check_size (),
"check-type", gimp_check_type (),
NULL);
@ -184,8 +184,7 @@ gimp_drawable_preview_dispose (GObject *object)
GimpPreview *preview = GIMP_PREVIEW (object);
PreviewSettings settings;
settings.x = preview->xoff + preview->xmin;
settings.y = preview->yoff + preview->ymin;
gimp_preview_get_position (preview, &settings.x, &settings.y);
settings.update = gimp_preview_get_update (preview);
gimp_set_data (data_name, &settings, sizeof (PreviewSettings));
@ -240,21 +239,25 @@ static void
gimp_drawable_preview_style_updated (GtkWidget *widget)
{
GimpPreview *preview = GIMP_PREVIEW (widget);
GtkWidget *area = gimp_preview_get_area (preview);
GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
if (preview->area)
if (area)
{
gint width = preview->xmax - preview->xmin;
gint height = preview->ymax - preview->ymin;
gint xmin, ymin;
gint xmax, ymax;
gint size;
gimp_preview_get_bounds (preview, &xmin, &ymin, &xmax, &ymax);
gtk_widget_style_get (widget,
"size", &size,
NULL);
gtk_widget_set_size_request (GIMP_PREVIEW (preview)->area,
MIN (width, size), MIN (height, size));
gtk_widget_set_size_request (area,
MIN (xmax - xmin, size),
MIN (ymax - ymin, size));
}
}
@ -264,24 +267,28 @@ gimp_drawable_preview_draw_original (GimpPreview *preview)
GimpDrawablePreviewPrivate *priv = GET_PRIVATE (preview);
guchar *buffer;
gint width, height;
gint xoff, yoff;
gint xmin, ymin;
gint xmax, ymax;
gint bpp;
GimpImageType type;
if (priv->drawable_ID < 1)
return;
preview->xoff = CLAMP (preview->xoff,
0, preview->xmax - preview->xmin - preview->width);
preview->yoff = CLAMP (preview->yoff,
0, preview->ymax - preview->ymin - preview->height);
gimp_preview_get_size (preview, &width, &height);
gimp_preview_get_offsets (preview, &xoff, &yoff);
gimp_preview_get_bounds (preview, &xmin, &ymin, &xmax, &ymax);
width = preview->width;
height = preview->height;
xoff = CLAMP (xoff, 0, xmax - xmin - width);
yoff = CLAMP (yoff, 0, ymax - ymin - height);
gimp_preview_set_offsets (preview, xoff, yoff);
buffer = gimp_drawable_get_sub_thumbnail_data (priv->drawable_ID,
preview->xoff + preview->xmin,
preview->yoff + preview->ymin,
preview->width, preview->height,
xoff + xmin,
yoff + ymin,
width, height,
&width, &height, &bpp);
switch (bpp)
@ -295,7 +302,7 @@ gimp_drawable_preview_draw_original (GimpPreview *preview)
return;
}
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
gimp_preview_area_draw (GIMP_PREVIEW_AREA (gimp_preview_get_area (preview)),
0, 0, width, height, type, buffer, width * bpp);
g_free (buffer);
}
@ -402,15 +409,21 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
{
GimpDrawablePreviewPrivate *priv = GET_PRIVATE (preview);
GimpPreview *gimp_preview = GIMP_PREVIEW (preview);
GtkWidget *area = gimp_preview_get_area (gimp_preview);
gint xmin, ymin;
gint xoff, yoff;
gint32 image_ID;
gimp_preview_get_bounds (gimp_preview, &xmin, &ymin, NULL, NULL);
gimp_preview_get_offsets (gimp_preview, &xoff, &yoff);
image_ID = gimp_item_get_image (priv->drawable_ID);
if (gimp_selection_is_empty (image_ID))
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (gimp_preview->area),
x - gimp_preview->xoff - gimp_preview->xmin,
y - gimp_preview->yoff - gimp_preview->ymin,
gimp_preview_area_draw (GIMP_PREVIEW_AREA (area),
x - xoff - xmin,
y - yoff - ymin,
width,
height,
gimp_drawable_type (priv->drawable_ID),
@ -475,9 +488,9 @@ gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
return;
}
gimp_preview_area_mask (GIMP_PREVIEW_AREA (gimp_preview->area),
draw_x - gimp_preview->xoff - gimp_preview->xmin,
draw_y - gimp_preview->yoff - gimp_preview->ymin,
gimp_preview_area_mask (GIMP_PREVIEW_AREA (area),
draw_x - xoff - xmin,
draw_y - yoff - ymin,
draw_width,
draw_height,
type,
@ -499,11 +512,15 @@ gimp_drawable_preview_draw_buffer (GimpPreview *preview,
const guchar *buffer,
gint rowstride)
{
gint x, y;
gint width, height;
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
gimp_drawable_preview_draw_area (GIMP_DRAWABLE_PREVIEW (preview),
preview->xmin + preview->xoff,
preview->ymin + preview->yoff,
preview->width,
preview->height,
x, y,
width, height,
buffer, rowstride);
}
@ -525,12 +542,13 @@ gimp_drawable_preview_set_drawable_id (GimpDrawablePreview *drawable_preview,
if (gimp_drawable_is_indexed (drawable_ID))
{
guint32 image_ID = gimp_item_get_image (drawable_ID);
guchar *cmap;
gint num_colors;
guint32 image_ID = gimp_item_get_image (drawable_ID);
GtkWidget *area = gimp_preview_get_area (preview);
guchar *cmap;
gint num_colors;
cmap = gimp_image_get_colormap (image_ID, &num_colors);
gimp_preview_area_set_colormap (GIMP_PREVIEW_AREA (preview->area),
gimp_preview_area_set_colormap (GIMP_PREVIEW_AREA (area),
cmap, num_colors);
g_free (cmap);
}

107
libgimp/gimpzoompreview.c
View File

@ -185,18 +185,20 @@ gimp_zoom_preview_class_init (GimpZoomPreviewClass *klass)
static void
gimp_zoom_preview_init (GimpZoomPreview *preview)
{
GtkWidget *area = gimp_preview_get_area (GIMP_PREVIEW (preview));
preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview,
GIMP_TYPE_ZOOM_PREVIEW,
GimpZoomPreviewPrivate);
g_signal_connect (GIMP_PREVIEW (preview)->area, "size-allocate",
g_signal_connect (area, "size-allocate",
G_CALLBACK (gimp_zoom_preview_size_allocate),
preview);
g_signal_connect (GIMP_PREVIEW (preview)->area, "scroll-event",
g_signal_connect (area, "scroll-event",
G_CALLBACK (gimp_zoom_preview_scroll_event),
preview);
g_object_set (GIMP_PREVIEW (preview)->area,
g_object_set (area,
"check-size", gimp_check_size (),
"check-type", gimp_check_type (),
NULL);
@ -324,14 +326,13 @@ gimp_zoom_preview_set_adjustments (GimpZoomPreview *preview,
GimpScrolledPreview *scrolled_preview = GIMP_SCROLLED_PREVIEW (preview);
GtkAdjustment *hadj;
GtkAdjustment *vadj;
gdouble width;
gdouble height;
gint width;
gint height;
gdouble ratio;
gimp_scrolled_preview_freeze (scrolled_preview);
width = GIMP_PREVIEW (preview)->width;
height = GIMP_PREVIEW (preview)->height;
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, &height);
ratio = new_factor / old_factor;
@ -365,11 +366,13 @@ gimp_zoom_preview_size_allocate (GtkWidget *widget,
{
gdouble zoom;
#if 0
gint width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin;
gint height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin;
GIMP_PREVIEW (preview)->width = MIN (width, allocation->width);
GIMP_PREVIEW (preview)->height = MIN (height, allocation->height);
#endif
zoom = gimp_zoom_model_get_factor (preview->priv->model);
@ -380,14 +383,18 @@ static void
gimp_zoom_preview_style_updated (GtkWidget *widget)
{
GimpPreview *preview = GIMP_PREVIEW (widget);
GtkWidget *area = gimp_preview_get_area (preview);
GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
if (preview->area)
if (area)
{
GimpZoomPreviewPrivate *priv = GET_PRIVATE (preview);
gint size;
gint width, height;
gint width;
gint height;
gint preview_width;
gint preview_height;
gint x1, y1;
gint x2, y2;
@ -407,17 +414,16 @@ gimp_zoom_preview_style_updated (GtkWidget *widget)
if (width > height)
{
preview->width = MIN (width, size);
preview->height = (height * preview->width) / width;
preview_width = MIN (width, size);
preview_height = (height * preview_width) / width;
}
else
{
preview->height = MIN (height, size);
preview->width = (width * preview->height) / height;
preview_height = MIN (height, size);
preview_width = (width * preview_height) / height;
}
gtk_widget_set_size_request (preview->area,
preview->width, preview->height);
gimp_preview_set_size (preview, preview_width, preview_height);
}
}
@ -472,7 +478,9 @@ gimp_zoom_preview_draw (GimpPreview *preview)
if (data)
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
GtkWidget *area = gimp_preview_get_area (preview);
gimp_preview_area_draw (GIMP_PREVIEW_AREA (area),
0, 0, width, height,
gimp_drawable_type (priv->drawable_ID),
data, width * bpp);
@ -486,15 +494,19 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
gint rowstride)
{
GimpZoomPreviewPrivate *priv = GIMP_ZOOM_PREVIEW (preview)->priv;
GtkWidget *area = gimp_preview_get_area (preview);
gint width;
gint height;
gint32 image_ID;
gimp_preview_get_size (preview, &width, &height);
image_ID = gimp_item_get_image (priv->drawable_ID);
if (gimp_selection_is_empty (image_ID))
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
gimp_preview_area_draw (GIMP_PREVIEW_AREA (area),
0, 0,
preview->width, preview->height,
width, height,
gimp_drawable_type (priv->drawable_ID),
buffer,
rowstride);
@ -504,7 +516,7 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
guchar *sel;
guchar *src;
gint selection_ID;
gint width, height;
gint w, h;
gint bpp;
gint src_x;
gint src_y;
@ -515,8 +527,8 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
selection_ID = gimp_image_get_selection (image_ID);
width = preview->width;
height = preview->height;
w = width;
h = height;
gimp_zoom_preview_get_source_area (preview,
&src_x, &src_y,
@ -525,15 +537,15 @@ gimp_zoom_preview_draw_buffer (GimpPreview *preview,
src = gimp_drawable_get_sub_thumbnail_data (priv->drawable_ID,
src_x, src_y,
src_width, src_height,
&width, &height, &bpp);
&w, &h, &bpp);
gimp_drawable_offsets (priv->drawable_ID, &offsx, &offsy);
sel = gimp_drawable_get_sub_thumbnail_data (selection_ID,
src_x + offsx, src_y + offsy,
src_width, src_height,
&width, &height, &bpp);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (preview->area),
0, 0, preview->width, preview->height,
gimp_preview_area_mask (GIMP_PREVIEW_AREA (area),
0, 0, width, height,
gimp_drawable_type (priv->drawable_ID),
src, width * gimp_drawable_bpp (priv->drawable_ID),
buffer, rowstride,
@ -561,7 +573,9 @@ gimp_zoom_preview_draw_thumb (GimpPreview *preview,
static void
gimp_zoom_preview_set_cursor (GimpPreview *preview)
{
if (! gtk_widget_get_realized (preview->area))
GtkWidget *area = gimp_preview_get_area (preview);
if (! gtk_widget_get_realized (area))
return;
if (gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview)) > 1.0)
@ -570,14 +584,14 @@ gimp_zoom_preview_set_cursor (GimpPreview *preview)
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (display, GDK_HAND1);
gdk_window_set_cursor (gtk_widget_get_window (preview->area),
gdk_window_set_cursor (gtk_widget_get_window (area),
cursor);
g_object_unref (cursor);
}
else
{
gdk_window_set_cursor (gtk_widget_get_window (preview->area),
preview->default_cursor);
gdk_window_set_cursor (gtk_widget_get_window (area),
gimp_preview_get_default_cursor (preview));
}
}
@ -589,14 +603,22 @@ gimp_zoom_preview_transform (GimpPreview *preview,
gint *dest_y)
{
GimpZoomPreviewPrivate *priv = GIMP_ZOOM_PREVIEW (preview)->priv;
gint width;
gint height;
gint xoff;
gint yoff;
gdouble zoom;
gdouble zoom = gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview));
gimp_preview_get_size (preview, &width, &height);
gimp_preview_get_offsets (preview, &xoff, &yoff);
zoom = gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview));
*dest_x = ((gdouble) (src_x - priv->extents.x) *
preview->width / priv->extents.width * zoom) - preview->xoff;
width / priv->extents.width * zoom) - xoff;
*dest_y = ((gdouble) (src_y - priv->extents.y) *
preview->height / priv->extents.height * zoom) - preview->yoff;
height / priv->extents.height * zoom) - yoff;
}
static void
@ -607,16 +629,24 @@ gimp_zoom_preview_untransform (GimpPreview *preview,
gint *dest_y)
{
GimpZoomPreviewPrivate *priv = GIMP_ZOOM_PREVIEW (preview)->priv;
gint width;
gint height;
gint xoff;
gint yoff;
gdouble zoom;
gdouble zoom = gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview));
gimp_preview_get_size (preview, &width, &height);
gimp_preview_get_offsets (preview, &xoff, &yoff);
zoom = gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview));
*dest_x = (priv->extents.x +
((gdouble) (src_x + preview->xoff) *
priv->extents.width / preview->width / zoom));
((gdouble) (src_x + xoff) *
priv->extents.width / width / zoom));
*dest_y = (priv->extents.y +
((gdouble) (src_y + preview->yoff) *
priv->extents.height / preview->height / zoom));
((gdouble) (src_y + yoff) *
priv->extents.height / height / zoom));
}
static void
@ -663,7 +693,7 @@ gimp_zoom_preview_set_drawable_id (GimpZoomPreview *preview,
gimp_preview_set_bounds (GIMP_PREVIEW (preview),
0, 0, max_width, max_height);
g_object_set (GIMP_PREVIEW (preview)->frame,
g_object_set (gimp_preview_get_frame (GIMP_PREVIEW (preview)),
"ratio", (gdouble) width / (gdouble) height,
NULL);
}
@ -877,8 +907,7 @@ gimp_zoom_preview_get_source (GimpZoomPreview *preview,
gint src_width;
gint src_height;
*width = gimp_preview->width;
*height = gimp_preview->height;
gimp_preview_get_size (gimp_preview, width, height);
gimp_zoom_preview_get_source_area (gimp_preview,
&src_x, &src_y,

351
libgimpwidgets/gimppreview.c
View File

@ -62,7 +62,20 @@ enum
struct _GimpPreviewPrivate
{
GtkWidget *area;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *controls;
GdkCursor *cursor_busy;
GdkCursor *default_cursor;
gint xoff, yoff;
gint xmin, xmax, ymin, ymax;
gint width, height;
gboolean update_preview;
guint timeout_id;
};
#define GET_PRIVATE(obj) (((GimpPreview *) (obj))->priv)
@ -224,88 +237,88 @@ gimp_preview_init (GimpPreview *preview)
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);
priv->frame = gtk_aspect_frame_new (NULL, xalign, 0.0, 1.0, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (priv->frame), GTK_SHADOW_NONE);
gtk_box_pack_start (GTK_BOX (preview), priv->frame, TRUE, TRUE, 0);
gtk_widget_show (priv->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);
priv->table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacing (GTK_TABLE (priv->table), 1, 3);
gtk_container_add (GTK_CONTAINER (priv->frame), priv->table);
gtk_widget_show (priv->table);
preview->timeout_id = 0;
priv->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;
priv->xmin = priv->ymin = 0;
priv->xmax = priv->ymax = 1;
priv->width = priv->xmax - priv->xmin;
priv->height = priv->ymax - priv->ymin;
preview->xoff = 0;
preview->yoff = 0;
priv->xoff = 0;
priv->yoff = 0;
preview->default_cursor = NULL;
priv->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_table_attach (GTK_TABLE (priv->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);
priv->area = gimp_preview_area_new ();
gtk_container_add (GTK_CONTAINER (frame), priv->area);
gtk_widget_show (priv->area);
g_signal_connect_swapped (preview->area, "notify::check-size",
g_signal_connect_swapped (priv->area, "notify::check-size",
G_CALLBACK (gimp_preview_notify_checks),
preview);
g_signal_connect_swapped (preview->area, "notify::check-type",
g_signal_connect_swapped (priv->area, "notify::check-type",
G_CALLBACK (gimp_preview_notify_checks),
preview);
gtk_widget_add_events (preview->area,
gtk_widget_add_events (priv->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_signal_connect (priv->area, "event",
G_CALLBACK (gimp_preview_area_event),
preview);
g_signal_connect (preview->area, "realize",
g_signal_connect (priv->area, "realize",
G_CALLBACK (gimp_preview_area_realize),
preview);
g_signal_connect (preview->area, "unrealize",
g_signal_connect (priv->area, "unrealize",
G_CALLBACK (gimp_preview_area_unrealize),
preview);
g_signal_connect_data (preview->area, "realize",
g_signal_connect_data (priv->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_signal_connect (priv->area, "size-allocate",
G_CALLBACK (gimp_preview_area_size_allocate),
preview);
g_signal_connect_data (preview->area, "size-allocate",
g_signal_connect_data (priv->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_table_attach (GTK_TABLE (priv->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);
priv->toggle = gtk_check_button_new_with_mnemonic (_("_Preview"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->toggle),
priv->update_preview);
gtk_box_pack_start (GTK_BOX (priv->controls), priv->toggle, TRUE, TRUE, 0);
gtk_widget_show (priv->toggle);
g_signal_connect (preview->toggle, "toggled",
g_signal_connect (priv->toggle, "toggled",
G_CALLBACK (gimp_preview_toggle_callback),
preview);
}
@ -313,12 +326,12 @@ gimp_preview_init (GimpPreview *preview)
static void
gimp_preview_dispose (GObject *object)
{
GimpPreview *preview = GIMP_PREVIEW (object);
GimpPreviewPrivate *priv = GET_PRIVATE (object);
if (preview->timeout_id)
if (priv->timeout_id)
{
g_source_remove (preview->timeout_id);
preview->timeout_id = 0;
g_source_remove (priv->timeout_id);
priv->timeout_id = 0;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
@ -330,12 +343,12 @@ gimp_preview_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
GimpPreview *preview = GIMP_PREVIEW (object);
GimpPreviewPrivate *priv = GET_PRIVATE (object);
switch (property_id)
{
case PROP_UPDATE:
g_value_set_boolean (value, preview->update_preview);
g_value_set_boolean (value, priv->update_preview);
break;
default:
@ -350,12 +363,12 @@ gimp_preview_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
GimpPreview *preview = GIMP_PREVIEW (object);
GimpPreviewPrivate *priv = GET_PRIVATE (object);
switch (property_id)
{
case PROP_UPDATE:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (preview->toggle),
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->toggle),
g_value_get_boolean (value));
break;
@ -369,22 +382,22 @@ static void
gimp_preview_direction_changed (GtkWidget *widget,
GtkTextDirection prev_dir)
{
GimpPreview *preview = GIMP_PREVIEW (widget);
gdouble xalign = 0.0;
GimpPreviewPrivate *priv = GET_PRIVATE (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),
gtk_aspect_frame_set (GTK_ASPECT_FRAME (priv->frame),
xalign, 0.0, 1.0, TRUE);
}
static gboolean
gimp_preview_popup_menu (GtkWidget *widget)
{
GimpPreview *preview = GIMP_PREVIEW (widget);
GimpPreviewPrivate *priv = GET_PRIVATE (widget);
gimp_preview_area_menu_popup (GIMP_PREVIEW_AREA (preview->area), NULL);
gimp_preview_area_menu_popup (GIMP_PREVIEW_AREA (priv->area), NULL);
return TRUE;
}
@ -393,11 +406,12 @@ static void
gimp_preview_area_realize (GtkWidget *widget,
GimpPreview *preview)
{
GdkDisplay *display = gtk_widget_get_display (widget);
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
GdkDisplay *display = gtk_widget_get_display (widget);
g_return_if_fail (preview->cursor_busy == NULL);
g_return_if_fail (priv->cursor_busy == NULL);
preview->cursor_busy = gdk_cursor_new_for_display (display, GDK_WATCH);
priv->cursor_busy = gdk_cursor_new_for_display (display, GDK_WATCH);
}
@ -405,11 +419,9 @@ static void
gimp_preview_area_unrealize (GtkWidget *widget,
GimpPreview *preview)
{
if (preview->cursor_busy)
{
g_object_unref (preview->cursor_busy);
preview->cursor_busy = NULL;
}
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
g_clear_object (&priv->cursor_busy);
}
static void
@ -417,11 +429,12 @@ gimp_preview_area_size_allocate (GtkWidget *widget,
GtkAllocation *allocation,
GimpPreview *preview)
{
gint width = preview->xmax - preview->xmin;
gint height = preview->ymax - preview->ymin;
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
gint width = priv->xmax - priv->xmin;
gint height = priv->ymax - priv->ymin;
preview->width = MIN (width, allocation->width);
preview->height = MIN (height, allocation->height);
priv->width = MIN (width, allocation->width);
priv->height = MIN (height, allocation->height);
gimp_preview_draw (preview);
gimp_preview_invalidate (preview);
@ -462,20 +475,22 @@ static void
gimp_preview_toggle_callback (GtkWidget *toggle,
GimpPreview *preview)
{
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)))
{
preview->update_preview = TRUE;
priv->update_preview = TRUE;
g_object_notify (G_OBJECT (preview), "update");
if (preview->timeout_id)
g_source_remove (preview->timeout_id);
if (priv->timeout_id)
g_source_remove (priv->timeout_id);
gimp_preview_invalidate_now (preview);
}
else
{
preview->update_preview = FALSE;
priv->update_preview = FALSE;
g_object_notify (G_OBJECT (preview), "update");
@ -493,19 +508,20 @@ gimp_preview_notify_checks (GimpPreview *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);
GimpPreviewPrivate *priv = GET_PRIVATE (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;
priv->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);
priv->cursor_busy);
gdk_window_set_cursor (gtk_widget_get_window (priv->area),
priv->cursor_busy);
gdk_flush ();
@ -525,9 +541,11 @@ gimp_preview_invalidate_now (GimpPreview *preview)
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);
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
if (gtk_widget_get_realized (priv->area))
gdk_window_set_cursor (gtk_widget_get_window (priv->area),
priv->default_cursor);
}
static void
@ -537,8 +555,10 @@ gimp_preview_real_transform (GimpPreview *preview,
gint *dest_x,
gint *dest_y)
{
*dest_x = src_x - preview->xoff - preview->xmin;
*dest_y = src_y - preview->yoff - preview->ymin;
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
*dest_x = src_x - priv->xoff - priv->xmin;
*dest_y = src_y - priv->yoff - priv->ymin;
}
static void
@ -548,8 +568,10 @@ gimp_preview_real_untransform (GimpPreview *preview,
gint *dest_x,
gint *dest_y)
{
*dest_x = src_x + preview->xoff + preview->xmin;
*dest_y = src_y + preview->yoff + preview->ymin;
GimpPreviewPrivate *priv = GET_PRIVATE (preview);
*dest_x = src_x + priv->xoff + priv->xmin;
*dest_y = src_y + priv->yoff + priv->ymin;
}
/**
@ -586,7 +608,7 @@ gimp_preview_get_update (GimpPreview *preview)
{
g_return_val_if_fail (GIMP_IS_PREVIEW (preview), FALSE);
return preview->update_preview;
return GET_PRIVATE (preview)->update_preview;
}
/**
@ -610,20 +632,60 @@ gimp_preview_set_bounds (GimpPreview *preview,
gint xmax,
gint ymax)
{
GimpPreviewPrivate *priv;
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;
priv = GET_PRIVATE (preview);
gimp_preview_area_set_max_size (GIMP_PREVIEW_AREA (preview->area),
priv->xmin = xmin;
priv->ymin = ymin;
priv->xmax = xmax;
priv->ymax = ymax;
gimp_preview_area_set_max_size (GIMP_PREVIEW_AREA (priv->area),
xmax - xmin,
ymax - ymin);
}
void
gimp_preview_get_bounds (GimpPreview *preview,
gint *xmin,
gint *ymin,
gint *xmax,
gint *ymax)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
priv = GET_PRIVATE (preview);
if (xmin) *xmin = priv->xmin;
if (ymin) *ymin = priv->ymin;
if (xmax) *xmax = priv->xmax;
if (ymax) *ymax = priv->ymax;
}
void
gimp_preview_set_size (GimpPreview *preview,
gint width,
gint height)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
priv = GET_PRIVATE (preview);
priv->width = width;
priv->height = height;
gtk_widget_set_size_request (priv->area, width, height);
}
/**
* gimp_preview_get_size:
* @preview: a #GimpPreview widget
@ -637,13 +699,44 @@ gimp_preview_get_size (GimpPreview *preview,
gint *width,
gint *height)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
if (width)
*width = preview->width;
priv = GET_PRIVATE (preview);
if (height)
*height = preview->height;
if (width) *width = priv->width;
if (height) *height = priv->height;
}
void
gimp_preview_set_offsets (GimpPreview *preview,
gint xoff,
gint yoff)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
priv = GET_PRIVATE (preview);
priv->xoff = xoff;
priv->yoff = yoff;
}
void
gimp_preview_get_offsets (GimpPreview *preview,
gint *xoff,
gint *yoff)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
priv = GET_PRIVATE (preview);
if (xoff) *xoff = priv->xoff;
if (yoff) *yoff = priv->yoff;
}
/**
@ -659,13 +752,14 @@ gimp_preview_get_position (GimpPreview *preview,
gint *x,
gint *y)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
if (x)
*x = preview->xoff + preview->xmin;
priv = GET_PRIVATE (preview);
if (y)
*y = preview->yoff + preview->ymin;
if (x) *x = priv->xoff + priv->xmin;
if (y) *y = priv->yoff + priv->ymin;
}
/**
@ -720,6 +814,38 @@ gimp_preview_untransform (GimpPreview *preview,
src_x, src_y, dest_x, dest_y);
}
/**
* gimp_preview_get_frame:
* @preview: a #GimpPreview widget
*
* Return value: a pointer to the #GtkAspectFrame used in the @preview.
*
* Since: 3.0
**/
GtkWidget *
gimp_preview_get_frame (GimpPreview *preview)
{
g_return_val_if_fail (GIMP_IS_PREVIEW (preview), NULL);
return GET_PRIVATE (preview)->frame;
}
/**
* gimp_preview_get_table:
* @preview: a #GimpPreview widget
*
* Return value: a pointer to the #GtkTable used in the @preview.
*
* Since: 3.0
**/
GtkWidget *
gimp_preview_get_table (GimpPreview *preview)
{
g_return_val_if_fail (GIMP_IS_PREVIEW (preview), NULL);
return GET_PRIVATE (preview)->table;
}
/**
* gimp_preview_get_area:
* @preview: a #GimpPreview widget
@ -738,7 +864,7 @@ gimp_preview_get_area (GimpPreview *preview)
{
g_return_val_if_fail (GIMP_IS_PREVIEW (preview), NULL);
return preview->area;
return GET_PRIVATE (preview)->area;
}
/**
@ -805,14 +931,18 @@ gimp_preview_draw_buffer (GimpPreview *preview,
void
gimp_preview_invalidate (GimpPreview *preview)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
if (preview->update_preview)
{
if (preview->timeout_id)
g_source_remove (preview->timeout_id);
priv = GET_PRIVATE (preview);
preview->timeout_id =
if (priv->update_preview)
{
if (priv->timeout_id)
g_source_remove (priv->timeout_id);
priv->timeout_id =
g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE, PREVIEW_TIMEOUT,
(GSourceFunc) gimp_preview_invalidate_now,
preview, NULL);
@ -834,15 +964,30 @@ void
gimp_preview_set_default_cursor (GimpPreview *preview,
GdkCursor *cursor)
{
GimpPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_PREVIEW (preview));
if (preview->default_cursor)
g_object_unref (preview->default_cursor);
priv = GET_PRIVATE (preview);
if (cursor)
g_object_ref (cursor);
if (cursor != priv->default_cursor)
{
if (priv->default_cursor)
g_object_unref (priv->default_cursor);
preview->default_cursor = cursor;
if (cursor)
g_object_ref (cursor);
priv->default_cursor = cursor;
}
}
GdkCursor *
gimp_preview_get_default_cursor (GimpPreview *preview)
{
g_return_val_if_fail (GIMP_IS_PREVIEW (preview), NULL);
return GET_PRIVATE (preview)->default_cursor;
}
/**

43
libgimpwidgets/gimppreview.h
View File

@ -47,24 +47,6 @@ struct _GimpPreview
GtkBox parent_instance;
GimpPreviewPrivate *priv;
/* FIXME MOVE TO PRIVATE */
gboolean update_preview;
/*< protected >*/
GtkWidget *area;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *toggle;
GdkCursor *cursor_busy;
GdkCursor *default_cursor;
/*< private >*/
gint xoff, yoff;
gint xmin, xmax, ymin, ymax;
gint width, height;
guint timeout_id;
};
struct _GimpPreviewClass
@ -119,13 +101,29 @@ void gimp_preview_set_bounds (GimpPreview *preview,
gint ymin,
gint xmax,
gint ymax);
void gimp_preview_get_bounds (GimpPreview *preview,
gint *xmin,
gint *ymin,
gint *xmax,
gint *ymax);
void gimp_preview_set_size (GimpPreview *preview,
gint width,
gint height);
void gimp_preview_get_size (GimpPreview *preview,
gint *width,
gint *height);
void gimp_preview_set_offsets (GimpPreview *preview,
gint xoff,
gint yoff);
void gimp_preview_get_offsets (GimpPreview *preview,
gint *xoff,
gint *yoff);
void gimp_preview_get_position (GimpPreview *preview,
gint *x,
gint *y);
void gimp_preview_get_size (GimpPreview *preview,
gint *width,
gint *height);
void gimp_preview_transform (GimpPreview *preview,
gint src_x,
@ -138,6 +136,8 @@ void gimp_preview_untransform (GimpPreview *preview,
gint *dest_x,
gint *dest_y);
GtkWidget * gimp_preview_get_frame (GimpPreview *preview);
GtkWidget * gimp_preview_get_table (GimpPreview *preview);
GtkWidget * gimp_preview_get_area (GimpPreview *preview);
void gimp_preview_draw (GimpPreview *preview);
@ -149,6 +149,7 @@ void gimp_preview_invalidate (GimpPreview *preview);
void gimp_preview_set_default_cursor (GimpPreview *preview,
GdkCursor *cursor);
GdkCursor * gimp_preview_get_default_cursor (GimpPreview *preview);
GtkWidget * gimp_preview_get_controls (GimpPreview *preview);

143
libgimpwidgets/gimpscrolledpreview.c
View File

@ -152,7 +152,11 @@ gimp_scrolled_preview_init (GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv;
GtkWidget *image;
GtkWidget *table;
GtkWidget *area;
GtkAdjustment *adj;
gint width;
gint height;
preview->priv = G_TYPE_INSTANCE_GET_PRIVATE (preview,
GIMP_TYPE_SCROLLED_PREVIEW,
@ -168,54 +172,58 @@ gimp_scrolled_preview_init (GimpScrolledPreview *preview)
priv->in_drag = FALSE;
priv->frozen = 1; /* we are frozen during init */
table = gimp_preview_get_table (GIMP_PREVIEW (preview));
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, &height);
/* scrollbars */
adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, GIMP_PREVIEW (preview)->width - 1, 1.0,
GIMP_PREVIEW (preview)->width,
GIMP_PREVIEW (preview)->width));
adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width - 1, 1.0,
width, width));
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_scrolled_preview_h_scroll),
preview);
priv->hscr = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, adj);
gtk_table_attach (GTK_TABLE (GIMP_PREVIEW (preview)->table),
gtk_table_attach (GTK_TABLE (table),
priv->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));
adj = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height - 1, 1.0,
height, height));
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_scrolled_preview_v_scroll),
preview);
priv->vscr = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adj);
gtk_table_attach (GTK_TABLE (GIMP_PREVIEW (preview)->table),
gtk_table_attach (GTK_TABLE (table),
priv->vscr, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
area = gimp_preview_get_area (GIMP_PREVIEW (preview));
/* 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_signal_connect_after (area, "event",
G_CALLBACK (gimp_scrolled_preview_area_event),
preview);
g_signal_connect (GIMP_PREVIEW (preview)->area, "realize",
g_signal_connect (area, "realize",
G_CALLBACK (gimp_scrolled_preview_area_realize),
preview);
g_signal_connect (GIMP_PREVIEW (preview)->area, "unrealize",
g_signal_connect (area, "unrealize",
G_CALLBACK (gimp_scrolled_preview_area_unrealize),
preview);
g_signal_connect (GIMP_PREVIEW (preview)->area, "size-allocate",
g_signal_connect (area, "size-allocate",
G_CALLBACK (gimp_scrolled_preview_area_size_allocate),
preview);
/* navigation icon */
priv->nav_icon = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (GIMP_PREVIEW(preview)->table),
gtk_table_attach (GTK_TABLE (table),
priv->nav_icon, 1,2, 1,2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
@ -267,18 +275,20 @@ gimp_scrolled_preview_hscr_update (GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
GtkAdjustment *adj;
gint xmin, xmax;
gint width;
adj = gtk_range_get_adjustment (GTK_RANGE (priv->hscr));
width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin;
gimp_preview_get_bounds (GIMP_PREVIEW (preview), &xmin, NULL, &xmax, NULL);
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, NULL);
gtk_adjustment_configure (adj,
gtk_adjustment_get_value (adj),
0, width,
0, xmax - xmin,
1.0,
MAX (GIMP_PREVIEW (preview)->width / 2.0, 1.0),
GIMP_PREVIEW (preview)->width);
MAX (width / 2.0, 1.0),
width);
}
static void
@ -286,18 +296,20 @@ gimp_scrolled_preview_vscr_update (GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
GtkAdjustment *adj;
gint ymin, ymax;
gint height;
adj = gtk_range_get_adjustment (GTK_RANGE (priv->vscr));
height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin;
gimp_preview_get_bounds (GIMP_PREVIEW (preview), NULL, &ymin, NULL, &ymax);
gimp_preview_get_size (GIMP_PREVIEW (preview), NULL, &height);
gtk_adjustment_configure (adj,
gtk_adjustment_get_value (adj),
0, height,
0, ymax - ymin,
1.0,
MAX (GIMP_PREVIEW (preview)->height / 2.0, 1.0),
GIMP_PREVIEW (preview)->height);
MAX (height / 2.0, 1.0),
height);
}
static void
@ -306,22 +318,27 @@ gimp_scrolled_preview_area_size_allocate (GtkWidget *widget,
GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
gint xmin, ymin;
gint xmax, ymax;
gint width;
gint height;
gint width = GIMP_PREVIEW (preview)->xmax - GIMP_PREVIEW (preview)->xmin;
gint height = GIMP_PREVIEW (preview)->ymax - GIMP_PREVIEW (preview)->ymin;
gimp_preview_get_bounds (GIMP_PREVIEW (preview), &xmin, &ymin, &xmax, &ymax);
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, &height);
gimp_scrolled_preview_freeze (preview);
GIMP_PREVIEW (preview)->width = MIN (width, allocation->width);
GIMP_PREVIEW (preview)->height = MIN (height, allocation->height);
#if 0
GIMP_PREVIEW (preview)->width = MIN (xmax - xmin, allocation->width);
GIMP_PREVIEW (preview)->height = MIN (ymax - ymin, allocation->height);
#endif
gimp_scrolled_preview_hscr_update (preview);
switch (priv->hscr_policy)
{
case GTK_POLICY_AUTOMATIC:
gtk_widget_set_visible (priv->hscr,
width > GIMP_PREVIEW (preview)->width);
gtk_widget_set_visible (priv->hscr, xmax - xmin > width);
break;
case GTK_POLICY_ALWAYS:
@ -338,8 +355,7 @@ gimp_scrolled_preview_area_size_allocate (GtkWidget *widget,
switch (priv->vscr_policy)
{
case GTK_POLICY_AUTOMATIC:
gtk_widget_set_visible (priv->vscr,
height > GIMP_PREVIEW (preview)->height);
gtk_widget_set_visible (priv->vscr, ymax - ymin > height);
break;
case GTK_POLICY_ALWAYS:
@ -367,6 +383,9 @@ gimp_scrolled_preview_area_event (GtkWidget *area,
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
GdkEventButton *button_event = (GdkEventButton *) event;
GdkCursor *cursor;
gint xoff, yoff;
gimp_preview_get_offsets (GIMP_PREVIEW (preview), &xoff, &yoff);
switch (event->type)
{
@ -387,8 +406,8 @@ gimp_scrolled_preview_area_event (GtkWidget *area,
{
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->drag_xoff = xoff;
priv->drag_yoff = yoff;
priv->in_drag = TRUE;
gtk_grab_add (area);
}
@ -439,8 +458,8 @@ gimp_scrolled_preview_area_event (GtkWidget *area,
gtk_adjustment_get_upper (vadj) -
gtk_adjustment_get_page_size (vadj));
if (GIMP_PREVIEW (preview)->xoff != x ||
GIMP_PREVIEW (preview)->yoff != y)
if (xoff != x ||
yoff != y)
{
gtk_adjustment_set_value (hadj, x);
gtk_adjustment_set_value (vadj, y);
@ -522,11 +541,18 @@ gimp_scrolled_preview_h_scroll (GtkAdjustment *hadj,
GimpPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
GtkWidget *area;
gint xoff, yoff;
preview->xoff = gtk_adjustment_get_value (hadj);
gimp_preview_get_offsets (preview, NULL, &yoff);
gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (preview->area),
preview->xoff, preview->yoff);
xoff = gtk_adjustment_get_value (hadj);
gimp_preview_set_offsets (preview, xoff, yoff);
area = gimp_preview_get_area (preview);
gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (area), xoff, yoff);
if (! (priv->in_drag || priv->frozen))
{
@ -540,11 +566,18 @@ gimp_scrolled_preview_v_scroll (GtkAdjustment *vadj,
GimpPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
GtkWidget *area;
gint xoff, yoff;
preview->yoff = gtk_adjustment_get_value (vadj);
gimp_preview_get_offsets (preview, &xoff, NULL);
gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (preview->area),
preview->xoff, preview->yoff);
yoff = gtk_adjustment_get_value (vadj);
gimp_preview_set_offsets (preview, xoff, yoff);
area = gimp_preview_get_area (preview);
gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (area), xoff, yoff);
if (! (priv->in_drag || priv->frozen))
{
@ -594,7 +627,7 @@ gimp_scrolled_preview_nav_button_press (GtkWidget *widget,
gtk_container_add (GTK_CONTAINER (outer), inner);
gtk_widget_show (inner);
g_object_get (gimp_preview->area,
g_object_get (gimp_preview_get_area (gimp_preview),
"check-type", &check_type,
NULL);
@ -799,20 +832,29 @@ static void
gimp_scrolled_preview_set_cursor (GimpPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GET_PRIVATE (preview);
GtkWidget *area;
gint width, height;
gint xmin, ymin;
gint xmax, ymax;
if (! gtk_widget_get_realized (preview->area))
area = gimp_preview_get_area (preview);
if (! gtk_widget_get_realized (area))
return;
if (preview->xmax - preview->xmin > preview->width ||
preview->ymax - preview->ymin > preview->height)
gimp_preview_get_size (preview, &width, &height);
gimp_preview_get_bounds (preview, &xmin, &ymin, &xmax, &ymax);
if (xmax - xmin > width ||
ymax - ymin > height)
{
gdk_window_set_cursor (gtk_widget_get_window (preview->area),
gdk_window_set_cursor (gtk_widget_get_window (area),
priv->cursor_move);
}
else
{
gdk_window_set_cursor (gtk_widget_get_window (preview->area),
preview->default_cursor);
gdk_window_set_cursor (gtk_widget_get_window (area),
gimp_preview_get_default_cursor (preview));
}
}
@ -831,6 +873,7 @@ gimp_scrolled_preview_set_position (GimpScrolledPreview *preview,
{
GimpScrolledPreviewPrivate *priv;
GtkAdjustment *adj;
gint xmin, ymin;
g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview));
@ -841,11 +884,13 @@ gimp_scrolled_preview_set_position (GimpScrolledPreview *preview,
gimp_scrolled_preview_hscr_update (preview);
gimp_scrolled_preview_vscr_update (preview);
gimp_preview_get_bounds (GIMP_PREVIEW (preview), &xmin, &ymin, NULL, NULL);
adj = gtk_range_get_adjustment (GTK_RANGE (priv->hscr));
gtk_adjustment_set_value (adj, x - GIMP_PREVIEW (preview)->xmin);
gtk_adjustment_set_value (adj, x - xmin);
adj = gtk_range_get_adjustment (GTK_RANGE (priv->vscr));
gtk_adjustment_set_value (adj, y - GIMP_PREVIEW (preview)->ymin);
gtk_adjustment_set_value (adj, y - ymin);
gimp_scrolled_preview_thaw (preview);
}
@ -872,7 +917,7 @@ gimp_scrolled_preview_set_policy (GimpScrolledPreview *preview,
priv->hscr_policy = hscrollbar_policy;
priv->vscr_policy = vscrollbar_policy;
gtk_widget_queue_resize (GIMP_PREVIEW (preview)->area);
gtk_widget_queue_resize (gimp_preview_get_area (GIMP_PREVIEW (preview)));
}
void

4
plug-ins/common/despeckle.c
View File

@ -586,9 +586,7 @@ preview_update (GtkWidget *widget)
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
width = preview->width;
height = preview->height;
gimp_preview_get_size (preview, &width, &height);
gimp_preview_get_position (preview, &x1, &y1);
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, width, height, FALSE, FALSE);