trace-view: Make event and CPU dialogs generic

Since the event and CPU dialogs may also be used by the trace-graph
make it generic and remove the dependency of the trace-view-store.

This also changes them to accept a callback function for when a response
is made.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

8 files changed, 454 insertions, 143 deletions

diff --git a/kernel-shark.c b/kernel-shark.c
index a55fc8a..4b8966f 100644
--- a/kernel-shark.c
+++ b/kernel-shark.c
@@ -118,8 +118,26 @@ static void
 events_clicked (gpointer data)
 {
         struct shark_info *info = data;
+        GtkTreeView *trace_tree = GTK_TREE_VIEW(info->treeview);
+        GtkTreeModel *model;
+        TraceViewStore *store;
+        gboolean all_events;
+        gchar **systems;
+        gint *events;
+
+        model = gtk_tree_view_get_model(trace_tree);
+        if (!model)
+                return;
 
-        trace_filter_event_dialog(info->treeview);
+        store = TRACE_VIEW_STORE(model);
+
+        all_events = trace_view_store_get_all_events_enabled(store);
+        systems = trace_view_store_get_systems_enabled(store);
+        events = trace_view_store_get_events_enabled(store);
+
+        trace_filter_event_dialog(store->handle, all_events,
+                                  systems, events,
+                                  trace_view_event_filter_callback, trace_tree);
 }
 
 /* Callback for the clicked signal of the CPUs filter button */
@@ -127,8 +145,19 @@ static void
 cpus_clicked (gpointer data)
 {
         struct shark_info *info = data;
+        GtkTreeView *trace_tree = GTK_TREE_VIEW(info->treeview);
+        TraceViewStore *store;
+        gboolean all_cpus;
+        guint64 *cpu_mask;
+
+        store = TRACE_VIEW_STORE(gtk_tree_view_get_model(trace_tree));
+
+        all_cpus = trace_view_store_get_all_cpus(store);
+        cpu_mask = trace_view_store_get_cpu_mask(store);
 
-        trace_filter_cpu_dialog(info->treeview);
+        trace_filter_cpu_dialog(all_cpus, cpu_mask,
+                                trace_view_store_get_cpus(store),
+                                trace_view_cpu_filter_callback, trace_tree);
 }
 
 static void row_double_clicked(GtkTreeView        *treeview,
diff --git a/trace-filter.c b/trace-filter.c
index fd456aa..894448e 100644
--- a/trace-filter.c
+++ b/trace-filter.c
@@ -5,31 +5,15 @@
 #include "trace-cmd.h"
 #include "trace-local.h"
 #include "trace-view-store.h"
+#include "trace-view.h"
+
+#include "cpu.h"
 
 #define DIALOG_WIDTH    400
 #define DIALOG_HEIGHT   600
 
-static void cpu_mask_set(guint64 *mask, gint cpu)
-{
-        mask += (cpu >> 6);
-        *mask |= 1ULL << (cpu & ((1ULL << 6) - 1));
-}
-
-static void cpu_mask_clear(guint64 *mask, gint cpu)
-{
-        mask += (cpu >> 6);
-        *mask &= ~(1ULL << (cpu & ((1ULL << 6) - 1)));
-}
-
-static gboolean cpu_mask_isset(guint64 *mask, gint cpu)
-{
-        mask += (cpu >> 6);
-        return *mask & (1ULL << (cpu & ((1ULL << 6) - 1)));
-}
-
 struct dialog_helper {
         GtkWidget               *dialog;
-        GtkWidget               *trace_tree;
         gpointer                data;
 };
 
@@ -41,28 +25,56 @@ enum {
         NUM_EVENT_COLS,
 };
 
+struct event_filter_helper {
+        trace_filter_event_cb_func      func;
+        GtkTreeView                     *view;
+        gpointer                        data;
+};
+
+gboolean system_is_enabled(gchar **systems, gint systems_size, const gchar *system)
+{
+        const gchar **sys = &system;
+
+        if (!systems)
+                return FALSE;
+
+        sys = bsearch(sys, systems, systems_size, sizeof(system), str_cmp);
+
+        return sys != NULL;
+}
+
+gboolean event_is_enabled(gint *events, gint events_size, gint event)
+{
+        gint *ret;
+
+        if (!events)
+                return FALSE;
+
+        ret = bsearch(&event, events, events_size, sizeof(gint), id_cmp);
+
+        return ret != NULL;
+}
+
 static GtkTreeModel *
-create_tree_event_model(GtkWidget *tree_view)
+create_tree_event_model(struct tracecmd_input *handle,
+                       gboolean all_events, gchar **systems_set,
+                       gint *event_ids_set)
 {
-        GtkTreeModel *model;
-        TraceViewStore *trace_view;
         GtkTreeStore *treestore;
         GtkTreeIter iter_all, iter_sys, iter_events;
         struct pevent *pevent;
         struct event_format **events;
         struct event_format *event;
         char *last_system = NULL;
-        gboolean all_events;
         gboolean sysactive;
         gboolean active;
+        gchar **systems = NULL;
+        gint *event_ids = NULL;
+        gint systems_size;
+        gint event_ids_size;
         gint i;
 
-        model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
-        trace_view = TRACE_VIEW_STORE(model);
-
-        all_events = trace_view_store_get_all_events_enabled(trace_view);
-
-        pevent = tracecmd_get_pevent(trace_view->handle);
+        pevent = tracecmd_get_pevent(handle);
 
         treestore = gtk_tree_store_new(NUM_EVENT_COLS, G_TYPE_STRING,
                                        G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
@@ -79,12 +91,28 @@ create_tree_event_model(GtkWidget *tree_view)
         if (!events)
                 return GTK_TREE_MODEL(treestore);
 
+        if (systems_set) {
+                for (systems_size = 0; systems_set[systems_size]; systems_size++)
+                        ;
+                systems = g_new(typeof(*systems), systems_size + 1);
+                memcpy(systems, systems_set, sizeof(*systems) * (systems_size + 1));
+                qsort(systems, systems_size, sizeof(gchar *), str_cmp);
+        }
+
+        if (event_ids_set) {
+                for (event_ids_size = 0; event_ids_set[event_ids_size] != -1; event_ids_size++)
+                        ;
+                event_ids = g_new(typeof(*event_ids), event_ids_size + 1);
+                memcpy(event_ids, event_ids_set, sizeof(*event_ids) * (event_ids_size + 1));
+                qsort(event_ids, event_ids_size, sizeof(gint), id_cmp);
+        }
+
         for (i = 0; events[i]; i++) {
                 event = events[i];
                 if (!last_system || strcmp(last_system, event->system) != 0) {
                         gtk_tree_store_append(treestore, &iter_sys, &iter_all);
                         sysactive = all_events ||
-                                trace_view_store_system_enabled(trace_view, event->system);
+                                system_is_enabled(systems, systems_size, event->system);
                         gtk_tree_store_set(treestore, &iter_sys,
                                            COL_EVENT, event->system,
                                            COL_ACTIVE, sysactive,
@@ -93,7 +121,7 @@ create_tree_event_model(GtkWidget *tree_view)
                 }
 
                 active = all_events || sysactive ||
-                        trace_view_store_event_enabled(trace_view, event->id);
+                        event_is_enabled(event_ids, event_ids_size, event->id);
                 gtk_tree_store_append(treestore, &iter_events, &iter_sys);
                 gtk_tree_store_set(treestore, &iter_events,
                                    COL_EVENT, event->name,
@@ -103,6 +131,9 @@ create_tree_event_model(GtkWidget *tree_view)
 
         }
 
+        g_free(systems);
+        g_free(event_ids);
+
         return GTK_TREE_MODEL(treestore);
 }
 
@@ -203,9 +234,13 @@ static void event_cursor_changed(GtkTreeView *treeview, gpointer data)
                 /* set this system */
                 update_active_events(model, &iter, active);
 
-                if (!active)
+                if (!active) {
                         /* disable the all events toggle */
                         gtk_tree_model_iter_parent(model, &parent, &iter);
+                        gtk_tree_store_set(GTK_TREE_STORE(model), &parent,
+                                           COL_ACTIVE, FALSE,
+                                           -1);
+                }
 
         } else {
                 if (!active) {
@@ -225,7 +260,10 @@ static void event_cursor_changed(GtkTreeView *treeview, gpointer data)
         gtk_tree_path_free(path);
 }
 
-static GtkWidget *create_event_list_view(GtkWidget *tree_view)
+static GtkWidget *
+create_event_list_view(struct tracecmd_input *handle,
+                       gboolean all_events, gchar **systems,
+                       gint *events)
 {
         GtkTreeViewColumn *col;
         GtkCellRenderer *renderer;
@@ -253,7 +291,7 @@ static GtkWidget *create_event_list_view(GtkWidget *tree_view)
 
         gtk_tree_view_column_add_attribute(col, renderer, "text", COL_EVENT);
 
-        model = create_tree_event_model(tree_view);
+        model = create_tree_event_model(handle, all_events, systems, events);
 
         gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
 
@@ -271,16 +309,46 @@ static GtkWidget *create_event_list_view(GtkWidget *tree_view)
         return view;
 }
 
-static void update_events(TraceViewStore *store,
-                          GtkTreeModel *model,
-                          GtkTreeIter *parent)
+static gchar **add_system(gchar **systems, gint size, gchar *system)
+{
+        if (!systems) {
+                systems = g_new0(gchar *, 2);
+                size = 0;
+        } else {
+                systems = g_realloc(systems,
+                                    sizeof(*systems) * (size + 2));
+        }
+        systems[size] = g_strdup(system);
+        systems[size+1] = NULL;
+
+        return systems;
+}
+
+static gint *add_event(gint *events, gint size, gint event)
+{
+        if (!events) {
+                events = g_new0(gint, 2);
+                size = 0;
+        } else {
+                events = g_realloc(events,
+                                   sizeof(*events) * (size + 2));
+        }
+        events[size] = event;
+        events[size+1] = -1;
+
+        return events;
+}
+
+static gint update_events(GtkTreeModel *model,
+                          GtkTreeIter *parent,
+                          gint **events, gint size)
 {
         GtkTreeIter event;
         gboolean active;
         gint id;
 
         if (!gtk_tree_model_iter_children(model, &event, parent))
-                return;
+                return size;
 
         for (;;) {
 
@@ -290,25 +358,28 @@ static void update_events(TraceViewStore *store,
                                    -1);
 
                 if (active)
-                        trace_view_store_set_event_enabled(store, id);
+                        *events = add_event(*events, size++, id);
 
                 if (!gtk_tree_model_iter_next(model, &event))
                         break;
         }
+
+        return size;
 }
 
-static void update_system_events(TraceViewStore *store,
-                                 GtkTreeModel *model,
-                                 GtkTreeIter *parent)
+static gint update_system_events(GtkTreeModel *model,
+                                 GtkTreeIter *parent,
+                                 gchar ***systems,
+                                 gint size,
+                                 gint **events,
+                                 gint *events_size)
 {
         GtkTreeIter sys;
         gboolean active;
         gchar *system;
 
         if (!gtk_tree_model_iter_children(model, &sys, parent))
-                return;
-
-        trace_view_store_clear_all_events_enabled(store);
+                return size;
 
         for (;;) {
 
@@ -318,29 +389,30 @@ static void update_system_events(TraceViewStore *store,
                                    -1);
 
                 if (active)
-                        trace_view_store_set_system_enabled(store, system);
+                        *systems = add_system(*systems, size++, system);
                 else
-                        update_events(store, model, &sys);
+                        *events_size = update_events(model, &sys, events, *events_size);
 
                 g_free(system);
 
                 if (!gtk_tree_model_iter_next(model, &sys))
                         break;
         }
+
+        return size;
 }
 
-static void accept_events(GtkWidget *trace_tree_view, GtkTreeView *view)
+static void accept_events(struct event_filter_helper *event_helper)
 {
+        GtkTreeView *view = event_helper->view;
         GtkTreeModel *model;
-        TraceViewStore *store;
         GtkTreeIter iter;
         gboolean active;
-
-        model = gtk_tree_view_get_model(GTK_TREE_VIEW(trace_tree_view));
-        if (!model)
-                return;
-
-        store = TRACE_VIEW_STORE(model);
+        gchar **systems = NULL;
+        gint *events = NULL;
+        gint events_size = 0;
+        gint systems_size = 0;
+        gint i;
 
         model = gtk_tree_view_get_model(view);
         if (!model)
@@ -353,21 +425,21 @@ static void accept_events(GtkWidget *trace_tree_view, GtkTreeView *view)
                            COL_ACTIVE, &active,
                            -1);
 
-        if (active) {
-                if (trace_view_store_get_all_events_enabled(store))
-                        return;
+        if (!active)
+                update_system_events(model, &iter,
+                                     &systems, systems_size,
+                                     &events, &events_size);
 
-                trace_view_store_set_all_events_enabled(store);
-        } else
-                update_system_events(store, model, &iter);
+        event_helper->func(TRUE, active, systems, events,
+                           event_helper->data);
 
-        /* Force an update */
-        g_object_ref(store);
-        gtk_tree_view_set_model(GTK_TREE_VIEW(trace_tree_view), NULL);
-        trace_view_store_update_filter(store);
-        gtk_tree_view_set_model(GTK_TREE_VIEW(trace_tree_view), GTK_TREE_MODEL(store));
-        g_object_unref(store);
+        if (systems) {
+                for (i = 0; systems[i]; i++)
+                        g_free(systems[i]);
 
+                g_free(systems);
+        }
+        g_free(events);
 }
 
 /* Callback for the clicked signal of the Events filter button */
@@ -375,15 +447,17 @@ static void
 event_dialog_response (gpointer data, gint response_id)
 {
         struct dialog_helper *helper = data;
-        GtkTreeView *view = helper->data;
+        struct event_filter_helper *event_helper = helper->data;
 
         switch (response_id) {
         case GTK_RESPONSE_ACCEPT:
                 printf("accept!\n");
-                accept_events(helper->trace_tree, view);
+                accept_events(event_helper);
                 break;
         case GTK_RESPONSE_REJECT:
                 printf("reject!\n");
+                event_helper->func(FALSE, FALSE, NULL, NULL,
+                                   event_helper->data);
                 break;
         default:
                 break;
@@ -391,13 +465,30 @@ event_dialog_response (gpointer data, gint response_id)
 
         gtk_widget_destroy(GTK_WIDGET(helper->dialog));
 
+        g_free(event_helper);
         g_free(helper);
 }
 
-void trace_filter_event_dialog(void *trace_tree)
+/**
+ * trace_filter_event_dialog - make dialog with event listing
+ * @handle: the handle to the tracecmd data file
+ * @all_events: if TRUE then select all events.
+ * @systems: NULL or a string array of systems terminated with NULL
+ * @events: NULL or a int array of event ids terminated with -1
+ * @func: The function to call when accept or cancel is pressed
+ * @data: data to pass to the function @func
+ *
+ * If @all_events is set, then @systems and @events are ignored.
+ */
+void trace_filter_event_dialog(struct tracecmd_input *handle,
+                               gboolean all_events,
+                               gchar **systems,
+                               gint *events,
+                               trace_filter_event_cb_func func,
+                               gpointer data)
 {
-        GtkWidget *tree_view = GTK_WIDGET(trace_tree);
         struct dialog_helper *helper;
+        struct event_filter_helper *event_helper;
         GtkWidget *dialog;
         GtkWidget *scrollwin;
         GtkWidget *view;
@@ -415,8 +506,14 @@ void trace_filter_event_dialog(void *trace_tree)
                                              GTK_RESPONSE_REJECT,
                                              NULL);
 
+        event_helper = g_new0(typeof(*event_helper), 1);
+        g_assert(event_helper);
+
         helper->dialog = dialog;
-        helper->trace_tree = tree_view;
+        helper->data = event_helper;
+
+        event_helper->func = func;
+        event_helper->data = data;
 
         /* We can attach the Quit menu item to our exit function */
         g_signal_connect_swapped (dialog, "response",
@@ -427,8 +524,8 @@ void trace_filter_event_dialog(void *trace_tree)
         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
                                        GTK_POLICY_AUTOMATIC,
                                        GTK_POLICY_AUTOMATIC);
-        view = create_event_list_view(tree_view);
-        helper->data = view;
+        view = create_event_list_view(handle, all_events, systems, events);
+        event_helper->view = GTK_TREE_VIEW(view);
 
         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollwin, TRUE, TRUE, 0);
         gtk_container_add(GTK_CONTAINER(scrollwin), view);
@@ -440,10 +537,12 @@ void trace_filter_event_dialog(void *trace_tree)
 }
 
 struct cpu_filter_helper {
-        gboolean allcpus;
-        guint64 *cpu_mask;
-        GtkWidget **buttons;
-        int cpus;
+        gboolean                        allcpus;
+        guint64                         *cpu_mask;
+        GtkWidget                       **buttons;
+        int                             cpus;
+        trace_filter_cpu_cb_func        func;
+        gpointer                        data;
 };
 
 static void destroy_cpu_helper(struct cpu_filter_helper *cpu_helper)
@@ -459,40 +558,28 @@ cpu_dialog_response (gpointer data, gint response_id)
 {
         struct dialog_helper *helper = data;
         struct cpu_filter_helper *cpu_helper = helper->data;
-        GtkTreeView *view = GTK_TREE_VIEW(helper->trace_tree);
-        TraceViewStore *store;
-        gint cpu;
-
-        store = TRACE_VIEW_STORE(gtk_tree_view_get_model(view));
+        guint64 *cpu_mask = NULL;
 
         switch (response_id) {
         case GTK_RESPONSE_ACCEPT:
-                g_object_ref(store);
-                gtk_tree_view_set_model(view, NULL);
 
-                if (cpu_helper->allcpus) {
-                        trace_view_store_set_all_cpus(store);
-                        gtk_tree_view_set_model(view, GTK_TREE_MODEL(store));
-                        g_object_unref(store);
-                        break;
+                if (!cpu_helper->allcpus) {
+                        cpu_mask = cpu_helper->cpu_mask;
+                        cpu_helper->cpu_mask = NULL;
                 }
 
-                for (cpu = 0; cpu < cpu_helper->cpus; cpu++) {
-                        if (cpu_mask_isset(cpu_helper->cpu_mask, cpu))
-                                trace_view_store_set_cpu(store, cpu);
-                        else
-                                trace_view_store_clear_cpu(store, cpu);
-                }
-                gtk_tree_view_set_model(view, GTK_TREE_MODEL(store));
-                g_object_unref(store);
+                cpu_helper->func(TRUE, cpu_helper->allcpus, cpu_mask, cpu_helper->data);
                 break;
 
         case GTK_RESPONSE_REJECT:
+                cpu_helper->func(FALSE, FALSE, NULL, cpu_helper->data);
                 break;
         default:
                 break;
         };
 
+        g_free(cpu_mask);
+
         gtk_widget_destroy(GTK_WIDGET(helper->dialog));
 
         destroy_cpu_helper(helper->data);
@@ -525,11 +612,11 @@ void cpu_toggle(gpointer data, GtkWidget *widget)
         /* Get the CPU # from the label. Pass "CPU " */
         cpu = atoi(label + 4);
         if (active) {
-                cpu_mask_set(cpu_helper->cpu_mask, cpu);
+                cpu_set(cpu_helper->cpu_mask, cpu);
                 return;
         }
 
-        cpu_mask_clear(cpu_helper->cpu_mask, cpu);
+        cpu_clear(cpu_helper->cpu_mask, cpu);
 
         if (!cpu_helper->allcpus)
                 return;
@@ -538,10 +625,18 @@ void cpu_toggle(gpointer data, GtkWidget *widget)
                                      FALSE);
 }
 
-void trace_filter_cpu_dialog(void *trace_tree)
+/**
+ * trace_filter_cpu_dialog - make dialog with cpu listing
+ * @all_cpus: if TRUE then select all cpus.
+ * @cpus_selected: NULL or a CPU mask with the CPUs to be select set.
+ * @func: The function to call when accept or cancel is pressed
+ * @data: data to pass to the function @func
+ *
+ * If @all_cpus is set, then @cpus_selected is ignored.
+ */
+void trace_filter_cpu_dialog(gboolean all_cpus, guint64 *cpus_selected, gint cpus,
+                             trace_filter_cpu_cb_func func, gpointer data)
 {
-        GtkWidget *tree_view = GTK_WIDGET(trace_tree);
-        TraceViewStore *store;
         struct dialog_helper *helper;
         struct cpu_filter_helper *cpu_helper;
         GtkWidget *dialog;
@@ -554,17 +649,12 @@ void trace_filter_cpu_dialog(void *trace_tree)
         gchar   counter[100];
         gint width, height;
         gint allset;
-        gint cpus;
         gint cpu;
 
-        store = TRACE_VIEW_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)));
-
-        cpus = trace_view_store_get_cpus(store);
-
         helper = g_malloc(sizeof(*helper));
         g_assert(helper != NULL);
 
-        cpu_helper = g_new0(typeof(*cpu_helper), sizeof(*cpu_helper));
+        cpu_helper = g_new0(typeof(*cpu_helper), 1);
         g_assert(cpu_helper != NULL);
 
         helper->data = cpu_helper;
@@ -581,12 +671,14 @@ void trace_filter_cpu_dialog(void *trace_tree)
                                              NULL);
 
         helper->dialog = dialog;
-        helper->trace_tree = tree_view;
 
         cpu_helper->cpus = cpus;
         cpu_helper->buttons = g_new0(GtkWidget *, cpus + 1);
         g_assert(cpu_helper->buttons);
 
+        cpu_helper->func = func;
+        cpu_helper->data = data;
+
         g_signal_connect_swapped (dialog, "response",
                                   G_CALLBACK (cpu_dialog_response),
                                   (gpointer) helper);
@@ -618,7 +710,16 @@ void trace_filter_cpu_dialog(void *trace_tree)
         /* The last button will be the all CPUs button */
         cpu_helper->buttons[cpus] = check;
 
-        allset = trace_view_store_get_all_cpus(store);
+        allset = cpus_selected ? 0 : 1;
+        if (!allset) {
+                /* check if the list is all set */
+                for (cpu = 0; cpu < cpus; cpu++)
+                        if (!cpu_isset(cpus_selected, cpu))
+                                break;
+                if (cpu == cpus)
+                        allset = 1;
+        }
+
         if (allset)
                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
 
@@ -637,10 +738,11 @@ void trace_filter_cpu_dialog(void *trace_tree)
                 check = gtk_check_button_new_with_label(counter);
                 cpu_helper->buttons[cpu] = check;
                 gtk_box_pack_start(GTK_BOX(vbox), check, TRUE, FALSE, 0);
-                if (allset || trace_view_store_cpu_isset(store, cpu)) {
-                        cpu_mask_set(cpu_helper->cpu_mask, cpu);
+                if (cpus_selected && cpu_isset(cpus_selected, cpu)) {
+                        cpu_set(cpu_helper->cpu_mask, cpu);
                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
-                }
+                } else
+                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
 
                 g_signal_connect_swapped (check, "toggled",
                                           G_CALLBACK (cpu_toggle),
diff --git a/trace-hash.c b/trace-hash.c
index 8435e6c..a41b2ce 100644
--- a/trace-hash.c
+++ b/trace-hash.c
@@ -160,3 +160,23 @@ struct filter_task *filter_task_hash_copy(struct filter_task *hash)
         return new_hash;
 }
 
+
+int str_cmp(const void *a, const void *b)
+{
+        char * const * sa = a;
+        char * const * sb = b;
+
+        return strcmp(*sa, *sb);
+}
+
+int id_cmp(const void *a, const void *b)
+{
+        const gint *ia = a;
+        const gint *ib = b;
+
+        if (*ia > *ib)
+                return 1;
+        if (*ia < *ib)
+                return -1;
+        return 0;
+}
diff --git a/trace-hash.h b/trace-hash.h
index 9948138..04543f7 100644
--- a/trace-hash.h
+++ b/trace-hash.h
@@ -29,4 +29,9 @@ static inline gint filter_task_count(struct filter_task *hash)
         return hash->count;
 }
 
+/* put here because there's no other place */
+
+int str_cmp(const void *a, const void *b);
+int id_cmp(const void *a, const void *b);
+
 #endif /* _TRACE_HASH_H */
diff --git a/trace-view-main.c b/trace-view-main.c
index 2f4042e..122cda8 100644
--- a/trace-view-main.c
+++ b/trace-view-main.c
@@ -47,18 +47,45 @@ delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
 static void
 events_clicked (gpointer data)
 {
-        GtkWidget *trace_tree = data;
+        GtkTreeView *trace_tree = data;
+        GtkTreeModel *model;
+        TraceViewStore *store;
+        gboolean all_events;
+        gchar **systems;
+        gint *events;
+
+        model = gtk_tree_view_get_model(trace_tree);
+        if (!model)
+                return;
+
+        store = TRACE_VIEW_STORE(model);
+
+        all_events = trace_view_store_get_all_events_enabled(store);
+        systems = trace_view_store_get_systems_enabled(store);
+        events = trace_view_store_get_events_enabled(store);
 
-        trace_filter_event_dialog(trace_tree);
+        trace_filter_event_dialog(store->handle, all_events,
+                                  systems, events,
+                                  trace_view_event_filter_callback, trace_tree);
 }
 
 /* Callback for the clicked signal of the CPUs filter button */
 static void
 cpus_clicked (gpointer data)
 {
-        GtkWidget *trace_tree = data;
+        GtkTreeView *trace_tree = data;
+        TraceViewStore *store;
+        gboolean all_cpus;
+        guint64 *cpu_mask;
+
+        store = TRACE_VIEW_STORE(gtk_tree_view_get_model(trace_tree));
+
+        all_cpus = trace_view_store_get_all_cpus(store);
+        cpu_mask = trace_view_store_get_cpu_mask(store);
 
-        trace_filter_cpu_dialog(trace_tree);
+        trace_filter_cpu_dialog(all_cpus, cpu_mask,
+                                trace_view_store_get_cpus(store),
+                                trace_view_cpu_filter_callback, trace_tree);
 }
 
 #if 0
diff --git a/trace-view-store.c b/trace-view-store.c
index 58280dd..cc6b865 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -494,26 +494,6 @@ trace_view_store_get_value (GtkTreeModel *tree_model,
         }
 }
 
-int str_cmp(const void *a, const void *b)
-{
-        char * const * sa = a;
-        char * const * sb = b;
-
-        return strcmp(*sa, *sb);
-}
-
-int id_cmp(const void *a, const void *b)
-{
-        const gint *ia = a;
-        const gint *ib = b;
-
-        if (*ia > *ib)
-                return 1;
-        if (*ia < *ib)
-                return -1;
-        return 0;
-}
-
 gboolean trace_view_store_system_enabled(TraceViewStore *store, const gchar *system)
 {
         const gchar **sys = &system;
diff --git a/trace-view.c b/trace-view.c
index 6ed71d8..c73f95a 100644
--- a/trace-view.c
+++ b/trace-view.c
@@ -28,6 +28,7 @@
 #include "trace-local.h"
 #include "trace-view.h"
 #include "trace-compat.h"
+#include "cpu.h"
 
 enum {
         COL_INDEX,
@@ -351,3 +352,92 @@ void trace_view_select(GtkWidget *treeview, guint64 time)
         gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0.5, 0.0);
         gtk_tree_path_free(path);
 }
+
+void trace_view_event_filter_callback(gboolean accept,
+                                      gboolean all_events,
+                                      gchar **systems,
+                                      gint *events,
+                                      gpointer data)
+{
+        GtkTreeView *trace_tree = data;
+        GtkTreeModel *model;
+        TraceViewStore *store;
+        gint i;
+
+        if (!accept)
+                return;
+
+        model = gtk_tree_view_get_model(trace_tree);
+        if (!model)
+                return;
+
+        store = TRACE_VIEW_STORE(model);
+
+        if (all_events) {
+                if (trace_view_store_get_all_events_enabled(store))
+                        return;
+
+                trace_view_store_set_all_events_enabled(store);
+        } else {
+                trace_view_store_clear_all_events_enabled(store);
+
+                if (systems) {
+                        for (i = 0; systems[i]; i++)
+                                trace_view_store_set_system_enabled(store, systems[i]);
+                }
+
+                if (events) {
+                        for (i = 0; events[i] >= 0; i++)
+                                trace_view_store_set_event_enabled(store, events[i]);
+                }
+        }
+
+        /* Force an update */
+        g_object_ref(store);
+        gtk_tree_view_set_model(trace_tree, NULL);
+        trace_view_store_update_filter(store);
+        gtk_tree_view_set_model(trace_tree, GTK_TREE_MODEL(store));
+        g_object_unref(store);
+}
+
+void trace_view_cpu_filter_callback(gboolean accept,
+                                    gboolean all_cpus,
+                                    guint64 *selected_cpu_mask,
+                                    gpointer data)
+{
+        GtkTreeView *trace_tree = data;
+        GtkTreeModel *model;
+        TraceViewStore *store;
+        gint cpus;
+        gint cpu;
+
+        model = gtk_tree_view_get_model(trace_tree);
+        if (!model)
+                return;
+
+        store = TRACE_VIEW_STORE(model);
+
+        if (!accept)
+                return;
+
+        g_object_ref(store);
+        gtk_tree_view_set_model(trace_tree, NULL);
+
+        if (all_cpus) {
+                trace_view_store_set_all_cpus(store);
+                goto set_model;
+        }
+
+        cpus = trace_view_store_get_cpus(store);
+
+        for (cpu = 0; cpu < cpus; cpu++) {
+                if (cpu_isset(selected_cpu_mask, cpu))
+                        trace_view_store_set_cpu(store, cpu);
+                else
+                        trace_view_store_clear_cpu(store, cpu);
+        }
+
+ set_model:
+        gtk_tree_view_set_model(trace_tree, GTK_TREE_MODEL(store));
+        g_object_unref(store);
+}
diff --git a/trace-view.h b/trace-view.h
index 03d331c..44cf0d0 100644
--- a/trace-view.h
+++ b/trace-view.h
@@ -12,10 +12,68 @@ void trace_view(int argc, char **argv);
 void trace_view_update_task_filter(GtkWidget *treeview, struct filter_task *filter);
 void trace_view_make_selection_visible(GtkWidget *treeview);
 
-/* We use void because this can be used by non gtk files */
-void trace_filter_event_dialog(void *traceview);
-void trace_filter_cpu_dialog(void *trace_tree);
+struct event_filter_list {
+        struct event_filter_list        *next;
+        struct event                    *event;
+};
+
+/**
+ * trace_filter_event_cb_func - callback type for event dialog
+ * @accept: TRUE if the accept button was pressed, otherwise FALSE
+ * @all_events: TRUE if "All Events" was checked
+ * @systems: NULL or a string array of systems terminated with NULL
+ * @events: NULL or a int array of event ids terminated with -1
+ * @data: The data given passed in to the event dialog function
+ *
+ * If @accept is FALSE then @all_events, @systems, and @events
+ * should be ignored. @data is still valid.
+ *
+ * If @all_events is TRUE then @systems and @events should be ignored.
+ */
+typedef void (*trace_filter_event_cb_func)(gboolean accept,
+                                           gboolean all_events,
+                                           char **systems,
+                                           gint *events,
+                                           gpointer data);
+
+void trace_filter_event_dialog(struct tracecmd_input *handle,
+                               gboolean all_events,
+                               gchar **systems,
+                               gint *events,
+                               trace_filter_event_cb_func func,
+                               gpointer data);
+
+/**
+ * trace_filter_cpu_cb_func - callback type for CPU dialog
+ * @accept: TRUE if the accept button was pressed, otherwise FALSE
+ * @all_cpus: TRUE if "All CPUS" was checked
+ * @selected_cpus: NULL or a cpu_mask with the cpus that were checked set.
+ * @data: The data given passed in to the CPU dialog function
+ *
+ * If @accept is FALSE then @all_cpus and @selected_cpus should be ignored.
+ * @data is still valid.
+ *
+ * If @all_cpus is TRUE then @selected_cpus should be ignored.
+ */
+typedef void (*trace_filter_cpu_cb_func)(gboolean accept,
+                                         gboolean all_cpus,
+                                         guint64 *selected_cpus,
+                                         gpointer data);
+
+void trace_filter_cpu_dialog(gboolean all_cpus, guint64 *cpu_mask_selected, gint cpus,
+                             trace_filter_cpu_cb_func func, gpointer data);
 
 void trace_view_select(GtkWidget *treeview, guint64 time);
 
+void trace_view_event_filter_callback(gboolean accept,
+                                      gboolean all_events,
+                                      gchar **systems,
+                                      gint *events,
+                                      gpointer data);
+
+void trace_view_cpu_filter_callback(gboolean accept,
+                                    gboolean all_cpus,
+                                    guint64 *selected_cpu_mask,
+                                    gpointer data);
+
 #endif /* _TRACE_VIEW_H */