New widget, a dialogue which uses filter-druid to present the various

2000-02-24  NotZed  <NotZed@HelixCode.com>

        * filter-editor.c: New widget, a dialogue which uses filter-druid
        to present the various editing views.

        * filter-druid.c: Changed to just being a notebook with no tabs,
        rather than a full druid (no next/prev/etc buttons).

svn path=/trunk/; revision=1914

1 files changed, 329 insertions, 0 deletions

diff --git a/filter/filter-editor.c b/filter/filter-editor.c
new file mode 100644
index 0000000000..d37769359f
--- /dev/null
+++ b/filter/filter-editor.c
@@ -0,0 +1,329 @@
+/*
+ *  Copyright (C) 2000 Helix Code Inc.
+ *
+ *  Authors: Michael Zucchi <notzed@helixcode.com>
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public License
+ *  as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This 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 Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "filter-druid.h"
+#include "filter-editor.h"
+
+
+static void filter_editor_class_init (FilterEditorClass *klass);
+static void filter_editor_init       (FilterEditor *obj);
+
+static GnomeDialogClass *filter_editor_parent;
+
+#define _PRIVATE(x) (((FilterEditor *)(x))->priv)
+
+struct _FilterEditorPrivate {
+	FilterDruid *druid;
+
+	GtkWidget *edit, *add, *remove, *up, *down;
+
+	/* for sub-druid */
+	GtkWidget *druid_dialogue;
+	FilterDruid *druid_druid;
+};
+
+enum SIGNALS {
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+guint
+filter_editor_get_type (void)
+{
+	static guint type = 0;
+	
+	if (!type) {
+		GtkTypeInfo type_info = {
+			"FilterEditor",
+			sizeof (FilterEditor),
+			sizeof (FilterEditorClass),
+			(GtkClassInitFunc) filter_editor_class_init,
+			(GtkObjectInitFunc) filter_editor_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL
+		};
+		
+		type = gtk_type_unique (gnome_dialog_get_type (), &type_info);
+	}
+	
+	return type;
+}
+
+static void
+filter_editor_class_init (FilterEditorClass *klass)
+{
+	GtkObjectClass *object_class = (GtkObjectClass *) klass;
+	
+	filter_editor_parent = gtk_type_class (gnome_dialog_get_type ());
+
+	gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL);
+}
+
+static void
+filter_editor_init (FilterEditor *obj)
+{
+	obj->priv = g_malloc0(sizeof(*obj->priv));
+}
+
+
+static void
+sensitise(FilterEditor *e)
+{
+	struct _FilterEditorPrivate *p = _PRIVATE(e);
+
+	gtk_widget_set_sensitive(p->add, TRUE);
+	gtk_widget_set_sensitive(p->edit, e->option_current != NULL);
+	gtk_widget_set_sensitive(p->remove, e->option_current != NULL);
+	gtk_widget_set_sensitive(p->up, g_list_index(e->useroptions, e->option_current)>0);
+	gtk_widget_set_sensitive(p->down, g_list_index(e->useroptions, e->option_current)!=g_list_length(e->useroptions)-1);
+}
+
+static void
+druid_option_selected(FilterDruid *f, struct filter_option *option, FilterEditor *e)
+{
+	printf("option selected: %p\n", option);
+	e->option_current = option;
+	sensitise(e);
+}
+
+static void
+druid_dialogue_clicked(GnomeDialog *d, int button, FilterEditor *e)
+{
+	struct _FilterEditorPrivate *p = _PRIVATE(e);
+	int page = filter_druid_get_page(p->druid_druid);
+
+	switch(button) {
+	case 1:
+		if (page<4) {
+			page++;
+		}
+		break;
+	case 0:
+		if (page>0) {
+			page--;
+		}
+		break;
+	case 2:
+		printf("Finish!\n");
+		if (p->druid_druid->option_current) {
+			/* FIXME: this should be copied? */
+			e->useroptions = g_list_append(e->useroptions, p->druid_druid->option_current);
+			filter_druid_set_rules(p->druid, e->useroptions, e->rules, NULL);
+		}
+	case 3:
+		printf("cancel!\n");
+		gnome_dialog_close(d);
+		return;
+	}
+	filter_druid_set_page(p->druid_druid, page);
+
+	gnome_dialog_set_sensitive(p->druid_dialogue, 0, page>0);
+	gnome_dialog_set_sensitive(p->druid_dialogue, 1, page<4);
+	gnome_dialog_set_sensitive(p->druid_dialogue, 2, page==4); /* FIXME: make this depenedant on when the rules are actually done */	
+}
+
+static void
+druid_dialogue_option_selected(FilterDruid *f, struct filter_option *option, FilterEditor *e)
+{
+	struct _FilterEditorPrivate *p = _PRIVATE(e);
+
+	gnome_dialog_set_sensitive(p->druid_dialogue, 1, TRUE);
+}
+
+static void
+add_or_edit(FilterEditor *e, struct filter_option *option)
+{
+	GnomeDialog *dialogue;
+	FilterDruid *druid;
+	struct _FilterEditorPrivate *p = _PRIVATE(e);
+
+	dialogue = gnome_dialog_new(option?"Edit Filter":"Create filter", "Prev", "Next", "Finish", "Cancel", 0);
+
+	p->druid_dialogue = dialogue;
+
+	gnome_dialog_set_close(dialogue, FALSE);
+	gnome_dialog_set_sensitive(dialogue, 0, FALSE);
+	gnome_dialog_set_sensitive(dialogue, 1, FALSE);
+	gnome_dialog_set_sensitive(dialogue, 2, FALSE);
+	gnome_dialog_set_default(dialogue, 1);
+
+	gtk_signal_connect(GTK_OBJECT(dialogue), "clicked", druid_dialogue_clicked, e);
+
+	druid = filter_druid_new();
+
+	p->druid_druid = druid;
+
+	filter_druid_set_default_html(p->druid_druid, "<h2>Create Filtering Rule</h2>"
+				      "<p>Select one of the base rules above, then continue "
+				      "forwards to customise it.</p>");
+
+	filter_druid_set_rules(druid, e->systemoptions, e->rules, option);
+	gtk_box_pack_start(dialogue->vbox, druid, TRUE, TRUE, 0);
+
+	if (option) {
+		druid_dialogue_clicked(dialogue, 1, e);
+	}
+
+	gtk_signal_connect(druid, "option_selected", druid_dialogue_option_selected, e);
+
+	gtk_widget_show(druid);
+	gtk_widget_show(dialogue);
+}
+
+static void
+add_clicked(GtkWidget *w, FilterEditor *e)
+{
+	printf("add new ...\n");
+
+	add_or_edit(e, NULL);
+}
+
+static void
+edit_clicked(GtkWidget *w, FilterEditor *e)
+{
+	printf("add new ...\n");
+
+	add_or_edit(e, e->option_current);
+}
+
+static void
+remove_clicked(GtkWidget *w, FilterEditor *e)
+{
+	printf("remove current ...\n");
+}
+
+static void
+up_clicked(GtkWidget *w, FilterEditor *e)
+{
+	printf("up ...\n");
+}
+
+static void
+down_clicked(GtkWidget *w, FilterEditor *e)
+{
+	printf("down ...\n");
+}
+
+/* build the contents of the editor */
+static void
+build_editor(FilterEditor *e)
+{
+	struct _FilterEditorPrivate *p = _PRIVATE(e);
+	GtkWidget *hbox;
+	GtkWidget *vbox;
+
+	hbox = gtk_hbox_new(FALSE, 3);
+
+	p->druid = (GtkWidget *)filter_druid_new();
+	gtk_box_pack_start((GtkBox *)hbox, p->druid, TRUE, TRUE, 0);
+
+	vbox = gtk_vbox_new(FALSE, 0);
+	
+	p->edit = gtk_button_new_with_label ("Edit");
+	p->add = gtk_button_new_with_label ("Add");
+	p->remove = gtk_button_new_with_label ("Remove");
+	p->up = gtk_button_new_with_label ("Up");
+	p->down = gtk_button_new_with_label ("Down");
+
+	gtk_box_pack_start((GtkBox *)vbox, p->edit, FALSE, TRUE, 0);
+	gtk_box_pack_start((GtkBox *)vbox, p->add, FALSE, TRUE, 3);
+	gtk_box_pack_start((GtkBox *)vbox, p->remove, FALSE, TRUE, 0);
+	gtk_box_pack_start((GtkBox *)vbox, p->up, FALSE, TRUE, 3);
+	gtk_box_pack_start((GtkBox *)vbox, p->down, FALSE, TRUE, 0);
+
+	gtk_box_pack_start((GtkBox *)hbox, vbox, FALSE, FALSE, 0);
+
+	gtk_box_pack_start((GtkBox *)e->parent.vbox, hbox, TRUE, TRUE, 0);
+
+	gtk_signal_connect(p->druid, "option_selected", druid_option_selected, e);
+
+	gtk_signal_connect(p->edit, "clicked", edit_clicked, e);
+	gtk_signal_connect(p->add, "clicked", add_clicked, e);
+	gtk_signal_connect(p->remove, "clicked", remove_clicked, e);
+	gtk_signal_connect(p->up, "clicked", up_clicked, e);
+	gtk_signal_connect(p->down, "clicked", down_clicked, e);
+
+	filter_druid_set_default_html(p->druid, "<h2>Filtering Rules</h2>"
+				      "<p>Select one of the rules above to <i>view</i>, and "
+				      "<i>edit</i>.  Or <i>Add</i> a new rule.</p>");
+
+	gtk_widget_show_all(hbox);
+	sensitise(e);
+}
+
+
+/**
+ * filter_editor_new:
+ *
+ * Create a new FilterEditor object.
+ * 
+ * Return value: A new FilterEditor widget.
+ **/
+FilterEditor *
+filter_editor_new (void)
+{
+	FilterEditor *new = FILTER_EDITOR ( gtk_type_new (filter_editor_get_type ()));
+
+	build_editor(new);
+
+	return new;
+}
+
+void
+filter_editor_set_rules(FilterEditor *e, GList *rules, GList *systemoptions, GList *useroptions)
+{
+	struct _FilterEditorPrivate *p = _PRIVATE(e);
+
+	e->rules= rules;
+	e->systemoptions = systemoptions;
+	e->useroptions = useroptions;
+
+	filter_druid_set_rules(p->druid, useroptions, rules, NULL);
+}
+
+int main(int argc, char **argv)
+{
+	GList *rules, *options, *options2;
+	xmlDocPtr doc, out, optionset, filteroptions;
+	GString *s;
+
+	gnome_init("Test", "0.0", argc, argv);
+	gdk_rgb_init ();
+	gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
+	gtk_widget_set_default_visual (gdk_rgb_get_visual ());
+
+	{
+
+		GtkWidget *w = filter_editor_new();
+
+		doc = xmlParseFile("filterdescription.xml");
+		rules = filter_load_ruleset(doc);
+		options = filter_load_optionset(doc, rules);
+		options2 = options;
+		out = xmlParseFile("saveoptions.xml");
+		options = filter_load_optionset(out, rules);
+
+		filter_editor_set_rules(w, rules, options2, options);
+
+		gtk_widget_show(w);
+		gtk_main();
+	}
+}