kernelshark: Convert to using event_filters for graph and list

Use the new pevent event_filter infrastructure to filter events.
It removes a lot of specific graph and list code and is also
faster.

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

10 files changed, 193 insertions, 307 deletions

diff --git a/kernel-shark.c b/kernel-shark.c
index d199e56..d13819d 100644
--- a/kernel-shark.c
+++ b/kernel-shark.c
@@ -192,6 +192,7 @@ static void
 list_events_clicked (gpointer data)
 {
         struct shark_info *info = data;
+        struct event_filter *event_filter;
         GtkTreeView *trace_tree = GTK_TREE_VIEW(info->treeview);
         GtkTreeModel *model;
         TraceViewStore *store;
@@ -206,12 +207,16 @@ list_events_clicked (gpointer data)
         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);
+        event_filter = trace_view_store_get_event_filter(store);
+
+        trace_filter_convert_filter_to_names(event_filter,
+                                             &systems, &events);
 
         trace_filter_event_dialog(store->handle, all_events,
                                   systems, events,
                                   trace_view_event_filter_callback, info->treeview);
+        free(systems);
+        free(events);
 }
 
 static void
@@ -224,18 +229,20 @@ graph_events_clicked (gpointer data)
         gint *events;
 
         all_events = ginfo->all_events;
-        systems = ginfo->systems;
-        events = ginfo->event_ids;
-
+        trace_filter_convert_filter_to_names(ginfo->event_filter,
+                                             &systems, &events);
         trace_filter_event_dialog(info->handle, all_events,
                                   systems, events,
                                   trace_graph_event_filter_callback, ginfo);
+        free(systems);
+        free(events);
 }
 
 static void
 sync_graph_events_to_list_clicked (gpointer data)
 {
         struct shark_info *info = data;
+        struct event_filter *event_filter;
         GtkTreeView *trace_tree = GTK_TREE_VIEW(info->treeview);
         GtkTreeModel *model;
         TraceViewStore *store;
@@ -250,11 +257,15 @@ sync_graph_events_to_list_clicked (gpointer data)
         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);
+        event_filter = trace_view_store_get_event_filter(store);
+
+        trace_filter_convert_filter_to_names(event_filter,
+                                             &systems, &events);
 
         trace_graph_event_filter_callback(TRUE, all_events, systems,
                                           events, info->ginfo);
+        free(systems);
+        free(events);
 }
 
 
@@ -268,11 +279,13 @@ sync_list_events_to_graph_clicked (gpointer data)
         gint *events;
 
         all_events = ginfo->all_events;
-        systems = ginfo->systems;
-        events = ginfo->event_ids;
+        trace_filter_convert_filter_to_names(ginfo->event_filter,
+                                             &systems, &events);
 
         trace_view_event_filter_callback(TRUE, all_events, systems,
                                          events, info->treeview);
+        free(systems);
+        free(events);
 }
 
 /* Callback for the clicked signal of the CPUs filter button */
diff --git a/trace-filter.c b/trace-filter.c
index 126d181..7e5d37d 100644
--- a/trace-filter.c
+++ b/trace-filter.c
@@ -590,8 +590,7 @@ event_dialog_response (gpointer data, gint response_id)
  */
 void trace_filter_event_dialog(struct tracecmd_input *handle,
                                gboolean all_events,
-                               gchar **systems,
-                               gint *events,
+                               gchar **systems, gint *events,
                                trace_filter_event_cb_func func,
                                gpointer data)
 {
@@ -883,3 +882,130 @@ void trace_filter_cpu_dialog(gboolean all_cpus, guint64 *cpus_selected, gint cpu
 
         gtk_widget_show_all(dialog);
 }
+
+static void add_system_str(gchar ***systems, char *system, int count)
+{
+        if (!systems)
+                return;
+
+        if (!count)
+                *systems = malloc_or_die(sizeof(char *) * 2);
+        else
+                *systems = realloc(*systems, sizeof(char *) * (count + 2));
+        if (!*systems)
+                die("Can't allocate systems");
+
+        (*systems)[count] = system;
+        (*systems)[count+1] = NULL;
+}
+
+static void add_event_int(gint **events, gint event, int count)
+{
+        if (!events)
+                return;
+
+        if (!count)
+                *events = malloc_or_die(sizeof(gint) * 2);
+        else
+                *events = realloc(*events, sizeof(gint) * (count + 2));
+        if (!*events)
+                die("Can't allocate events");
+
+        (*events)[count] = event;
+        (*events)[count+1] = -1;
+}
+
+/* -- Helper functions -- */
+
+/**
+ * trace_filter_convert_filter_to_names - convert a filter to names.
+ * @filter: the filter to convert
+ * @systems: array of systems that the filter selects (may be NULL)
+ * @event_ids: array of event ids that the filter selects (may be NULL)
+ *
+ * @systems will be filled when the filter selects all events within
+ * its system. (may return NULL)
+ *
+ * @event_ids will be all events selected (not including those selected
+ *  by @systems)
+ */
+void trace_filter_convert_filter_to_names(struct event_filter *filter,
+                                          gchar ***systems,
+                                          gint **event_ids)
+{
+        struct pevent *pevent = filter->pevent;
+        struct event_format **events;
+        struct event_format *event;
+        char *last_system = NULL;
+        int all_selected = 1;
+        int start_sys = 0;
+        int sys_count = 0;
+        int event_count = 0;
+        int i, x;
+
+        if (systems)
+                *systems = NULL;
+        if (event_ids)
+                *event_ids = NULL;
+
+        events = pevent_list_events(pevent, EVENT_SORT_SYSTEM);
+
+        for (i = 0; events[i]; i++) {
+                event = events[i];
+
+                if (systems && last_system &&
+                    strcmp(last_system, events[i]->system) != 0) {
+                        if (all_selected)
+                                add_system_str(systems, last_system, sys_count++);
+                        start_sys = i;
+                        all_selected = 1;
+                }
+
+                if (pevent_event_filtered(filter, event->id)) {
+                        if (!all_selected || !systems)
+                                add_event_int(event_ids, event->id, event_count++);
+                } else {
+                        if (all_selected && event_ids) {
+                                for (x = start_sys; x < i; x++) {
+                                        add_event_int(event_ids,
+                                                      events[x]->id, event_count++);
+                                }
+                        }
+                        all_selected = 0;
+                }
+                last_system = event->system;
+        }
+
+        if (systems && last_system && all_selected)
+                add_system_str(systems, last_system, sys_count++);
+}
+
+/**
+ * trace_filter_convert_char_to_filter - convert the strings to the filter
+ * @filter: the filter to convert
+ * @systems: array of systems that will have its events selected in @filter
+ * @events: array of event ids that will be selected in @filter
+ */
+void trace_filter_convert_char_to_filter(struct event_filter *filter,
+                                         gchar **systems,
+                                         gint *events)
+{
+        struct event_format *event;
+        int i;
+
+        if (systems) {
+                for (i = 0; systems[i]; i++)
+                        pevent_filter_add_filter_str(filter,
+                                                     systems[i], NULL);
+        }
+
+        if (events) {
+                for (i = 0; events[i] >= 0; i++) {
+                        event = pevent_find_event(filter->pevent, events[i]);
+                        if (event)
+                                pevent_filter_add_filter_str(filter,
+                                                             event->name,
+                                                             NULL);
+                }
+        }
+}
diff --git a/trace-filter.h b/trace-filter.h
index e20e742..73bdb67 100644
--- a/trace-filter.h
+++ b/trace-filter.h
@@ -54,6 +54,13 @@ void trace_filter_event_dialog(struct tracecmd_input *handle,
                                trace_filter_event_cb_func func,
                                gpointer data);
 
+void trace_filter_convert_filter_to_names(struct event_filter *filter,
+                                          gchar ***systems,
+                                          gint **events);
+
+void trace_filter_convert_char_to_filter(struct event_filter *filter,
+                                         gchar **systems,
+                                         gint *events);
 /**
  * trace_filter_cpu_cb_func - callback type for CPU dialog
  * @accept: TRUE if the accept button was pressed, otherwise FALSE
diff --git a/trace-graph-main.c b/trace-graph-main.c
index e3e5b48..b31e118 100644
--- a/trace-graph-main.c
+++ b/trace-graph-main.c
@@ -106,12 +106,14 @@ events_clicked (gpointer data)
                 return;
 
         all_events = ginfo->all_events;
-        systems = ginfo->systems;
-        events = ginfo->event_ids;
 
+        trace_filter_convert_filter_to_names(ginfo->event_filter,
+                                             &systems, &events);
         trace_filter_event_dialog(ginfo->handle, all_events,
                                   systems, events,
                                   trace_graph_event_filter_callback, ginfo);
+        free(systems);
+        free(events);
 }
 
 void trace_graph(int argc, char **argv)
diff --git a/trace-graph.c b/trace-graph.c
index 6f2661e..a440602 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -178,42 +178,9 @@ static void graph_filter_task_clear(struct graph_info *ginfo)
         ginfo->filter_enabled = 0;
 }
 
-gboolean graph_filter_system(struct graph_info *ginfo, const gchar *system)
-{
-        const gchar **sys = &system;
-
-        if (ginfo->all_events)
-                return TRUE;
-
-        if (!ginfo->systems)
-                return FALSE;
-
-        sys = bsearch(sys, ginfo->systems, ginfo->systems_size,
-                      sizeof(system), str_cmp);
-
-        return sys != NULL;
-}
-
-gboolean graph_filter_event(struct graph_info *ginfo, gint event_id)
-{
-        gint *event = &event_id;
-
-        if (ginfo->all_events)
-                return TRUE;
-
-        if (!ginfo->event_ids)
-                return FALSE;
-
-        event = bsearch(event, ginfo->event_ids, ginfo->event_ids_size,
-                        sizeof(event_id), id_cmp);
-
-        return event != NULL;
-}
-
 gboolean trace_graph_filter_on_event(struct graph_info *ginfo, struct record *record)
 {
-        struct event_format *event;
-        gint event_id;
+        int ret;
 
         if (!record)
                 return TRUE;
@@ -221,18 +188,8 @@ gboolean trace_graph_filter_on_event(struct graph_info *ginfo, struct record *re
         if (ginfo->all_events)
                 return FALSE;
 
-        event_id = pevent_data_type(ginfo->pevent, record);
-        event = pevent_data_event_from_type(ginfo->pevent, event_id);
-        if (!event)
-                return TRUE;
-
-        if (graph_filter_system(ginfo, event->system))
-                return FALSE;
-
-        if (graph_filter_event(ginfo, event_id))
-                return FALSE;
-
-        return TRUE;
+        ret = pevent_filter_match(ginfo->event_filter, record);
+        return ret == FILTER_MATCH ? FALSE : TRUE;
 }
 
 gboolean trace_graph_filter_on_task(struct graph_info *ginfo, gint pid)
@@ -1766,28 +1723,6 @@ void trace_graph_select_by_time(struct graph_info *ginfo, guint64 time)
                 gtk_adjustment_set_value(vadj, (PLOT_BOTTOM(i) - view_width) + 10);
 }
 
-static void graph_free_systems(struct graph_info *ginfo)
-{
-        gint i;
-
-        if (!ginfo->systems)
-                return;
-
-        for (i = 0; ginfo->systems[i]; i++)
-                g_free(ginfo->systems[i]);
-
-        g_free(ginfo->systems);
-        ginfo->systems = NULL;
-        ginfo->systems_size = 0;
-}
-
-static void graph_free_events(struct graph_info *ginfo)
-{
-        g_free(ginfo->event_ids);
-        ginfo->event_ids = NULL;
-        ginfo->event_ids_size = 0;
-}
-
 void trace_graph_event_filter_callback(gboolean accept,
                                        gboolean all_events,
                                        gchar **systems,
@@ -1795,14 +1730,10 @@ void trace_graph_event_filter_callback(gboolean accept,
                                        gpointer data)
 {
         struct graph_info *ginfo = data;
-        gint i;
 
         if (!accept)
                 return;
 
-        graph_free_systems(ginfo);
-        graph_free_events(ginfo);
-
         if (all_events) {
                 ginfo->all_events = TRUE;
                 redraw_graph(ginfo);
@@ -1811,33 +1742,10 @@ void trace_graph_event_filter_callback(gboolean accept,
 
         ginfo->all_events = FALSE;
 
-        if (systems) {
-                for (ginfo->systems_size = 0;
-                     systems[ginfo->systems_size];
-                     ginfo->systems_size++)
-                        ;
-
-                ginfo->systems = g_new(typeof(*systems), ginfo->systems_size + 1);
-                for (i = 0; i < ginfo->systems_size; i++)
-                        ginfo->systems[i] = g_strdup(systems[i]);
-                ginfo->systems[i] = NULL;
-
-                qsort(ginfo->systems, ginfo->systems_size, sizeof(gchar *), str_cmp);
-        }
-
-        if (events) {
-                for (ginfo->event_ids_size = 0;
-                     events[ginfo->event_ids_size] >= 0;
-                     ginfo->event_ids_size++)
-                        ;
-
-                ginfo->event_ids = g_new(typeof(*events), ginfo->event_ids_size + 1);
-                for (i = 0; i < ginfo->event_ids_size; i++)
-                        ginfo->event_ids[i] = events[i];
-                ginfo->event_ids[i] = -1;
+        pevent_filter_reset(ginfo->event_filter);
 
-                qsort(ginfo->event_ids, ginfo->event_ids_size, sizeof(gint), id_cmp);
-        }
+        trace_filter_convert_char_to_filter(ginfo->event_filter,
+                                            systems, events);
 
         redraw_graph(ginfo);
 }
@@ -1908,9 +1816,6 @@ destroy_event(GtkWidget *widget, gpointer data)
 
         trace_graph_free_info(ginfo);
 
-        graph_free_systems(ginfo);
-        graph_free_events(ginfo);
-
         filter_task_hash_free(ginfo->task_filter);
         filter_task_hash_free(ginfo->hide_tasks);
 
@@ -2040,6 +1945,7 @@ create_graph_info(struct graph_info *ginfo)
 void trace_graph_free_info(struct graph_info *ginfo)
 {
         if (ginfo->handle) {
+                pevent_filter_free(ginfo->event_filter);
                 trace_graph_plot_free(ginfo);
                 tracecmd_close(ginfo->handle);
         }
@@ -2068,6 +1974,8 @@ static int load_handle(struct graph_info *ginfo,
         ginfo->cpus = tracecmd_cpus(handle);
         ginfo->all_events = TRUE;
 
+        ginfo->event_filter = pevent_filter_alloc(ginfo->pevent);
+
         ginfo->start_time = -1ULL;
         ginfo->end_time = 0;
 
diff --git a/trace-graph.h b/trace-graph.h
index 1bbe4d5..411e750 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -187,10 +187,7 @@ struct graph_info {
         gboolean                filter_available;
 
         gboolean                all_events;     /* all events enabled */
-        gchar                   **systems;      /* event systems to filter on */
-        gint                    *event_ids;     /* events to filter on */
-        gint                    systems_size;
-        gint                    event_ids_size;
+        struct event_filter     *event_filter;  /* filtered events */
 
         /* cache of event fields */
         gint                    ftrace_sched_switch_id;
diff --git a/trace-view-main.c b/trace-view-main.c
index e04fd05..2bbfd42 100644
--- a/trace-view-main.c
+++ b/trace-view-main.c
@@ -99,6 +99,7 @@ static void
 events_clicked (gpointer data)
 {
         struct trace_tree_info *info = data;
+        struct event_filter *event_filter;
         GtkTreeView *trace_tree = GTK_TREE_VIEW(info->trace_tree);
         GtkTreeModel *model;
         TraceViewStore *store;
@@ -113,12 +114,16 @@ events_clicked (gpointer data)
         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);
+        event_filter = trace_view_store_get_event_filter(store);
+
+        trace_filter_convert_filter_to_names(event_filter,
+                                             &systems, &events);
 
         trace_filter_event_dialog(store->handle, all_events,
                                   systems, events,
                                   trace_view_event_filter_callback, trace_tree);
+        free(systems);
+        free(events);
 }
 
 /* Callback for the clicked signal of the CPUs filter button */
diff --git a/trace-view-store.c b/trace-view-store.c
index 366571f..e148f67 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -239,6 +239,7 @@ trace_view_store_finalize (GObject *object)
                 store->spin = NULL;
         }
 
+        pevent_filter_free(store->event_filter);
         tracecmd_close(store->handle);
 
         /* must chain up - finalize parent */
@@ -520,61 +521,9 @@ trace_view_store_get_value (GtkTreeModel *tree_model,
         }
 }
 
-gboolean trace_view_store_system_enabled(TraceViewStore *store, const gchar *system)
-{
-        const gchar **sys = &system;
-
-        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), FALSE);
-
-        if (store->all_events)
-                return TRUE;
-
-        if (!store->systems)
-                return FALSE;
-
-        sys = bsearch(sys, store->systems, store->systems_size,
-                      sizeof(system), str_cmp);
-
-        return sys != NULL;
-}
-
-gboolean trace_view_store_event_enabled(TraceViewStore *store, gint event_id)
-{
-        gint key = event_id;
-        gint *ret;
-
-        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), FALSE);
-
-        if (store->all_events)
-                return TRUE;
-
-        /* TODO: search for the system of the event? */
-
-        if (!store->event_types)
-                return FALSE;
-
-        ret = bsearch(&key, store->event_types, store->event_types_size,
-                      sizeof(gint), id_cmp);
-
-        return ret != NULL;
-}
-
 static void clear_all_events(TraceViewStore *store)
 {
-        gint i;
-
-        if (store->systems_size) {
-                for (i = 0; i < store->systems_size; i++)
-                        g_free(store->systems[i]);
-
-                g_free(store->systems);
-                store->systems = NULL;
-                store->systems_size = 0;
-        }
-
-        g_free(store->event_types);
-        store->event_types = NULL;
-        store->event_types_size = 0;
+        pevent_filter_reset(store->event_filter);
 }
 
 void trace_view_store_clear_all_events_enabled(TraceViewStore *store)
@@ -602,99 +551,6 @@ void trace_view_store_set_all_events_enabled(TraceViewStore *store)
         store->all_events = 1;
 }
 
-static void remove_system(TraceViewStore *store, const gchar *system)
-{
-        const gchar **sys = &system;
-
-        if (!store->systems)
-                return;
-
-        sys = bsearch(sys, store->systems, store->systems_size,
-                      sizeof(system), str_cmp);
-
-        if (!sys)
-                return;
-
-        g_free(*((gchar **)sys));
-
-        g_memmove(sys, sys+1, sizeof(*sys) * (store->systems_size -
-                                              ((gchar **)sys - store->systems)));
-        store->systems_size--;
-        store->systems[store->systems_size] = NULL;
-}
-
-void trace_view_store_set_system_enabled(TraceViewStore *store, const gchar *system)
-{
-        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
-
-        if (store->all_events)
-                /*
-                 * We are adding a new filter, so this is the
-                 * only system enabled.
-                 */
-                store->all_events = 0;
-
-        if (trace_view_store_system_enabled(store, system))
-                return;
-
-        if (!store->systems) {
-                store->systems = g_new0(gchar *, 2);
-                store->systems[0] = g_strdup(system);
-                store->systems_size++;
-                return;
-        }
-
-        store->systems_size++;
-        store->systems = g_realloc(store->systems,
-                                   sizeof(*store->systems) * (store->systems_size+1));
-        store->systems[store->systems_size - 1] = g_strdup(system);
-        store->systems[store->systems_size] = NULL;
-
-        qsort(store->systems, store->systems_size, sizeof(gchar *), str_cmp);
-}
-
-
-void trace_view_store_set_event_enabled(TraceViewStore *store, gint event_id)
-{
-        struct pevent *pevent;
-        struct event_format *event;
-
-        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
-
-        pevent = tracecmd_get_pevent(store->handle);
-        event = pevent_find_event(pevent, event_id);
-        if (!event)
-                return;
-
-        if (store->all_events)
-                /*
-                 * We are adding a new filter, so this is the
-                 * only system enabled.
-                 */
-                store->all_events = 0;
-
-        remove_system(store, event->system);
-
-        if (trace_view_store_event_enabled(store, event_id))
-                return;
-
-        if (!store->event_types) {
-                store->event_types = g_new0(gint, 2);
-                store->event_types[0] = event_id;
-                store->event_types[1] = -1;
-                store->event_types_size++;
-                return;
-        }
-
-        store->event_types_size++;
-        store->event_types = g_realloc(store->event_types,
-                                       sizeof(*store->event_types) * (store->event_types_size+1));
-        store->event_types[store->event_types_size - 1] = event_id;
-        store->event_types[store->event_types_size] = -1;
-
-        qsort(store->event_types, store->event_types_size, sizeof(gint), id_cmp);
-}
-
 
 /*****************************************************************************
  *
@@ -1018,6 +874,7 @@ trace_view_store_new (struct tracecmd_input *handle)
         newstore->handle = handle;
         newstore->cpus = tracecmd_cpus(handle);
         tracecmd_ref(handle);
+        newstore->event_filter = pevent_filter_alloc(tracecmd_get_pevent(handle));
 
         newstore->cpu_list = g_new(TraceViewRecord *, newstore->cpus);
         g_assert(newstore->cpu_list != NULL);
@@ -1361,11 +1218,8 @@ static gboolean show_task(TraceViewStore *store, struct pevent *pevent,
 static void update_filter_tasks(TraceViewStore *store)
 {
         struct tracecmd_input *handle;
-        struct event_format *event;
         struct pevent *pevent;
         struct record *record;
-        gint last_event_id = -1;
-        gint event_id;
         gint pid;
         gint cpu;
         gint i;
@@ -1404,15 +1258,10 @@ static void update_filter_tasks(TraceViewStore *store)
 
                         /* The record may be filtered by the events */
                         if (!store->all_events) {
-                                event_id = pevent_data_type(pevent, record);
-                                if (last_event_id != event_id) {
-                                        /* optimize: only search event when new */
-                                        event = pevent_find_event(pevent, event_id);
-                                        g_assert(event);
-                                }
-                                last_event_id = event_id;
-                                if (!trace_view_store_system_enabled(store, event->system) &&
-                                    !trace_view_store_event_enabled(store, event_id)) {
+                                int ret;
+                                ret = pevent_filter_match(store->event_filter,
+                                                          record);
+                                if (ret != FILTER_MATCH) {
                                         store->cpu_list[cpu][i].visible = 0;
                                         goto skip;
                                 }
diff --git a/trace-view-store.h b/trace-view-store.h
index 5a57cd9..ac907e0 100644
--- a/trace-view-store.h
+++ b/trace-view-store.h
@@ -117,10 +117,7 @@ struct trace_view_store
         /* filters */
         gint                    all_events; /* set 1 when all events are enabled */
                                                 /* else */
-        gchar                   **systems;  /* sorted list of systems that are enabled */
-        gint                    *event_types; /* sorted list of events that are enabled */
-        gint                    systems_size; /* size of systems array */
-        gint                    event_types_size; /* size of event_types array */
+        struct event_filter     *event_filter; /* Filtered events */
         struct filter_task      *task_filter;   /* hash of tasks to filter on */
         struct filter_task      *hide_tasks;    /* hash of tasks to not display */
 
@@ -157,16 +154,10 @@ TraceViewRecord *trace_view_store_get_row(TraceViewStore *store, gint row);
 
 TraceViewRecord *trace_view_store_get_visible_row(TraceViewStore *store, gint row);
 
-gboolean trace_view_store_system_enabled(TraceViewStore *store, const gchar *system);
-
 gboolean trace_view_store_event_enabled(TraceViewStore *store, gint event_id);
 
 void trace_view_store_set_all_events_enabled(TraceViewStore *store);
 
-void trace_view_store_set_system_enabled(TraceViewStore *store, const gchar *system);
-
-void trace_view_store_set_event_enabled(TraceViewStore *store, gint event_id);
-
 void trace_view_store_clear_all_events_enabled(TraceViewStore *store);
 
 void trace_view_store_update_filter(TraceViewStore *store);
@@ -249,16 +240,10 @@ static inline gboolean trace_view_store_get_all_events_enabled(TraceViewStore *s
         return store->all_events;
 }
 
-static inline gchar **trace_view_store_get_systems_enabled(TraceViewStore *store)
-{
-        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), NULL);
-        return store->systems;
-}
-
-static inline gint *trace_view_store_get_events_enabled(TraceViewStore *store)
+static inline struct event_filter *
+trace_view_store_get_event_filter(TraceViewStore *store)
 {
-        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), NULL);
-        return store->event_types;
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), FALSE);
+        return store->event_filter;
 }
-
 #endif /* _trace_view_store_h_included_ */
diff --git a/trace-view.c b/trace-view.c
index 75605a5..5de5f51 100644
--- a/trace-view.c
+++ b/trace-view.c
@@ -384,13 +384,13 @@ void trace_view_event_filter_callback(gboolean accept,
                                       gint *events,
                                       gpointer data)
 {
+        struct event_filter *event_filter;
         GtkTreeView *trace_tree = data;
         GtkTreeModel *model;
         TraceViewStore *store;
         TraceViewRecord *vrec;
         guint64 time;
         gint row;
-        gint i;
 
         if (!accept)
                 return;
@@ -409,15 +409,9 @@ void trace_view_event_filter_callback(gboolean accept,
         } 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]);
-                }
+                event_filter = trace_view_store_get_event_filter(store);
 
-                if (events) {
-                        for (i = 0; events[i] >= 0; i++)
-                                trace_view_store_set_event_enabled(store, events[i]);
-                }
+                trace_filter_convert_char_to_filter(event_filter, systems, events);
         }
 
         /* Keep track of the currently selected row */