--- a/src/xs_curve.c	Wed Apr 02 21:29:26 2008 +0300
+++ b/src/xs_curve.c	Wed Apr 02 22:10:05 2008 +0300
@@ -33,29 +33,29 @@
 #include <gtk/gtksignal.h>
 
 
-#define RADIUS		3	/* radius of the control points */
-#define RADIUS2		(RADIUS * 2)
-#define MIN_DISTANCE	7	/* min distance between control points */
+#define RADIUS        3    /* radius of the control points */
+#define RADIUS2        (RADIUS * 2)
+#define MIN_DISTANCE    7    /* min distance between control points */
 
 
-#define GRAPH_MASK	(GDK_EXPOSURE_MASK |		\
-			GDK_POINTER_MOTION_MASK |	\
-			GDK_POINTER_MOTION_HINT_MASK |	\
-			GDK_ENTER_NOTIFY_MASK |		\
-			GDK_BUTTON_PRESS_MASK |		\
-			GDK_BUTTON_RELEASE_MASK |	\
-			GDK_BUTTON1_MOTION_MASK)
+#define GRAPH_MASK    (GDK_EXPOSURE_MASK |        \
+            GDK_POINTER_MOTION_MASK |    \
+            GDK_POINTER_MOTION_HINT_MASK |    \
+            GDK_ENTER_NOTIFY_MASK |        \
+            GDK_BUTTON_PRESS_MASK |        \
+            GDK_BUTTON_RELEASE_MASK |    \
+            GDK_BUTTON1_MOTION_MASK)
 
-#define GET_X(i)	curve->ctlpoints[i].x
-#define GET_Y(i)	curve->ctlpoints[i].y
+#define GET_X(i)    curve->ctlpoints[i].x
+#define GET_Y(i)    curve->ctlpoints[i].y
 
 
 enum {
-	ARG_0,
-	ARG_MIN_X,
-	ARG_MAX_X,
-	ARG_MIN_Y,
-	ARG_MAX_Y
+    ARG_0,
+    ARG_MIN_X,
+    ARG_MAX_X,
+    ARG_MIN_Y,
+    ARG_MAX_Y
 };
 
 static GtkDrawingAreaClass *parent_class = NULL;
@@ -71,586 +71,586 @@
 
 GtkType xs_curve_get_type(void)
 {
-	static GtkType curve_type = 0;
+    static GtkType curve_type = 0;
 
-	if (!curve_type) {
-		static const GtkTypeInfo curve_info = {
-			"XSCurve",
-			sizeof(XSCurve),
-			sizeof(XSCurveClass),
-			(GtkClassInitFunc) xs_curve_class_init,
-			(GtkObjectInitFunc) xs_curve_init,
-			/* reserved_1 */ NULL,
-			/* reserved_2 */ NULL,
-			(GtkClassInitFunc) NULL,
-		};
+    if (!curve_type) {
+        static const GtkTypeInfo curve_info = {
+            "XSCurve",
+            sizeof(XSCurve),
+            sizeof(XSCurveClass),
+            (GtkClassInitFunc) xs_curve_class_init,
+            (GtkObjectInitFunc) xs_curve_init,
+            /* reserved_1 */ NULL,
+            /* reserved_2 */ NULL,
+            (GtkClassInitFunc) NULL,
+        };
 
-		curve_type = gtk_type_unique(GTK_TYPE_DRAWING_AREA, &curve_info);
-	}
-	return curve_type;
+        curve_type = gtk_type_unique(GTK_TYPE_DRAWING_AREA, &curve_info);
+    }
+    return curve_type;
 }
 
 
 static void xs_curve_class_init(XSCurveClass *class)
 {
-	GtkObjectClass *object_class;
+    GtkObjectClass *object_class;
 
-	parent_class = gtk_type_class(GTK_TYPE_DRAWING_AREA);
+    parent_class = gtk_type_class(GTK_TYPE_DRAWING_AREA);
 
-	object_class = (GtkObjectClass *) class;
+    object_class = (GtkObjectClass *) class;
 
-	object_class->set_arg = xs_curve_set_arg;
-	object_class->get_arg = xs_curve_get_arg;
-	object_class->finalize = xs_curve_finalize;
+    object_class->set_arg = xs_curve_set_arg;
+    object_class->get_arg = xs_curve_get_arg;
+    object_class->finalize = xs_curve_finalize;
 
-	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);
+    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 xs_curve_init(XSCurve *curve)
 {
-	gint old_mask;
+    gint old_mask;
 
-	curve->pixmap = NULL;
-	curve->grab_point = -1;
+    curve->pixmap = NULL;
+    curve->grab_point = -1;
 
-	curve->nctlpoints = 0;
-	curve->ctlpoints = NULL;
+    curve->nctlpoints = 0;
+    curve->ctlpoints = NULL;
 
-	curve->min_x = 0.0;
-	curve->max_x = 2047.0;
-	curve->min_y = 0.0;
-	curve->max_y = 24000.0;
+    curve->min_x = 0.0;
+    curve->max_x = 2047.0;
+    curve->min_y = 0.0;
+    curve->max_y = 24000.0;
 
-	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) xs_curve_graph_events, curve);
-	xs_curve_size_graph(curve);
+    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) xs_curve_graph_events, curve);
+    xs_curve_size_graph(curve);
 }
 
 
 static void xs_curve_set_arg(GtkObject *object, GtkArg *arg, guint arg_id)
 {
-	XSCurve *curve = XS_CURVE(object);
+    XSCurve *curve = XS_CURVE(object);
 
-	switch (arg_id) {
-	case ARG_MIN_X:
-		xs_curve_set_range(curve, GTK_VALUE_FLOAT(*arg), curve->max_x, curve->min_y, curve->max_y);
-		break;
-	case ARG_MAX_X:
-		xs_curve_set_range(curve, curve->min_x, GTK_VALUE_FLOAT(*arg), curve->min_y, curve->max_y);
-		break;
-	case ARG_MIN_Y:
-		xs_curve_set_range(curve, curve->min_x, curve->max_x, GTK_VALUE_FLOAT(*arg), curve->max_y);
-		break;
-	case ARG_MAX_Y:
-		xs_curve_set_range(curve, curve->min_x, curve->max_x, curve->min_y, GTK_VALUE_FLOAT(*arg));
-		break;
-	}
+    switch (arg_id) {
+    case ARG_MIN_X:
+        xs_curve_set_range(curve, GTK_VALUE_FLOAT(*arg), curve->max_x, curve->min_y, curve->max_y);
+        break;
+    case ARG_MAX_X:
+        xs_curve_set_range(curve, curve->min_x, GTK_VALUE_FLOAT(*arg), curve->min_y, curve->max_y);
+        break;
+    case ARG_MIN_Y:
+        xs_curve_set_range(curve, curve->min_x, curve->max_x, GTK_VALUE_FLOAT(*arg), curve->max_y);
+        break;
+    case ARG_MAX_Y:
+        xs_curve_set_range(curve, curve->min_x, curve->max_x, curve->min_y, GTK_VALUE_FLOAT(*arg));
+        break;
+    }
 }
 
 
 static void xs_curve_get_arg(GtkObject *object, GtkArg *arg, guint arg_id)
 {
-	XSCurve *curve = XS_CURVE(object);
+    XSCurve *curve = XS_CURVE(object);
 
-	switch (arg_id) {
-	case ARG_MIN_X:
-		GTK_VALUE_FLOAT(*arg) = curve->min_x;
-		break;
-	case ARG_MAX_X:
-		GTK_VALUE_FLOAT(*arg) = curve->max_x;
-		break;
-	case ARG_MIN_Y:
-		GTK_VALUE_FLOAT(*arg) = curve->min_y;
-		break;
-	case ARG_MAX_Y:
-		GTK_VALUE_FLOAT(*arg) = curve->max_y;
-		break;
-	default:
-		arg->type = GTK_TYPE_INVALID;
-		break;
-	}
+    switch (arg_id) {
+    case ARG_MIN_X:
+        GTK_VALUE_FLOAT(*arg) = curve->min_x;
+        break;
+    case ARG_MAX_X:
+        GTK_VALUE_FLOAT(*arg) = curve->max_x;
+        break;
+    case ARG_MIN_Y:
+        GTK_VALUE_FLOAT(*arg) = curve->min_y;
+        break;
+    case ARG_MAX_Y:
+        GTK_VALUE_FLOAT(*arg) = curve->max_y;
+        break;
+    default:
+        arg->type = GTK_TYPE_INVALID;
+        break;
+    }
 }
 
 
 static int xs_project(gfloat value, gfloat min, gfloat max, int norm)
 {
-	return (norm - 1) * ((value - min) / (max - min)) + 0.5;
+    return (norm - 1) * ((value - min) / (max - min)) + 0.5;
 }
 
 
 static gfloat xs_unproject(gint value, gfloat min, gfloat max, int norm)
 {
-	return value / (gfloat) (norm - 1) * (max - min) + min;
+    return value / (gfloat) (norm - 1) * (max - min) + min;
 }
 
 
 static inline void xs_cubic_coeff(gfloat x1, gfloat y1,
-			gfloat x2, gfloat y2,
-			gfloat k1, gfloat k2,
-			gfloat *a, gfloat *b,
-			gfloat *c, gfloat *d)
+            gfloat x2, gfloat y2,
+            gfloat k1, gfloat k2,
+            gfloat *a, gfloat *b,
+            gfloat *c, gfloat *d)
 {
-	gfloat dx = x2 - x1, dy = y2 - y1;
+    gfloat dx = x2 - x1, dy = y2 - y1;
 
-	*a = ((k1 + k2) - 2 * dy / dx) / (dx * dx);
-	*b = ((k2 - k1) / dx - 3 * (x1 + x2) * (*a)) / 2;
-	*c = k1 - (3 * x1 * (*a) + 2 * (*b)) * x1;
-	*d = y1 - ((x1 * (*a) + (*b)) * x1 + (*c)) * x1;
+    *a = ((k1 + k2) - 2 * dy / dx) / (dx * dx);
+    *b = ((k2 - k1) / dx - 3 * (x1 + x2) * (*a)) / 2;
+    *c = k1 - (3 * x1 * (*a) + 2 * (*b)) * x1;
+    *d = y1 - ((x1 * (*a) + (*b)) * x1 + (*c)) * x1;
 }
 
 
 static void xs_curve_draw(XSCurve *curve, gint width, gint height)
 {
-	gfloat res = 5.0f;
-	GtkStateType state;
-	GtkStyle *style;
-	gint i, ox = -1, oy = -1;
-	t_xs_point *p0, *p1, *p2, *p3;
+    gfloat res = 5.0f;
+    GtkStateType state;
+    GtkStyle *style;
+    gint i, ox = -1, oy = -1;
+    t_xs_point *p0, *p1, *p2, *p3;
 
-	if (!curve->pixmap)
-		return;
+    if (!curve->pixmap)
+        return;
 
-	state = GTK_STATE_NORMAL;
-	if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve)))
-		state = GTK_STATE_INSENSITIVE;
+    state = GTK_STATE_NORMAL;
+    if (!GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(curve)))
+        state = GTK_STATE_INSENSITIVE;
 
-	style = GTK_WIDGET(curve)->style;
+    style = GTK_WIDGET(curve)->style;
 
-	/* Clear the pixmap */
-	gtk_paint_flat_box(style, curve->pixmap,
-		GTK_STATE_NORMAL, GTK_SHADOW_NONE,
-		NULL, GTK_WIDGET(curve), "curve_bg",
-		0, 0,
-		width + RADIUS2,
-		height + RADIUS2);
+    /* Clear the pixmap */
+    gtk_paint_flat_box(style, curve->pixmap,
+        GTK_STATE_NORMAL, GTK_SHADOW_NONE,
+        NULL, GTK_WIDGET(curve), "curve_bg",
+        0, 0,
+        width + RADIUS2,
+        height + RADIUS2);
 
-	
-	/* Draw the grid */
-	for (i = 0; i < 5; i++) {
-		gdk_draw_line(curve->pixmap, style->dark_gc[state],
-			RADIUS,		i * (height / 4.0) + RADIUS,
-			width + RADIUS,	i * (height / 4.0) + RADIUS);
+    
+    /* Draw the grid */
+    for (i = 0; i < 5; i++) {
+        gdk_draw_line(curve->pixmap, style->dark_gc[state],
+            RADIUS,        i * (height / 4.0) + RADIUS,
+            width + RADIUS,    i * (height / 4.0) + RADIUS);
 
-		gdk_draw_line(curve->pixmap, style->dark_gc[state],
-			i * (width / 4.0) + RADIUS, RADIUS,
-			i * (width / 4.0) + RADIUS, height + RADIUS);
-	}
+        gdk_draw_line(curve->pixmap, style->dark_gc[state],
+            i * (width / 4.0) + RADIUS, RADIUS,
+            i * (width / 4.0) + RADIUS, height + RADIUS);
+    }
 
 #if 1
-	/* Draw the spline/curve itself */
-	p0 = curve->ctlpoints;
-	p1 = p0;
-	p2 = p1; p2++;
-	p3 = p2; p3++;
+    /* Draw the spline/curve itself */
+    p0 = curve->ctlpoints;
+    p1 = p0;
+    p2 = p1; p2++;
+    p3 = p2; p3++;
 
-	/* Draw each curve segment */
-	if (curve->nctlpoints > 5)
-	for (i = 0; i < curve->nctlpoints; i++, ++p0, ++p1, ++p2, ++p3) {
-		gint n;
-		gfloat k1, k2, a, b, c, d, x;
-		
-		if (p1->x == p2->x)
-			continue;
+    /* Draw each curve segment */
+    if (curve->nctlpoints > 5)
+    for (i = 0; i < curve->nctlpoints; i++, ++p0, ++p1, ++p2, ++p3) {
+        gint n;
+        gfloat k1, k2, a, b, c, d, x;
+        
+        if (p1->x == p2->x)
+            continue;
 
-		if (p0->x == p1->x && p2->x == p3->x) {
-			k1 = k2 = (p2->y - p1->y) / (p2->x - p1->x);
-		} else if (p0->x == p1->x) {
-			k2 = (p3->y - p1->y) / (p3->x - p1->x);
-			k1 = (3 * (p2->y - p1->y) / (p2->x - p1->x) - k2) / 2;
-		} else if (p2->x == p3->x) {
-			k1 = (p2->y - p0->y) / (p2->x - p0->x);
-			k2 = (3 * (p2->y - p1->y) / (p2->x - p1->x) - k1) / 2;
-		} else {
-			k1 = (p2->y - p0->y) / (p2->x - p0->x);
-			k2 = (p3->y - p1->y) / (p3->x - p1->x);
-		}
+        if (p0->x == p1->x && p2->x == p3->x) {
+            k1 = k2 = (p2->y - p1->y) / (p2->x - p1->x);
+        } else if (p0->x == p1->x) {
+            k2 = (p3->y - p1->y) / (p3->x - p1->x);
+            k1 = (3 * (p2->y - p1->y) / (p2->x - p1->x) - k2) / 2;
+        } else if (p2->x == p3->x) {
+            k1 = (p2->y - p0->y) / (p2->x - p0->x);
+            k2 = (3 * (p2->y - p1->y) / (p2->x - p1->x) - k1) / 2;
+        } else {
+            k1 = (p2->y - p0->y) / (p2->x - p0->x);
+            k2 = (p3->y - p1->y) / (p3->x - p1->x);
+        }
 
-		xs_cubic_coeff(p1->x, p1->y, p2->x, p2->y, k1, k2, &a, &b, &c, &d);
+        xs_cubic_coeff(p1->x, p1->y, p2->x, p2->y, k1, k2, &a, &b, &c, &d);
 
-		for (x = p1->x; x <= p2->x; x += res, n++) {
-			gfloat y = ((a * x + b) * x + c) * x + d;
-			gint qx, qy;
-			qx = RADIUS + xs_project(x, curve->min_x, curve->max_x, width);
-			qy = RADIUS + xs_project(y, curve->min_y, curve->max_y, height);
-			
-			if (ox != -1) {
-				gdk_draw_line(curve->pixmap, style->fg_gc[state],
-					ox, oy, qx, qy);
-			}
-			ox = qx; oy = qy;
-		}
-	}
+        for (x = p1->x; x <= p2->x; x += res, n++) {
+            gfloat y = ((a * x + b) * x + c) * x + d;
+            gint qx, qy;
+            qx = RADIUS + xs_project(x, curve->min_x, curve->max_x, width);
+            qy = RADIUS + xs_project(y, curve->min_y, curve->max_y, height);
+            
+            if (ox != -1) {
+                gdk_draw_line(curve->pixmap, style->fg_gc[state],
+                    ox, oy, qx, qy);
+            }
+            ox = qx; oy = qy;
+        }
+    }
 
 #endif
 
-	/* Draw control points */
-	for (i = 0; i < curve->nctlpoints; ++i) {
-		gint x, y;
-		GtkStateType cstate;
+    /* Draw control points */
+    for (i = 0; i < curve->nctlpoints; ++i) {
+        gint x, y;
+        GtkStateType cstate;
 
-		if (GET_X(i) < curve->min_x || GET_Y(i) < curve->min_y ||
-			GET_X(i) >= curve->max_x || GET_Y(i) >= curve->max_y)
-			continue;
+        if (GET_X(i) < curve->min_x || GET_Y(i) < curve->min_y ||
+            GET_X(i) >= curve->max_x || GET_Y(i) >= curve->max_y)
+            continue;
 
-		x = xs_project(GET_X(i), curve->min_x, curve->max_x, width);
-		y = xs_project(GET_Y(i), curve->min_y, curve->max_y, height);
-		
-		if (i == curve->grab_point) {
-			cstate = GTK_STATE_SELECTED;
-			gdk_draw_line(curve->pixmap, style->fg_gc[cstate],
-				x + RADIUS, RADIUS, x + RADIUS, height + RADIUS);
-			gdk_draw_line(curve->pixmap, style->fg_gc[cstate],
-				RADIUS, y + RADIUS, width + RADIUS, y + RADIUS);
-		} else
-			cstate = state;
-		
-		gdk_draw_arc(curve->pixmap, style->fg_gc[cstate], TRUE,
-			x, y, RADIUS2, RADIUS2, 0, 360 * 64);
-	}
-	
-	/* Draw pixmap in the widget */
-	gdk_draw_pixmap(GTK_WIDGET(curve)->window,
-			style->fg_gc[state], curve->pixmap,
-			0, 0, 0, 0,
-			width + RADIUS2,
-			height + RADIUS2);
+        x = xs_project(GET_X(i), curve->min_x, curve->max_x, width);
+        y = xs_project(GET_Y(i), curve->min_y, curve->max_y, height);
+        
+        if (i == curve->grab_point) {
+            cstate = GTK_STATE_SELECTED;
+            gdk_draw_line(curve->pixmap, style->fg_gc[cstate],
+                x + RADIUS, RADIUS, x + RADIUS, height + RADIUS);
+            gdk_draw_line(curve->pixmap, style->fg_gc[cstate],
+                RADIUS, y + RADIUS, width + RADIUS, y + RADIUS);
+        } else
+            cstate = state;
+        
+        gdk_draw_arc(curve->pixmap, style->fg_gc[cstate], TRUE,
+            x, y, RADIUS2, RADIUS2, 0, 360 * 64);
+    }
+    
+    /* Draw pixmap in the widget */
+    gdk_draw_pixmap(GTK_WIDGET(curve)->window,
+            style->fg_gc[state], curve->pixmap,
+            0, 0, 0, 0,
+            width + RADIUS2,
+            height + RADIUS2);
 }
 
 
 static gint xs_curve_graph_events(GtkWidget *widget, GdkEvent *event, XSCurve *curve)
 {
-	GdkCursorType new_type = curve->cursor_type;
-	GdkEventButton *bevent;
-	GtkWidget *w;
-	gint i, width, height, x, y, tx, ty, cx, closest_point = 0, min_x;
-	guint distance;
+    GdkCursorType new_type = curve->cursor_type;
+    GdkEventButton *bevent;
+    GtkWidget *w;
+    gint i, width, height, x, y, tx, ty, cx, closest_point = 0, min_x;
+    guint distance;
 
-	w = GTK_WIDGET(curve);
-	width = w->allocation.width - RADIUS2;
-	height = w->allocation.height - RADIUS2;
+    w = GTK_WIDGET(curve);
+    width = w->allocation.width - RADIUS2;
+    height = w->allocation.height - RADIUS2;
 
-	if ((width < 0) || (height < 0))
-		return FALSE;
+    if ((width < 0) || (height < 0))
+        return FALSE;
 
-	/* get the pointer position */
-	gdk_window_get_pointer(w->window, &tx, &ty, NULL);
-	x = CLAMP((tx - RADIUS), 0, width - 1);
-	y = CLAMP((ty - RADIUS), 0, height - 1);
-	min_x = curve->min_x;
+    /* get the pointer position */
+    gdk_window_get_pointer(w->window, &tx, &ty, NULL);
+    x = CLAMP((tx - RADIUS), 0, width - 1);
+    y = CLAMP((ty - RADIUS), 0, height - 1);
+    min_x = curve->min_x;
 
-	distance = ~0U;
-	for (i = 0; i < curve->nctlpoints; ++i) {
-		cx = xs_project(GET_X(i), min_x, curve->max_x, width);
-		if ((guint) abs(x - cx) < distance) {
-			distance = abs(x - cx);
-			closest_point = i;
-		}
-	}
-	
-	/* Act based on event type */
-	switch (event->type) {
-	case GDK_CONFIGURE:
-		if (curve->pixmap)
-			gdk_pixmap_unref(curve->pixmap);
-		curve->pixmap = 0;
+    distance = ~0U;
+    for (i = 0; i < curve->nctlpoints; ++i) {
+        cx = xs_project(GET_X(i), min_x, curve->max_x, width);
+        if ((guint) abs(x - cx) < distance) {
+            distance = abs(x - cx);
+            closest_point = i;
+        }
+    }
+    
+    /* Act based on event type */
+    switch (event->type) {
+    case GDK_CONFIGURE:
+        if (curve->pixmap)
+            gdk_pixmap_unref(curve->pixmap);
+        curve->pixmap = 0;
 
-		/* fall through */
+        /* fall through */
 
-	case GDK_EXPOSE:
-		if (!curve->pixmap) {
-			curve->pixmap = gdk_pixmap_new(w->window,
-			w->allocation.width, w->allocation.height, -1);
-		}
-		xs_curve_draw(curve, width, height);
-		break;
+    case GDK_EXPOSE:
+        if (!curve->pixmap) {
+            curve->pixmap = gdk_pixmap_new(w->window,
+            w->allocation.width, w->allocation.height, -1);
+        }
+        xs_curve_draw(curve, width, height);
+        break;
 
-	case GDK_BUTTON_PRESS:
-		gtk_grab_add(widget);
+    case GDK_BUTTON_PRESS:
+        gtk_grab_add(widget);
 
-		bevent = (GdkEventButton *) event;
-		new_type = GDK_TCROSS;
+        bevent = (GdkEventButton *) event;
+        new_type = GDK_TCROSS;
 
-		if (distance > MIN_DISTANCE) {
-			/* insert a new control point */
-			if (curve->nctlpoints > 0) {
-				cx = xs_project(GET_X(closest_point), min_x, curve->max_x, width);
-				if (x > cx) closest_point++;
-			}
-			
-			curve->nctlpoints++;
-			
-			curve->ctlpoints = g_realloc(curve->ctlpoints,
-				curve->nctlpoints * sizeof(*curve->ctlpoints));
-			
-			for (i = curve->nctlpoints - 1; i > closest_point; --i) {
-				memcpy(curve->ctlpoints + i,
-					curve->ctlpoints + i - 1,
-					sizeof(*curve->ctlpoints));
-			}
-		}
-		
-		curve->grab_point = closest_point;
-		GET_X(curve->grab_point) = xs_unproject(x, min_x, curve->max_x, width);
-		GET_Y(curve->grab_point) = xs_unproject(y, curve->min_y, curve->max_y, height);
+        if (distance > MIN_DISTANCE) {
+            /* insert a new control point */
+            if (curve->nctlpoints > 0) {
+                cx = xs_project(GET_X(closest_point), min_x, curve->max_x, width);
+                if (x > cx) closest_point++;
+            }
+            
+            curve->nctlpoints++;
+            
+            curve->ctlpoints = g_realloc(curve->ctlpoints,
+                curve->nctlpoints * sizeof(*curve->ctlpoints));
+            
+            for (i = curve->nctlpoints - 1; i > closest_point; --i) {
+                memcpy(curve->ctlpoints + i,
+                    curve->ctlpoints + i - 1,
+                    sizeof(*curve->ctlpoints));
+            }
+        }
+        
+        curve->grab_point = closest_point;
+        GET_X(curve->grab_point) = xs_unproject(x, min_x, curve->max_x, width);
+        GET_Y(curve->grab_point) = xs_unproject(y, curve->min_y, curve->max_y, height);
 
-		xs_curve_draw(curve, width, height);
-		break;
+        xs_curve_draw(curve, width, height);
+        break;
 
-	case GDK_BUTTON_RELEASE:
-		{
-		gint src, dst;
-		
-		gtk_grab_remove(widget);
+    case GDK_BUTTON_RELEASE:
+        {
+        gint src, dst;
+        
+        gtk_grab_remove(widget);
 
-		/* delete inactive points: */
-		for (src = dst = 0; src < curve->nctlpoints; ++src) {
-			if (GET_X(src) >= min_x) {
-				memcpy(curve->ctlpoints + dst,
-					curve->ctlpoints + src,
-					sizeof(*curve->ctlpoints));
-				dst++;
-			}
-		}
+        /* delete inactive points: */
+        for (src = dst = 0; src < curve->nctlpoints; ++src) {
+            if (GET_X(src) >= min_x) {
+                memcpy(curve->ctlpoints + dst,
+                    curve->ctlpoints + src,
+                    sizeof(*curve->ctlpoints));
+                dst++;
+            }
+        }
 
-		if (dst < src) {
-			curve->nctlpoints -= (src - dst);
-			if (curve->nctlpoints <= 0) {
-				curve->nctlpoints = 1;
-				GET_X(0) = min_x;
-				GET_Y(0) = curve->min_y;
-				xs_curve_draw(curve, width, height);
-			}
-			curve->ctlpoints = g_realloc(curve->ctlpoints,
-				curve->nctlpoints * sizeof(*curve->ctlpoints));
-		}
+        if (dst < src) {
+            curve->nctlpoints -= (src - dst);
+            if (curve->nctlpoints <= 0) {
+                curve->nctlpoints = 1;
+                GET_X(0) = min_x;
+                GET_Y(0) = curve->min_y;
+                xs_curve_draw(curve, width, height);
+            }
+            curve->ctlpoints = g_realloc(curve->ctlpoints,
+                curve->nctlpoints * sizeof(*curve->ctlpoints));
+        }
 
-		new_type = GDK_FLEUR;
-		curve->grab_point = -1;
-		}
-		xs_curve_draw(curve, width, height);
-		break;
+        new_type = GDK_FLEUR;
+        curve->grab_point = -1;
+        }
+        xs_curve_draw(curve, width, height);
+        break;
 
-	case GDK_MOTION_NOTIFY:
-		if (curve->grab_point == -1) {
-			/* if no point is grabbed...  */
-			if (distance <= MIN_DISTANCE)
-				new_type = GDK_FLEUR;
-			else
-				new_type = GDK_TCROSS;
-		} else {
-			gint leftbound, rightbound;
-			
-			/* drag the grabbed point  */
-			new_type = GDK_TCROSS;
-			
-			leftbound = -MIN_DISTANCE;
-			if (curve->grab_point > 0) {
-				leftbound = xs_project(
-					GET_X(curve->grab_point-1),
-					min_x, curve->max_x, width);
-			}
+    case GDK_MOTION_NOTIFY:
+        if (curve->grab_point == -1) {
+            /* if no point is grabbed...  */
+            if (distance <= MIN_DISTANCE)
+                new_type = GDK_FLEUR;
+            else
+                new_type = GDK_TCROSS;
+        } else {
+            gint leftbound, rightbound;
+            
+            /* drag the grabbed point  */
+            new_type = GDK_TCROSS;
+            
+            leftbound = -MIN_DISTANCE;
+            if (curve->grab_point > 0) {
+                leftbound = xs_project(
+                    GET_X(curve->grab_point-1),
+                    min_x, curve->max_x, width);
+            }
 
-			rightbound = width + RADIUS2 + MIN_DISTANCE;
-			if (curve->grab_point + 1 < curve->nctlpoints) {
-				rightbound = xs_project(
-					GET_X(curve->grab_point+1),
-					min_x, curve->max_x, width);
-			}
+            rightbound = width + RADIUS2 + MIN_DISTANCE;
+            if (curve->grab_point + 1 < curve->nctlpoints) {
+                rightbound = xs_project(
+                    GET_X(curve->grab_point+1),
+                    min_x, curve->max_x, width);
+            }
 
-			if ((tx <= leftbound) || (tx >= rightbound) ||
-				(ty > height + RADIUS2 + MIN_DISTANCE) || (ty < -MIN_DISTANCE)) {
-				GET_X(curve->grab_point) = min_x - 1.0;
-			} else {
-				GET_X(curve->grab_point) =
-					xs_unproject(x, min_x, curve->max_x, width);
-				GET_Y(curve->grab_point) =
-					xs_unproject(y, curve->min_y, curve->max_y, height);
-			}
-			
-			xs_curve_draw(curve, width, height);
-		}
-		
-		/* See if cursor type was changed and update accordingly */
-		if (new_type != (GdkCursorType) curve->cursor_type) {
-			GdkCursor *cursor;
-			curve->cursor_type = new_type;
-			cursor = gdk_cursor_new(curve->cursor_type);
-			gdk_window_set_cursor(w->window, cursor);
-			gdk_cursor_destroy(cursor);
-		}
-		break;
+            if ((tx <= leftbound) || (tx >= rightbound) ||
+                (ty > height + RADIUS2 + MIN_DISTANCE) || (ty < -MIN_DISTANCE)) {
+                GET_X(curve->grab_point) = min_x - 1.0;
+            } else {
+                GET_X(curve->grab_point) =
+                    xs_unproject(x, min_x, curve->max_x, width);
+                GET_Y(curve->grab_point) =
+                    xs_unproject(y, curve->min_y, curve->max_y, height);
+            }
+            
+            xs_curve_draw(curve, width, height);
+        }
+        
+        /* See if cursor type was changed and update accordingly */
+        if (new_type != (GdkCursorType) curve->cursor_type) {
+            GdkCursor *cursor;
+            curve->cursor_type = new_type;
+            cursor = gdk_cursor_new(curve->cursor_type);
+            gdk_window_set_cursor(w->window, cursor);
+            gdk_cursor_destroy(cursor);
+        }
+        break;
 
-	default:
-		break;
-	}
-	
-	return FALSE;
+    default:
+        break;
+    }
+    
+    return FALSE;
 }
 
 
 static void xs_curve_size_graph(XSCurve *curve)
 {
-	gint width, height;
-	gfloat aspect;
+    gint width, height;
+    gfloat aspect;
 
-	width = (curve->max_x - curve->min_x) + 1;
-	height = (curve->max_y - curve->min_y) + 1;
-	aspect = width / (gfloat) height;
+    width = (curve->max_x - curve->min_x) + 1;
+    height = (curve->max_y - curve->min_y) + 1;
+    aspect = width / (gfloat) height;
 
-	if (width > gdk_screen_width() / 4)
-		width = gdk_screen_width() / 4;
+    if (width > gdk_screen_width() / 4)
+        width = gdk_screen_width() / 4;
 
-	if (height > gdk_screen_height() / 4)
-		height = gdk_screen_height() / 4;
+    if (height > gdk_screen_height() / 4)
+        height = gdk_screen_height() / 4;
 
-	if (aspect < 1.0)
-		width = height * aspect;
-	else
-		height = width / aspect;
+    if (aspect < 1.0)
+        width = height * aspect;
+    else
+        height = width / aspect;
 
-	gtk_drawing_area_size(GTK_DRAWING_AREA(curve), width + RADIUS2, height + RADIUS2);
+    gtk_drawing_area_size(GTK_DRAWING_AREA(curve), width + RADIUS2, height + RADIUS2);
 }
 
 
 static void xs_curve_update(XSCurve *curve)
 {
-	if (curve->pixmap) {
-		gint width, height;
+    if (curve->pixmap) {
+        gint width, height;
 
-		width = GTK_WIDGET(curve)->allocation.width - RADIUS2;
-		height = GTK_WIDGET(curve)->allocation.height - RADIUS2;
-		xs_curve_draw(curve, width, height);
-	}
+        width = GTK_WIDGET(curve)->allocation.width - RADIUS2;
+        height = GTK_WIDGET(curve)->allocation.height - RADIUS2;
+        xs_curve_draw(curve, width, height);
+    }
 }
 
 
 void xs_curve_reset(XSCurve *curve)
 {
-	if (curve->ctlpoints)
-		g_free(curve->ctlpoints);
+    if (curve->ctlpoints)
+        g_free(curve->ctlpoints);
 
-	curve->nctlpoints = 4;
-	curve->ctlpoints = g_malloc(curve->nctlpoints * sizeof(curve->ctlpoints[0]));
+    curve->nctlpoints = 4;
+    curve->ctlpoints = g_malloc(curve->nctlpoints * sizeof(curve->ctlpoints[0]));
 
-	GET_X(0) = curve->min_x;
-	GET_Y(0) = curve->min_y;
-	GET_X(1) = curve->min_x;
-	GET_Y(1) = curve->min_y;
+    GET_X(0) = curve->min_x;
+    GET_Y(0) = curve->min_y;
+    GET_X(1) = curve->min_x;
+    GET_Y(1) = curve->min_y;
 
-	GET_X(2) = curve->max_x;
-	GET_Y(2) = curve->max_y;
-	GET_X(3) = curve->max_x;
-	GET_Y(3) = curve->max_y;
-	
-	xs_curve_update(curve);
+    GET_X(2) = curve->max_x;
+    GET_Y(2) = curve->max_y;
+    GET_X(3) = curve->max_x;
+    GET_Y(3) = curve->max_y;
+    
+    xs_curve_update(curve);
 }
 
 
 void xs_curve_set_range(XSCurve *curve, gfloat min_x, gfloat min_y, gfloat max_x, gfloat max_y)
 {
-	curve->min_x = min_x;
-	curve->max_x = max_x;
-	
-	curve->min_y = min_y;
-	curve->max_y = max_y;
+    curve->min_x = min_x;
+    curve->max_x = max_x;
+    
+    curve->min_y = min_y;
+    curve->max_y = max_y;
 
-	xs_curve_size_graph(curve);
-	xs_curve_reset(curve);
+    xs_curve_size_graph(curve);
+    xs_curve_reset(curve);
 }
 
 
 gboolean xs_curve_realloc_data(XSCurve *curve, gint npoints)
 {
-	if (npoints != curve->nctlpoints) {
-		curve->nctlpoints = npoints;
-		curve->ctlpoints = (t_xs_point *) g_realloc(curve->ctlpoints,
-			curve->nctlpoints * sizeof(*curve->ctlpoints));
+    if (npoints != curve->nctlpoints) {
+        curve->nctlpoints = npoints;
+        curve->ctlpoints = (t_xs_point *) g_realloc(curve->ctlpoints,
+            curve->nctlpoints * sizeof(*curve->ctlpoints));
 
-		if (curve->ctlpoints == NULL)
-			return FALSE;
-	}
-	
-	return TRUE;
+        if (curve->ctlpoints == NULL)
+            return FALSE;
+    }
+    
+    return TRUE;
 }
 
 
 void xs_curve_get_data(XSCurve *curve, t_xs_point ***points, gint **npoints)
 {
-	*points = &(curve->ctlpoints);
-	*npoints = &(curve->nctlpoints);
+    *points = &(curve->ctlpoints);
+    *npoints = &(curve->nctlpoints);
 }
 
 
 gboolean xs_curve_set_points(XSCurve *curve, t_xs_int_point *points, gint npoints)
 {
-	gint i;
+    gint i;
 
-	if (!xs_curve_realloc_data(curve, npoints + 4))
-		return FALSE;
-	
-	GET_X(0) = curve->min_x;
-	GET_Y(0) = curve->min_y;
-	GET_X(1) = curve->min_x;
-	GET_Y(1) = curve->min_y;
+    if (!xs_curve_realloc_data(curve, npoints + 4))
+        return FALSE;
+    
+    GET_X(0) = curve->min_x;
+    GET_Y(0) = curve->min_y;
+    GET_X(1) = curve->min_x;
+    GET_Y(1) = curve->min_y;
 
-	for (i = 0; i < npoints; i++) {
-		GET_X(i+2) = points[i].x;
-		GET_Y(i+2) = points[i].y;
-	}
+    for (i = 0; i < npoints; i++) {
+        GET_X(i+2) = points[i].x;
+        GET_Y(i+2) = points[i].y;
+    }
 
-	GET_X(npoints+2) = curve->max_x;
-	GET_Y(npoints+2) = curve->max_y;
-	GET_X(npoints+3) = curve->max_x;
-	GET_Y(npoints+3) = curve->max_y;
-	
-	xs_curve_update(curve);
-	return TRUE;
+    GET_X(npoints+2) = curve->max_x;
+    GET_Y(npoints+2) = curve->max_y;
+    GET_X(npoints+3) = curve->max_x;
+    GET_Y(npoints+3) = curve->max_y;
+    
+    xs_curve_update(curve);
+    return TRUE;
 }
 
 
 gboolean xs_curve_get_points(XSCurve *curve, t_xs_int_point **points, gint *npoints)
 {
-	gint i, n;
-	
-	n = curve->nctlpoints - 4;
-	
-	*points = g_malloc(n * sizeof(t_xs_int_point));
-	if (*points == NULL)
-		return FALSE;
-	
-	*npoints = n;
-	for (i = 2; i < curve->nctlpoints - 2; i++) {
-		(*points)[i].x = GET_X(i);
-		(*points)[i].y = GET_Y(i);
-	}
+    gint i, n;
+    
+    n = curve->nctlpoints - 4;
+    
+    *points = g_malloc(n * sizeof(t_xs_int_point));
+    if (*points == NULL)
+        return FALSE;
+    
+    *npoints = n;
+    for (i = 2; i < curve->nctlpoints - 2; i++) {
+        (*points)[i].x = GET_X(i);
+        (*points)[i].y = GET_Y(i);
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 
 GtkWidget *xs_curve_new(void)
 {
-	return gtk_type_new(xs_curve_get_type());
+    return gtk_type_new(xs_curve_get_type());
 }
 
 
 static void xs_curve_finalize(GtkObject *object)
 {
-	XSCurve *curve;
+    XSCurve *curve;
 
-	g_return_if_fail(object != NULL);
-	g_return_if_fail(XS_IS_CURVE(object));
+    g_return_if_fail(object != NULL);
+    g_return_if_fail(XS_IS_CURVE(object));
 
-	curve = XS_CURVE(object);
-	if (curve->pixmap)
-		gdk_pixmap_unref(curve->pixmap);
-	if (curve->ctlpoints)
-		g_free(curve->ctlpoints);
+    curve = XS_CURVE(object);
+    if (curve->pixmap)
+        gdk_pixmap_unref(curve->pixmap);
+    if (curve->ctlpoints)
+        g_free(curve->ctlpoints);
 
-	(*GTK_OBJECT_CLASS(parent_class)->finalize) (object);
+    (*GTK_OBJECT_CLASS(parent_class)->finalize) (object);
 }