smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-06 23:05:04 +01:00
Code Issues Projects Releases Wiki Activity

more gobject fixups

Browse source 
git-svn-id: svn://localhost/trunk/ardour2@127 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Nick Mainsbridge 2005-11-27 01:23:55 +00:00
parent 5c776da778
commit 52eba2ccbe
7 changed files with 278 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

182
gtk2_ardour/canvas-imageframe.c
View file

@ -18,28 +18,36 @@
#include "libart_lgpl/art_rgb_pixbuf_affine.h" #include "libart_lgpl/art_rgb_pixbuf_affine.h"
#include "canvas-imageframe.h" #include "canvas-imageframe.h"
#include <libgnomecanvas/gnome-canvas-util.h> #include <libgnomecanvas/gnome-canvas-util.h>
#include "gettext.h"
#define _(Text) dgettext (PACKAGE,Text)
//GTK2FIX //GTK2FIX
//#include <libgnomecanvas/gnome-canvastypebuiltins.h> //#include <libgnomecanvas/gnome-canvastypebuiltins.h>
enum { enum {
ARG_0, PROP_0,
ARG_PIXBUF, PROP_PIXBUF,
ARG_X, PROP_X,
ARG_Y, PROP_Y,
ARG_WIDTH, PROP_WIDTH,
ARG_HEIGHT, PROP_HEIGHT,
ARG_DRAWWIDTH, PROP_DRAWWIDTH,
ARG_ANCHOR PROP_ANCHOR
}; };
static void gnome_canvas_imageframe_class_init(GnomeCanvasImageFrameClass* class) ; static void gnome_canvas_imageframe_class_init(GnomeCanvasImageFrameClass* class) ;
static void gnome_canvas_imageframe_init(GnomeCanvasImageFrame* image) ; static void gnome_canvas_imageframe_init(GnomeCanvasImageFrame* image) ;
static void gnome_canvas_imageframe_destroy(GtkObject* object) ; static void gnome_canvas_imageframe_destroy(GtkObject* object) ;
static void gnome_canvas_imageframe_set_arg(GtkObject* object, GtkArg* arg, guint arg_id) ; static void gnome_canvas_imageframe_set_property(GObject* object,
static void gnome_canvas_imageframe_get_arg(GtkObject* object, GtkArg* arg, guint arg_id) ; 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_update(GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags) ;
static void gnome_canvas_imageframe_realize(GnomeCanvasItem *item) ; static void gnome_canvas_imageframe_realize(GnomeCanvasItem *item) ;
static void gnome_canvas_imageframe_unrealize(GnomeCanvasItem *item) ; static void gnome_canvas_imageframe_unrealize(GnomeCanvasItem *item) ;
@ -51,10 +59,10 @@ static void gnome_canvas_imageframe_render(GnomeCanvasItem *item, GnomeCanvasBuf
static GnomeCanvasItemClass *parent_class; static GnomeCanvasItemClass *parent_class;
GtkType GType
gnome_canvas_imageframe_get_type (void) gnome_canvas_imageframe_get_type (void)
{ {
static GtkType imageframe_type = 0; static GType imageframe_type = 0;
if (!imageframe_type) { if (!imageframe_type) {
GtkTypeInfo imageframe_info = { GtkTypeInfo imageframe_info = {
@ -77,25 +85,83 @@ gnome_canvas_imageframe_get_type (void)
static void static void
gnome_canvas_imageframe_class_init (GnomeCanvasImageFrameClass *class) gnome_canvas_imageframe_class_init (GnomeCanvasImageFrameClass *class)
{ {
GObjectClass *gobject_class;
GtkObjectClass *object_class; GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class; GnomeCanvasItemClass *item_class;
gobject_class = (GObjectClass *) class;
object_class = (GtkObjectClass *) class; object_class = (GtkObjectClass *) class;
item_class = (GnomeCanvasItemClass *) class; item_class = (GnomeCanvasItemClass *) class;
parent_class = gtk_type_class (gnome_canvas_item_get_type ()); parent_class = gtk_type_class (gnome_canvas_item_get_type ());
gtk_object_add_arg_type ("GnomeCanvasImageFrame::pixbuf", GTK_TYPE_BOXED, GTK_ARG_WRITABLE, ARG_PIXBUF); gobject_class->set_property = gnome_canvas_imageframe_set_property;
gtk_object_add_arg_type ("GnomeCanvasImageFrame::x", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X); gobject_class->get_property = gnome_canvas_imageframe_get_property;
gtk_object_add_arg_type ("GnomeCanvasImageFrame::y", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y);
gtk_object_add_arg_type ("GnomeCanvasImageFrame::width", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_WIDTH); g_object_class_install_property (gobject_class,
gtk_object_add_arg_type ("GnomeCanvasImageFrame::drawwidth", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_DRAWWIDTH); PROP_PIXBUF,
gtk_object_add_arg_type ("GnomeCanvasImageFrame::height", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_HEIGHT); g_param_spec_boxed ("pixbuf",
gtk_object_add_arg_type ("GnomeCanvasImageFrame::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, ARG_ANCHOR); _("pixbuf"),
_("the pixbuf"),
GDK_TYPE_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; object_class->destroy = gnome_canvas_imageframe_destroy;
object_class->set_arg = gnome_canvas_imageframe_set_arg;
object_class->get_arg = gnome_canvas_imageframe_get_arg;
item_class->update = gnome_canvas_imageframe_update; item_class->update = gnome_canvas_imageframe_update;
item_class->realize = gnome_canvas_imageframe_realize; item_class->realize = gnome_canvas_imageframe_realize;
@ -207,7 +273,10 @@ get_bounds_item_relative (GnomeCanvasImageFrame *image, double *px1, double *py1
} }
static void static void
gnome_canvas_imageframe_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) gnome_canvas_imageframe_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{ {
GnomeCanvasItem *item; GnomeCanvasItem *item;
GnomeCanvasImageFrame *image; GnomeCanvasImageFrame *image;
@ -220,43 +289,43 @@ gnome_canvas_imageframe_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
update = FALSE; update = FALSE;
calc_bounds = FALSE; calc_bounds = FALSE;
switch (arg_id) { switch (prop_id) {
case ARG_PIXBUF: case PROP_PIXBUF:
if (item->canvas->aa && GTK_VALUE_BOXED (*arg)) { if (item->canvas->aa && g_value_get_boxed (value)) {
if (image->pixbuf != NULL) if (image->pixbuf != NULL)
art_pixbuf_free (image->pixbuf); art_pixbuf_free (image->pixbuf);
image->pixbuf = GTK_VALUE_BOXED (*arg); image->pixbuf = g_value_get_boxed (value);
} }
update = TRUE; update = TRUE;
break; break;
case ARG_X: case PROP_X:
image->x = GTK_VALUE_DOUBLE (*arg); image->x = g_value_get_double (value);
update = TRUE; update = TRUE;
break; break;
case ARG_Y: case PROP_Y:
image->y = GTK_VALUE_DOUBLE (*arg); image->y = g_value_get_double (value);
update = TRUE; update = TRUE;
break; break;
case ARG_WIDTH: case PROP_WIDTH:
image->width = fabs (GTK_VALUE_DOUBLE (*arg)); image->width = fabs (g_value_get_double (value));
update = TRUE; update = TRUE;
break; break;
case ARG_HEIGHT: case PROP_HEIGHT:
image->height = fabs (GTK_VALUE_DOUBLE (*arg)); image->height = fabs (g_value_get_double (value));
update = TRUE; update = TRUE;
break; break;
case ARG_DRAWWIDTH: case PROP_DRAWWIDTH:
image->drawwidth = fabs (GTK_VALUE_DOUBLE (*arg)); image->drawwidth = fabs (g_value_get_double (value));
update = TRUE; update = TRUE;
break; break;
case ARG_ANCHOR: case PROP_ANCHOR:
image->anchor = GTK_VALUE_ENUM (*arg); image->anchor = g_value_get_enum (value);
update = TRUE; update = TRUE;
break; break;
@ -269,40 +338,43 @@ gnome_canvas_imageframe_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
} }
static void static void
gnome_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)
{ {
GnomeCanvasImageFrame *image; GnomeCanvasImageFrame *image;
image = GNOME_CANVAS_IMAGEFRAME (object); image = GNOME_CANVAS_IMAGEFRAME (object);
switch (arg_id) { switch (prop_id) {
case ARG_X: case PROP_X:
GTK_VALUE_DOUBLE (*arg) = image->x; g_value_set_double (value, image->x);
break; break;
case ARG_Y: case PROP_Y:
GTK_VALUE_DOUBLE (*arg) = image->y; g_value_set_double (value, image->y);
break; break;
case ARG_WIDTH: case PROP_WIDTH:
GTK_VALUE_DOUBLE (*arg) = image->width; g_value_set_double (value, image->width);
break; break;
case ARG_HEIGHT: case PROP_HEIGHT:
GTK_VALUE_DOUBLE (*arg) = image->height; g_value_set_double (value, image->height);
break; break;
case ARG_DRAWWIDTH: case PROP_DRAWWIDTH:
GTK_VALUE_DOUBLE (*arg) = image->drawwidth; g_value_set_double (value, image->drawwidth);
break; break;
case ARG_ANCHOR: case PROP_ANCHOR:
GTK_VALUE_ENUM (*arg) = image->anchor; g_value_set_enum (value, image->anchor);
break; break;
default: default:
arg->type = GTK_TYPE_INVALID; G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
} }
} }

203
gtk2_ardour/canvas-ruler.c
View file

@ -6,26 +6,27 @@
#include "rgb_macros.h" #include "rgb_macros.h"
enum { enum {
ARG_0, PROP_0,
ARG_X1, PROP_X1,
ARG_Y1, PROP_Y1,
ARG_X2, PROP_X2,
ARG_Y2, PROP_Y2,
ARG_FRAMES_PER_UNIT, PROP_FRAMES_PER_UNIT,
ARG_FILL_COLOR, PROP_FILL_COLOR,
ARG_TICK_COLOR PROP_TICK_COLOR
}; };
static void gnome_canvas_ruler_class_init (GnomeCanvasRulerClass *class); static void gnome_canvas_ruler_class_init (GnomeCanvasRulerClass *class);
static void gnome_canvas_ruler_init (GnomeCanvasRuler *ruler); static void gnome_canvas_ruler_init (GnomeCanvasRuler *ruler);
static void gnome_canvas_ruler_set_arg (GtkObject *object, static void gnome_canvas_ruler_set_arg (GObject *object,
GtkArg *arg, guint prop_id
guint arg_id); const GValue *value,
static void gnome_canvas_ruler_get_arg (GtkObject *object, GParamSpec *pspec);
GtkArg *arg, static void gnome_canvas_ruler_get_arg (GObject *object,
guint arg_id); guint prop_id
GValue *value,
GParamSpec *pspec);
static void gnome_canvas_ruler_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags); static void gnome_canvas_ruler_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
static void gnome_canvas_ruler_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2); static void gnome_canvas_ruler_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
static double gnome_canvas_ruler_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item); static double gnome_canvas_ruler_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
@ -64,22 +65,87 @@ gnome_canvas_ruler_class_init (GnomeCanvasRulerClass *class)
GtkObjectClass *object_class; GtkObjectClass *object_class;
GnomeCanvasItemClass *item_class; GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass *) class; object_class = G_OBJECT_CLASS (class);
item_class = (GnomeCanvasItemClass *) class; item_class = (GnomeCanvasItemClass *) class;
parent_class = gtk_type_class (gnome_canvas_item_get_type ()); parent_class = gtk_type_class (gnome_canvas_item_get_type ());
gtk_object_add_arg_type ("GnomeCanvasRuler::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1); object_class->set_property = gnome_canvas_ruler_set_property;
gtk_object_add_arg_type ("GnomeCanvasRuler::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1); object_class->get_property = gnome_canvas_ruler_get_property;
gtk_object_add_arg_type ("GnomeCanvasRuler::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
gtk_object_add_arg_type ("GnomeCanvasRuler::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
gtk_object_add_arg_type ("GnomeCanvasRuler::frames_per_unit", GTK_TYPE_LONG, GTK_ARG_READWRITE, ARG_FRAMES_PER_UNIT);
gtk_object_add_arg_type ("GnomeCanvasRuler::fill_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FILL_COLOR);
gtk_object_add_arg_type ("GnomeCanvasRuler::tick_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_TICK_COLOR);
object_class->set_arg = gnome_canvas_ruler_set_arg;
object_class->get_arg = gnome_canvas_ruler_get_arg;
g_object_class_install_property (object_class,
PROP_X1,
g_param_spec_double ("x1",
_("x1"),
_("x coordinate of upper left corner of rect"),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_Y1,
g_param_spec_double ("y1",
_("y1"),
_("y coordinate of upper left corner of rect "),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_X2,
g_param_spec_double ("x2",
_("x2"),
_("x coordinate of lower right corner of rect"),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_Y2,
g_param_spec_double ("y2",
_("y2"),
_("y coordinate of lower right corner of rect "),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FRAMES_PER_UNIT,
g_param_spec_long ("frames_per_unit",
_("frames_per_unit"),
_("frames_per_unit of ruler"),
-G_MAXLONG,
G_MAXLONG,
0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FILL_COLOR,
g_param_spec_uint ("fill_color",
_("fill color"),
_("color of fill"),
0,
G_MAXINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_TICK_COLOR,
g_param_spec_uint ("tick_color",
_("tick color"),
_("color of tick"),
0,
G_MAXINT,
0,
G_PARAM_READWRITE));
item_class->update = gnome_canvas_ruler_update; item_class->update = gnome_canvas_ruler_update;
item_class->bounds = gnome_canvas_ruler_bounds; item_class->bounds = gnome_canvas_ruler_bounds;
item_class->point = gnome_canvas_ruler_point; item_class->point = gnome_canvas_ruler_point;
@ -136,7 +202,10 @@ gnome_canvas_ruler_reset_bounds (GnomeCanvasItem *item)
*/ */
static void static void
gnome_canvas_ruler_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) gnome_canvas_ruler_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{ {
GnomeCanvasItem *item; GnomeCanvasItem *item;
GnomeCanvasRuler *ruler; GnomeCanvasRuler *ruler;
@ -149,52 +218,52 @@ gnome_canvas_ruler_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
redraw = FALSE; redraw = FALSE;
calc_bounds = FALSE; calc_bounds = FALSE;
switch (arg_id) { switch (prop_id) {
case ARG_X1: case PROP_X1:
if (ruler->x1 != GTK_VALUE_DOUBLE (*arg)) { if (ruler->x1 != g_value_get_double (value)) {
ruler->x1 = GTK_VALUE_DOUBLE (*arg); ruler->x1 = g_value_get_double (value);
calc_bounds = TRUE; calc_bounds = TRUE;
} }
break; break;
case ARG_Y1: case PROP_Y1:
if (ruler->y1 != GTK_VALUE_DOUBLE (*arg)) { if (ruler->y1 != g_value_get_double (value)) {
ruler->y1 = GTK_VALUE_DOUBLE (*arg); ruler->y1 = g_value_get_double (value);
calc_bounds = TRUE; calc_bounds = TRUE;
} }
break; break;
case ARG_X2: case PROP_X2:
if (ruler->x2 != GTK_VALUE_DOUBLE (*arg)) { if (ruler->x2 != g_value_get_double (value)) {
ruler->x2 = GTK_VALUE_DOUBLE (*arg); ruler->x2 = g_value_get_double (value);
calc_bounds = TRUE; calc_bounds = TRUE;
} }
break; break;
case ARG_Y2: case PROP_Y2:
if (ruler->y2 != GTK_VALUE_DOUBLE (*arg)) { if (ruler->y2 != g_value_get_double (value)) {
ruler->y2 = GTK_VALUE_DOUBLE (*arg); ruler->y2 = g_value_get_double (value);
calc_bounds = TRUE; calc_bounds = TRUE;
} }
break; break;
case ARG_FRAMES_PER_UNIT: case PROP_FRAMES_PER_UNIT:
if (ruler->frames_per_unit != GTK_VALUE_LONG(*arg)) { if (ruler->frames_per_unit != g_value_get_long(value)) {
ruler->frames_per_unit = GTK_VALUE_LONG(*arg); ruler->frames_per_unit = g_value_get_long(value);
redraw = TRUE; redraw = TRUE;
} }
break; break;
case ARG_FILL_COLOR: case PROP_FILL_COLOR:
if (ruler->fill_color != GTK_VALUE_INT(*arg)) { if (ruler->fill_color != g_value_get_uint(value)) {
ruler->fill_color = GTK_VALUE_INT(*arg); ruler->fill_color = g_value_get_uint(value);
redraw = TRUE; redraw = TRUE;
} }
break; break;
case ARG_TICK_COLOR: case PROP_TICK_COLOR:
if (ruler->tick_color != GTK_VALUE_INT(*arg)) { if (ruler->tick_color != g_value_get_uint(value)) {
ruler->tick_color = GTK_VALUE_INT(*arg); ruler->tick_color = g_value_get_uint(value);
redraw = TRUE; redraw = TRUE;
} }
break; break;
@ -214,33 +283,37 @@ gnome_canvas_ruler_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
} }
static void static void
gnome_canvas_ruler_get_arg (GtkObject *object, GtkArg *arg, guint arg_id) gnome_canvas_ruler_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{ {
GnomeCanvasRuler *ruler; GnomeCanvasRuler *ruler;
ruler = GNOME_CANVAS_RULER (object); ruler = GNOME_CANVAS_RULER (object);
switch (arg_id) { switch (prop_id) {
case ARG_X1: case PROP_X1:
GTK_VALUE_DOUBLE (*arg) = ruler->x1; g_value_set_double (value, ruler->x1);
break; break;
case ARG_Y1: case PROP_Y1:
GTK_VALUE_DOUBLE (*arg) = ruler->y1; g_value_set_double (value, ruler->y1);
break; break;
case ARG_X2: case PROP_X2:
GTK_VALUE_DOUBLE (*arg) = ruler->x2; g_value_set_double (value, ruler->x2);
break; break;
case ARG_Y2: case PROP_Y2:
GTK_VALUE_DOUBLE (*arg) = ruler->y2; g_value_set_double (value, ruler->y2);
break; break;
case ARG_FRAMES_PER_UNIT: case PROP_FRAMES_PER_UNIT:
GTK_VALUE_LONG (*arg) = ruler->frames_per_unit; g_value_set_long (value, ruler->frames_per_unit);
break; break;
case ARG_FILL_COLOR: case PROP_FILL_COLOR:
GTK_VALUE_INT (*arg) = ruler->fill_color; g_value_set_uint (value, ruler->fill_color);
break; break;
case ARG_TICK_COLOR: case PROP_TICK_COLOR:
GTK_VALUE_INT (*arg) = ruler->tick_color; g_value_set_uint (value, ruler->tick_color);
break; break;
default: default:
arg->type = GTK_TYPE_INVALID; arg->type = GTK_TYPE_INVALID;

2
gtk2_ardour/canvas-simplerect.c
View file

@ -484,6 +484,8 @@ gnome_canvas_simplerect_update (GnomeCanvasItem *item, double *affine, ArtSVP *c
GnomeCanvasSimpleRect *simplerect; GnomeCanvasSimpleRect *simplerect;
unsigned char foo; unsigned char foo;
g_return_if_fail (clip_path != NULL);
simplerect = GNOME_CANVAS_SIMPLERECT (item); simplerect = GNOME_CANVAS_SIMPLERECT (item);
if (parent_class->update) if (parent_class->update)

2
gtk2_ardour/gtk-custom-hruler.c
View file

@ -44,7 +44,7 @@ static gint gtk_custom_hruler_motion_notify (GtkWidget * widget, GdkEventMotion
static void gtk_custom_hruler_draw_ticks (GtkCustomRuler * ruler); static void gtk_custom_hruler_draw_ticks (GtkCustomRuler * ruler);
static void gtk_custom_hruler_draw_pos (GtkCustomRuler * ruler); static void gtk_custom_hruler_draw_pos (GtkCustomRuler * ruler);
guint gtk_custom_hruler_get_type (void) GType gtk_custom_hruler_get_type (void)
{ {
static GType hruler_type = 0; static GType hruler_type = 0;

2
gtk2_ardour/gtk-custom-hruler.h
View file

@ -56,7 +56,7 @@ struct _GtkCustomHRulerClass
}; };
guint gtk_custom_hruler_get_type (void); GType gtk_custom_hruler_get_type (void);
GtkWidget* gtk_custom_hruler_new (void); GtkWidget* gtk_custom_hruler_new (void);

16
gtk2_ardour/gtk-custom-ruler.c
View file

@ -72,7 +72,7 @@ static const GtkCustomMetric default_metric = {
static GtkWidgetClass *parent_class; static GtkWidgetClass *parent_class;
GtkType gtk_custom_ruler_get_type (void) GType gtk_custom_ruler_get_type (void)
{ {
static GType ruler_type = 0; static GType ruler_type = 0;
@ -81,10 +81,10 @@ GtkType gtk_custom_ruler_get_type (void)
static const GTypeInfo ruler_info = static const GTypeInfo ruler_info =
{ {
sizeof (GtkCustomRulerClass), sizeof (GtkCustomRulerClass),
NULL, /* base_init */ (GBaseInitFunc) NULL, /* base_init */
NULL, /* base_finalize */ (GBaseFinalizeFunc) NULL, /* base_finalize */
(GClassInitFunc) gtk_custom_ruler_class_init, (GClassInitFunc) gtk_custom_ruler_class_init,
NULL, /* class_finalize */ (GClassFinalizeFunc) NULL, /* class_finalize */
NULL, /* class_data */ NULL, /* class_data */
sizeof (GtkCustomRuler), sizeof (GtkCustomRuler),
0, /* n_preallocs */ 0, /* n_preallocs */
@ -104,7 +104,7 @@ gtk_custom_ruler_class_init (GtkCustomRulerClass * class)
GObjectClass *gobject_class; GObjectClass *gobject_class;
GtkWidgetClass *widget_class; GtkWidgetClass *widget_class;
gobject_class = G_OBJECT_CLASS (class); gobject_class = (GObjectClass *) class;
widget_class = (GtkWidgetClass*) class; widget_class = (GtkWidgetClass*) class;
parent_class = g_type_class_peek_parent (class); parent_class = g_type_class_peek_parent (class);
@ -334,11 +334,11 @@ gtk_custom_ruler_get_range (GtkCustomRuler *ruler,
void void
gtk_custom_ruler_draw_ticks (GtkCustomRuler * ruler) gtk_custom_ruler_draw_ticks (GtkCustomRuler * ruler)
{ {
GtkCustomRulerClass *klass; GtkCustomRulerClass *klass;
g_return_if_fail (ruler != NULL); g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler));
klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT (ruler)); klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT_CLASS (ruler));
if (klass->draw_ticks) if (klass->draw_ticks)
klass->draw_ticks (ruler); klass->draw_ticks (ruler);
} }
@ -350,7 +350,7 @@ gtk_custom_ruler_draw_pos (GtkCustomRuler * ruler)
g_return_if_fail (ruler != NULL); g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler));
klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT (ruler)); klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT_CLASS (ruler));
if (klass->draw_pos && ruler->show_position) if (klass->draw_pos && ruler->show_position)
klass->draw_pos (ruler); klass->draw_pos (ruler);
} }

2
gtk2_ardour/gtk-custom-ruler.h
View file

@ -91,7 +91,7 @@ struct _GtkCustomMetric {
gint (* get_marks) (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars); gint (* get_marks) (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars);
}; };
GtkType gtk_custom_ruler_get_type (void); GType gtk_custom_ruler_get_type (void);
void gtk_custom_ruler_set_metric (GtkCustomRuler *ruler, GtkCustomMetric *metric); void gtk_custom_ruler_set_metric (GtkCustomRuler *ruler, GtkCustomMetric *metric);
void gtk_custom_ruler_set_range (GtkCustomRuler *ruler, void gtk_custom_ruler_set_range (GtkCustomRuler *ruler,
gdouble lower, gdouble lower,