-/* Image item type for GtkCanvas widget
+/* Image item type for GnomeCanvas widget
*
- * GtkCanvas is basically a port of the Tk toolkit's most excellent canvas widget. Tk is
+ * GnomeCanvas is basically a port of the Tk toolkit's most excellent canvas widget. Tk is
* copyrighted by the Regents of the University of California, Sun Microsystems, and other parties.
*
* Copyright (C) 1998 The Free Software Foundation
*
* Author: Federico Mena <federico@nuclecu.unam.mx>
*/
-
-
+
+
#include <string.h> /* for memcpy() */
#include <math.h>
#include <stdio.h>
#include "libart_lgpl/art_pixbuf.h"
#include "libart_lgpl/art_rgb_pixbuf_affine.h"
#include "canvas-imageframe.h"
-#include <gtk-canvas/gtk-canvas-util.h>
-#include <gtk-canvas/gtk-canvastypebuiltins.h>
+#include <libgnomecanvas/gnome-canvas-util.h>
+#include "gettext.h"
+#define _(Text) dgettext (PACKAGE,Text)
+
+//GTK2FIX
+//#include <libgnomecanvas/gnome-canvastypebuiltins.h>
enum {
- ARG_0,
- ARG_PIXBUF,
- ARG_X,
- ARG_Y,
- ARG_WIDTH,
- ARG_HEIGHT,
- ARG_DRAWWIDTH,
- ARG_ANCHOR
+ PROP_0,
+ PROP_PIXBUF,
+ PROP_X,
+ PROP_Y,
+ PROP_WIDTH,
+ PROP_HEIGHT,
+ PROP_DRAWWIDTH,
+ PROP_ANCHOR
};
-static void gtk_canvas_imageframe_class_init(GtkCanvasImageFrameClass* class) ;
-static void gtk_canvas_imageframe_init(GtkCanvasImageFrame* image) ;
-static void gtk_canvas_imageframe_destroy(GtkObject* object) ;
-static void gtk_canvas_imageframe_set_arg(GtkObject* object, GtkArg* arg, guint arg_id) ;
-static void gtk_canvas_imageframe_get_arg(GtkObject* object, GtkArg* arg, guint arg_id) ;
-
-static void gtk_canvas_imageframe_update(GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags) ;
-static void gtk_canvas_imageframe_realize(GtkCanvasItem *item) ;
-static void gtk_canvas_imageframe_unrealize(GtkCanvasItem *item) ;
-static void gtk_canvas_imageframe_draw(GtkCanvasItem *item, GdkDrawable *drawable, int x, int y, int width, int height) ;
-static double gtk_canvas_imageframe_point(GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item) ;
-static void gtk_canvas_imageframe_translate(GtkCanvasItem *item, double dx, double dy) ;
-static void gtk_canvas_imageframe_bounds(GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2) ;
-static void gtk_canvas_imageframe_render(GtkCanvasItem *item, GtkCanvasBuf *buf) ;
-
-static GtkCanvasItemClass *parent_class;
-
-
-GtkType
-gtk_canvas_imageframe_get_type (void)
+static void gnome_canvas_imageframe_class_init(GnomeCanvasImageFrameClass* class) ;
+static void gnome_canvas_imageframe_init(GnomeCanvasImageFrame* image) ;
+static void gnome_canvas_imageframe_destroy(GtkObject* object) ;
+static void gnome_canvas_imageframe_set_property(GObject* object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gnome_canvas_imageframe_get_property(GObject* object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gnome_canvas_imageframe_update(GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags) ;
+static void gnome_canvas_imageframe_realize(GnomeCanvasItem *item) ;
+static void gnome_canvas_imageframe_unrealize(GnomeCanvasItem *item) ;
+static void gnome_canvas_imageframe_draw(GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int width, int height) ;
+static double gnome_canvas_imageframe_point(GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item) ;
+static void gnome_canvas_imageframe_bounds(GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2) ;
+static void gnome_canvas_imageframe_render(GnomeCanvasItem *item, GnomeCanvasBuf *buf) ;
+
+static GnomeCanvasItemClass *parent_class;
+
+
+GType
+gnome_canvas_imageframe_get_type (void)
{
- static GtkType imageframe_type = 0;
+ static GType imageframe_type = 0;
if (!imageframe_type) {
GtkTypeInfo imageframe_info = {
- "GtkCanvasImageFrame",
- sizeof (GtkCanvasImageFrame),
- sizeof (GtkCanvasImageFrameClass),
- (GtkClassInitFunc) gtk_canvas_imageframe_class_init,
- (GtkObjectInitFunc) gtk_canvas_imageframe_init,
+ "GnomeCanvasImageFrame",
+ sizeof (GnomeCanvasImageFrame),
+ sizeof (GnomeCanvasImageFrameClass),
+ (GtkClassInitFunc) gnome_canvas_imageframe_class_init,
+ (GtkObjectInitFunc) gnome_canvas_imageframe_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
- imageframe_type = gtk_type_unique (gtk_canvas_item_get_type (), &imageframe_info);
+ imageframe_type = gtk_type_unique (gnome_canvas_item_get_type (), &imageframe_info);
}
return imageframe_type;
}
static void
-gtk_canvas_imageframe_class_init (GtkCanvasImageFrameClass *class)
+gnome_canvas_imageframe_class_init (GnomeCanvasImageFrameClass *class)
{
+ GObjectClass *gobject_class;
GtkObjectClass *object_class;
- GtkCanvasItemClass *item_class;
+ GnomeCanvasItemClass *item_class;
+ gobject_class = (GObjectClass *) class;
object_class = (GtkObjectClass *) class;
- item_class = (GtkCanvasItemClass *) class;
-
- parent_class = gtk_type_class (gtk_canvas_item_get_type ());
-
- gtk_object_add_arg_type ("GtkCanvasImageFrame::pixbuf", GTK_TYPE_BOXED, GTK_ARG_WRITABLE, ARG_PIXBUF);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::x", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::y", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::width", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_WIDTH);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::drawwidth", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_DRAWWIDTH);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::height", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_HEIGHT);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, ARG_ANCHOR);
-
- object_class->destroy = gtk_canvas_imageframe_destroy;
- object_class->set_arg = gtk_canvas_imageframe_set_arg;
- object_class->get_arg = gtk_canvas_imageframe_get_arg;
-
- item_class->update = gtk_canvas_imageframe_update;
- item_class->realize = gtk_canvas_imageframe_realize;
- item_class->unrealize = gtk_canvas_imageframe_unrealize;
- item_class->draw = gtk_canvas_imageframe_draw;
- item_class->point = gtk_canvas_imageframe_point;
- item_class->translate = gtk_canvas_imageframe_translate;
- item_class->bounds = gtk_canvas_imageframe_bounds;
- item_class->render = gtk_canvas_imageframe_render;
+ item_class = (GnomeCanvasItemClass *) class;
+
+ parent_class = gtk_type_class (gnome_canvas_item_get_type ());
+
+ gobject_class->set_property = gnome_canvas_imageframe_set_property;
+ gobject_class->get_property = gnome_canvas_imageframe_get_property;
+
+ g_object_class_install_property (gobject_class,
+ PROP_PIXBUF,
+ g_param_spec_pointer ("pixbuf",
+ _("pixbuf"),
+ _("the pixbuf"),
+ G_PARAM_WRITABLE));
+ g_object_class_install_property (gobject_class,
+ PROP_X,
+ g_param_spec_double ("x",
+ _("x"),
+ _("x coordinate of upper left corner of rect"),
+ -G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ 0.0,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class,
+ PROP_Y,
+ g_param_spec_double ("y",
+ _("y"),
+ _("y coordinate of upper left corner of rect "),
+ -G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ 0.0,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_WIDTH,
+ g_param_spec_double ("width",
+ _("width"),
+ _("the width"),
+ -G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ 0.0,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class,
+ PROP_DRAWWIDTH,
+ g_param_spec_double ("drawwidth",
+ _("drawwidth"),
+ _("drawn width"),
+ -G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ 0.0,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_HEIGHT,
+ g_param_spec_double ("height",
+ _("height"),
+ _("the height"),
+ -G_MAXDOUBLE,
+ G_MAXDOUBLE,
+ 0.0,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_ANCHOR,
+ g_param_spec_enum ("anchor",
+ _("anchor"),
+ _("the anchor"),
+ GTK_TYPE_ANCHOR_TYPE,
+ GTK_ANCHOR_NW,
+ G_PARAM_READWRITE));
+
+ object_class->destroy = gnome_canvas_imageframe_destroy;
+
+ item_class->update = gnome_canvas_imageframe_update;
+ item_class->realize = gnome_canvas_imageframe_realize;
+ item_class->unrealize = gnome_canvas_imageframe_unrealize;
+ item_class->draw = gnome_canvas_imageframe_draw;
+ item_class->point = gnome_canvas_imageframe_point;
+ item_class->bounds = gnome_canvas_imageframe_bounds;
+ item_class->render = gnome_canvas_imageframe_render;
}
static void
-gtk_canvas_imageframe_init (GtkCanvasImageFrame *image)
+gnome_canvas_imageframe_init (GnomeCanvasImageFrame *image)
{
image->x = 0.0;
image->y = 0.0;
image->height = 0.0;
image->drawwidth = 0.0;
image->anchor = GTK_ANCHOR_CENTER;
- GTK_CANVAS_ITEM(image)->object.flags |= GTK_CANVAS_ITEM_NO_AUTO_REDRAW;
}
static void
-gtk_canvas_imageframe_destroy (GtkObject *object)
+gnome_canvas_imageframe_destroy (GtkObject *object)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_CANVAS_IS_CANVAS_IMAGEFRAME (object));
+ g_return_if_fail (GNOME_CANVAS_IS_CANVAS_IMAGEFRAME (object));
+
+ image = GNOME_CANVAS_IMAGEFRAME (object);
- image = GTK_CANVAS_IMAGEFRAME (object);
-
image->cwidth = 0;
image->cheight = 0;
/* Get's the image bounds expressed as item-relative coordinates. */
static void
-get_bounds_item_relative (GtkCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
+get_bounds_item_relative (GnomeCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
{
- GtkCanvasItem *item;
+ GnomeCanvasItem *item;
double x, y;
- item = GTK_CANVAS_ITEM (image);
+ item = GNOME_CANVAS_ITEM (image);
/* Get item coordinates */
}
static void
-get_bounds (GtkCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
+gnome_canvas_imageframe_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- GtkCanvasItem *item;
- double i2c[6];
- ArtDRect i_bbox, c_bbox;
-
- item = GTK_CANVAS_ITEM (image);
-
- gtk_canvas_item_i2c_affine (item, i2c);
-
- get_bounds_item_relative (image, &i_bbox.x0, &i_bbox.y0, &i_bbox.x1, &i_bbox.y1);
- art_drect_affine_transform (&c_bbox, &i_bbox, i2c);
-
- /* add a fudge factor */
- *px1 = c_bbox.x0 - 1;
- *py1 = c_bbox.y0 - 1;
- *px2 = c_bbox.x1 + 1;
- *py2 = c_bbox.y1 + 1;
-}
-
-/* deprecated */
-static void
-recalc_bounds (GtkCanvasImageFrame *image)
-{
- GtkCanvasItem *item;
-
- item = GTK_CANVAS_ITEM (image);
-
- get_bounds (image, &item->x1, &item->y1, &item->x2, &item->y2);
-
- item->x1 = image->cx;
- item->y1 = image->cy;
- item->x2 = image->cx + image->cwidth;
- item->y2 = image->cy + image->cheight;
-
- gtk_canvas_group_child_bounds (GTK_CANVAS_GROUP (item->parent), item);
-}
-
-static void
-gtk_canvas_imageframe_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
-{
- GtkCanvasItem *item;
- GtkCanvasImageFrame *image;
+ GnomeCanvasItem *item;
+ GnomeCanvasImageFrame *image;
int update;
int calc_bounds;
- item = GTK_CANVAS_ITEM (object);
- image = GTK_CANVAS_IMAGEFRAME (object);
+ item = GNOME_CANVAS_ITEM (object);
+ image = GNOME_CANVAS_IMAGEFRAME (object);
update = FALSE;
calc_bounds = FALSE;
- switch (arg_id) {
- case ARG_PIXBUF:
- if (item->canvas->aa && GTK_VALUE_BOXED (*arg)) {
+ switch (prop_id) {
+ case PROP_PIXBUF:
+ if (item->canvas->aa && g_value_get_pointer (value)) {
if (image->pixbuf != NULL)
art_pixbuf_free (image->pixbuf);
- image->pixbuf = GTK_VALUE_BOXED (*arg);
+ image->pixbuf = g_value_get_pointer (value);
}
update = TRUE;
break;
- case ARG_X:
- image->x = GTK_VALUE_DOUBLE (*arg);
+ case PROP_X:
+ image->x = g_value_get_double (value);
update = TRUE;
break;
- case ARG_Y:
- image->y = GTK_VALUE_DOUBLE (*arg);
+ case PROP_Y:
+ image->y = g_value_get_double (value);
update = TRUE;
break;
- case ARG_WIDTH:
- image->width = fabs (GTK_VALUE_DOUBLE (*arg));
+ case PROP_WIDTH:
+ image->width = fabs (g_value_get_double (value));
update = TRUE;
break;
- case ARG_HEIGHT:
- image->height = fabs (GTK_VALUE_DOUBLE (*arg));
+ case PROP_HEIGHT:
+ image->height = fabs (g_value_get_double (value));
update = TRUE;
break;
-
- case ARG_DRAWWIDTH:
- image->drawwidth = fabs (GTK_VALUE_DOUBLE (*arg));
+
+ case PROP_DRAWWIDTH:
+ image->drawwidth = fabs (g_value_get_double (value));
update = TRUE;
break;
- case ARG_ANCHOR:
- image->anchor = GTK_VALUE_ENUM (*arg);
+ case PROP_ANCHOR:
+ image->anchor = g_value_get_enum (value);
update = TRUE;
break;
break;
}
-#ifdef OLD_XFORM
if (update)
- (* GTK_CANVAS_ITEM_CLASS (item->object.klass)->update) (item, NULL, NULL, 0);
-
- if (calc_bounds)
- recalc_bounds (image);
-#else
- if (update)
- gtk_canvas_item_request_update (item);
-#endif
+ gnome_canvas_item_request_update (item);
}
static void
-gtk_canvas_imageframe_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_imageframe_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (object);
+ image = GNOME_CANVAS_IMAGEFRAME (object);
- switch (arg_id) {
+ switch (prop_id) {
- case ARG_X:
- GTK_VALUE_DOUBLE (*arg) = image->x;
+ case PROP_X:
+ g_value_set_double (value, image->x);
break;
- case ARG_Y:
- GTK_VALUE_DOUBLE (*arg) = image->y;
+ case PROP_Y:
+ g_value_set_double (value, image->y);
break;
- case ARG_WIDTH:
- GTK_VALUE_DOUBLE (*arg) = image->width;
+ case PROP_WIDTH:
+ g_value_set_double (value, image->width);
break;
- case ARG_HEIGHT:
- GTK_VALUE_DOUBLE (*arg) = image->height;
+ case PROP_HEIGHT:
+ g_value_set_double (value, image->height);
break;
-
- case ARG_DRAWWIDTH:
- GTK_VALUE_DOUBLE (*arg) = image->drawwidth;
+
+ case PROP_DRAWWIDTH:
+ g_value_set_double (value, image->drawwidth);
break;
- case ARG_ANCHOR:
- GTK_VALUE_ENUM (*arg) = image->anchor;
+ case PROP_ANCHOR:
+ g_value_set_enum (value, image->anchor);
break;
default:
- arg->type = GTK_TYPE_INVALID;
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
-gtk_canvas_imageframe_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_imageframe_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
ArtDRect i_bbox, c_bbox;
int w = 0;
int h = 0;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
image->need_recalc = TRUE ;
}
-#ifdef OLD_XFORM
- recalc_bounds (image);
-#else
get_bounds_item_relative (image, &i_bbox.x0, &i_bbox.y0, &i_bbox.x1, &i_bbox.y1);
art_drect_affine_transform (&c_bbox, &i_bbox, affine);
c_bbox.x1++;
c_bbox.y1++;
- gtk_canvas_update_bbox (item, c_bbox.x0, c_bbox.y0, c_bbox.x1, c_bbox.y1);
+ gnome_canvas_update_bbox (item, c_bbox.x0, c_bbox.y0, c_bbox.x1, c_bbox.y1);
if (image->pixbuf) {
w = image->pixbuf->width;
image->affine[3] = (affine[3] * image->height) / h;
image->affine[4] = i_bbox.x0 * affine[0] + i_bbox.y0 * affine[2] + affine[4];
image->affine[5] = i_bbox.x0 * affine[1] + i_bbox.y0 * affine[3] + affine[5];
-
-#endif
}
static void
-gtk_canvas_imageframe_realize (GtkCanvasItem *item)
+gnome_canvas_imageframe_realize (GnomeCanvasItem *item)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
if (parent_class->realize)
(* parent_class->realize) (item);
}
static void
-gtk_canvas_imageframe_unrealize (GtkCanvasItem *item)
+gnome_canvas_imageframe_unrealize (GnomeCanvasItem *item)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME(item);
+ image = GNOME_CANVAS_IMAGEFRAME(item);
if (parent_class->unrealize)
(* parent_class->unrealize) (item);
}
static void
-recalc_if_needed (GtkCanvasImageFrame *image)
+recalc_if_needed (GnomeCanvasImageFrame *image)
{}
static void
-gtk_canvas_imageframe_draw (GtkCanvasItem *item, GdkDrawable *drawable,
+gnome_canvas_imageframe_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
int x, int y, int width, int height)
{
- fprintf(stderr, "please don't use the CanvasImageFrame item in a non-aa Canvas\n") ;
- abort() ;
}
static double
-gtk_canvas_imageframe_point (GtkCanvasItem *item, double x, double y,
- int cx, int cy, GtkCanvasItem **actual_item)
+gnome_canvas_imageframe_point (GnomeCanvasItem *item, double x, double y,
+ int cx, int cy, GnomeCanvasItem **actual_item)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
int x1, y1, x2, y2;
int dx, dy;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
*actual_item = item;
}
static void
-gtk_canvas_imageframe_translate (GtkCanvasItem *item, double dx, double dy)
-{
-#ifdef OLD_XFORM
- GtkCanvasImageFrame *image;
-
- image = GTK_CANVAS_IMAGEFRAME (item);
-
- image->x += dx;
- image->y += dy;
-
- recalc_bounds (image);
-#endif
-}
-
-static void
-gtk_canvas_imageframe_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+gnome_canvas_imageframe_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
*x1 = image->x;
*y1 = image->y;
}
static void
-gtk_canvas_imageframe_render (GtkCanvasItem *item, GtkCanvasBuf *buf)
+gnome_canvas_imageframe_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
#ifdef VERBOSE
{
char str[128];
art_affine_to_string (str, image->affine);
- g_print ("gtk_canvas_imageframe_render %s\n", str);
+ g_print ("gnome_canvas_imageframe_render %s\n", str);
}
#endif
projects / ardour.git / blobdiff