X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fgtk-custom-ruler.c;h=797922f5639b3296bba965a7f6133ac72b767fc3;hb=549de1f298ad777febe201c6c50e2303a6ca0c4d;hp=4834be97f3bd973f7f7e63bb5caf2f1980062798;hpb=4b233612261e2d13ebbd1931f4d999c6da1451e9;p=ardour.git diff --git a/gtk2_ardour/gtk-custom-ruler.c b/gtk2_ardour/gtk-custom-ruler.c index 4834be97f3..797922f563 100644 --- a/gtk2_ardour/gtk-custom-ruler.c +++ b/gtk2_ardour/gtk-custom-ruler.c @@ -21,22 +21,25 @@ * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with - * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ /* modified by andreas meyer */ #include +#include "gettext.h" +#define _(Text) dgettext (PACKAGE,Text) + #include "gtk-custom-ruler.h" enum { - ARG_0, - ARG_LOWER, - ARG_UPPER, - ARG_POSITION, - ARG_MAX_SIZE, - ARG_SHOW_POSITION + PROP_0, + PROP_LOWER, + PROP_UPPER, + PROP_POSITION, + PROP_MAX_SIZE, + PROP_SHOW_POSITION }; static void gtk_custom_ruler_class_init (GtkCustomRulerClass * klass); @@ -46,12 +49,24 @@ static void gtk_custom_ruler_unrealize (GtkWidget * widget); static void gtk_custom_ruler_size_allocate (GtkWidget * widget, GtkAllocation * allocation); static gint gtk_custom_ruler_expose (GtkWidget * widget, GdkEventExpose * event); static void gtk_custom_ruler_make_pixmap (GtkCustomRuler * ruler); -static void gtk_custom_ruler_set_arg (GtkObject * object, GtkArg * arg, guint arg_id); -static void gtk_custom_ruler_get_arg (GtkObject * object, GtkArg * arg, guint arg_id); +static void gtk_custom_ruler_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void gtk_custom_ruler_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + static gint -default_metric_get_marks (GtkCustomRulerMark **marks, gulong lower, gulong upper, gint maxchars) +default_metric_get_marks (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars) { + (void) marks; + (void) lower; + (void) upper; + (void) maxchars; + return 0; } @@ -62,39 +77,46 @@ static const GtkCustomMetric default_metric = { static GtkWidgetClass *parent_class; -GtkType gtk_custom_ruler_get_type (void) +GType gtk_custom_ruler_get_type (void) { - static GtkType ruler_type = 0; - - if (!ruler_type) { - static const GtkTypeInfo ruler_info = { - "GtkCustomRuler", - sizeof (GtkCustomRuler), - sizeof (GtkCustomRulerClass), - (GtkClassInitFunc) gtk_custom_ruler_class_init, - (GtkObjectInitFunc) gtk_custom_ruler_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - ruler_type = gtk_type_unique (GTK_TYPE_WIDGET, &ruler_info); + static GType ruler_type = 0; + + if (!ruler_type) + { + static const GTypeInfo ruler_info = + { + sizeof (GtkCustomRulerClass), + (GBaseInitFunc) NULL, /* base_init */ + (GBaseFinalizeFunc) NULL, /* base_finalize */ + (GClassInitFunc) gtk_custom_ruler_class_init, + (GClassFinalizeFunc) NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GtkCustomRuler), + 0, /* n_preallocs */ + (GInstanceInitFunc) gtk_custom_ruler_init, + NULL /* value_table */ + }; + + ruler_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkCustomRuler", + &ruler_info, 0); } + return ruler_type; } static void gtk_custom_ruler_class_init (GtkCustomRulerClass * class) { - GtkObjectClass *object_class; + GObjectClass *gobject_class; GtkWidgetClass *widget_class; - object_class = (GtkObjectClass *) class; - widget_class = (GtkWidgetClass *) class; + gobject_class = (GObjectClass *) class; + widget_class = (GtkWidgetClass*) class; - parent_class = gtk_type_class (GTK_TYPE_WIDGET); + parent_class = g_type_class_peek_parent (class); - object_class->set_arg = gtk_custom_ruler_set_arg; - object_class->get_arg = gtk_custom_ruler_get_arg; + gobject_class->set_property = gtk_custom_ruler_set_property; + gobject_class->get_property = gtk_custom_ruler_get_property; widget_class->realize = gtk_custom_ruler_realize; widget_class->unrealize = gtk_custom_ruler_unrealize; @@ -104,11 +126,53 @@ gtk_custom_ruler_class_init (GtkCustomRulerClass * class) class->draw_ticks = NULL; class->draw_pos = NULL; - gtk_object_add_arg_type ("GtkCustomRuler::lower", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_LOWER); - gtk_object_add_arg_type ("GtkCustomRuler::upper", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_UPPER); - gtk_object_add_arg_type ("GtkCustomRuler::position", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_POSITION); - gtk_object_add_arg_type ("GtkCustomRuler::max_size", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_MAX_SIZE); - gtk_object_add_arg_type ("GtkCustomRuler::show_position", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_POSITION); + g_object_class_install_property (gobject_class, + PROP_LOWER, + g_param_spec_double ("lower", + _("Lower"), + _("Lower limit of ruler"), + -G_MAXDOUBLE, + G_MAXDOUBLE, + 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_UPPER, + g_param_spec_double ("upper", + _("Upper"), + _("Upper limit of ruler"), + -G_MAXDOUBLE, + G_MAXDOUBLE, + 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_POSITION, + g_param_spec_double ("position", + _("Position"), + _("Position of mark on the ruler"), + -G_MAXDOUBLE, + G_MAXDOUBLE, + 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_MAX_SIZE, + g_param_spec_double ("max_size", + _("Max Size"), + _("Maximum size of the ruler"), + -G_MAXDOUBLE, + G_MAXDOUBLE, + 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_SHOW_POSITION, + g_param_spec_boolean ("show_position", + _("Show Position"), + _("Draw current ruler position"), + TRUE, + G_PARAM_READWRITE)); } static void @@ -129,54 +193,68 @@ gtk_custom_ruler_init (GtkCustomRuler * ruler) } static void -gtk_custom_ruler_set_arg (GtkObject * object, GtkArg * arg, guint arg_id) +gtk_custom_ruler_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { - GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object); - - switch (arg_id) { - case ARG_LOWER: - gtk_custom_ruler_set_range (ruler, GTK_VALUE_ULONG (*arg), ruler->upper, ruler->position, ruler->max_size); - break; - case ARG_UPPER: - gtk_custom_ruler_set_range (ruler, ruler->lower, GTK_VALUE_ULONG (*arg), ruler->position, ruler->max_size); - break; - case ARG_POSITION: - gtk_custom_ruler_set_range (ruler, ruler->lower, ruler->upper, GTK_VALUE_ULONG (*arg), ruler->max_size); - break; - case ARG_MAX_SIZE: - gtk_custom_ruler_set_range (ruler, ruler->lower, ruler->upper, ruler->position, GTK_VALUE_ULONG (*arg)); - break; - case ARG_SHOW_POSITION: - // gtk_customer_ruler_set_show_position (ruler, GTK_VALUE_BOOL (*arg)); - break; - } + (void) pspec; + + GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object); + + switch (prop_id) + { + case PROP_LOWER: + gtk_custom_ruler_set_range (ruler, g_value_get_double (value), ruler->upper, + ruler->position, ruler->max_size); + break; + case PROP_UPPER: + gtk_custom_ruler_set_range (ruler, ruler->lower, g_value_get_double (value), + ruler->position, ruler->max_size); + break; + case PROP_POSITION: + gtk_custom_ruler_set_range (ruler, ruler->lower, ruler->upper, + g_value_get_double (value), ruler->max_size); + break; + case PROP_MAX_SIZE: + gtk_custom_ruler_set_range (ruler, ruler->lower, ruler->upper, + ruler->position, g_value_get_double (value)); + break; + case PROP_SHOW_POSITION: + gtk_custom_ruler_set_show_position (ruler, g_value_get_boolean (value)); + break; + } } static void -gtk_custom_ruler_get_arg (GtkObject * object, GtkArg * arg, guint arg_id) +gtk_custom_ruler_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { - GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object); - - switch (arg_id) { - case ARG_LOWER: - GTK_VALUE_ULONG (*arg) = ruler->lower; - break; - case ARG_UPPER: - GTK_VALUE_ULONG (*arg) = ruler->upper; - break; - case ARG_POSITION: - GTK_VALUE_ULONG (*arg) = ruler->position; - break; - case ARG_MAX_SIZE: - GTK_VALUE_ULONG (*arg) = ruler->max_size; - break; - case ARG_SHOW_POSITION: - GTK_VALUE_BOOL (*arg) = ruler->show_position; - break; - default: - arg->type = GTK_TYPE_INVALID; - break; - } + GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object); + + switch (prop_id) + { + case PROP_LOWER: + g_value_set_double (value, ruler->lower); + break; + case PROP_UPPER: + g_value_set_double (value, ruler->upper); + break; + case PROP_POSITION: + g_value_set_double (value, ruler->position); + break; + case PROP_MAX_SIZE: + g_value_set_double (value, ruler->max_size); + break; + case PROP_SHOW_POSITION: + g_value_set_boolean (value, ruler->show_position); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } } void @@ -195,42 +273,89 @@ gtk_custom_ruler_set_metric (GtkCustomRuler * ruler, GtkCustomMetric * metric) } void -gtk_custom_ruler_set_range (GtkCustomRuler * ruler, gulong lower, gulong upper, gulong position, gulong max_size) +gtk_custom_ruler_set_range (GtkCustomRuler *ruler, + gdouble lower, + gdouble upper, + gdouble position, + gdouble max_size) { - g_return_if_fail (ruler != NULL); - g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); - - ruler->lower = lower; - ruler->upper = upper; - ruler->position = position; - ruler->max_size = max_size; + g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); + + g_object_freeze_notify (G_OBJECT (ruler)); + if (ruler->lower != lower) + { + ruler->lower = lower; + g_object_notify (G_OBJECT (ruler), "lower"); + } + if (ruler->upper != upper) + { + ruler->upper = upper; + g_object_notify (G_OBJECT (ruler), "upper"); + } + if (ruler->position != position) + { + ruler->position = position; + g_object_notify (G_OBJECT (ruler), "position"); + } + if (ruler->max_size != max_size) + { + ruler->max_size = max_size; + g_object_notify (G_OBJECT (ruler), "max-size"); + } + g_object_thaw_notify (G_OBJECT (ruler)); + + if (GTK_WIDGET_DRAWABLE (ruler)) + gtk_widget_queue_draw (GTK_WIDGET (ruler)); +} - if (GTK_WIDGET_DRAWABLE (ruler)) - gtk_widget_queue_draw (GTK_WIDGET (ruler)); +/** + * gtk_custom_ruler_get_range: + * @ruler: a #GtkCustomRuler + * @lower: location to store lower limit of the ruler, or %NULL + * @upper: location to store upper limit of the ruler, or %NULL + * @position: location to store the current position of the mark on the ruler, or %NULL + * @max_size: location to store the maximum size of the ruler used when calculating + * the space to leave for the text, or %NULL. + * + * Retrieves values indicating the range and current position of a #GtkCustomRuler. + * See gtk_custom_ruler_set_range(). + **/ +void +gtk_custom_ruler_get_range (GtkCustomRuler *ruler, + gdouble *lower, + gdouble *upper, + gdouble *position, + gdouble *max_size) +{ + g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); + + if (lower) + *lower = ruler->lower; + if (upper) + *upper = ruler->upper; + if (position) + *position = ruler->position; + if (max_size) + *max_size = ruler->max_size; } void gtk_custom_ruler_draw_ticks (GtkCustomRuler * ruler) { - GtkCustomRulerClass *klass; - g_return_if_fail (ruler != NULL); - g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); + g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); + + if (GTK_CUSTOM_RULER_GET_CLASS (ruler)->draw_ticks) + GTK_CUSTOM_RULER_GET_CLASS (ruler)->draw_ticks (ruler); - klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT (ruler)); - if (klass->draw_ticks) - klass->draw_ticks (ruler); } void gtk_custom_ruler_draw_pos (GtkCustomRuler * ruler) { - GtkCustomRulerClass *klass; - g_return_if_fail (ruler != NULL); - g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); - - klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT (ruler)); - if (klass->draw_pos && ruler->show_position) - klass->draw_pos (ruler); + g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler)); + + if (GTK_CUSTOM_RULER_GET_CLASS (ruler)->draw_pos && ruler->show_position) + GTK_CUSTOM_RULER_GET_CLASS (ruler)->draw_pos (ruler); } static void @@ -269,43 +394,38 @@ gtk_custom_ruler_realize (GtkWidget * widget) } static void -gtk_custom_ruler_unrealize (GtkWidget * widget) +gtk_custom_ruler_unrealize (GtkWidget *widget) { - GtkCustomRuler *ruler; + GtkCustomRuler *ruler = GTK_CUSTOM_RULER (widget); - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_CUSTOM_RULER (widget)); + if (ruler->backing_store) + g_object_unref (ruler->backing_store); + if (ruler->non_gr_exp_gc) + g_object_unref (ruler->non_gr_exp_gc); - ruler = GTK_CUSTOM_RULER (widget); + ruler->backing_store = NULL; + ruler->non_gr_exp_gc = NULL; - if (ruler->backing_store) - gdk_pixmap_unref (ruler->backing_store); - if (ruler->non_gr_exp_gc) - gdk_gc_destroy (ruler->non_gr_exp_gc); - - ruler->backing_store = NULL; - ruler->non_gr_exp_gc = NULL; - - if (GTK_WIDGET_CLASS (parent_class)->unrealize) - (*GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); + if (GTK_WIDGET_CLASS (parent_class)->unrealize) + (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); } static void -gtk_custom_ruler_size_allocate (GtkWidget * widget, GtkAllocation * allocation) +gtk_custom_ruler_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) { - GtkCustomRuler *ruler; + GtkCustomRuler *ruler = GTK_CUSTOM_RULER (widget); - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_CUSTOM_RULER (widget)); - - ruler = GTK_CUSTOM_RULER (widget); - widget->allocation = *allocation; + widget->allocation = *allocation; - if (GTK_WIDGET_REALIZED (widget)) { - gdk_window_move_resize (widget->window, allocation->x, allocation->y, allocation->width, allocation->height); + if (GTK_WIDGET_REALIZED (widget)) + { + gdk_window_move_resize (widget->window, + allocation->x, allocation->y, + allocation->width, allocation->height); - gtk_custom_ruler_make_pixmap (ruler); - } + gtk_custom_ruler_make_pixmap (ruler); + } } static gint @@ -322,42 +442,49 @@ gtk_custom_ruler_expose (GtkWidget * widget, GdkEventExpose * event) gtk_custom_ruler_draw_ticks (ruler); - gdk_draw_pixmap (widget->window, - ruler->non_gr_exp_gc, - ruler->backing_store, 0, 0, 0, 0, widget->allocation.width, widget->allocation.height); - + gdk_draw_drawable (widget->window, + ruler->non_gr_exp_gc, + GDK_DRAWABLE(ruler->backing_store), 0, 0, 0, 0, widget->allocation.width, widget->allocation.height); + gtk_custom_ruler_draw_pos (ruler); } return FALSE; } + static void -gtk_custom_ruler_make_pixmap (GtkCustomRuler * ruler) +gtk_custom_ruler_make_pixmap (GtkCustomRuler *ruler) { - GtkWidget *widget; - gint width; - gint height; - - widget = GTK_WIDGET (ruler); - - if (ruler->backing_store) { - gdk_window_get_size (ruler->backing_store, &width, &height); - if ((width == widget->allocation.width) && (height == widget->allocation.height)) - return; - - gdk_pixmap_unref (ruler->backing_store); - } - - ruler->backing_store = gdk_pixmap_new (widget->window, widget->allocation.width, widget->allocation.height, -1); - - ruler->xsrc = 0; - ruler->ysrc = 0; - - if (!ruler->non_gr_exp_gc) { - ruler->non_gr_exp_gc = gdk_gc_new (widget->window); - gdk_gc_set_exposures (ruler->non_gr_exp_gc, FALSE); - } + GtkWidget *widget; + gint width; + gint height; + + widget = GTK_WIDGET (ruler); + + if (ruler->backing_store) + { + gdk_drawable_get_size (ruler->backing_store, &width, &height); + if ((width == widget->allocation.width) && + (height == widget->allocation.height)) + return; + + g_object_unref (ruler->backing_store); + } + + ruler->backing_store = gdk_pixmap_new (widget->window, + widget->allocation.width, + widget->allocation.height, + -1); + + ruler->xsrc = 0; + ruler->ysrc = 0; + + if (!ruler->non_gr_exp_gc) + { + ruler->non_gr_exp_gc = gdk_gc_new (widget->window); + gdk_gc_set_exposures (ruler->non_gr_exp_gc, FALSE); + } } void