update manpage

fix RP1000 support
add support for GNX4 and GNX3k patches
2010-10-07 11:08:59 +02:00 · 2010-08-25 11:15:29 +02:00 · 2010-06-17 19:20:58 +02:00 · 2010-04-24 15:07:18 +02:00 · 2010-03-04 18:54:58 +01:00 · 2010-02-05 09:43:21 +01:00
19 changed files with 6975 additions and 1904 deletions
--- a/.hgignore
+++ b/.hgignore
@@ -6,3 +6,7 @@ syntax: glob
 *.o
 *.patch
 *.diff
+*.m
+*.orig
+knob.h
+gdigi
--- a/12
+++ b/12
@@ -3,7 +3,7 @@ In general everything brings down to figure out:
 -Position
 -Possible value range

-There seems to be two possible ways to figure that out.
+There seems to be three possible ways to figure that out.
 1) Use USB sniffer together with X-Edit
   Once you set up X-Edit and usb sniffer, set some option.
   USB sniffer should report something like this being sent to device:
@@ -66,3 +66,13 @@ There seems to be two possible ways to figure that out.
       save new patch
       check patch file and note the change
     while you don't have all possible values
+3) Use gdigi
+   After starting gdigi turn the knobs on your device.
+   Check out console output, you should notice something like this:
+      ** Message: Received parameter change ID: 210 Position: 4 Value: 0
+   ID is ID, Position is Position and Value is one of possible values.
+   To get all possible values keep turning knobs and watch the output.
+   If you change effect type usually there's more messages - where,
+   usually the first one is type change, and rest are default values.
+   This way you *CANNOT* gather all information (there're X-Edit only
+   controlled values, check device manual for more information).
--- a/53
+++ b/53
@@ -1,28 +1,47 @@
 CC = gcc
-CFLAGS = `pkg-config --cflags glib-2.0 gio-2.0 gtk+-2.0` -Wall -g
-OFLAG = -o
-LIBS = `pkg-config --libs glib-2.0 gio-2.0 gtk+-2.0 alsa` -lexpat
+EXTRA_CFLAGS ?=
+EXTRA_LDFLAGS ?=
+CFLAGS := $(shell pkg-config --cflags glib-2.0 gio-2.0 gtk+-2.0) -Wall -g -ansi -std=c99 $(EXTRA_CFLAGS)
+LDFLAGS = $(EXTRA_LDFLAGS) -Wl,--as-needed
+LDADD := $(shell pkg-config --libs glib-2.0 gio-2.0 gtk+-2.0 gthread-2.0 alsa) -lexpat 
+OBJECTS = gdigi.o gui.o effects.o preset.o gtkknob.o
+DEPFILES = $(foreach m,$(OBJECTS:.o=),.$(m).m)

-.SUFFIXES : .o .c
-.c.o :
+.PHONY : clean distclean all
+%.o : %.c
 	$(CC) $(CFLAGS) -c $<

+.%.m : %.c
+	$(CC) $(CFLAGS) -M -MF $@ -MG $<
+
 all: gdigi

-gdigi: gdigi.o tests.o gui.o effects.o preset.o
-	$(CC) $(LIBS) $(OFLAG) gdigi gdigi.o tests.o gui.o effects.o preset.o
+gdigi: $(OBJECTS) 
+	$(CC) $(LDFLAGS) -o $@ $+ $(LDADD)

-gdigi.o: gdigi.c
-
-tests.o: tests.c
-
-gui.o: gui.c
-
-effects.o: effects.c
-
-preset.o: preset.c
+knob.h: knob.png
+	gdk-pixbuf-csource --name=knob_pixbuf knob.png > $@

 clean:
-	rm *.o
+	rm -f *.o
+	rm -f knob.h

+distclean : clean
+	rm -f .*.m
+	rm -f gdigi

+install: gdigi
+	install gdigi $(DESTDIR)/usr/bin
+
+NODEP_TARGETS := clean distclean
+depinc := 1
+ifneq (,$(filter $(NODEP_TARGETS),$(MAKECMDGOALS)))
+depinc := 0
+endif
+ifneq (,$(fitler-out $(NODEP_TARGETS),$(MAKECMDGOALS)))
+depinc := 1
+endif
+
+ifeq ($(depinc),1)
+-include $(DEPFILES)
+endif
--- a/32
+++ b/32
@@ -1,26 +1,6 @@
-figure out all magic commands
-make complete gui
-cabinet models
-tone library
-effects library
-effects level
-handling presets (loading, saving, exporting to xml patches)
-buildsystem
-start gui with proper values
-   To do so we need to figure out reply formatting of command querying preset.
-   amidi --port=hw:1,0,0 --send-hex F0 00 00 10 00 5E 02 2a 00 04 00 62 F7 --receive=preset
-   will create file named preset (give a while for it, and then hit ctrl+c)
-   this file should have around 440 bytes (depends on actual preset)
-   0x21 byte holds amount of options
-   from 0x22 byte starts effects configuration which is:
-     -2 bytes for ID
-     -1 byte for position
-     -1 to 3 bytes for value
-   Each 8th byte (beginning from 0x27) seems to be status byte which describes
-   whether or not we shall add 0x80 to ID or value and whether or not value
-   will be multibyte. So far I couldn't figure the exact meaning of those bytes.
-   To check you can download some patch from DigiTech Sound Community, apply
-   it to your device, and then do this amidi command.
-   Open resulting file in hex editor, and open patch file in text editor.
-   Every ID, position and value found in patch will appear in the binary file.
-fix expression pedal settings (possible types depend on active effects)
+-make complete gui (expression pedal settings, usb settings, effect level, preset level)
+-handling presets (saving, exporting to xml patches)
+-buildsystem (install knob.png to share dir, don't use inline knob pixbuf)
+-various fixes to MIDI IN messages handling
+-guess device port when user doesn't explicitly provide it (don't use hardcoded "hw:1,0,0")
+-optimizations
--- a/effects.c
+++ b/effects.c
--- a/effects.h
+++ b/effects.h
@@ -17,36 +17,98 @@
 #ifndef GDIGI_EFFECTS_H
 #define GDIGI_EFFECTS_H

-#include <glib/gtypes.h>
+#include <glib.h>
+
+enum {
+  VALUE_TYPE_PLAIN  = 0,      /**< value displayed directly */
+  VALUE_TYPE_SUFFIX = 1 << 0, /**< use suffix for displaying */
+  VALUE_TYPE_OFFSET = 1 << 1, /**< use value offset */
+  VALUE_TYPE_STEP   = 1 << 2, /**< use value step different than 1 */
+  VALUE_TYPE_LABEL  = 1 << 3, /**< use value labels (overrides any other option) */
+  VALUE_TYPE_EXTRA  = 1 << 4, /**< use extra values */
+  VALUE_TYPE_DECIMAL= 1 << 5, /**< display decimal places */
+} ValueType;
+
+typedef struct _EffectValues {
+    gdouble min;    /**< Minumum value */
+    gdouble max;    /**< Maximum value */
+    gint type;      /**< value type bitmask (ValueType) */
+
+    GStrv labels;   /**< value labels */
+    gint offset;    /**< value offset */
+    gdouble step;   /**< value step */
+    gchar *suffix;  /**< value suffix */
+
+    struct _EffectValues *extra;
+                    /**< additional value range,
+                         use it when there're different range types */
+    gint decimal;   /**< amount of decimal places to display */
+} EffectValues;

 typedef struct {
-    char *label;    /* Parameter name */
-    gdouble min;    /* Parameter minumum value */
-    gdouble max;    /* Parameter maximum value */
-    guint option;   /* ID (to set parameter) */
-    guint position; /* position */
+    gchar *label;         /**< Parameter name */
+    guint id;             /**< ID (to set parameter) */
+    guint position;       /**< position */
+    EffectValues *values; /**< valid parameter values */
 } EffectSettings;

 typedef struct {
-    guint id;                  /* value (type) */
-    gchar *label;              /* Effect name */
-    guint option;              /* ID (to set effect type) */
-    guint position;            /* position */
-    EffectSettings *settings;  /* possible parameters */
-    gint settings_amt;         /* possible parameters length */
+    guint type;                /**< value (type) */
+    gchar *label;              /**< Effect name */
+    EffectSettings *settings;  /**< possible parameters */
+    gint settings_amt;         /**< possible parameters length */
 } EffectGroup;

 typedef struct {
-    char *label;        /* Base effect name */
-    guint option;       /* ID (to set effect on/off) */
-    guint position;     /* position */
-    EffectGroup *group; /* possible effect types */
-    gint group_amt;     /* possible effect types length */
+    gchar *label;       /**< Group label */
+    guint id;           /**< ID to set effect on/off, or if it isn't on/off group then -1 */
+    guint type;         /**< ID to set effect type */
+    guint position;     /**< position */
+    EffectGroup *group; /**< possible effect types */
+    gint group_amt;     /**< possible effect types length */
 } Effect;

 typedef struct {
-    Effect *effect; /* list of supported effects */
-    gint amt;       /* list of supported effects length */
+    gchar *label;   /**< base effect name */
+    Effect *effect; /**< list of supported effects */
+    gint amt;       /**< list of supported effects length */
 } EffectList;

+typedef struct {
+    guint type;         /**< ID to set effect type */
+    guint position;
+    EffectGroup *group;
+    gint group_amt;
+} ModifierGroup;
+
+typedef struct {
+    gchar *name;
+    EffectList *effects;
+    gint n_effects;
+    gint n_rows;
+} EffectPage;
+
+typedef struct {
+    gchar *name;
+    PresetBank bank;
+} Banks;
+
+typedef struct {
+    gchar *name;
+    unsigned char family_id;
+    unsigned char product_id;
+    EffectPage *pages;
+    gint n_pages;
+    Banks *banks;
+    gint n_banks;
+} Device;
+
+ModifierGroup *modifier_linkable_list();
+void modifier_group_free(ModifierGroup *modifier_group);
+void get_values_info(EffectValues *values,
+                     gdouble *min, gdouble *max, gboolean *custom);
+gboolean get_device_info(unsigned char device_id, unsigned char family_id,
+                         unsigned char product_id,
+                         Device **device);
+
 #endif /* GDIGI_EFFECTS_H */
--- a/gdigi.1
+++ b/gdigi.1
@@ -0,0 +1,74 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.\" First parameter, NAME, should be all caps
+.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
+.\" other parameters are allowed: see man(7), man(1)
+.TH GDIGI 1 "October 07, 2010"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+gdigi \- utility to control DigiTech effect pedals
+.SH SYNOPSIS
+.B gdigi
+.RI [OPTION...]
+.SH DESCRIPTION
+gdigi is a tool aimed to provide X-Edit functionality to Linux users
+.PP
+Supported devices:
+.IP \(bu 
+RP250
+.IP \(bu
+RP255
+.IP \(bu 
+RP355
+.IP \(bu 
+RP500
+.IP \(bu 
+RP1000
+.IP \(bu
+GNX3000
+.IP \(bu 
+GNX4K
+.PP
+.SH OPTIONS
+These programs follow the usual GNU command line syntax, with long
+options starting with two dashes (`\-').
+A summary of options is included below.
+For a complete description, see the Info files.
+.TP
+.B \-?, \-\-help
+Show summary of options.
+.TP
+.B \-\-help\-all
+Show all help options.
+.TP
+.B \-\-help\-gtk
+Show GTK+ options.
+.TP
+.B \-\-display=\fIDISPLAY\fR
+X display to use.
+.TP
+.B \-d, \-\-device
+MIDI device port to use.
+.SH AUTHOR
+gdigi was written by Tomasz Moń <desowin@gmail.com>.
+.PP
+Send comments, bug reports and patches to gdigi
+mailinglist at Google Groups.
+.PP
+This manual page was written by Andrew O. Shadoura <bugzilla@tut.by>,
+for the Debian project (but may be used by others).
+.PP
+Permission is granted to copy, distribute and/or modify this document under the
+terms of the GNU General Public License as published by the Free Software
+Foundation, under version 3 of the License.
+
--- a/gdigi.c
+++ b/gdigi.c
--- a/gdigi.desktop
+++ b/gdigi.desktop
@@ -0,0 +1,6 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Name=gdigi
+Exec=gdigi
+
--- a/gdigi.h
+++ b/gdigi.h
--- a/gtkknob.c
+++ b/gtkknob.c
@@ -0,0 +1,919 @@
+/*****************************************************************************
+ *
+ * Most of this code comes from gAlan 0.2.0, copyright (C) 1999
+ * Tony Garnock-Jones, with modifications from Sean Bolton,
+ * copyright (C) 2004, William Weston copyright (C) 2007,
+ * Pete Shorthose copyright (C) 2007, and Tomasz Moń,
+ * copyright (C) 2009
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *****************************************************************************/
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include "gtkknob.h"
+
+
+#ifndef M_PI
+# define M_PI		3.14159265358979323846	/* pi */
+#endif
+#ifndef M_1_PI
+# define M_1_PI		0.31830988618379067154	/* 1/pi */
+#endif
+
+
+#define SCROLL_DELAY_LENGTH	250
+#define KNOB_SIZE		32	/* this should really be read from the knob image */
+
+#define STATE_IDLE		0
+#define STATE_PRESSED		1
+#define STATE_DRAGGING		2
+
+static void gtk_knob_class_init(GtkKnobClass *klass);
+static void gtk_knob_init(GtkKnob *knob);
+static void gtk_knob_destroy(GtkObject *object);
+static void gtk_knob_realize(GtkWidget *widget);
+static void gtk_knob_size_request(GtkWidget *widget, GtkRequisition *requisition);
+static void gtk_knob_size_allocate(GtkWidget *widget, GtkAllocation *allocation);
+static gint gtk_knob_expose(GtkWidget *widget, GdkEventExpose *event);
+static gint gtk_knob_scroll(GtkWidget *widget, GdkEventScroll *event);
+static gint gtk_knob_button_press(GtkWidget *widget, GdkEventButton *event);
+static gint gtk_knob_button_release(GtkWidget *widget, GdkEventButton *event);
+static gint gtk_knob_key_press(GtkWidget *widget, GdkEventKey *event);
+static gint gtk_knob_motion_notify(GtkWidget *widget, GdkEventMotion *event);
+static gint gtk_knob_timer(GtkKnob *knob);
+
+static void gtk_knob_update_mouse_update(GtkKnob *knob);
+static void gtk_knob_update_mouse(GtkKnob *knob, gint x, gint y, gboolean step);
+static void gtk_knob_update(GtkKnob *knob);
+static void gtk_knob_adjustment_changed(GtkAdjustment *adjustment, gpointer data);
+static void gtk_knob_adjustment_value_changed(GtkAdjustment *adjustment, gpointer data);
+
+/* Local data */
+
+static GtkWidgetClass *parent_class = NULL;
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_get_type()
+ *
+ *****************************************************************************/
+GType
+gtk_knob_get_type(void) {
+    static GType knob_type = 0;
+
+    if (!knob_type) {
+	static const GTypeInfo knob_info = {
+	    sizeof (GtkKnobClass),
+            NULL,
+	    NULL,
+	    (GClassInitFunc) gtk_knob_class_init,
+	    NULL,
+	    NULL,
+	    sizeof (GtkKnob),
+	    0,
+	    (GInstanceInitFunc) gtk_knob_init,
+	};
+	knob_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkKnob", &knob_info, 0);
+    }
+
+    return knob_type;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_class_init()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_class_init (GtkKnobClass *klass) {
+    GtkObjectClass *object_class;
+    GtkWidgetClass *widget_class;
+
+    object_class = (GtkObjectClass*) klass;
+    widget_class = (GtkWidgetClass*) klass;
+
+    parent_class = g_type_class_peek_parent(klass);
+
+    object_class->destroy = gtk_knob_destroy;
+
+    widget_class->realize              = gtk_knob_realize;
+    widget_class->expose_event         = gtk_knob_expose;
+    widget_class->size_request         = gtk_knob_size_request;
+    widget_class->size_allocate        = gtk_knob_size_allocate;
+    widget_class->scroll_event         = gtk_knob_scroll;
+    widget_class->button_press_event   = gtk_knob_button_press;
+    widget_class->button_release_event = gtk_knob_button_release;
+    widget_class->key_press_event      = gtk_knob_key_press;
+    widget_class->motion_notify_event  = gtk_knob_motion_notify;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_init()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_init (GtkKnob *knob) {
+    knob->policy     = GTK_UPDATE_CONTINUOUS;
+    knob->state      = STATE_IDLE;
+    knob->saved_x    = 0;
+    knob->saved_y    = 0;
+    knob->timer      = 0;
+    knob->anim       = NULL;
+    knob->mask       = NULL;
+    knob->mask_gc    = NULL;
+    knob->red_gc     = NULL;
+    knob->old_value  = 0.0;
+    knob->old_lower  = 0.0;
+    knob->old_upper  = 0.0;
+    knob->adjustment = NULL;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_new()
+ *
+ *****************************************************************************/
+GtkWidget *
+gtk_knob_new(GtkAdjustment *adjustment, GtkKnobAnim *anim) {
+    GtkKnob *knob;
+
+    g_return_val_if_fail (anim != NULL, NULL);
+    g_return_val_if_fail (GDK_IS_PIXBUF (anim->pixbuf), NULL);
+
+    knob = g_object_new (gtk_knob_get_type (), NULL);
+
+    gtk_knob_set_animation (knob, anim);
+
+    if (!adjustment) {
+	adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0,
+							  0.0, 0.0, 0.0);
+    }
+
+    gtk_knob_set_adjustment (knob, adjustment);
+
+    return GTK_WIDGET (knob);
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_destroy()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_destroy(GtkObject *object) {
+    GtkKnob *knob;
+
+    g_return_if_fail (object != NULL);
+    g_return_if_fail (GTK_IS_KNOB (object));
+
+    knob = GTK_KNOB (object);
+
+    gtk_knob_set_adjustment (knob, NULL);
+    /* FIXME: needs ref counting for automatic GtkKnobAnim cleanup
+       if (knob->anim) {
+	   gtk_knob_anim_unref (knob->anim);
+	   knob->anim = NULL;
+       }
+    */
+
+    if (knob->mask) {
+	g_object_unref (knob->mask);
+	knob->mask = NULL;
+    }
+
+    if (knob->mask_gc) {
+	g_object_unref (knob->mask_gc);
+	knob->mask_gc = NULL;
+    }
+    if (knob->red_gc) {
+	g_object_unref (knob->red_gc);
+	knob->red_gc = NULL;
+    }
+
+    if (GTK_OBJECT_CLASS (parent_class)->destroy) {
+	(*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_get_adjustment()
+ *
+ *****************************************************************************/
+GtkAdjustment*
+gtk_knob_get_adjustment(GtkKnob *knob) {
+
+    g_return_val_if_fail (knob != NULL, NULL);
+    g_return_val_if_fail (GTK_IS_KNOB (knob), NULL);
+
+    return knob->adjustment;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_set_update_policy()
+ *
+ *****************************************************************************/
+void
+gtk_knob_set_update_policy(GtkKnob *knob, GtkUpdateType policy) {
+
+    g_return_if_fail (knob != NULL);
+    g_return_if_fail (GTK_IS_KNOB (knob));
+
+    knob->policy = policy;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_set_adjustment()
+ *
+ *****************************************************************************/
+void
+gtk_knob_set_adjustment(GtkKnob *knob, GtkAdjustment *adjustment) {
+
+    g_return_if_fail (knob != NULL);
+    g_return_if_fail (GTK_IS_KNOB (knob));
+
+    if (knob->adjustment) {
+	g_signal_handlers_disconnect_matched(knob->adjustment,
+					     G_SIGNAL_MATCH_DATA,
+					     0, 0, NULL, NULL,
+					     knob);
+	g_object_unref (knob->adjustment);
+    }
+
+    knob->adjustment = adjustment;
+    if (adjustment) {
+        g_object_ref_sink (adjustment);
+
+        g_signal_connect (adjustment, "changed",
+    			G_CALLBACK(gtk_knob_adjustment_changed),
+			knob);
+	g_signal_connect (adjustment, "value_changed",
+			G_CALLBACK(gtk_knob_adjustment_value_changed),
+			knob);
+
+	knob->old_value = adjustment->value;
+	knob->old_lower = adjustment->lower;
+	knob->old_upper = adjustment->upper;
+
+	gtk_knob_update (knob);
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_realize()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_realize(GtkWidget *widget) {
+    GtkKnob *knob;
+    GdkWindowAttr attributes;
+    gint attributes_mask;
+    GdkColor color = { 0, 0xffff, 0, 0 };
+
+    g_return_if_fail (widget != NULL);
+    g_return_if_fail (GTK_IS_KNOB (widget));
+
+    GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+    GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
+    knob = GTK_KNOB (widget);
+
+    attributes.x           = widget->allocation.x;
+    attributes.y           = widget->allocation.y;
+    attributes.width       = widget->allocation.width;
+    attributes.height      = widget->allocation.height;
+    attributes.wclass      = GDK_INPUT_OUTPUT;
+    attributes.window_type = GDK_WINDOW_CHILD;
+    attributes.event_mask  =
+	gtk_widget_get_events (widget) |
+	GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
+	GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
+	GDK_POINTER_MOTION_HINT_MASK;
+    attributes.visual   = gtk_widget_get_visual (widget);
+    attributes.colormap = gtk_widget_get_colormap (widget);
+
+    attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+    widget->window = gdk_window_new (widget->parent->window,
+				     &attributes, attributes_mask);
+
+    widget->style = gtk_style_attach (widget->style, widget->window);
+
+    gdk_window_set_user_data (widget->window, widget);
+
+    gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+
+    knob->mask_gc = gdk_gc_new (widget->window);
+    gdk_gc_copy (knob->mask_gc, widget->style->bg_gc[GTK_STATE_NORMAL]);
+    gdk_gc_set_clip_mask (knob->mask_gc, knob->mask);
+
+    knob->red_gc = gdk_gc_new (widget->window);
+    gdk_gc_copy (knob->red_gc, widget->style->bg_gc[GTK_STATE_NORMAL]);
+    gdk_colormap_alloc_color (attributes.colormap, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (knob->red_gc, &color);
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_size_request()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_size_request (GtkWidget *widget, GtkRequisition *requisition) {
+
+    g_return_if_fail (widget != NULL);
+    g_return_if_fail (GTK_IS_KNOB (widget));
+
+    requisition->width  = GTK_KNOB (widget)->width;
+    requisition->height = GTK_KNOB (widget)->height;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_size_allocate()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_size_allocate (GtkWidget *widget, GtkAllocation *allocation) {
+    GtkKnob *knob;
+
+    g_return_if_fail (widget != NULL);
+    g_return_if_fail (GTK_IS_KNOB (widget));
+    g_return_if_fail (allocation != NULL);
+
+    widget->allocation = *allocation;
+    knob = GTK_KNOB (widget);
+
+    if (GTK_WIDGET_REALIZED (widget)) {
+	gdk_window_move_resize (widget->window,
+				allocation->x, allocation->y,
+				allocation->width, allocation->height);
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_expose()
+ *
+ *****************************************************************************/
+static gint
+gtk_knob_expose(GtkWidget *widget, GdkEventExpose *event) {
+    GtkKnob *knob;
+    gfloat dx, dy;
+    gint frames;
+
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_ADJUSTMENT (GTK_KNOB (widget)->adjustment), FALSE);
+
+    if (event->count > 0)
+	return FALSE;
+
+    knob = GTK_KNOB (widget);
+
+    frames = ((knob->anim->width / knob->anim->frame_width) - 1);
+    dx = knob->adjustment->value - knob->adjustment->lower;	/* value, from 0 */
+    dy = knob->adjustment->upper - knob->adjustment->lower;	/* range */
+
+    dx = (int)(frames * dx / dy) * knob->width;  /* check this for height != width */
+
+    gdk_draw_pixbuf (widget->window, knob->mask_gc, knob->anim->pixbuf,
+		     dx, 0, 0, 0, knob->width, knob->height,
+		     GDK_RGB_DITHER_NONE, 0, 0);
+
+    if (GTK_WIDGET_HAS_FOCUS(widget)) {
+        gtk_paint_focus (widget->style, widget->window, widget->state,
+                         NULL, widget, NULL, 0, 0,
+                         widget->allocation.width, widget->allocation.height);
+    }
+
+    return FALSE;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_scroll()
+ *
+ *****************************************************************************/
+static gint
+gtk_knob_scroll(GtkWidget *widget, GdkEventScroll *event) {
+    GtkKnob *knob;
+
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_ADJUSTMENT (GTK_KNOB (widget)->adjustment), FALSE);
+
+    knob = GTK_KNOB (widget);
+
+    switch (event->direction) {
+    case GDK_SCROLL_UP:
+	knob->adjustment->value += knob->adjustment->step_increment;
+	g_signal_emit_by_name (knob->adjustment, "value_changed");
+	break;
+    case GDK_SCROLL_DOWN:
+	knob->adjustment->value -= knob->adjustment->step_increment;
+	g_signal_emit_by_name (knob->adjustment, "value_changed");
+	break;
+    default:
+        break;
+    }
+
+    return FALSE;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_button_press()
+ *
+ *****************************************************************************/
+static gint
+gtk_knob_button_press(GtkWidget *widget, GdkEventButton *event) {
+    GtkKnob *knob;
+
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_ADJUSTMENT (GTK_KNOB (widget)->adjustment), FALSE);
+
+    knob = GTK_KNOB (widget);
+
+    switch (knob->state) {
+    case STATE_IDLE:
+	switch (event->button) {
+	case 1:
+	case 3:
+	    if (!GTK_WIDGET_HAS_FOCUS(widget))
+	        gtk_widget_grab_focus(widget);
+	    knob->state   = STATE_PRESSED;
+	    knob->saved_x = event->x;
+	    knob->saved_y = event->y;
+	    break;
+	case 2:
+	    knob->adjustment->value = floor ((knob->adjustment->lower +
+					      knob->adjustment->upper + 1.0)
+					     * 0.5);
+	    g_signal_emit_by_name (knob->adjustment, "value_changed");
+	    break;
+	}
+	break;
+    }
+
+    return FALSE;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_button_release()
+ *
+ *****************************************************************************/
+static gint
+gtk_knob_button_release(GtkWidget *widget, GdkEventButton *event) {
+    GtkKnob *knob;
+
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_ADJUSTMENT (GTK_KNOB (widget)->adjustment), FALSE);
+
+    knob = GTK_KNOB (widget);
+
+    switch (knob->state) {
+
+    case STATE_PRESSED:
+	knob->state = STATE_IDLE;
+	break;
+
+    case STATE_DRAGGING:
+	knob->state = STATE_IDLE;
+
+	switch (event->button) {
+	case 1:
+	case 3:
+	    if (knob->policy != GTK_UPDATE_CONTINUOUS
+		&& knob->old_value != knob->adjustment->value)
+	    {
+		g_signal_emit_by_name (knob->adjustment, "value_changed");
+	    }
+	    break;
+	}
+
+	break;
+    }
+
+    return FALSE;
+}
+
+static gint gtk_knob_key_press(GtkWidget *widget, GdkEventKey *event)
+{
+    GtkKnob *knob;
+
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_ADJUSTMENT (GTK_KNOB (widget)->adjustment), FALSE);
+
+    knob = GTK_KNOB (widget);
+
+    switch (event->keyval) {
+
+    case GDK_Up:
+        if (GTK_WIDGET_HAS_FOCUS (widget))
+        {
+            gtk_adjustment_set_value (knob->adjustment,
+                                      knob->old_value + knob->adjustment->step_increment);
+            return TRUE;
+        }
+        return FALSE;
+
+    case GDK_Down:
+        if (GTK_WIDGET_HAS_FOCUS (widget))
+        {
+            gtk_adjustment_set_value (knob->adjustment,
+                                      knob->old_value - knob->adjustment->step_increment);
+            return TRUE;
+        }
+        return FALSE;
+    default:
+        break;
+    }
+
+    return GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
+}
+
+/*****************************************************************************
+ *
+ * gtk_knob_motion_notify()
+ *
+ *****************************************************************************/
+static gint
+gtk_knob_motion_notify(GtkWidget *widget, GdkEventMotion *event) {
+    GtkKnob *knob;
+    GdkModifierType mods;
+    gint x, y;
+
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+
+    knob = GTK_KNOB (widget);
+
+    x = event->x;
+    y = event->y;
+
+    if (event->is_hint || (event->window != widget->window)) {
+	gdk_window_get_pointer (widget->window, &x, &y, &mods);
+    }
+
+    switch (knob->state) {
+
+    case STATE_PRESSED:
+	knob->state = STATE_DRAGGING;
+	/* fall through */
+
+    case STATE_DRAGGING:
+	if (mods & GDK_BUTTON1_MASK) {
+	    gtk_knob_update_mouse (knob, x, y, TRUE);
+	    return TRUE;
+	}
+	else if (mods & GDK_BUTTON3_MASK) {
+	    gtk_knob_update_mouse (knob, x, y, FALSE);
+	    return TRUE;
+	}
+	break;
+    }
+
+    return FALSE;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_timer()
+ *
+ *****************************************************************************/
+static gint
+gtk_knob_timer(GtkKnob *knob) {
+
+    g_return_val_if_fail (knob != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_KNOB (knob), FALSE);
+    g_return_val_if_fail (GTK_IS_ADJUSTMENT (knob->adjustment), FALSE);
+
+    if (knob->policy == GTK_UPDATE_DELAYED) {
+	g_signal_emit_by_name (knob->adjustment, "value_changed");
+    }
+
+    /* don't keep running this timer */
+    return FALSE;
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_update_mouse_update()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_update_mouse_update(GtkKnob *knob) {
+    g_return_if_fail(GTK_IS_ADJUSTMENT (knob->adjustment));
+
+    if (knob->policy == GTK_UPDATE_CONTINUOUS) {
+	g_signal_emit_by_name (knob->adjustment, "value_changed");
+    }
+    else {
+	gtk_widget_queue_draw (GTK_WIDGET (knob));
+
+	if (knob->policy == GTK_UPDATE_DELAYED) {
+	    if (knob->timer) {
+		g_source_remove (knob->timer);
+	    }
+	    knob->timer = g_timeout_add (SCROLL_DELAY_LENGTH,
+					 (GSourceFunc) gtk_knob_timer,
+					 (gpointer) knob);
+	}
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_update_mouse()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_update_mouse(GtkKnob *knob, gint x, gint y, gboolean step) {
+    gfloat old_value, new_value, dv, dh;
+    gfloat angle;
+
+    g_return_if_fail (knob != NULL);
+    g_return_if_fail (GTK_IS_KNOB (knob));
+    g_return_if_fail (GTK_IS_ADJUSTMENT (knob->adjustment));
+
+    old_value = knob->adjustment->value;
+
+    angle = atan2f (-y + (knob->height >> 1), x - (knob->width >> 1));
+
+    /* inverted cartesian graphics coordinate system */
+    dv = knob->saved_y - y;
+    dh = x - knob->saved_x;
+    knob->saved_x = x;
+    knob->saved_y = y;
+
+    if ((x >= 0) && (x <= knob->width)) {
+        dh = 0;  /* dead zone */
+    } else {
+        angle = cosf (angle);
+        dh *= angle * angle;
+    }
+
+    new_value = knob->adjustment->value +
+                dv * (step ? knob->adjustment->step_increment : knob->adjustment->page_increment) +
+                dh * (knob->adjustment->upper -
+                knob->adjustment->lower) * 0.005; /* 0.005 == (1 / 200) */
+
+    new_value = MAX (MIN (new_value, knob->adjustment->upper),
+                     knob->adjustment->lower);
+
+    knob->adjustment->value = new_value;
+
+    if (knob->adjustment->value != old_value) {
+        gtk_knob_update_mouse_update (knob);
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_update()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_update(GtkKnob *knob) {
+    gfloat new_value;
+
+    g_return_if_fail (knob != NULL);
+    g_return_if_fail (GTK_IS_KNOB (knob));
+    g_return_if_fail (GTK_IS_ADJUSTMENT (knob->adjustment));
+
+    if (knob->adjustment->step_increment == 1) {
+	new_value = floor (knob->adjustment->value + 0.5);
+    }
+    else {
+	new_value = knob->adjustment->value;
+    }
+
+    if (new_value < knob->adjustment->lower) {
+	new_value = knob->adjustment->lower;
+    }
+
+    if (new_value > knob->adjustment->upper) {
+	new_value = knob->adjustment->upper;
+    }
+
+    if (new_value != knob->adjustment->value) {
+	knob->adjustment->value = new_value;
+	g_signal_emit_by_name (knob->adjustment, "value_changed");
+    }
+
+    gtk_widget_queue_draw (GTK_WIDGET (knob));
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_adjustment_changed()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_adjustment_changed(GtkAdjustment *adjustment, gpointer data) {
+    GtkKnob *knob;
+
+    g_return_if_fail (adjustment != NULL);
+    g_return_if_fail (data != NULL);
+
+    knob = GTK_KNOB (data);
+
+    if ((knob->old_value != adjustment->value) ||
+	(knob->old_lower != adjustment->lower) ||
+	(knob->old_upper != adjustment->upper))
+    {
+	gtk_knob_update (knob);
+
+	knob->old_value = adjustment->value;
+	knob->old_lower = adjustment->lower;
+	knob->old_upper = adjustment->upper;
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_adjustment_value_changed()
+ *
+ *****************************************************************************/
+static void
+gtk_knob_adjustment_value_changed (GtkAdjustment *adjustment, gpointer data) {
+    GtkKnob *knob;
+
+    g_return_if_fail (adjustment != NULL);
+    g_return_if_fail (data != NULL);
+
+    knob = GTK_KNOB (data);
+
+    if (knob->old_value != adjustment->value) {
+	gtk_knob_update (knob);
+	knob->old_value = adjustment->value;
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_set_animation()
+ *
+ *****************************************************************************/
+void
+gtk_knob_set_animation (GtkKnob *knob, GtkKnobAnim *anim) {
+    g_return_if_fail (knob != NULL);
+    g_return_if_fail (anim != NULL);
+    g_return_if_fail (GTK_IS_KNOB (knob));
+    g_return_if_fail (GDK_IS_PIXBUF (anim->pixbuf));
+
+    knob->anim   = (GtkKnobAnim *)anim;
+    knob->width  = anim->frame_width;
+    knob->height = anim->height;
+
+    if (GTK_WIDGET_REALIZED (knob)) {
+    	gtk_widget_queue_resize (GTK_WIDGET (knob));
+    }
+}
+
+
+/*****************************************************************************
+ *
+ * gtk_knob_animation_new_from_file()
+ *
+ *****************************************************************************/
+GtkKnobAnim *
+gtk_knob_animation_new_from_file(gchar *filename) {
+    GtkKnobAnim *anim;
+
+    anim = gtk_knob_animation_new_from_file_full (filename, -1, -1, KNOB_SIZE);
+    return anim;
+}
+
+/*****************************************************************************
+ *
+ * gtk_knob_animation_new_from_inline()
+ *
+ *****************************************************************************/
+GtkKnobAnim *
+gtk_knob_animation_new_from_inline(const guint8 *pixbuf) {
+    GtkKnobAnim *anim = g_new0 (GtkKnobAnim, 1);
+
+    g_return_val_if_fail((pixbuf != NULL), NULL);
+
+    anim->pixbuf = gdk_pixbuf_new_from_inline(-1, pixbuf, FALSE, NULL);
+    if (anim->pixbuf == NULL) {
+        g_free(anim);
+        return NULL;
+    }
+
+    anim->height      = gdk_pixbuf_get_height (anim->pixbuf);
+    anim->width       = gdk_pixbuf_get_width (anim->pixbuf);
+    anim->frame_width = anim->height;
+
+    return anim;
+}
+
+/*****************************************************************************
+ *
+ * gtk_knob_new_from_file_full()
+ *
+ * frame_width: overrides the frame width (to make rectangular frames)
+ * but doesn't affect the image size width and height cause optional
+ * scaling if not set to -1 when they are derived from the native
+ * image size.
+ *
+ * FIXME: account for any problems where (width % frame_width != 0)
+ *
+ *****************************************************************************/
+GtkKnobAnim *
+gtk_knob_animation_new_from_file_full(gchar *filename, gint frame_width,
+				      gint width, gint height) {
+    GtkKnobAnim *anim = g_new0 (GtkKnobAnim, 1);
+
+    g_return_val_if_fail ((filename != NULL), NULL);
+
+    GError *gerror = NULL;
+
+#if GTK_MINOR_VERSION < 10
+    if (!(anim->pixbuf = gdk_pixbuf_new_from_file (filename, &gerror))) {
+        g_error_free(gerror);
+        gerror = NULL;
+	return NULL;
+    }
+#else /* GTK_MINOR_VERSION >= 10 */
+    if (!(anim->pixbuf = gdk_pixbuf_new_from_file_at_size (filename, width,
+							   height, &gerror))) {
+        g_error_free(gerror);
+        gerror = NULL;
+	return NULL;
+    }
+#endif /* GTK_MINOR_VERSION < 10 */
+    else {
+	anim->height      = gdk_pixbuf_get_height (anim->pixbuf);
+	anim->width       = gdk_pixbuf_get_width (anim->pixbuf);
+	anim->frame_width = (frame_width != -1) ? frame_width : anim->height;
+    }
+
+    return anim;
+}
+
+/*****************************************************************************
+ *
+ * gtk_knob_animation_free()
+ *
+ *****************************************************************************/
+void
+gtk_knob_animation_free(GtkKnobAnim *anim) {
+    g_return_if_fail (anim != NULL);
+
+    if (anim->pixbuf)
+        g_object_unref (anim->pixbuf);
+
+    g_free (anim);
+}
--- a/gtkknob.h
+++ b/gtkknob.h
@@ -0,0 +1,102 @@
+/*****************************************************************************
+ *
+ * Most of this code comes from gAlan 0.2.0, copyright (C) 1999
+ * Tony Garnock-Jones, with modifications by Sean Bolton,
+ * copyright (C) 2004, and minor modifications by William Weston,
+ * copyright (C) 2007, Tomasz Moń, copyright (C) 2009
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *****************************************************************************/
+#ifndef __GTK_KNOB_H__
+#define __GTK_KNOB_H__
+
+#include <gtk/gtk.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GTK_KNOB(obj)		G_TYPE_CHECK_INSTANCE_CAST(obj, gtk_knob_get_type(), GtkKnob)
+#define GTK_KNOB_CLASS(klass)	G_TYPE_CHECK_CLASS_CAST(klass, gtk_knob_get_type(), GtkKnobClass)
+#define GTK_IS_KNOB(obj)	G_TYPE_CHECK_INSTANCE_TYPE(obj, gtk_knob_get_type())
+
+typedef struct _GtkKnob		GtkKnob;
+typedef struct _GtkKnobClass	GtkKnobClass;
+typedef struct _GtkKnobAnim	GtkKnobAnim;
+
+	/* better to make this an object and let widgets ref/deref it perhaps */
+    struct _GtkKnobAnim {
+	GdkPixbuf *pixbuf;
+	gint width;  /* derived from image width */
+	gint height;  /* derived from image height. */
+	gint frame_width;  /* derived from pixbuf (width / height) or provided override for rectangular frames */
+    };
+    
+    struct _GtkKnob {
+	GtkWidget widget;
+
+	/* update policy (GTK_UPDATE_[CONTINUOUS/DELAYED/DISCONTINUOUS]) */
+	guint policy : 2;
+
+	/* State of widget (to do with user interaction) */
+	guint8 state;
+	gint saved_x, saved_y;
+
+	/* ID of update timer, or 0 if none */
+	guint32 timer;
+
+	/* knob animation */
+	GtkKnobAnim *anim;
+	gint width, height;
+	
+	GdkBitmap *mask;
+	GdkGC *mask_gc;
+	GdkGC *red_gc;
+
+	/* Old values from adjustment stored so we know when something changes */
+	gfloat old_value;
+	gfloat old_lower;
+	gfloat old_upper;
+
+	/* The adjustment object that stores the data for this knob */
+	GtkAdjustment *adjustment;
+    };
+
+    struct _GtkKnobClass {
+	GtkWidgetClass parent_class;
+    };
+
+
+    extern GtkWidget *gtk_knob_new(GtkAdjustment *adjustment, GtkKnobAnim *anim);
+    extern GType gtk_knob_get_type(void);
+    extern GtkAdjustment *gtk_knob_get_adjustment(GtkKnob *knob);
+    extern void gtk_knob_set_update_policy(GtkKnob *knob, GtkUpdateType  policy);
+    extern void gtk_knob_set_adjustment(GtkKnob *knob, GtkAdjustment *adjustment);
+
+    GtkKnobAnim *gtk_knob_animation_new_from_inline(const guint8 *pixbuf);
+    GtkKnobAnim *gtk_knob_animation_new_from_file_full(gchar *filename,
+						       gint frame_width,
+						       gint width,
+						       gint height);
+
+    GtkKnobAnim *gtk_knob_animation_new_from_file(gchar *filename);
+    void gtk_knob_set_animation (GtkKnob *knob, GtkKnobAnim *anim);
+    void gtk_knob_animation_free(GtkKnobAnim *anim);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/gui.c
+++ b/gui.c
--- a/gui.h
+++ b/gui.h
@@ -17,6 +17,14 @@
 #ifndef GDIGI_GUI_H
 #define GDIGI_GUI_H

-void create_window();
+#include <glib.h>
+#include "effects.h"
+
+void show_error_message(GtkWidget *parent, gchar *message);
+void apply_setting_param_to_gui(SettingParam *param);
+gboolean apply_current_preset_to_gui(gpointer data);
+void gui_create(Device *device);
+void gui_free();
+gboolean unsupported_device_dialog(Device **device);

 #endif /* GDIGI_GUI_H */
--- a/knob.png
+++ b/knob.png
--- a/preset.c
+++ b/preset.c
@@ -18,6 +18,9 @@
 #include <expat.h>
 #include <string.h>
 #include "preset.h"
+#include "gdigi.h"
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS

 enum {
  PARSER_TYPE_NOT_SET = -1,
@@ -26,12 +29,24 @@ enum {
  PARSER_TYPE_PARAM_POSITION,
  PARSER_TYPE_PARAM_VALUE,
  PARSER_TYPE_PARAM_NAME,
-  PARSER_TYPE_PARAM_TEXT
+  PARSER_TYPE_PARAM_TEXT,
+  PARSER_TYPE_GENETX_VERSION,
+  PARSER_TYPE_GENETX_TYPE,
+  PARSER_TYPE_GENETX_CHANNEL,
+  PARSER_TYPE_GENETX_NAME,
+  PARSER_TYPE_GENETX_DATA
+};
+
+enum {
+  SECTION_NOT_SET = -1,
+  SECTION_PARAMS,
+  SECTION_GENETX
 };

 typedef struct {
    int depth;
    int id;
+    int section;
    Preset *preset;
 } AppData;

@@ -43,18 +58,20 @@ static void XMLCALL start(void *data, const char *el, const char **attr) {
        if (ad->depth == 1) {
            ad->id = PARSER_TYPE_PRESET_NAME;
        } else if (ad->depth == 3) {
+            if (ad->section == SECTION_PARAMS) {
                ad->id = PARSER_TYPE_PARAM_NAME;
+            } else if (ad->section == SECTION_GENETX) {
+                ad->id = PARSER_TYPE_GENETX_NAME;
+            }
        }
    }

    if (g_strcmp0(el, "Params") == 0) {
+        ad->section = SECTION_PARAMS;
        if (ad->preset->params != NULL)
            g_message("Params aleady exists!");
    } else if (g_strcmp0(el, "Param") == 0) {
-        SettingParam *param = (SettingParam *)g_malloc(sizeof(SettingParam));
-        param->id = -1;
-        param->position = -1;
-        param->value = -1;
+        SettingParam *param = setting_param_new();
        ad->preset->params = g_list_prepend(ad->preset->params, param);
    } else if (g_strcmp0(el, "ID") == 0) {
        ad->id = PARSER_TYPE_PARAM_ID;
@@ -64,6 +81,21 @@ static void XMLCALL start(void *data, const char *el, const char **attr) {
        ad->id = PARSER_TYPE_PARAM_VALUE;
    } else if (g_strcmp0(el, "Text") == 0) {
        ad->id = PARSER_TYPE_PARAM_TEXT;
+    } else if (g_strcmp0(el, "Genetx") == 0) {
+        ad->section = SECTION_GENETX;
+        if (ad->preset->genetxs != NULL)
+            g_message("Genetx already exists!");
+    } else if (g_strcmp0(el, "GenetxModel") == 0) {
+        SettingGenetx *genetx = setting_genetx_new();
+        ad->preset->genetxs = g_list_prepend(ad->preset->genetxs, genetx);
+    } else if (g_strcmp0(el, "Version") == 0) {
+        ad->id = PARSER_TYPE_GENETX_VERSION;
+    } else if (g_strcmp0(el, "Type") == 0) {
+        ad->id = PARSER_TYPE_GENETX_TYPE;
+    } else if (g_strcmp0(el, "Channel") == 0) {
+        ad->id = PARSER_TYPE_GENETX_CHANNEL;
+    } else if (g_strcmp0(el, "Data") == 0) {
+        ad->id = PARSER_TYPE_GENETX_DATA;
    }

    ad->depth++;
@@ -88,6 +120,7 @@ static void XMLCALL text_cb(void *data, const char* text, int len)
        ad->preset->name = g_strndup(text, len);
    }

+    if (ad->section == SECTION_PARAMS) {
        if (ad->preset->params == NULL)
            return;

@@ -110,31 +143,94 @@ static void XMLCALL text_cb(void *data, const char* text, int len)
        }

        g_free(value);
+    } else if (ad->section == SECTION_GENETX) {
+        if (ad->preset->genetxs == NULL)
+            return;
+
+        SettingGenetx *genetx = (SettingGenetx *) ad->preset->genetxs->data;
+        if (genetx == NULL)
+            return;
+
+        gchar *value = g_strndup(text, len);
+
+        switch (ad->id) {
+            case PARSER_TYPE_GENETX_VERSION:
+                if (g_strcmp0(value, "Version1") == 0) {
+                    genetx->version = GENETX_VERSION_1;
+                } else if (g_strcmp0(value, "Version2") == 0) {
+                    genetx->version = GENETX_VERSION_2;
+                } else {
+                    g_message("Unknown GeNetX version: %s", value);
+                }
+                break;
+            case PARSER_TYPE_GENETX_TYPE:
+                if (g_strcmp0(value, "Amp") == 0) {
+                    genetx->type = GENETX_TYPE_AMP;
+                } else if (g_strcmp0(value, "Cabinet") == 0) {
+                    genetx->type = GENETX_TYPE_CABINET;
+                } else {
+                    g_message("Unknown GeNetX type: %s", value);
+                }
+                break;
+            case PARSER_TYPE_GENETX_CHANNEL:
+                if (g_strcmp0(value, "Channel1") == 0) {
+                    genetx->channel = GENETX_CHANNEL1;
+                } else if (g_strcmp0(value, "Channel2") == 0) {
+                    genetx->channel = GENETX_CHANNEL2;
+                } else {
+                    g_message("Unknown GeNetX channel: %s", value);
+                }
+                break;
+            case PARSER_TYPE_GENETX_NAME:
+                /* reassign pointer */
+                genetx->name = value;
+                value = NULL;
+                break;
+            case PARSER_TYPE_GENETX_DATA:
+                {
+                    guchar *data = NULL;
+                    gsize length = 0;
+
+                    data = g_base64_decode(value, &length);
+                    genetx->data = g_string_new_len((gchar *) data, length);
+
+                    g_free(data);
+                    break;
+                }
        }

-/*
-   Parses preset file
-   On success returns Preset which must be freed using preset_free, or NULL on error
-*/
-Preset *create_preset_from_xml_file(gchar *filename)
+        g_free(value);
+    }
+}
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+/**
+ *  \param filename valid path to file
+ *  \param error return location for an error
+ *
+ *  Tries to open file pointed by path, then parses it.
+ *
+ *  \return Preset which must be freed using preset_free, or NULL on error.
+ **/
+Preset *create_preset_from_xml_file(gchar *filename, GError **error)
 {
-    GFile *file;
-    GError *error = NULL;
+    GError *err = NULL;
    gchar *contents;

-    file = g_file_new_for_path(filename);
-    if (g_file_get_contents(filename, &contents, NULL, &error) == FALSE) {
-        g_message("Failed to get %s contents: %s", filename, error->message);
-        g_error_free(error);
-        g_object_unref(file);
+    if (g_file_get_contents(filename, &contents, NULL, &err) == FALSE) {
+        g_message("Failed to get %s contents: %s", filename, err->message);
+        *error = g_error_copy(err);
+        g_error_free(err);
        return NULL;
    }

-    AppData *ad = (AppData *) g_malloc(sizeof(AppData));
+    AppData *ad = g_slice_new(AppData);
    ad->depth = 0;
-    ad->preset = g_malloc(sizeof(Preset));
+    ad->preset = g_slice_new(Preset);
    ad->preset->name = NULL;
    ad->preset->params = NULL;
+    ad->preset->genetxs = NULL;
    ad->id = PARSER_TYPE_NOT_SET;

    XML_Parser p;
@@ -144,38 +240,118 @@ Preset *create_preset_from_xml_file(gchar *filename)
    XML_SetCharacterDataHandler(p, text_cb);

    if (XML_Parse(p, contents, strlen(contents), XML_TRUE) != XML_STATUS_OK) {
-        g_warning("Parse error at line %d:\n%s",
+        g_set_error(error, 0, 0, "Parse error at line %d:\n%s",
                    (int)XML_GetCurrentLineNumber(p),
                    XML_ErrorString(XML_GetErrorCode(p)));
        preset_free(ad->preset);
-        g_free(ad);
+        g_slice_free(AppData, ad);
        g_free(contents);
-        g_object_unref(file);
        return NULL;
    }

    Preset *preset = ad->preset;
    preset->params = g_list_reverse(preset->params);
+    preset->genetxs = g_list_reverse(preset->genetxs);

    XML_ParserFree(p);
-    g_free(ad);
+    g_slice_free(AppData, ad);

    g_free(contents);
-    g_object_unref(file);
    return preset;
 }

+/**
+ *  \param list list containing unpacked preset SysEx messages.
+ *
+ *  Parses message
+ *
+ *  \return Preset which must be freed using preset_free, or NULL on error.
+ **/
+Preset *create_preset_from_data(GList *list)
+{
+    GString *data;
+    GList *iter;
+    gint total, n, x;
+    gint bank, number, modified;
+    gchar *name;
+
+    g_return_val_if_fail(list != NULL, NULL);
+
+    Preset *preset = g_slice_new(Preset);
+    preset->name = NULL;
+    preset->params = NULL;
+    preset->genetxs = NULL;
+
+    iter = list;
+    for (iter = list; iter; iter = g_list_next(iter)) {
+        data = (GString*) iter->data;
+        switch (get_message_id(data)) {
+            case RECEIVE_PRESET_START:
+                bank = (unsigned char)data->str[8];
+                number = (unsigned char)data->str[9];
+                name = g_strdup(&data->str[10]);
+                modified = (unsigned char)data->str[11+strlen(name)];
+
+                if ((bank == PRESETS_EDIT_BUFFER) && (number == 0)) {
+                    g_message("Received current edit buffer");
+                } else {
+                    g_message("Received preset %d from bank %d", number, bank);
+                }
+
+                g_message("Modified flag: %d Name: %s", modified, name);
+                preset->name = name;
+                break;
+            case RECEIVE_PRESET_PARAMETERS:
+                x = 0x09;
+                n = 0;
+                total = (unsigned char)data->str[x];
+                x++;
+
+                do {
+                    SettingParam *param = setting_param_new_from_data(&data->str[x], &x);
+                    n++;
+                    preset->params = g_list_prepend(preset->params, param);
+                    g_message("%d ID %d Position %d Value %d", n, param->id, param->position, param->value);
+                } while ((x < data->len) && n<total);
+                g_message("TOTAL %d", total);
+                preset->params = g_list_reverse(preset->params);
+                break;
+            case RECEIVE_PRESET_END:
+                break;
+            default:
+                g_message("Unhandled message in preset messages list");
+        }
+    }
+
+    return preset;
+}
+
+/**
+ *  \param preset preset to be freed
+ *
+ *  Frees all memory used by preset.
+ **/
 void preset_free(Preset *preset)
 {
    g_return_if_fail(preset != NULL);

    if (preset->params != NULL) {
-        g_list_foreach(preset->params, (GFunc)g_free, NULL);
+        GList *iter;
+        for (iter = preset->params; iter; iter = iter->next) {
+            setting_param_free((SettingParam*)iter->data);
+        }
        g_list_free(preset->params);
    }

-    if (preset->name != NULL)
+    if (preset->genetxs != NULL) {
+        GList *iter;
+        for (iter = preset->genetxs; iter; iter = iter->next) {
+            setting_genetx_free((SettingGenetx*)iter->data);
+        }
+        g_list_free(preset->genetxs);
+    }
+
    g_free(preset->name);

-    g_free(preset);
+    g_slice_free(Preset, preset);
 }
--- a/preset.h
+++ b/preset.h
@@ -19,18 +19,14 @@

 #include <glib.h>

-typedef struct {
-    int id;
-    int position;
-    int value;
-} SettingParam;
-
 typedef struct {
    gchar *name;
    GList *params;
+    GList *genetxs;
 } Preset;

-Preset *create_preset_from_xml_file(gchar *filename);
+Preset *create_preset_from_xml_file(gchar *filename, GError **error);
+Preset *create_preset_from_data(GList *list);
 void preset_free(Preset *preset);

 #endif /* GDIGI_PRESET_H */
--- a/tests.c
+++ b/tests.c
@@ -1,889 +0,0 @@
-/*
- *  Copyright (c) 2009 Tomasz Moń <desowin@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; under version 3 of the License.
- *
- *  This program 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 General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses>.
- */
-
-#include "gdigi.h"
-
-void test_wah()
-{
-    int x;
-
-    set_option(WAH_TYPE, WAH_POSITION, WAH_TYPE_CRY);
-    for (x=0; x<=99; x++)
-        set_option(WAH_MIN, WAH_POSITION_MIN_MAX, x);
-
-    for (x=0; x<=99; x++)
-        set_option(WAH_MAX, WAH_POSITION_MIN_MAX, x);
-
-    for (x=0; x<=12; x++)
-        set_option(WAH_LEVEL, WAH_POSITION, x);
-
-    set_option(WAH_TYPE, WAH_POSITION, WAH_TYPE_FULLRANGE);
-    for (x=0; x<=99; x++)
-        set_option(WAH_MIN, WAH_POSITION_MIN_MAX, x);
-
-    for (x=0; x<=99; x++)
-        set_option(WAH_MAX, WAH_POSITION_MIN_MAX, x);
-
-    for (x=0; x<=12; x++)
-        set_option(WAH_LEVEL, WAH_POSITION, x);
-
-    set_option(WAH_TYPE, WAH_POSITION, WAH_TYPE_CLYDE);
-    for (x=0; x<=99; x++)
-        set_option(WAH_MIN, WAH_POSITION_MIN_MAX, x);
-
-    for (x=0; x<=99; x++)
-        set_option(WAH_MAX, WAH_POSITION_MIN_MAX, x);
-
-    for (x=0; x<=12; x++)
-        set_option(WAH_LEVEL, WAH_POSITION, x);
-
-    set_option(WAH_ON_OFF, WAH_POSITION, 1);
-    set_option(WAH_ON_OFF, WAH_POSITION, 0);
-}
-
-void test_compressor()
-{
-    int x;
-
-    set_option(COMP_TYPE, COMP_POSITION, COMP_TYPE_DIGI);
-    for (x=0; x<=99; x++)
-        set_option(COMP_SUSTAIN, COMP_POSITION, x);
-
-    for (x=0; x<=99; x++)
-        set_option(COMP_TONE, COMP_POSITION, x);
-
-    for (x=0; x<=99; x++)
-        set_option(COMP_ATTACK, COMP_POSITION, x);
-
-    for (x=0; x<=99; x++)
-        set_option(COMP_LEVEL, COMP_POSITION, x);
-
-    set_option(COMP_TYPE, COMP_POSITION, COMP_TYPE_CS);
-    for (x=0; x<=99; x++)
-        set_option(COMP_SUSTAIN, COMP_POSITION, x);
-
-    for (x=0; x<=99; x++)
-        set_option(COMP_ATTACK, COMP_POSITION, x);
-
-    for (x=0; x<=99; x++)
-        set_option(COMP_LEVEL, COMP_POSITION, x);
-
-    set_option(COMP_ON_OFF, COMP_POSITION, 1);
-    set_option(COMP_ON_OFF, COMP_POSITION, 0);
-}
-
-void test_dist()
-{
-    int x;
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_SCREAMER);
-    for (x=0; x<=99; x++)
-        set_option(DIST_SCREAMER_DRIVE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_SCREAMER_TONE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_SCREAMER_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_808);
-    for (x=0; x<=99; x++)
-        set_option(DIST_808_OVERDRIVE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_808_TONE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_808_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_GUYOD);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GUYOD_DRIVE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GUYOD_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_DOD250);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DOD250_GAIN, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DOD250_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_RODENT);
-    for (x=0; x<=99; x++)
-        set_option(DIST_RODENT_DIST, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_RODENT_FILTER, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_RODENT_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_MX);
-    for (x=0; x<=99; x++)
-        set_option(DIST_MX_DIST, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_MX_OUTPUT, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_DS);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DS_GAIN, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DS_TONE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DS_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_GRUNGE);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GRUNGE_GRUNGE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GRUNGE_FACE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GRUNGE_LOUD, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GRUNGE_BUTT, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_ZONE);
-    for (x=0; x<=99; x++)
-        set_option(DIST_ZONE_GAIN, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_ZONE_LOW, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_ZONE_MID_LVL, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_ZONE_MID_FREQ, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_ZONE_HIGH, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_ZONE_LEVEL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_DEATH);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DEATH_LOW, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DEATH_MID, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DEATH_HIGH, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_DEATH_LVL, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_GONK);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GONK_GONK, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GONK_SMEAR, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GONK_SUCK, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_GONK_HEAVE, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_FUZZY);
-    for (x=0; x<=99; x++)
-        set_option(DIST_FUZZY_FUZZ, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_FUZZY_VOLUME, DIST_POSITION, x);
-
-    set_option(DIST_TYPE, DIST_POSITION, DIST_TYPE_MP);
-    for (x=0; x<=99; x++)
-        set_option(DIST_MP_SUSTAIN, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_MP_TONE, DIST_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIST_MP_VOLUME, DIST_POSITION, x);
-
-    set_option(DIST_ON_OFF, DIST_POSITION, 1);
-    set_option(DIST_ON_OFF, DIST_POSITION, 0);
-}
-
-void test_presets()
-{
-    int x;
-
-    for (x=0; x<=60; x++)
-        switch_preset(PRESETS_USER, x);
-
-    for (x=0; x<=60; x++)
-        switch_preset(PRESETS_SYSTEM, x);
-
-    for (x=0; x<=99; x++)
-        set_preset_level(x);
-}
-
-void test_pickups()
-{
-    set_option(PICKUP_TYPE, PICKUP_POSITION, PICKUP_TYPE_HB_SC);
-    set_option(PICKUP_TYPE, PICKUP_POSITION, PICKUP_TYPE_SC_HB);
-
-    set_option(PICKUP_ON_OFF, PICKUP_POSITION, 1);
-    set_option(PICKUP_ON_OFF, PICKUP_POSITION, 0);
-}
-
-void test_eq()
-{
-    int x;
-
-    set_option(EQ_TYPE, EQ_POSITION, EQ_TYPE_BRIGHT);
-    set_option(EQ_TYPE, EQ_POSITION, EQ_TYPE_MIDBOOST);
-    set_option(EQ_TYPE, EQ_POSITION, EQ_TYPE_SCOOP);
-    set_option(EQ_TYPE, EQ_POSITION, EQ_TYPE_WARM);
-
-    for (x=0; x<=99; x++)
-        set_option(AMP_GAIN, AMP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(AMP_LEVEL, AMP_POSITION, x);
-
-    for (x=0; x<=0x18; x++)
-        set_option(EQ_BASS, EQ_POSITION, x);
-    for (x=0; x<=0x18; x++)
-        set_option(EQ_MID, EQ_POSITION, x);
-    for (x=0; x<=4700; x++)
-        set_option(EQ_MID_HZ, EQ_POSITION, x);
-    for (x=0; x<=0x18; x++)
-        set_option(EQ_TREBLE, EQ_POSITION, x);
-    for (x=0; x<=7500; x++)
-        set_option(EQ_TREBLE_HZ, EQ_POSITION, x);
-
-    set_option(EQ_ON_OFF, EQ_POSITION, 1);
-    set_option(EQ_ON_OFF, EQ_POSITION, 0);
-}
-
-void test_noisegate()
-{
-    int x;
-
-    set_option(NOISEGATE_TYPE, NOISEGATE_POSITION, NOISEGATE_GATE);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_GATE_TRESHOLD, NOISEGATE_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_ATTACK, NOISEGATE_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_RELEASE, NOISEGATE_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_ATTN, NOISEGATE_POSITION, x);
-
-    set_option(NOISEGATE_TYPE, NOISEGATE_POSITION, NOISEGATE_SWELL);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_SWELL_SENS, NOISEGATE_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_ATTACK, NOISEGATE_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_RELEASE, NOISEGATE_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(NOISEGATE_ATTN, NOISEGATE_POSITION, x);
-
-    set_option(NOISEGATE_ON_OFF, NOISEGATE_POSITION, 1);
-    set_option(NOISEGATE_ON_OFF, NOISEGATE_POSITION, 0);
-}
-
-void test_chorusfx()
-{
-    int x;
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_CE);
-    for (x=0; x<=99; x++)
-        set_option(CE_CHORUS_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(CE_CHORUS_DEPTH, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_DUAL);
-    for (x=0; x<=99; x++)
-        set_option(DUAL_CHORUS_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DUAL_CHORUS_DEPTH, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DUAL_CHORUS_LEVEL, CHORUSFX_POSITION, x);
-    set_option(DUAL_CHORUS_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(DUAL_CHORUS_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(DUAL_CHORUS_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_MULTI);
-    for (x=0; x<=99; x++)
-        set_option(MULTI_CHORUS_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MULTI_CHORUS_DEPTH, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MULTI_CHORUS_LEVEL, CHORUSFX_POSITION, x);
-    set_option(MULTI_CHORUS_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(MULTI_CHORUS_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(MULTI_CHORUS_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_FLANGER);
-    for (x=0; x<=99; x++)
-        set_option(FLANGER_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(FLANGER_DEPTH, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(FLANGER_REGEN, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(FLANGER_LEVEL, CHORUSFX_POSITION, x);
-    set_option(FLANGER_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(FLANGER_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(FLANGER_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_MXR_FLANGER);
-    for (x=0; x<=99; x++)
-        set_option(MXR_FLANGER_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MXR_FLANGER_WIDTH, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MXR_FLANGER_REGEN, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MXR_FLANGER_MANUAL, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_PHASER);
-    for (x=0; x<=99; x++)
-        set_option(PHASER_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PHASER_DEPTH, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PHASER_REGEN, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PHASER_LEVEL, CHORUSFX_POSITION, x);
-    set_option(PHASER_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(PHASER_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(PHASER_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_VIBRATO);
-    for (x=0; x<=99; x++)
-        set_option(VIBRATO_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(VIBRATO_DEPTH, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_ROTARY);
-    for (x=0; x<=99; x++)
-        set_option(ROTARY_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(ROTARY_INTENSITY, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(ROTARY_DOPPLER, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(ROTARY_CROSSOVER, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_VIBROPAN);
-    for (x=0; x<=99; x++)
-        set_option(VIBROPAN_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(VIBROPAN_DEPTH, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(VIBROPAN_VIBRA, CHORUSFX_POSITION, x);
-    set_option(VIBROPAN_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(VIBROPAN_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(VIBROPAN_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_TREMOLO);
-    for (x=0; x<=99; x++)
-        set_option(TREMOLO_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(TREMOLO_DEPTH, CHORUSFX_POSITION, x);
-    set_option(TREMOLO_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(TREMOLO_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(TREMOLO_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_PANNER);
-    for (x=0; x<=99; x++)
-        set_option(PANNER_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PANNER_DEPTH, CHORUSFX_POSITION, x);
-    set_option(PANNER_WAVE, CHORUSFX_POSITION, WAVE_TRI);
-    set_option(PANNER_WAVE, CHORUSFX_POSITION, WAVE_SINE);
-    set_option(PANNER_WAVE, CHORUSFX_POSITION, WAVE_SQUARE);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_ENVELOPE);
-    for (x=0; x<=99; x++)
-        set_option(ENVELOPE_SENSITIVITY, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(ENVELOPE_RANGE, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_AUTOYA);
-    for (x=0; x<=99; x++)
-        set_option(AUTOYA_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(AUTOYA_INTENSITY, CHORUSFX_POSITION, x);
-    for (x=0; x<=0x31; x++)
-        set_option(AUTOYA_RANGE, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_YAYA);
-    for (x=0; x<=99; x++)
-        set_option(YAYA_PEDAL, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(YAYA_INTENSITY, CHORUSFX_POSITION, x);
-    for (x=0; x<=0x31; x++)
-        set_option(YAYA_RANGE, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_STEP_FILTER);
-    for (x=0; x<=99; x++)
-        set_option(STEP_FILTER_SPEED, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(STEP_FILTER_INTENSITY, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_WHAMMY);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_OCT_UP);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_2OCT_UP);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_2ND_DN);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_RV_2ND);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_4TH_DN);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_OCT_DN);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_2OCT_DN);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_DIV_BMB);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_M3_MA);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_2ND_MA3);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_3RD_4TH);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_4TH_5TH);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_5TH_OCT);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_HOCT_UP);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_HOCT_DN);
-    set_option(WHAMMY_AMOUNT, CHORUSFX_POSITION, WHAMMY_OCT_UD);
-    for (x=0; x<=99; x++)
-        set_option(WHAMMY_PEDAL, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(WHAMMY_MIX, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_PITCH_SHIFT);
-    for (x=0; x<=0x30; x++)
-        set_option(PITCH_AMOUNT, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PITCH_MIX, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_DETUNE);
-    for (x=0; x<=0x30; x++)
-        set_option(DETUNE_AMOUNT, CHORUSFX_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DETUNE_LEVEL, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_TYPE, CHORUSFX_POSITION, CHORUS_TYPE_IPS);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_OCT_D);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_7TH_DN);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_6TH_DN);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_5TH_DN);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_4TH_DN);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_3RD_DN);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_2ND_DN);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_2ND_UP);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_3RD_UP);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_4TH_UP);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_5TH_UP);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_6TH_UP);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_7TH_UP);
-    set_option(IPS_SHIFT_AMOUNT, CHORUSFX_POSITION, IPS_OCT_U);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_E);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_F);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_GB);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_G);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_AB);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_A);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_BB);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_B);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_C);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_DD);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_D);
-    set_option(IPS_KEY, CHORUSFX_POSITION, IPS_EB);
-    set_option(IPS_SCALE, CHORUSFX_POSITION, IPS_MAJOR);
-    set_option(IPS_SCALE, CHORUSFX_POSITION, IPS_MINOR);
-    set_option(IPS_SCALE, CHORUSFX_POSITION, IPS_DORIA);
-    set_option(IPS_SCALE, CHORUSFX_POSITION, IPS_MIXLYD);
-    set_option(IPS_SCALE, CHORUSFX_POSITION, IPS_LYDIAN);
-    set_option(IPS_SCALE, CHORUSFX_POSITION, IPS_HMINO);
-    for (x=0; x<=99; x++)
-        set_option(IPS_LEVEL, CHORUSFX_POSITION, x);
-
-    set_option(CHORUSFX_ON_OFF, CHORUSFX_POSITION, 1);
-    set_option(CHORUSFX_ON_OFF, CHORUSFX_POSITION, 0);
-}
-
-void test_delay()
-{
-    int x;
-
-    set_option(DELAY_TYPE, DELAY_POSITION, DELAY_TYPE_ANALOG);
-    for (x=0; x<=139; x++)
-        set_option(DELAY_TIME, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(ANALOG_LEVEL, DELAY_POSITION, x);
-    for (x=0; x<=100; x++)
-        set_option(ANALOG_REPEATS, DELAY_POSITION, x);
-
-    set_option(DELAY_TYPE, DELAY_POSITION, DELAY_TYPE_DIGITAL);
-    for (x=0; x<=139; x++)
-        set_option(DELAY_TIME, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIGITAL_LEVEL, DELAY_POSITION, x);
-    for (x=0; x<=100; x++)
-        set_option(DIGITAL_REPEATS, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIGITAL_DUCKER_THRESH, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(DIGITAL_DUCKER_LEVEL, DELAY_POSITION, x);
-
-    set_option(DELAY_TYPE, DELAY_POSITION, DELAY_TYPE_MODULATED);
-    for (x=0; x<=139; x++)
-        set_option(DELAY_TIME, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MODULATED_LEVEL, DELAY_POSITION, x);
-    for (x=0; x<=100; x++)
-        set_option(MODULATED_REPEATS, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(MODULATED_DEPTH, DELAY_POSITION, x);
-
-    set_option(DELAY_TYPE, DELAY_POSITION, DELAY_TYPE_PONG);
-    for (x=0; x<=139; x++)
-        set_option(DELAY_TIME, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PONG_LEVEL, DELAY_POSITION, x);
-    for (x=0; x<=100; x++)
-        set_option(PONG_REPEATS, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PONG_DUCKER_THRESH, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(PONG_DUCKER_LEVEL, DELAY_POSITION, x);
-
-    set_option(DELAY_TYPE, DELAY_POSITION, DELAY_TYPE_TAPE);
-    for (x=0; x<=139; x++)
-        set_option(DELAY_TIME, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(TAPE_LEVEL, DELAY_POSITION, x);
-    for (x=0; x<=100; x++)
-        set_option(TAPE_REPEATS, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(TAPE_WOW, DELAY_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(TAPE_FLUTTER, DELAY_POSITION, x);
-
-    set_option(DELAY_ON_OFF, DELAY_POSITION, 1);
-    set_option(DELAY_ON_OFF, DELAY_POSITION, 0);
-}
-
-void test_reverb()
-{
-    int x;
-
-    set_option(REVERB_TYPE, REVERB_POSITION, REVERB_TYPE_TWIN);
-    for (x=0; x<=99; x++)
-        set_option(TWIN_REVERB, REVERB_POSITION, x);
-
-    set_option(REVERB_TYPE, REVERB_POSITION, REVERB_TYPE_LEX_AMBIENCE);
-    for (x=0; x<=15; x++)
-        set_option(LEX_AMBIENCE_PREDELAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_AMBIENCE_DECAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_AMBIENCE_LIVELINESS, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_AMBIENCE_LEVEL, REVERB_POSITION, x);
-
-    set_option(REVERB_TYPE, REVERB_POSITION, REVERB_TYPE_LEX_STUDIO);
-    for (x=0; x<=15; x++)
-        set_option(LEX_STUDIO_PREDELAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_STUDIO_DECAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_STUDIO_LIVELINESS, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_STUDIO_LEVEL, REVERB_POSITION, x);
-
-    set_option(REVERB_TYPE, REVERB_POSITION, REVERB_TYPE_LEX_ROOM);
-    for (x=0; x<=15; x++)
-        set_option(LEX_ROOM_PREDELAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_ROOM_DECAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_ROOM_LIVELINESS, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_ROOM_LEVEL, REVERB_POSITION, x);
-
-    set_option(REVERB_TYPE, REVERB_POSITION, REVERB_TYPE_LEX_HALL);
-    for (x=0; x<=15; x++)
-        set_option(LEX_HALL_PREDELAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_HALL_DECAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_HALL_LIVELINESS, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(LEX_HALL_LEVEL, REVERB_POSITION, x);
-
-    set_option(REVERB_TYPE, REVERB_POSITION, REVERB_TYPE_EMT240_PLATE);
-    for (x=0; x<=15; x++)
-        set_option(EMT240_PLATE_PREDELAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EMT240_PLATE_DECAY, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EMT240_PLATE_LIVELINESS, REVERB_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EMT240_PLATE_LEVEL, REVERB_POSITION, x);
-
-    set_option(REVERB_ON_OFF, REVERB_POSITION, 1);
-    set_option(REVERB_ON_OFF, REVERB_POSITION, 0);
-}
-
-void test_exp()
-{
-    int x;
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_NONE);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PICKUP_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PIKCUP_TYPE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_COMP_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_COMP_SUST);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_COMP_TONE);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_COMP_LEVEL);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_COMP_ATTACK);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DIST_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DIST_DISTORTION);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DIST_FILTER);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DIST_VOLUME);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_AMP_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_AMP_GAIN);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_AMP_LEVEL);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_EQ_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_EQ_BASS);
-    for (x=0; x<=24; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=24; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_EQ_MID);
-    for (x=0; x<=24; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=24; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_EQ_TREB);
-    for (x=0; x<=24; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=24; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_GATE_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_GATE_THRESHOLD);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_GATE_ATTACK);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_GATE_RELEASE);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_GATE_ATTN);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_CHORUSFX_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PHASER_SPEED);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PHASER_DEPTH);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PHASER_REGEN);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PHASER_WAVEFORM);
-    for (x=0; x<=2; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=2; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_PHASER_LEVEL);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DELAY_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DELAY_TIME);
-    for (x=0; x<=139; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=139; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DELAY_REPEATS);
-    for (x=0; x<=100; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=100; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DELAY_LEVEL);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DELAY_DUCK_THRESH);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_DELAY_DUCK_LEVEL);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_REVERB_ENABLE);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=1; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_REVERB_LEVEL);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_VOLUME_PRE_FX);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-
-    set_option(EXP_TYPE, EXP_POSITION, EXP_TYPE_VOLUME_POST_FX);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MIN, EXP_POSITION, x);
-    for (x=0; x<=99; x++)
-        set_option(EXP_MAX, EXP_POSITION, x);
-}
-
-void test_usb()
-{
-    int x;
-
-    for (x=0; x<=100; x++)
-        set_option(USB_AUDIO_PLAYBACK_MIX, USB_POSITION, x);
-
-    for (x=0; x<=36; x++)
-        set_option(USB_AUDIO_LEVEL, USB_POSITION, x);
-}
-
-void test_all()
-{
-    test_wah();
-    test_compressor();
-    test_dist();
-    test_presets();
-    test_pickups();
-    test_eq();
-    test_noisegate();
-    test_chorusfx();
-    test_delay();
-    test_reverb();
-    test_exp();
-    test_usb();
-}
--- a/tests.h
+++ b/tests.h
@@ -1,36 +0,0 @@
-/*
- *  Copyright (c) 2009 Tomasz Moń <desowin@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; under version 3 of the License.
- *
- *  This program 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 General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses>.
- */
-
-#ifndef GDIGI_TESTS_H
-#define GDIGI_TESTS_H
-
-#include "gdigi.h"
-
-void test_wah();
-void test_compressor();
-void test_dist();
-void test_presets();
-void test_pickups();
-void test_eq();
-void test_noisegate();
-void test_chorusfx();
-void test_delay();
-void test_reverb();
-void test_exp();
-void test_usb();
-void test_all();
-
-#endif /* GDIGI_TESTS_H */
Author	SHA1	Message	Date
Tomasz Moń	0bb0f6db71	update manpage	2010-10-07 11:08:59 +02:00
Tomasz Moń	dcf66adfa9	fix RP1000 support	2010-08-25 11:15:29 +02:00
Tomasz Moń	0886ba00c1	add support for GNX4 and GNX3k patches	2010-06-17 19:20:58 +02:00
Jonathan A. Tice	e12de97fab	add RP1000 support	2010-04-24 15:07:18 +02:00
Miklos Aubert	59753a61dc	add RP255 support	2010-03-04 18:54:58 +01:00
Tomasz Moń	ff0be8230e	fix some rp500 values	2010-02-05 09:43:21 +01:00
Tomasz Moń	07cfd70941	display values correctly (offsets, correct steps, suffixes, labels)	2010-01-03 14:18:53 +01:00
Rafael Moreno	2523b27205	add rp355p to SupportedFileTypes	2009-09-20 20:06:27 +02:00
Tomasz Moń	530dd397c5	remove USB settings from effect list as they're not part of Preset	2009-09-20 19:57:39 +02:00
Rafael Moreno	158fd081a5	fix RP355 amp B settings	2009-09-04 17:49:11 +02:00
Tomasz Moń	a8bac07f68	correct manpage	2009-08-11 12:18:03 +02:00
Andreas Karajannis	87bb59f43a	don't use uninitialized value	2009-08-11 12:17:28 +02:00
Andrew O. Shadoura	cdeb821deb	added manpage	2009-08-10 19:56:56 +01:00
Andrew O. Shadoura	ce463b29d8	added simple .desktop file	2009-08-08 21:04:40 +01:00
Andrew O. Shadoura	159bca158e	use LDADD instead of LDFLAGS and -Wl,--as-needed; added install target	2009-08-08 20:53:07 +01:00
Tomasz Moń	6ae750c4fb	GFile requires gio.h	2009-07-31 14:10:21 +02:00
Rafael Moreno	5f21c62a2f	fix RP355 support	2009-07-28 11:38:24 +02:00
Tomasz Moń	08b20b398f	remove redundant GFile	2009-07-19 18:52:57 +02:00
Tomasz Moń	1be664e82f	rename Pickup to Pickup/USB as this frame contains both pickup and USB settings	2009-07-19 18:32:48 +02:00
Tomasz Moń	3ab55054c1	add restore_backup_file()	2009-07-19 16:15:23 +02:00
Tomasz Moń	97b8c9fd6d	add create_backup_file()	2009-07-19 14:03:55 +02:00
Tomasz Moń	211df27cf8	fix typos in comments	2009-06-29 20:03:54 +02:00
Rafael Moreno	dfe28ac81d	add RP355 support	2009-06-29 20:02:50 +02:00
Tomasz Moń	3da458d370	Added tag 0.1.8 for changeset 5e6d6124b5f2	2009-06-22 16:36:52 +02:00
Tomasz Moń	ba04930133	display GNX3000 settings in tabs	2009-06-21 20:05:42 +02:00
Stephen Rigler	18f137636d	add GNX3000 amp channel settings	2009-05-20 20:51:10 +02:00
Jaco Kroon	eba8bbe5aa	fix Makefile	2009-05-15 21:54:42 +02:00
Tomasz Moń	7a6e3b159c	greatly reduce number of comparisions required to apply parameters to GUI	2009-05-15 20:59:28 +02:00
Tomasz Moń	cc85da9c71	update ignore list	2009-05-15 16:39:31 +02:00
Jaco Kroon	9586f6cd31	make buildsystem aware of header changes	2009-05-15 16:37:55 +02:00
Tomasz Moń	4a7ab848e7	remove id and position fields from EffectGroup	2009-05-15 10:20:42 +02:00
Jaco Kroon	2703e79d39	add GNX4 stompbox, noisegate, chorus, delay and reverb settings	2009-05-15 09:19:23 +02:00
Tomasz Moń	dbab804d52	actually the compressor settings are the same for both GNX3000 and GNX4	2009-05-13 12:19:44 +02:00
Tomasz Moń	c3f82416f5	rename values_synth_talk_balance as it's actually used for more effects	2009-05-13 12:10:40 +02:00
Tomasz Moń	145b41cb6c	actually the whammy settings are the same for both GNX3000 and GNX4	2009-05-13 10:41:58 +02:00
Stephen Rigler	26d1db9e4f	add GNX3000 amp channel + warping settings	2009-05-13 08:03:29 +02:00
Jaco Kroon	cc311f4f18	add GNX4 pickup, wah, compressor and whammy effect	2009-05-13 07:47:58 +02:00
Jaco Kroon	d85e83c89e	make get_device_info interate over list of supported product and family ID	2009-05-13 07:27:11 +02:00
Tomasz Moń	55b9b08230	check RECEIVE_WHO_AM_I reply size	2009-05-12 21:51:43 +02:00
Tomasz Moń	400e221a4f	make some devices happy	2009-05-12 21:14:46 +02:00
Jaco Kroon	5b93c91bfe	fix unsigned comparisions	2009-05-12 19:43:17 +02:00
Tomasz Moń	cbd07a9709	revise create_preset_from_data	2009-05-11 23:32:17 +02:00
Tomasz Moń	def4917a07	revise mutex logic	2009-05-11 21:17:04 +02:00
Stephen Rigler	e9c0ed8b38	add GNX3000 reverb settings	2009-05-11 07:39:15 +02:00
Tomasz Moń	400a7d41f8	merge GNX3000 delay settings	2009-05-10 15:28:30 +02:00
Stephen Rigler	40a9d06e4c	add GNX3000 delay settings	2009-05-10 14:13:40 +02:00
Stephen Rigler	e820ce0cc4	add GNX3000 chorus settings	2009-05-09 07:47:22 +02:00
Tomasz Moń	ebc603143e	update TODO	2009-05-08 14:24:01 +02:00
Tomasz Moń	c74290d8e1	use gtk_dialog_get_content_area	2009-05-07 14:17:03 +02:00
Tomasz Moń	295e932bf1	update HACKING file	2009-05-06 17:57:51 +02:00
Tomasz Moń	1a65deb8d5	if get_message_by_id can't find message, wait until new message is pushed before retrying	2009-05-06 13:19:49 +02:00
Tomasz Moń	4509c14bbc	make get_current_preset return list of messages describing preset rather than just one message with preset parameters	2009-05-06 13:10:46 +02:00
Stephen Rigler	d7f10eb509	add GNX3000 whammy/ips, preset level and noisegate settings	2009-05-06 08:14:27 +02:00
Tomasz Moń	b1a8d69dba	Receive Who Am I can vary in length between versions	2009-05-04 17:39:46 +02:00
Tomasz Moń	20769ace01	Fix memory leak	2009-05-04 17:29:22 +02:00
Tomasz Moń	2633bac5d8	update GUI on remote preset change	2009-05-04 17:04:32 +02:00
Stephen Rigler	af1d3a2906	add GNX3000 pickup, wah and compressor settings	2009-05-04 15:26:15 +02:00
Tomasz Moń	06fd3eee66	apply asynchronous parameters changes to GUI	2009-05-03 22:17:41 +02:00
Tomasz Moń	acb1c1e273	introduce setting_param_new, setting_param_new_from_data and setting_param_free	2009-05-03 21:38:15 +02:00
Tomasz Moń	7bf55352b8	set device into GUI mode	2009-05-03 20:32:13 +02:00
Tomasz Moń	6a1d1de390	fix compiler warning	2009-05-02 14:25:50 +02:00
Tomasz Moń	b798d6ee39	remove reduntant defines	2009-05-01 20:33:09 +02:00
Tomasz Moń	ba810bf4f8	reuse widget table if possible	2009-05-01 16:12:58 +02:00
Tomasz Moń	24a1c2718b	remove reduntant defines	2009-05-01 16:06:15 +02:00
Tomasz Moń	31a635839a	add GNX3000 distortion settings	2009-05-01 07:53:23 +02:00
Tomasz Moń	d7b3f7a3d6	add Device struct	2009-04-30 17:27:55 +02:00
Tomasz Moń	6512696240	read MIDI IN messages in new thread	2009-04-30 10:32:24 +02:00
Tomasz Moń	f1359d18e4	open device in sync mode	2009-04-27 13:46:27 +02:00
Tomasz Moń	85ce157bb8	remove reduntant defines	2009-04-17 17:45:01 +02:00
Tomasz Moń	6daaf47cd8	remove tests as they are now obsolete	2009-04-17 17:32:55 +02:00
Tomasz Moń	3a849de954	add RP250 pickup settings	2009-04-17 17:30:50 +02:00
Tomasz Moń	a06c5dc07e	Added tag 0.1.7 for changeset c622b5d3c3b3	2009-04-15 06:55:22 +02:00
Tomasz Moń	29124043ba	add RP500 distortion settings	2009-04-14 23:23:41 +02:00
Tomasz Moń	e93e6bd16b	add compability mode dialog	2009-04-14 21:00:10 +02:00
Tomasz Moń	f7ddd5e0d6	add RP500 chorusfx settings	2009-04-14 18:22:32 +02:00
Tomasz Moń	6a082acc53	add RP500 delay settings	2009-04-13 11:42:15 +02:00
Tomasz Moń	1abcc82829	add RP500 equalizer settings	2009-04-12 20:55:17 +02:00
Tomasz Moń	c964d38c17	add RP500 compressor and amp settings	2009-04-12 18:36:41 +02:00
Tomasz Moń	12c2ccc87f	Use single header includes	2009-04-11 22:32:21 +02:00
Tomasz Moń	a6d07fd802	disconnect adjustment signals on gtk_knob_destroy	2009-04-10 14:23:23 +02:00
Tomasz Moń	215683b167	actually g_type_class_peek_parent makes more sense	2009-04-10 13:32:03 +02:00
Tomasz Moń	741482afd4	Added tag 0.1.6 for changeset 80e56807413b	2009-03-26 15:21:18 +01:00
Tomasz Moń	991527418a	Don't use deprecated functions in GtkKnob; optipng knob.png	2009-03-24 22:21:01 +01:00
Tomasz Moń	96317d5ac5	actually 'is it connected' doesn't make sense here	2009-03-17 15:36:16 +01:00
Tomasz Moń	d24cc97f5d	add error reporting to create_preset_from_xml_file	2009-03-17 12:54:46 +01:00
Tomasz Moń	cac7e74d71	display preset number in preset list	2009-03-15 20:12:58 +01:00
Tomasz Moń	74583e9a7c	make GUI more compact	2009-03-15 20:06:18 +01:00
Tomasz Moń	03c3c48ecf	remove reduntant text	2009-03-15 18:52:14 +01:00
Tomasz Moń	aa2cc7bbb1	some Doxygen work	2009-03-14 18:51:08 +01:00
Tomasz Moń	ec14a41869	Added tag 0.1.5 for changeset 45f897c02e72	2009-03-14 14:27:12 +01:00
Tomasz Moń	9778dc47c3	add comments	2009-03-14 14:23:18 +01:00
Tomasz Moń	71c3a1e66f	use g_slice	2009-03-14 12:58:11 +01:00
Tomasz Moń	bdb35ddf54	finish modifier_linkable_list(), add modifier_group_free()	2009-03-14 12:39:45 +01:00
Tomasz Moń	4ca140ab48	rename get_modifier_label to get_modifier	2009-03-14 10:31:40 +01:00
Tomasz Moń	d2f821eee1	add EffectValues to Modifiers	2009-03-14 10:24:58 +01:00
Tomasz Moń	e607c6cf37	move modifier_linkable_list to effects.c	2009-03-14 10:07:00 +01:00
Tomasz Moń	dc66db841a	introduce get_message_by_id	2009-03-14 10:04:56 +01:00
Tomasz Moń	e80683aea2	add cabinet models	2009-03-14 08:38:28 +01:00
Tomasz Moń	b7d2d7d1c5	introduce EffectValues	2009-03-13 22:42:46 +01:00
Tomasz Moń	cd5d7387f3	remove obsolete function	2009-03-13 20:33:24 +01:00
Tomasz Moń	8a39a178c6	add tone library and effects library	2009-03-13 19:46:02 +01:00
Tomasz Moń	40ebcfaf16	make modifiers[] complete	2009-03-13 18:00:41 +01:00
Tomasz Moń	de68d0449f	some renames, no functional changes	2009-03-10 20:57:34 +01:00
Tomasz Moń	d280bf1ca6	add some comments	2009-03-10 19:45:16 +01:00
Tomasz Moń	b245e1bac6	add gtk_knob_key_press	2009-03-09 22:51:38 +01:00
Tomasz Moń	8d7fffb6d1	atan2f requires C99	2009-03-09 20:58:03 +01:00
Tomasz Moń	f8e35ff685	let GtkKnob grab focus	2009-03-09 19:57:13 +01:00
Tomasz Moń	3f717a51cd	add gui_free	2009-03-09 18:49:29 +01:00
Tomasz Moń	90df427200	add knobs	2009-03-09 18:22:20 +01:00
Tomasz Moń	322c59032e	tweak GtkKnob a bit	2009-03-08 13:46:14 +01:00
Tomasz Moń	1b1919649e	add GtkKnob from phasex-0.11.1	2009-03-08 13:31:43 +01:00
Tomasz Moń	e7c7efe857	expression pedal settings work-in-progress	2009-03-08 13:25:37 +01:00
Tomasz Moń	17b067f853	don't crash if query preset names fail	2009-03-04 19:00:32 +01:00
Tomasz Moń	8ec3d6579c	change query_preset_names	2009-03-04 18:26:22 +01:00
Tomasz Moń	5bd6f8fc2c	Added tag 0.1.4 for changeset 78367821f4f4	2009-03-04 08:14:21 +01:00
Tomasz Moń	c61c2372ae	cleaning	2009-03-03 23:06:03 +01:00
Tomasz Moń	49b7f42012	compile with -ansi	2009-03-03 22:39:55 +01:00
Tomasz Moń	157fba0380	make set_option wrapper to send_message	2009-03-03 22:31:25 +01:00
Tomasz Moń	904a30bb38	propertly apply xml patch	2009-03-03 21:57:47 +01:00
Tomasz Moń	8e445bb408	update gui on preset switch	2009-03-03 13:42:15 +01:00
Tomasz Moń	eb48d0b9d2	add get_message_id stub	2009-03-03 11:46:28 +01:00
Tomasz Moń	baa3829263	start gui with proper values	2009-03-03 11:39:25 +01:00
Tomasz Moń	79554a99ce	Added tag 0.1.3 for changeset 5cc97dba5d41	2009-03-01 20:24:06 +01:00