# HG changeset patch # User Matti Hamalainen # Date 1131515521 0 # Node ID df6f12a00305fc9cb522adae46c2948b934674bf # Parent 4611f11949414a5d94dfb9a4799d9935893b1d3e Work on filter curve widget begins, based on GtkCurve widget from Gtk+ 1.2.10. diff -r 4611f1194941 -r df6f12a00305 src/xs_config.c --- a/src/xs_config.c Wed Nov 09 05:22:05 2005 +0000 +++ b/src/xs_config.c Wed Nov 09 05:52:01 2005 +0000 @@ -26,6 +26,7 @@ #include "xs_glade.h" #include "xs_interface.h" #include "xs_support.h" +#include "xs_curve.h" /* * Global widgets @@ -806,15 +807,15 @@ void xs_cfg_filter2_reset(GtkButton * button, gpointer user_data) { gfloat cv[] = { 0, 0, 25, 25, 50, 50, 75, 50, 85, 55, 100, 100 }; - GtkCurve *c = GTK_CURVE(LUW("cfg_filter2_curve")); + XSCurve *c = XS_CURVE(LUW("cfg_filter2_curve")); (void) button; (void) user_data; - gtk_curve_set_range(c, 0, 256, 0, 256); - gtk_curve_set_vector(c, 6, cv); + xs_curve_set_range(c, 0, 256, 0, 256); + xs_curve_set_vector(c, 6, cv); /* - gtk_curve_set_curve_type(c, GTK_CURVE_TYPE_SPLINE); + xs_curve_set_curve_type(c, GTK_CURVE_TYPE_SPLINE); */ } @@ -837,7 +838,7 @@ xs_configwin = create_xs_configwin(); /* Create the custom filter curve widget for libSIDPlay2 */ - c = gtk_curve_new(); + c = xs_curve_new(); gtk_widget_set_name(c, "cfg_filter2_curve"); gtk_widget_ref(c); diff -r 4611f1194941 -r df6f12a00305 src/xs_curve.c --- a/src/xs_curve.c Wed Nov 09 05:22:05 2005 +0000 +++ b/src/xs_curve.c Wed Nov 09 05:52:01 2005 +0000 @@ -32,10 +32,7 @@ #include #include #include -/* -#include -#include -*/ + #define RADIUS 3 /* radius of the control points */ #define MIN_DISTANCE 8 /* min distance between control points */ @@ -63,25 +60,25 @@ /* forward declarations: */ -static void gtk_curve_class_init(GtkCurveClass * class); -static void gtk_curve_init(GtkCurve * curve); -static void gtk_curve_set_arg(GtkObject * object, GtkArg * arg, guint arg_id); -static void gtk_curve_get_arg(GtkObject * object, GtkArg * arg, guint arg_id); -static void gtk_curve_finalize(GtkObject * object); -static gint gtk_curve_graph_events(GtkWidget * widget, GdkEvent * event, GtkCurve * c); -static void gtk_curve_size_graph(GtkCurve * curve); +static void xs_curve_class_init(XSCurveClass * class); +static void xs_curve_init(XSCurve * curve); +static void xs_curve_set_arg(GtkObject * object, GtkArg * arg, guint arg_id); +static void xs_curve_get_arg(GtkObject * object, GtkArg * arg, guint arg_id); +static void xs_curve_finalize(GtkObject * object); +static gint xs_curve_graph_events(GtkWidget * widget, GdkEvent * event, XSCurve * c); +static void xs_curve_size_graph(XSCurve * curve); -GtkType gtk_curve_get_type(void) +GtkType xs_curve_get_type(void) { static GtkType curve_type = 0; if (!curve_type) { static const GtkTypeInfo curve_info = { - "GtkCurve", - sizeof(GtkCurve), - sizeof(GtkCurveClass), - (GtkClassInitFunc) gtk_curve_class_init, - (GtkObjectInitFunc) gtk_curve_init, + "XSCurve", + sizeof(XSCurve), + sizeof(XSCurveClass), + (GtkClassInitFunc) xs_curve_class_init, + (GtkObjectInitFunc) xs_curve_init, /* reserved_1 */ NULL, /* reserved_2 */ NULL, (GtkClassInitFunc) NULL, @@ -92,7 +89,7 @@ return curve_type; } -static void gtk_curve_class_init(GtkCurveClass * class) +static void xs_curve_class_init(XSCurveClass * class) { GtkObjectClass *object_class; @@ -100,24 +97,24 @@ object_class = (GtkObjectClass *) class; - object_class->set_arg = gtk_curve_set_arg; - object_class->get_arg = gtk_curve_get_arg; - object_class->finalize = gtk_curve_finalize; + object_class->set_arg = xs_curve_set_arg; + object_class->get_arg = xs_curve_get_arg; + object_class->finalize = xs_curve_finalize; curve_type_changed_signal = gtk_signal_new("curve_type_changed", GTK_RUN_FIRST, object_class->type, - GTK_SIGNAL_OFFSET(GtkCurveClass, curve_type_changed), + GTK_SIGNAL_OFFSET(XSCurveClass, curve_type_changed), gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0); gtk_object_class_add_signals(object_class, &curve_type_changed_signal, 1); - gtk_object_add_arg_type("GtkCurve::curve_type", GTK_TYPE_CURVE_TYPE, GTK_ARG_READWRITE, ARG_CURVE_TYPE); - gtk_object_add_arg_type("GtkCurve::min_x", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MIN_X); - gtk_object_add_arg_type("GtkCurve::max_x", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MAX_X); - gtk_object_add_arg_type("GtkCurve::min_y", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MIN_Y); - gtk_object_add_arg_type("GtkCurve::max_y", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MAX_Y); + gtk_object_add_arg_type("XSCurve::curve_type", GTK_TYPE_CURVE_TYPE, GTK_ARG_READWRITE, ARG_CURVE_TYPE); + gtk_object_add_arg_type("XSCurve::min_x", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MIN_X); + gtk_object_add_arg_type("XSCurve::max_x", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MAX_X); + gtk_object_add_arg_type("XSCurve::min_y", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MIN_Y); + gtk_object_add_arg_type("XSCurve::max_y", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_MAX_Y); } -static void gtk_curve_init(GtkCurve * curve) +static void xs_curve_init(XSCurve * curve) { gint old_mask; @@ -140,36 +137,36 @@ old_mask = gtk_widget_get_events(GTK_WIDGET(curve)); gtk_widget_set_events(GTK_WIDGET(curve), old_mask | GRAPH_MASK); - gtk_signal_connect(GTK_OBJECT(curve), "event", (GtkSignalFunc) gtk_curve_graph_events, curve); - gtk_curve_size_graph(curve); + gtk_signal_connect(GTK_OBJECT(curve), "event", (GtkSignalFunc) xs_curve_graph_events, curve); + xs_curve_size_graph(curve); } -static void gtk_curve_set_arg(GtkObject * object, GtkArg * arg, guint arg_id) +static void xs_curve_set_arg(GtkObject * object, GtkArg * arg, guint arg_id) { - GtkCurve *curve = GTK_CURVE(object); + XSCurve *curve = XS_CURVE(object); switch (arg_id) { case ARG_CURVE_TYPE: - gtk_curve_set_curve_type(curve, GTK_VALUE_ENUM(*arg)); + xs_curve_set_curve_type(curve, GTK_VALUE_ENUM(*arg)); break; case ARG_MIN_X: - gtk_curve_set_range(curve, GTK_VALUE_FLOAT(*arg), curve->max_x, curve->min_y, curve->max_y); + xs_curve_set_range(curve, GTK_VALUE_FLOAT(*arg), curve->max_x, curve->min_y, curve->max_y); break; case ARG_MAX_X: - gtk_curve_set_range(curve, curve->min_x, GTK_VALUE_FLOAT(*arg), curve->min_y, curve->max_y); + xs_curve_set_range(curve, curve->min_x, GTK_VALUE_FLOAT(*arg), curve->min_y, curve->max_y); break; case ARG_MIN_Y: - gtk_curve_set_range(curve, curve->min_x, curve->max_x, GTK_VALUE_FLOAT(*arg), curve->max_y); + xs_curve_set_range(curve, curve->min_x, curve->max_x, GTK_VALUE_FLOAT(*arg), curve->max_y); break; case ARG_MAX_Y: - gtk_curve_set_range(curve, curve->min_x, curve->max_x, curve->min_y, GTK_VALUE_FLOAT(*arg)); + xs_curve_set_range(curve, curve->min_x, curve->max_x, curve->min_y, GTK_VALUE_FLOAT(*arg)); break; } } -static void gtk_curve_get_arg(GtkObject * object, GtkArg * arg, guint arg_id) +static void xs_curve_get_arg(GtkObject * object, GtkArg * arg, guint arg_id) { - GtkCurve *curve = GTK_CURVE(object); + XSCurve *curve = XS_CURVE(object); switch (arg_id) { case ARG_CURVE_TYPE: @@ -255,14 +252,14 @@ return a * y[k_lo] + b * y[k_hi] + ((a * a * a - a) * y2[k_lo] + (b * b * b - b) * y2[k_hi]) * (h * h) / 6.0; } -static void gtk_curve_interpolate(GtkCurve * c, gint width, gint height) +static void xs_curve_interpolate(XSCurve * c, gint width, gint height) { gfloat *vector; int i; vector = g_malloc(width * sizeof(vector[0])); - gtk_curve_get_vector(c, width, vector); + xs_curve_get_vector(c, width, vector); c->height = height; if (c->num_points != width) { @@ -280,7 +277,7 @@ g_free(vector); } -static void gtk_curve_draw(GtkCurve * c, gint width, gint height) +static void xs_curve_draw(XSCurve * c, gint width, gint height) { GtkStateType state; GtkStyle *style; @@ -290,7 +287,7 @@ return; if (c->height != height || c->num_points != width) - gtk_curve_interpolate(c, width, height); + xs_curve_interpolate(c, width, height); state = GTK_STATE_NORMAL; if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(c))) @@ -323,11 +320,12 @@ /* draw a bullet: */ gdk_draw_arc(c->pixmap, style->fg_gc[state], TRUE, x, y, RADIUS * 2, RADIUS * 2, 0, 360 * 64); } + gdk_draw_pixmap(GTK_WIDGET(c)->window, style->fg_gc[state], c->pixmap, 0, 0, 0, 0, width + RADIUS * 2, height + RADIUS * 2); } -static gint gtk_curve_graph_events(GtkWidget * widget, GdkEvent * event, GtkCurve * c) +static gint xs_curve_graph_events(GtkWidget * widget, GdkEvent * event, XSCurve * c) { GdkCursorType new_type = c->cursor_type; gint i, src, dst, leftbound, rightbound; @@ -373,7 +371,7 @@ case GDK_EXPOSE: if (!c->pixmap) c->pixmap = gdk_pixmap_new(w->window, w->allocation.width, w->allocation.height, -1); - gtk_curve_draw(c, width, height); + xs_curve_draw(c, width, height); break; case GDK_BUTTON_PRESS: @@ -401,7 +399,7 @@ c->ctlpoint[c->grab_point][0] = unproject(x, min_x, c->max_x, width); c->ctlpoint[c->grab_point][1] = unproject(height - y, c->min_y, c->max_y, height); - gtk_curve_interpolate(c, width, height); + xs_curve_interpolate(c, width, height); break; case GTK_CURVE_TYPE_FREE: @@ -411,7 +409,7 @@ c->last = y; break; } - gtk_curve_draw(c, width, height); + xs_curve_draw(c, width, height); break; case GDK_BUTTON_RELEASE: @@ -431,8 +429,8 @@ c->num_ctlpoints = 1; c->ctlpoint[0][0] = min_x; c->ctlpoint[0][1] = c->min_y; - gtk_curve_interpolate(c, width, height); - gtk_curve_draw(c, width, height); + xs_curve_interpolate(c, width, height); + xs_curve_draw(c, width, height); } c->ctlpoint = g_realloc(c->ctlpoint, c->num_ctlpoints * sizeof(*c->ctlpoint)); } @@ -474,8 +472,8 @@ c->ctlpoint[c->grab_point][0] = rx; c->ctlpoint[c->grab_point][1] = ry; } - gtk_curve_interpolate(c, width, height); - gtk_curve_draw(c, width, height); + xs_curve_interpolate(c, width, height); + xs_curve_draw(c, width, height); } break; @@ -503,7 +501,7 @@ } c->grab_point = x; c->last = y; - gtk_curve_draw(c, width, height); + xs_curve_draw(c, width, height); } if (mevent->state & GDK_BUTTON1_MASK) new_type = GDK_TCROSS; @@ -528,7 +526,7 @@ return FALSE; } -void gtk_curve_set_curve_type(GtkCurve * c, GtkCurveType new_type) +void xs_curve_set_curve_type(XSCurve * c, GtkCurveType new_type) { gfloat rx, dx; gint x, i; @@ -540,7 +538,7 @@ height = GTK_WIDGET(c)->allocation.height - RADIUS * 2; if (new_type == GTK_CURVE_TYPE_FREE) { - gtk_curve_interpolate(c, width, height); + xs_curve_interpolate(c, width, height); c->curve_type = new_type; } else if (c->curve_type == GTK_CURVE_TYPE_FREE) { if (c->ctlpoint) @@ -558,17 +556,17 @@ unproject(RADIUS + height - c->point[x].y, c->min_y, c->max_y, height); } c->curve_type = new_type; - gtk_curve_interpolate(c, width, height); + xs_curve_interpolate(c, width, height); } else { c->curve_type = new_type; - gtk_curve_interpolate(c, width, height); + xs_curve_interpolate(c, width, height); } gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal); - gtk_curve_draw(c, width, height); + xs_curve_draw(c, width, height); } } -static void gtk_curve_size_graph(GtkCurve * curve) +static void xs_curve_size_graph(XSCurve * curve) { gint width, height; gfloat aspect; @@ -589,7 +587,7 @@ gtk_drawing_area_size(GTK_DRAWING_AREA(curve), width + RADIUS * 2, height + RADIUS * 2); } -static void gtk_curve_reset_vector(GtkCurve * curve) +static void xs_curve_reset_vector(XSCurve * curve) { if (curve->ctlpoint) g_free(curve->ctlpoint); @@ -609,27 +607,27 @@ if (curve->curve_type == GTK_CURVE_TYPE_FREE) { curve->curve_type = GTK_CURVE_TYPE_LINEAR; - gtk_curve_interpolate(curve, width, height); + xs_curve_interpolate(curve, width, height); curve->curve_type = GTK_CURVE_TYPE_FREE; } else - gtk_curve_interpolate(curve, width, height); - gtk_curve_draw(curve, width, height); + xs_curve_interpolate(curve, width, height); + xs_curve_draw(curve, width, height); } } -void gtk_curve_reset(GtkCurve * c) +void xs_curve_reset(XSCurve * c) { GtkCurveType old_type; old_type = c->curve_type; c->curve_type = GTK_CURVE_TYPE_SPLINE; - gtk_curve_reset_vector(c); + xs_curve_reset_vector(c); if (old_type != GTK_CURVE_TYPE_SPLINE) gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal); } -void gtk_curve_set_gamma(GtkCurve * c, gfloat gamma) +void xs_curve_set_gamma(XSCurve * c, gfloat gamma) { gfloat x, one_over_gamma, height, one_over_width; GtkCurveType old_type; @@ -656,21 +654,21 @@ if (old_type != GTK_CURVE_TYPE_FREE) gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal); - gtk_curve_draw(c, c->num_points, c->height); + xs_curve_draw(c, c->num_points, c->height); } -void gtk_curve_set_range(GtkCurve * curve, gfloat min_x, gfloat max_x, gfloat min_y, gfloat max_y) +void xs_curve_set_range(XSCurve * curve, gfloat min_x, gfloat max_x, gfloat min_y, gfloat max_y) { curve->min_x = min_x; curve->max_x = max_x; curve->min_y = min_y; curve->max_y = max_y; - gtk_curve_size_graph(curve); - gtk_curve_reset_vector(curve); + xs_curve_size_graph(curve); + xs_curve_reset_vector(curve); } -void gtk_curve_set_vector(GtkCurve * c, int veclen, gfloat vector[]) +void xs_curve_set_vector(XSCurve * c, int veclen, gfloat vector[]) { GtkCurveType old_type; gfloat rx, dx, ry; @@ -705,10 +703,10 @@ if (old_type != GTK_CURVE_TYPE_FREE) gtk_signal_emit(GTK_OBJECT(c), curve_type_changed_signal); - gtk_curve_draw(c, c->num_points, height); + xs_curve_draw(c, c->num_points, height); } -void gtk_curve_get_vector(GtkCurve * c, int veclen, gfloat vector[]) +void xs_curve_get_vector(XSCurve * c, int veclen, gfloat vector[]) { gfloat rx, ry, dx, dy, min_x, delta_x, *mem, *xv, *yv, *y2v, prev; gint dst, i, x, next, num_active_ctlpoints = 0, first_active = -1; @@ -815,19 +813,19 @@ } } -GtkWidget *gtk_curve_new(void) +GtkWidget *xs_curve_new(void) { - return gtk_type_new(gtk_curve_get_type()); + return gtk_type_new(xs_curve_get_type()); } -static void gtk_curve_finalize(GtkObject * object) +static void xs_curve_finalize(GtkObject * object) { - GtkCurve *curve; + XSCurve *curve; g_return_if_fail(object != NULL); - g_return_if_fail(GTK_IS_CURVE(object)); + g_return_if_fail(XS_IS_CURVE(object)); - curve = GTK_CURVE(object); + curve = XS_CURVE(object); if (curve->pixmap) gdk_pixmap_unref(curve->pixmap); if (curve->point) diff -r 4611f1194941 -r df6f12a00305 src/xs_curve.h --- a/src/xs_curve.h Wed Nov 09 05:22:05 2005 +0000 +++ b/src/xs_curve.h Wed Nov 09 05:52:01 2005 +0000 @@ -1,53 +1,26 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library 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 - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -/* - * 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/. - */ - -#ifndef __GTK_CURVE_H__ -#define __GTK_CURVE_H__ - +#ifndef _XS_CURVE_H +#define _XS_CURVE_H #include #include #ifdef __cplusplus extern "C" { -#endif /* __cplusplus */ +#endif -#define GTK_TYPE_CURVE (gtk_curve_get_type ()) -#define GTK_CURVE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CURVE, GtkCurve)) -#define GTK_CURVE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CURVE, GtkCurveClass)) -#define GTK_IS_CURVE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CURVE)) -#define GTK_IS_CURVE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CURVE)) +#define XS_TYPE_CURVE (xs_curve_get_type ()) +#define XS_CURVE(obj) (GTK_CHECK_CAST ((obj), XS_TYPE_CURVE, XSCurve)) +#define XS_CURVE_CLASS(luokka) (GTK_CHECK_CLASS_CAST ((luokka), XS_TYPE_CURVE, XSCurveClass)) +#define XS_IS_CURVE(obj) (GTK_CHECK_TYPE ((obj), XS_TYPE_CURVE)) +#define XS_IS_CURVE_CLASS(luokka) (GTK_CHECK_CLASS_TYPE ((luokka), XS_TYPE_CURVE)) -typedef struct _GtkCurve GtkCurve; -typedef struct _GtkCurveClass GtkCurveClass; +typedef struct _XSCurve XSCurve; +typedef struct _XSCurveClass XSCurveClass; -struct _GtkCurve +struct _XSCurve { GtkDrawingArea graph; @@ -71,31 +44,30 @@ gfloat (*ctlpoint)[2]; /* array of control points */ }; -struct _GtkCurveClass +struct _XSCurveClass { GtkDrawingAreaClass parent_class; - void (* curve_type_changed) (GtkCurve *curve); + void (* curve_type_changed) (XSCurve *curve); }; -GtkType gtk_curve_get_type (void); -GtkWidget* gtk_curve_new (void); -void gtk_curve_reset (GtkCurve *curve); -void gtk_curve_set_gamma (GtkCurve *curve, gfloat gamma); -void gtk_curve_set_range (GtkCurve *curve, +GtkType xs_curve_get_type (void); +GtkWidget* xs_curve_new (void); +void xs_curve_reset (XSCurve *curve); +void xs_curve_set_gamma (XSCurve *curve, gfloat gamma); +void xs_curve_set_range (XSCurve *curve, gfloat min_x, gfloat max_x, gfloat min_y, gfloat max_y); -void gtk_curve_get_vector (GtkCurve *curve, +void xs_curve_get_vector (XSCurve *curve, int veclen, gfloat vector[]); -void gtk_curve_set_vector (GtkCurve *curve, +void xs_curve_set_vector (XSCurve *curve, int veclen, gfloat vector[]); -void gtk_curve_set_curve_type (GtkCurve *curve, GtkCurveType type); +void xs_curve_set_curve_type (XSCurve *curve, GtkCurveType type); #ifdef __cplusplus } -#endif /* __cplusplus */ +#endif - -#endif /* __GTK_CURVE_H__ */ +#endif /* _XS_CURVE_H */