1 files changed, 1226 insertions, 0 deletions
diff --git a/src/eom-print-preview.c b/src/eom-print-preview.c
new file mode 100644
index 0000000..13957c6
--- /dev/null
+++ b/src/eom-print-preview.c
@@ -0,0 +1,1226 @@
+/* Eye Of MATE -- Print Preview Widget
+ *
+ * Copyright (C) 2006-2008 The Free Software Foundation
+ *
+ * Author: Claudio Saavedra <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <gtk/gtk.h>
+#include <cairo.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "eom-image.h"
+#include "eom-print-preview.h"
+
+#define EOM_PRINT_PREVIEW_GET_PRIVATE(object) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((object), EOM_TYPE_PRINT_PREVIEW, EomPrintPreviewPrivate))
+
+G_DEFINE_TYPE (EomPrintPreview, eom_print_preview, GTK_TYPE_ASPECT_FRAME)
+
+struct _EomPrintPreviewPrivate {
+ GtkWidget *area;
+ GdkPixbuf *image;
+ GdkPixbuf *image_scaled;
+
+ /* The surface to set to the cairo context, created from the image */
+ cairo_surface_t *surface;
+
+ /* Flag whether we have to create surface */
+ gboolean flag_create_surface;
+
+ /* the alignment of the image in the page */
+ gfloat image_x_align, image_y_align;
+
+ /* real paper size, in inches */
+ gfloat p_width, p_height;
+
+ /* page margins, in inches */
+ gfloat l_margin, r_margin, t_margin, b_margin;
+
+ /* page margins, relatives to the widget size */
+ gint l_rmargin, r_rmargin, t_rmargin, b_rmargin;
+
+ /* image width, relative to the widget size */
+ gint r_width, r_height;
+
+ /* scale of the image, as defined by the user */
+ gfloat i_scale;
+
+ /* scale of the page, relative to the widget size */
+ gfloat p_scale;
+
+ /* whether we are currently grabbing the image */
+ gboolean grabbed;
+
+ /* the last cursor position */
+ gdouble cursorx, cursory;
+
+ /* if we reject to move the image,
+ store the delta here */
+ gdouble r_dx, r_dy;
+};
+
+/* Signal IDs */
+enum {
+ SIGNAL_IMAGE_MOVED,
+ SIGNAL_LAST
+};
+static gint preview_signals [SIGNAL_LAST];
+
+enum {
+ PROP_IMAGE = 1,
+ PROP_IMAGE_X_ALIGN,
+ PROP_IMAGE_Y_ALIGN,
+ PROP_IMAGE_SCALE,
+ PROP_PAPER_WIDTH,
+ PROP_PAPER_HEIGHT,
+ PROP_PAGE_LEFT_MARGIN,
+ PROP_PAGE_RIGHT_MARGIN,
+ PROP_PAGE_TOP_MARGIN,
+ PROP_PAGE_BOTTOM_MARGIN
+};
+
+static void eom_print_preview_draw (EomPrintPreview *preview, cairo_t *cr);
+static void eom_print_preview_finalize (GObject *object);
+static void update_relative_sizes (EomPrintPreview *preview);
+static void create_surface (EomPrintPreview *preview);
+static void create_image_scaled (EomPrintPreview *preview);
+static gboolean create_surface_when_idle (EomPrintPreview *preview);
+
+static void
+eom_print_preview_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ EomPrintPreviewPrivate *priv = EOM_PRINT_PREVIEW (object)->priv;
+
+ switch (prop_id) {
+ case PROP_IMAGE:
+ g_value_set_object (value, priv->image);
+ break;
+ case PROP_IMAGE_X_ALIGN:
+ g_value_set_float (value, priv->image_x_align);
+ break;
+ case PROP_IMAGE_Y_ALIGN:
+ g_value_set_float (value, priv->image_y_align);
+ break;
+ case PROP_IMAGE_SCALE:
+ g_value_set_float (value, priv->i_scale);
+ break;
+ case PROP_PAPER_WIDTH:
+ g_value_set_float (value, priv->p_width);
+ break;
+ case PROP_PAPER_HEIGHT:
+ g_value_set_float (value, priv->p_height);
+ break;
+ case PROP_PAGE_LEFT_MARGIN:
+ g_value_set_float (value, priv->l_margin);
+ break;
+ case PROP_PAGE_RIGHT_MARGIN:
+ g_value_set_float (value, priv->r_margin);
+ break;
+ case PROP_PAGE_TOP_MARGIN:
+ g_value_set_float (value, priv->t_margin);
+ break;
+ case PROP_PAGE_BOTTOM_MARGIN:
+ g_value_set_float (value, priv->b_margin);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+eom_print_preview_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ EomPrintPreviewPrivate *priv = EOM_PRINT_PREVIEW (object)->priv;
+ gboolean paper_size_changed = FALSE;
+
+ switch (prop_id) {
+ case PROP_IMAGE:
+ if (priv->image) {
+ g_object_unref (priv->image);
+ }
+ priv->image = GDK_PIXBUF (g_value_dup_object (value));
+
+ if (priv->image_scaled) {
+ g_object_unref (priv->image_scaled);
+ priv->image_scaled = NULL;
+ }
+
+ priv->flag_create_surface = TRUE;
+ break;
+ case PROP_IMAGE_X_ALIGN:
+ priv->image_x_align = g_value_get_float (value);
+ break;
+ case PROP_IMAGE_Y_ALIGN:
+ priv->image_y_align = g_value_get_float (value);
+ break;
+ case PROP_IMAGE_SCALE:
+ priv->i_scale = g_value_get_float (value);
+ priv->flag_create_surface = TRUE;
+ break;
+ case PROP_PAPER_WIDTH:
+ priv->p_width = g_value_get_float (value);
+ paper_size_changed = TRUE;
+ break;
+ case PROP_PAPER_HEIGHT:
+ priv->p_height = g_value_get_float (value);
+ paper_size_changed = TRUE;
+ break;
+ case PROP_PAGE_LEFT_MARGIN:
+ priv->l_margin = g_value_get_float (value);
+ break;
+ case PROP_PAGE_RIGHT_MARGIN:
+ priv->r_margin = g_value_get_float (value);
+ break;
+ case PROP_PAGE_TOP_MARGIN:
+ priv->t_margin = g_value_get_float (value);
+ break;
+ case PROP_PAGE_BOTTOM_MARGIN:
+ priv->b_margin = g_value_get_float (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+
+ if (paper_size_changed) {
+ g_object_set (object,
+ "ratio", priv->p_width/priv->p_height,
+ NULL);
+ }
+
+ update_relative_sizes (EOM_PRINT_PREVIEW (object));
+ gtk_widget_queue_draw (priv->area);
+}
+
+static void
+eom_print_preview_class_init (EomPrintPreviewClass *klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = (GObjectClass*) klass;
+
+ gobject_class->get_property = eom_print_preview_get_property;
+ gobject_class->set_property = eom_print_preview_set_property;
+ gobject_class->finalize = eom_print_preview_finalize;
+
+/**
+ * EomPrintPreview:image:
+ *
+ * The "image" property defines the image that is previewed
+ * in the widget.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IMAGE,
+ g_param_spec_object ("image",
+ "Image to show in the preview",
+ "",
+ G_TYPE_OBJECT,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:image-x-align:
+ *
+ * The "image-x-align" property defines the horizontal alignment
+ * of the image in the widget.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IMAGE_X_ALIGN,
+ g_param_spec_float ("image-x-align",
+ "Horizontal alignment for the image",
+ "",
+ 0,
+ 1,
+ 0.5,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:image-y-align:
+ *
+ * The "image-y-align" property defines the horizontal alignment
+ * of the image in the widget.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IMAGE_Y_ALIGN,
+ g_param_spec_float ("image-y-align",
+ "Vertical alignment for the image",
+ "",
+ 0,
+ 1,
+ 0.5,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:image-scale:
+ *
+ * The "image-scale" property defines the scaling of the image
+ * that the user wants for the printing.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IMAGE_SCALE,
+ g_param_spec_float ("image-scale",
+ "The scale for the image",
+ "",
+ 0,
+ 1,
+ 1,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:paper-width:
+ *
+ * The width of the previewed paper, in inches.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PAPER_WIDTH,
+ g_param_spec_float ("paper-width",
+ "Real paper width in inches",
+ "",
+ 0,
+ 100,
+ 8.5,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:paper-height:
+ *
+ * The height of the previewed paper, in inches.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PAPER_HEIGHT,
+ g_param_spec_float ("paper-height",
+ "Real paper height in inches",
+ "",
+ 0,
+ 200,
+ 11,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:page-left-margin:
+ *
+ * The size of the page's left margin, in inches.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PAGE_LEFT_MARGIN,
+ g_param_spec_float ("page-left-margin",
+ "Left margin of the page in inches",
+ "",
+ 0,
+ 100,
+ 0.25,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:page-right-margin:
+ *
+ * The size of the page's right margin, in inches.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PAGE_RIGHT_MARGIN,
+ g_param_spec_float ("page-right-margin",
+ "Right margin of the page in inches",
+ "",
+ 0,
+ 200,
+ 0.25,
+ G_PARAM_READWRITE));
+/**
+ * EomPrintPreview:page-top-margin:
+ *
+ * The size of the page's top margin, in inches.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PAGE_TOP_MARGIN,
+ g_param_spec_float ("page-top-margin",
+ "Top margin of the page in inches",
+ "",
+ 0,
+ 100,
+ 0.25,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview:page-bottom-margin:
+ *
+ * The size of the page's bottom margin, in inches.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PAGE_BOTTOM_MARGIN,
+ g_param_spec_float ("page-bottom-margin",
+ "Bottom margin of the page in inches",
+ "",
+ 0,
+ 200,
+ 0.56,
+ G_PARAM_READWRITE));
+
+/**
+ * EomPrintPreview::image-moved:
+ * @preview: the object which received the signal
+ *
+ * The #EomPrintPreview::image-moved signal is emitted when the position
+ * of the image is changed.
+ */
+ preview_signals [SIGNAL_IMAGE_MOVED] =
+ g_signal_new ("image_moved",
+ G_TYPE_FROM_CLASS (gobject_class),
+ G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
+ g_cclosure_marshal_VOID__VOID, G_TYPE_NONE,
+ 0, NULL);
+
+ g_type_class_add_private (klass, sizeof (EomPrintPreviewPrivate));
+}
+
+static void
+eom_print_preview_finalize (GObject *object)
+{
+ EomPrintPreviewPrivate *priv;
+
+ priv = EOM_PRINT_PREVIEW (object)->priv;
+
+ if (priv->image) {
+ g_object_unref (priv->image);
+ priv->image = NULL;
+ }
+
+ if (priv->image_scaled) {
+ g_object_unref (priv->image_scaled);
+ priv->image_scaled = NULL;
+ }
+
+ if (priv->surface) {
+ cairo_surface_destroy (priv->surface);
+ priv->surface = NULL;
+ }
+
+ G_OBJECT_CLASS (eom_print_preview_parent_class)->finalize (object);
+}
+
+static void
+eom_print_preview_init (EomPrintPreview *preview)
+{
+ EomPrintPreviewPrivate *priv;
+ gfloat ratio;
+
+ priv = preview->priv = EOM_PRINT_PREVIEW_GET_PRIVATE (preview);
+
+ priv->area = GTK_WIDGET (gtk_drawing_area_new ());
+
+ gtk_container_add (GTK_CONTAINER (preview), priv->area);
+
+ priv->p_width = 8.5;
+ priv->p_height = 11.0;
+
+ ratio = priv->p_width/priv->p_height;
+
+ gtk_aspect_frame_set (GTK_ASPECT_FRAME (preview),
+ 0.5, 0.5, ratio, FALSE);
+
+ priv->image = NULL;
+ priv->image_scaled = NULL;
+ priv->image_x_align = 0.5;
+ priv->image_y_align = 0.5;
+ priv->i_scale = 1;
+
+ priv->surface = NULL;
+ priv->flag_create_surface = TRUE;
+
+ priv->p_scale = 0;
+
+ priv->l_margin = 0.25;
+ priv->r_margin = 0.25;
+ priv->t_margin = 0.25;
+ priv->b_margin = 0.56;
+
+ priv->grabbed = FALSE;
+ priv->cursorx = 0;
+ priv->cursory = 0;
+ priv->r_dx = 0;
+ priv->r_dy = 0;
+}
+
+static gboolean button_press_event_cb (GtkWidget *widget, GdkEventButton *bev, gpointer user_data);
+static gboolean button_release_event_cb (GtkWidget *widget, GdkEventButton *bev, gpointer user_data);
+static gboolean motion_notify_event_cb (GtkWidget *widget, GdkEventMotion *mev, gpointer user_data);
+static gboolean key_press_event_cb (GtkWidget *widget, GdkEventKey *event, gpointer user_data);
+
+static void expose_event_cb (GtkDrawingArea *drawing_area, GdkEventExpose *eev, gpointer user_data);
+static void size_allocate_cb (GtkWidget *widget, GtkAllocation *allocation, gpointer user_data);
+
+/**
+ * eom_print_preview_new_with_pixbuf:
+ * @pixbuf: a #GdkPixbuf
+ *
+ * Creates a new #EomPrintPreview widget, and sets the #GdkPixbuf to preview
+ * on it.
+ *
+ * Returns: A new #EomPrintPreview widget.
+ **/
+GtkWidget *
+eom_print_preview_new_with_pixbuf (GdkPixbuf *pixbuf)
+{
+ EomPrintPreview *preview;
+
+ g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
+
+ preview = EOM_PRINT_PREVIEW (eom_print_preview_new ());
+
+ preview->priv->image = g_object_ref (pixbuf);
+
+ update_relative_sizes (preview);
+
+ return GTK_WIDGET (preview);
+}
+
+/**
+ * eom_print_preview_new:
+ *
+ * Creates a new #EomPrintPreview widget, setting it to the default values,
+ * and leaving the page empty. You still need to set the #EomPrintPreview:image
+ * property to make it useful.
+ *
+ * Returns: A new and empty #EomPrintPreview widget.
+ **/
+GtkWidget *
+eom_print_preview_new (void)
+{
+ EomPrintPreview *preview;
+ GtkWidget *area;
+
+ preview = g_object_new (EOM_TYPE_PRINT_PREVIEW, NULL);
+
+ area = preview->priv->area;
+
+ gtk_widget_set_events (area,
+ GDK_EXPOSURE_MASK |
+ GDK_POINTER_MOTION_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_KEY_PRESS_MASK);
+
+ g_object_set (G_OBJECT (area),
+ "can-focus", TRUE,
+ NULL);
+
+/* update_relative_sizes (preview); */
+
+ g_signal_connect (G_OBJECT (area), "expose-event",
+ G_CALLBACK (expose_event_cb), preview);
+
+ g_signal_connect (G_OBJECT (area), "motion-notify-event",
+ G_CALLBACK (motion_notify_event_cb), preview);
+
+ g_signal_connect (G_OBJECT (area), "button-press-event",
+ G_CALLBACK (button_press_event_cb), preview);
+
+ g_signal_connect (G_OBJECT (area), "button-release-event",
+ G_CALLBACK (button_release_event_cb), preview);
+
+ g_signal_connect (G_OBJECT (area), "key-press-event",
+ G_CALLBACK (key_press_event_cb), preview);
+
+ g_signal_connect (area, "size-allocate",
+ G_CALLBACK (size_allocate_cb), preview);
+
+ return GTK_WIDGET (preview);
+}
+
+static void
+expose_event_cb (GtkDrawingArea *drawing_area,
+ GdkEventExpose *eev,
+ gpointer user_data)
+{
+ GtkWidget *widget;
+ EomPrintPreviewPrivate *priv;
+ cairo_t *cr;
+
+ widget = GTK_WIDGET (drawing_area);
+ priv = EOM_PRINT_PREVIEW (user_data)->priv;
+
+ update_relative_sizes (EOM_PRINT_PREVIEW (user_data));
+
+ cr = gdk_cairo_create (gtk_widget_get_window (widget));
+
+ eom_print_preview_draw (EOM_PRINT_PREVIEW (user_data), cr);
+
+ if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
+ fprintf (stderr, "Cairo is unhappy: %s\n",
+ cairo_status_to_string (cairo_status (cr)));
+ }
+
+ cairo_destroy (cr);
+
+ gdk_window_get_pointer (gtk_widget_get_window (widget), NULL, NULL, NULL);
+}
+
+/**
+ * get_current_image_coordinates:
+ * @preview: an #EomPrintPreview
+ * @x0: A pointer where to store the x coordinate.
+ * @y0: A pointer where to store the y coordinate.
+ *
+ * This function returns the current image coordinates, according
+ * with the properties of the given @preview widget.
+ **/
+static void
+get_current_image_coordinates (EomPrintPreview *preview,
+ gint *x0, gint *y0)
+{
+ EomPrintPreviewPrivate *priv;
+ GtkAllocation allocation;
+
+ priv = preview->priv;
+ gtk_widget_get_allocation (GTK_WIDGET (priv->area), &allocation);
+
+ *x0 = (gint)((1 - priv->image_x_align)*priv->l_rmargin + priv->image_x_align*(allocation.width - priv->r_rmargin - priv->r_width));
+ *y0 = (gint)((1 - priv->image_y_align)*priv->t_rmargin + priv->image_y_align*(allocation.height - priv->b_rmargin - priv->r_height));
+}
+
+/**
+ * press_inside_image_area:
+ * @preview: an #EomPrintPreview
+ * @x: the points x coordinate
+ * @y: the points y coordinate
+ *
+ * Returns whether the given point is inside the image area.
+ *
+ * Returns: %TRUE if the given point is inside of the image area,
+ * %FALSE otherwise.
+ **/
+static gboolean
+press_inside_image_area (EomPrintPreview *preview,
+ guint x,
+ guint y)
+{
+ EomPrintPreviewPrivate *priv;
+ gint x0, y0;
+
+ priv = preview->priv;
+ get_current_image_coordinates (preview, &x0, &y0);
+
+ if (x >= x0 && y >= y0 &&
+ x <= x0 + priv->r_width && y <= y0 + priv->r_height)
+ return TRUE;
+
+ return FALSE;
+}
+
+static void
+create_image_scaled (EomPrintPreview *preview)
+{
+ EomPrintPreviewPrivate *priv = preview->priv;
+
+ if (!priv->image_scaled) {
+ gint i_width, i_height;
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (priv->area, &allocation);
+ i_width = gdk_pixbuf_get_width (priv->image);
+ i_height = gdk_pixbuf_get_height (priv->image);
+
+ if ((i_width > allocation.width) ||
+ (i_height > allocation.height)) {
+ gdouble scale;
+ scale = MIN ((gdouble) allocation.width/i_width,
+ (gdouble) allocation.height/i_height);
+ priv->image_scaled = gdk_pixbuf_scale_simple (priv->image,
+ i_width*scale,
+ i_height*scale,
+ GDK_INTERP_TILES);
+ } else {
+ priv->image_scaled = priv->image;
+ g_object_ref (priv->image_scaled);
+ }
+ }
+}
+
+static GdkPixbuf *
+create_preview_buffer (EomPrintPreview *preview)
+{
+ GdkPixbuf *pixbuf;
+ gint width, height;
+ GdkInterpType type = GDK_INTERP_TILES;
+
+ if (preview->priv->image == NULL) {
+ return NULL;
+ }
+
+ create_image_scaled (preview);
+
+ width = gdk_pixbuf_get_width (preview->priv->image);
+ height = gdk_pixbuf_get_height (preview->priv->image);
+
+ width *= preview->priv->i_scale * preview->priv->p_scale;
+ height *= preview->priv->i_scale * preview->priv->p_scale;
+
+ if (width < 1 || height < 1)
+ return NULL;
+
+ /* to use GDK_INTERP_TILES for small pixbufs is expensive and unnecessary */
+ if (width < 25 || height < 25)
+ type = GDK_INTERP_NEAREST;
+
+ if (preview->priv->image_scaled) {
+ pixbuf = gdk_pixbuf_scale_simple (preview->priv->image_scaled,
+ width, height, type);
+ } else {
+ pixbuf = gdk_pixbuf_scale_simple (preview->priv->image,
+ width, height, type);
+ }
+
+ return pixbuf;
+}
+
+/*
+ Function inspired from gdk_cairo_set_source_pixbuf (). The main reason is
+ that I want to save the cairo_surface_t created from the scaled buffer to
+ improve performance.
+*/
+static cairo_surface_t *
+create_surface_from_pixbuf (GdkPixbuf *pixbuf)
+{
+ gint width = gdk_pixbuf_get_width (pixbuf);
+ gint height = gdk_pixbuf_get_height (pixbuf);
+ guchar *gdk_pixels = gdk_pixbuf_get_pixels (pixbuf);
+ int gdk_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
+ int cairo_stride;
+ guchar *cairo_pixels;
+ cairo_format_t format;
+ cairo_surface_t *surface;
+ static const cairo_user_data_key_t key;
+ int j;
+
+ if (n_channels == 3)
+ format = CAIRO_FORMAT_RGB24;
+ else
+ format = CAIRO_FORMAT_ARGB32;
+
+ cairo_stride = cairo_format_stride_for_width (format, width);
+ cairo_pixels = g_malloc (height * cairo_stride);
+ surface = cairo_image_surface_create_for_data ((unsigned char *)cairo_pixels,
+ format,
+ width, height, cairo_stride);
+ cairo_surface_set_user_data (surface, &key,
+ cairo_pixels, (cairo_destroy_func_t)g_free);
+
+ for (j = height; j; j--)
+ {
+ guchar *p = gdk_pixels;
+ guchar *q = cairo_pixels;
+
+ if (n_channels == 3)
+ {
+ guchar *end = p + 3 * width;
+
+ while (p < end)
+ {
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+ q[0] = p[2];
+ q[1] = p[1];
+ q[2] = p[0];
+#else
+ q[1] = p[0];
+ q[2] = p[1];
+ q[3] = p[2];
+#endif
+ p += 3;
+ q += 4;
+ }
+ }
+ else
+ {
+ guchar *end = p + 4 * width;
+ guint t1,t2,t3;
+
+#define MULT(d,c,a,t) G_STMT_START { t = c * a + 0x7f; d = ((t >> 8) + t) >> 8; } G_STMT_END
+
+ while (p < end)
+ {
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+ MULT(q[0], p[2], p[3], t1);
+ MULT(q[1], p[1], p[3], t2);
+ MULT(q[2], p[0], p[3], t3);
+ q[3] = p[3];
+#else
+ q[0] = p[3];
+ MULT(q[1], p[0], p[3], t1);
+ MULT(q[2], p[1], p[3], t2);
+ MULT(q[3], p[2], p[3], t3);
+#endif
+
+ p += 4;
+ q += 4;
+ }
+
+#undef MULT
+ }
+
+ gdk_pixels += gdk_rowstride;
+ cairo_pixels += cairo_stride;
+ }
+
+ return surface;
+}
+
+static void
+create_surface (EomPrintPreview *preview)
+{
+ EomPrintPreviewPrivate *priv = preview->priv;
+ GdkPixbuf *pixbuf;
+
+ if (priv->surface) {
+ cairo_surface_destroy (priv->surface);
+ priv->surface = NULL;
+ }
+
+ pixbuf = create_preview_buffer (preview);
+ if (pixbuf) {
+ priv->surface = create_surface_from_pixbuf (pixbuf);
+ g_object_unref (pixbuf);
+ }
+ priv->flag_create_surface = FALSE;
+}
+
+static gboolean
+create_surface_when_idle (EomPrintPreview *preview)
+{
+ create_surface (preview);
+
+ return FALSE;
+}
+
+static gboolean
+button_press_event_cb (GtkWidget *widget,
+ GdkEventButton *event,
+ gpointer user_data)
+{
+ EomPrintPreview *preview = EOM_PRINT_PREVIEW (user_data);
+
+ preview->priv->cursorx = event->x;
+ preview->priv->cursory = event->y;
+
+ switch (event->button) {
+ case 1:
+ preview->priv->grabbed = press_inside_image_area (preview, event->x, event->y);
+ break;
+ }
+
+ if (preview->priv->grabbed) {
+ gtk_widget_queue_draw (GTK_WIDGET (preview));
+ }
+
+ gtk_widget_grab_focus (preview->priv->area);
+
+ return FALSE;
+}
+
+static gboolean
+button_release_event_cb (GtkWidget *widget,
+ GdkEventButton *event,
+ gpointer user_data)
+{
+ EomPrintPreview *preview = EOM_PRINT_PREVIEW (user_data);
+
+ switch (event->button) {
+ case 1:
+ preview->priv->grabbed = FALSE;
+ preview->priv->r_dx = 0;
+ preview->priv->r_dy = 0;
+ gtk_widget_queue_draw (GTK_WIDGET (preview));
+
+ }
+ return FALSE;
+}
+
+static gboolean
+key_press_event_cb (GtkWidget *widget,
+ GdkEventKey *event,
+ gpointer user_data)
+{
+ EomPrintPreviewPrivate *priv;
+ gfloat delta, align;
+ gboolean stop_emission = FALSE;
+ const gchar *property;
+
+ priv = EOM_PRINT_PREVIEW (user_data)->priv;
+
+ delta = 0;
+
+ switch (event->keyval) {
+ case GDK_Left:
+ property = "image-x-align";
+ delta = -0.01;
+ break;
+ case GDK_Right:
+ property = "image-x-align";
+ delta = 0.01;
+ break;
+ case GDK_Up:
+ property = "image-y-align";
+ delta = -0.01;
+ break;
+ case GDK_Down:
+ property = "image-y-align";
+ delta = 0.01;
+ break;
+ }
+
+ if (delta != 0) {
+ g_object_get (G_OBJECT (user_data),
+ property, &align,
+ NULL);
+
+ align += delta;
+ align = CLAMP (align, 0, 1);
+ g_object_set (G_OBJECT (user_data),
+ property, align,
+ NULL);
+
+ stop_emission = TRUE;
+ g_signal_emit (G_OBJECT (user_data),
+ preview_signals
+ [SIGNAL_IMAGE_MOVED], 0);
+ }
+
+ return stop_emission;
+}
+
+static gboolean
+motion_notify_event_cb (GtkWidget *widget,
+ GdkEventMotion *event,
+ gpointer user_data)
+{
+ EomPrintPreviewPrivate *priv = EOM_PRINT_PREVIEW (user_data)->priv;
+ gdouble dx, dy;
+ GtkAllocation allocation;
+
+ if (priv->grabbed) {
+ dx = event->x - priv->cursorx;
+ dy = event->y - priv->cursory;
+
+ gtk_widget_get_allocation (widget, &allocation);
+
+ /* Make sure the image stays inside the margins */
+
+ priv->image_x_align += (dx + priv->r_dx)/(allocation.width - priv->r_width - priv->l_rmargin - priv->r_rmargin);
+ if (priv->image_x_align < 0. || priv->image_x_align > 1.) {
+ priv->image_x_align = CLAMP (priv->image_x_align, 0., 1.);
+ priv->r_dx += dx;
+ }
+ else
+ priv->r_dx = 0;
+
+ priv->image_y_align += (dy + priv->r_dy)/(allocation.height - priv->r_height - priv->t_rmargin - priv->b_rmargin);
+ if (priv->image_y_align < 0. || priv->image_y_align > 1.) {
+ priv->image_y_align = CLAMP (priv->image_y_align, 0., 1.);
+ priv->r_dy += dy;
+ } else
+ priv->r_dy = 0;
+
+ /* we do this to correctly change the property values */
+ g_object_set (EOM_PRINT_PREVIEW (user_data),
+ "image-x-align", priv->image_x_align,
+ "image-y-align", priv->image_y_align,
+ NULL);
+
+ priv->cursorx = event->x;
+ priv->cursory = event->y;
+
+ g_signal_emit (G_OBJECT (user_data),
+ preview_signals
+ [SIGNAL_IMAGE_MOVED], 0);
+ } else {
+ if (press_inside_image_area (EOM_PRINT_PREVIEW (user_data), event->x, event->y)) {
+ GdkCursor *cursor;
+ cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
+ GDK_FLEUR);
+ gdk_window_set_cursor (gtk_widget_get_window (widget),
+ cursor);
+ gdk_cursor_unref (cursor);
+ } else {
+ gdk_window_set_cursor (gtk_widget_get_window (widget),
+ NULL);
+ }
+ }
+ return FALSE;
+}
+
+static void
+size_allocate_cb (GtkWidget *widget,
+ GtkAllocation *allocation,
+ gpointer user_data)
+{
+ EomPrintPreview *preview;
+
+ preview = EOM_PRINT_PREVIEW (user_data);
+ update_relative_sizes (preview);
+
+ preview->priv->flag_create_surface = TRUE;
+
+ if (preview->priv->image_scaled) {
+ g_object_unref (preview->priv->image_scaled);
+ preview->priv->image_scaled = NULL;
+ }
+
+ g_idle_add ((GSourceFunc) create_surface_when_idle, preview);
+}
+
+static void
+eom_print_preview_draw (EomPrintPreview *preview, cairo_t *cr)
+{
+ EomPrintPreviewPrivate *priv;
+ GtkWidget *area;
+ GtkAllocation allocation;
+ gint x0, y0;
+ GtkStyle *style;
+ gboolean has_focus;
+
+ priv = preview->priv;
+ area = priv->area;
+
+ has_focus = gtk_widget_has_focus (area);
+
+ style = gtk_widget_get_style (area);
+
+ gtk_widget_get_allocation (area, &allocation);
+
+ /* draw the page */
+ gdk_cairo_set_source_color (cr, &style->white);
+ cairo_rectangle (cr, 0, 0, allocation.width, allocation.height);
+ cairo_fill (cr);
+
+ /* draw the page margins */
+ gdk_cairo_set_source_color (cr, &style->black);
+ cairo_set_line_width (cr, 0.1);
+ cairo_rectangle (cr,
+ priv->l_rmargin, priv->t_rmargin,
+ allocation.width - priv->l_rmargin - priv->r_rmargin,
+ allocation.height - priv->t_rmargin - priv->b_rmargin);
+ cairo_stroke (cr);
+
+ get_current_image_coordinates (preview, &x0, &y0);
+
+ if (priv->flag_create_surface) {
+ create_surface (preview);
+ }
+
+ if (priv->surface) {
+ cairo_set_source_surface (cr, priv->surface, x0, y0);
+ cairo_paint (cr);
+ } else if (priv->image_scaled) {
+ /* just in the remote case we don't have the surface */
+
+ /* adjust (x0, y0) to the new scale */
+ gdouble scale = priv->i_scale * priv->p_scale *
+ gdk_pixbuf_get_width (priv->image) / gdk_pixbuf_get_width (priv->image_scaled);
+ x0 /= scale;
+ y0 /= scale;
+
+ cairo_scale (cr, scale, scale);
+ gdk_cairo_set_source_pixbuf (cr, priv->image_scaled, x0, y0);
+ cairo_paint (cr);
+ } else if (priv->image) {
+ /* just in the remote case we don't have the surface */
+
+ /* adjust (x0, y0) to the new scale */
+ x0 /= priv->i_scale * priv->p_scale;
+ y0 /= priv->i_scale * priv->p_scale;
+
+ cairo_scale (cr, priv->i_scale*priv->p_scale, priv->i_scale*priv->p_scale);
+ gdk_cairo_set_source_pixbuf (cr, priv->image, x0, y0);
+ cairo_paint (cr);
+ }
+
+ if (has_focus) {
+ gtk_paint_focus (style, gtk_widget_get_window (area),
+ GTK_STATE_NORMAL, NULL, NULL, NULL,
+ 0, 0, allocation.width, allocation.height);
+ }
+}
+
+static void
+update_relative_sizes (EomPrintPreview *preview)
+{
+ EomPrintPreviewPrivate *priv;
+ GtkAllocation allocation;
+ gint i_width, i_height;
+
+ priv = preview->priv;
+
+ if (priv->image != NULL) {
+ i_width = gdk_pixbuf_get_width (priv->image);
+ i_height = gdk_pixbuf_get_height (priv->image);
+ } else {
+ i_width = i_height = 0;
+ }
+
+ gtk_widget_get_allocation (priv->area, &allocation);
+
+ priv->p_scale = (gfloat) allocation.width / (priv->p_width * 72.0);
+
+ priv->r_width = (gint) i_width * priv->i_scale * priv->p_scale;
+ priv->r_height = (gint) i_height * priv->i_scale * priv->p_scale;
+
+ priv->l_rmargin = (gint) (72. * priv->l_margin * priv->p_scale);
+ priv->r_rmargin = (gint) (72. * priv->r_margin * priv->p_scale);
+ priv->t_rmargin = (gint) (72. * priv->t_margin * priv->p_scale);
+ priv->b_rmargin = (gint) (72. * priv->b_margin * priv->p_scale);
+}
+
+/**
+ * eom_print_preview_set_page_margins:
+ * @preview: a #EomPrintPreview
+ * @l_margin: Left margin.
+ * @r_margin: Right margin.
+ * @t_margin: Top margin.
+ * @b_margin: Bottom margin.
+ *
+ * Manually set the margins, in inches.
+ **/
+void
+eom_print_preview_set_page_margins (EomPrintPreview *preview,
+ gfloat l_margin,
+ gfloat r_margin,
+ gfloat t_margin,
+ gfloat b_margin)
+{
+ g_return_if_fail (EOM_IS_PRINT_PREVIEW (preview));
+
+ g_object_set (G_OBJECT(preview),
+ "page-left-margin", l_margin,
+ "page-right-margin", r_margin,
+ "page-top-margin", t_margin,
+ "page-bottom-margin", r_margin,
+ NULL);
+}
+
+/**
+ * eom_print_preview_set_from_page_setup:
+ * @preview: a #EomPrintPreview
+ * @setup: a #GtkPageSetup to set the properties from
+ *
+ * Sets up the page properties from a #GtkPageSetup. Useful when using the
+ * widget with the GtkPrint API.
+ **/
+void
+eom_print_preview_set_from_page_setup (EomPrintPreview *preview,
+ GtkPageSetup *setup)
+{
+ g_return_if_fail (EOM_IS_PRINT_PREVIEW (preview));
+ g_return_if_fail (GTK_IS_PAGE_SETUP (setup));
+
+ g_object_set (G_OBJECT (preview),
+ "page-left-margin", gtk_page_setup_get_left_margin (setup, GTK_UNIT_INCH),
+ "page-right-margin", gtk_page_setup_get_right_margin (setup, GTK_UNIT_INCH),
+ "page-top-margin", gtk_page_setup_get_top_margin (setup, GTK_UNIT_INCH),
+ "page-bottom-margin", gtk_page_setup_get_bottom_margin (setup, GTK_UNIT_INCH),
+ "paper-width", gtk_page_setup_get_paper_width (setup, GTK_UNIT_INCH),
+ "paper-height", gtk_page_setup_get_paper_height (setup, GTK_UNIT_INCH),
+ NULL);
+
+}
+
+/**
+ * eom_print_preview_get_image_position:
+ * @preview: a #EomPrintPreview
+ * @x: a pointer to a #gdouble, or %NULL to ignore it
+ * @y: a pointer to a #gdouble, or %NULL to ignore it
+ *
+ * Gets current image position in inches, relative to the margins. A
+ * (0, 0) position is the intersection between the left and top margins.
+ **/
+void
+eom_print_preview_get_image_position (EomPrintPreview *preview,
+ gdouble *x,
+ gdouble *y)
+{
+ EomPrintPreviewPrivate *priv;
+ gdouble width, height;
+
+ g_return_if_fail (EOM_IS_PRINT_PREVIEW (preview));
+
+ priv = preview->priv;
+
+ if (x != NULL) {
+ width = gdk_pixbuf_get_width (priv->image) * priv->i_scale / 72.;
+ *x = priv->image_x_align * (priv->p_width - priv->l_margin - priv->r_margin - width);
+ }
+ if (y != NULL) {
+ height = gdk_pixbuf_get_height (priv->image) * priv->i_scale / 72.;
+ *y = priv->image_y_align * (priv->p_height - priv->t_margin - priv->b_margin - height);
+ }
+}
+
+/**
+ * eom_print_preview_set_image_position:
+ * @preview: a #EomPrintPreview
+ * @x: The X coordinate, in inches, or -1 to ignore it.
+ * @y: The Y coordinate, in inches, or -1 to ignore it.
+ *
+ * Sets the image position. You can pass -1 to one of the coordinates if you
+ * only want to set the other.
+ **/
+void
+eom_print_preview_set_image_position (EomPrintPreview *preview,
+ gdouble x,
+ gdouble y)
+{
+ EomPrintPreviewPrivate *priv;
+ gfloat x_align, y_align;
+ gdouble width, height;
+
+ g_return_if_fail (EOM_IS_PRINT_PREVIEW (preview));
+
+ priv = preview->priv;
+
+ if (x != -1) {
+ width = gdk_pixbuf_get_width (priv->image) * priv->i_scale / 72.;
+ x_align = CLAMP (x/(priv->p_width - priv->l_margin - priv->r_margin - width), 0, 1);
+ g_object_set (preview, "image-x-align", x_align, NULL);
+ }
+
+ if (y != -1) {
+ height = gdk_pixbuf_get_height (priv->image) * priv->i_scale / 72.;
+ y_align = CLAMP (y/(priv->p_height - priv->t_margin - priv->b_margin - height), 0, 1);
+ g_object_set (preview, "image-y-align", y_align, NULL);
+ }
+}
+
+/**
+ * eom_print_preview_set_scale:
+ * @preview: a #EomPrintPreview
+ * @scale: a scale value, between 0 and 1.
+ *
+ * Sets the scale for the image.
+ **/
+void
+eom_print_preview_set_scale (EomPrintPreview *preview,
+ gfloat scale)
+{
+ g_return_if_fail (EOM_IS_PRINT_PREVIEW (preview));
+
+ g_object_set (preview,
+ "image-scale", scale,
+ NULL);
+}