Merge branch 'kernelshark-devel' into trace-cmd

Conflicts:
	Makefile

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

1 files changed, 326 insertions, 32 deletions

diff --git a/trace-view-main.c b/trace-view-main.c
index 52678ce..59d6838 100644
--- a/trace-view-main.c
+++ b/trace-view-main.c
@@ -28,6 +28,12 @@
 
 #include "trace-cmd.h"
 #include "trace-view.h"
+#include "trace-xml.h"
+#include "trace-filter.h"
+#include "trace-gui.h"
+#include "trace-compat.h"
+
+#include "version.h"
 
 #define version "0.1.1"
 
@@ -38,8 +44,13 @@
 static char *input_file;
 
 struct trace_tree_info {
-        GtkWidget *trace_tree;
-        GtkWidget *spin;
+        struct tracecmd_input   *handle;
+        GtkWidget               *trace_tree;
+        GtkWidget               *spin;
+        gint                    filter_enabled;
+        gint                    filter_task_selected;
+        struct filter_task      *task_filter;
+        struct filter_task      *hide_tasks;
 };
 
 void usage(char *prog)
@@ -55,26 +66,76 @@ load_clicked (gpointer data)
 {
         struct trace_tree_info *info = data;
         struct tracecmd_input *handle;
-        GtkWidget *dialog;
         gchar *filename;
 
-        dialog = gtk_file_chooser_dialog_new("Load File",
-                                             NULL,
-                                             GTK_FILE_CHOOSER_ACTION_OPEN,
-                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                             GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                             NULL);
-        if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
-                filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
-                handle = tracecmd_open(filename);
-                if (handle) {
-                        trace_view_reload(info->trace_tree, handle, info->spin);
-                        /* Free handle when freeing the trace tree */
-                        tracecmd_close(handle);
-                }
-                g_free(filename);
+        filename = trace_get_file_dialog("Load File");
+        if (!filename)
+                return;
+
+        handle = tracecmd_open(filename);
+        if (handle) {
+                trace_view_reload(info->trace_tree, handle, info->spin);
+                /* Free handle when freeing the trace tree */
+                tracecmd_close(handle);
+                info->handle = handle;
         }
-        gtk_widget_destroy(dialog);
+        g_free(filename);
+}
+
+/* Callback for the clicked signal of the Load Filters button */
+static void
+load_filters_clicked (gpointer data)
+{
+        struct trace_tree_info *info = data;
+        GtkTreeView *trace_tree = GTK_TREE_VIEW(info->trace_tree);
+        struct tracecmd_xml_handle *handle;
+        gchar *filename;
+
+        filename = trace_get_file_dialog("Load Filters");
+        if (!filename)
+                return;
+
+        handle = tracecmd_xml_open(filename);
+        if (!handle) {
+                warning("Could not open %s", filename);
+                return;
+        }
+        g_free(filename);
+
+        trace_filter_load_filters(handle,
+                                  "ListTaskFilter",
+                                  info->task_filter,
+                                  info->hide_tasks);
+
+        trace_view_load_filters(handle, trace_tree);
+
+        tracecmd_xml_close(handle);
+}
+
+/* Callback for the clicked signal of the Save Filters button */
+static void
+save_filters_clicked (gpointer data)
+{
+        struct trace_tree_info *info = data;
+        GtkTreeView *trace_tree = GTK_TREE_VIEW(info->trace_tree);
+        struct tracecmd_xml_handle *handle;
+        gchar *filename;
+
+        filename = trace_get_file_dialog("Save Filters");
+        if (!filename)
+                return;
+
+        handle = tracecmd_xml_create(filename, VERSION_STRING);
+        if (!handle)
+                warning("Could not create %s", filename);
+        g_free(filename);
+
+        trace_filter_save_filters(handle,
+                                  "ListTaskFilter",
+                                  info->task_filter, info->hide_tasks);
+        trace_view_save_filters(handle, trace_tree);
+
+        tracecmd_xml_close(handle);
 }
 
 /* Callback for the clicked signal of the Exit button */
@@ -162,24 +223,209 @@ cpus_clicked (gpointer data)
                                 trace_view_cpu_filter_callback, trace_tree);
 }
 
-#if 0
-static GtkTreeModel *
-create_combo_box_model(void)
+static void
+filter_list_clicked (gpointer data)
 {
-        GtkListStore *store;
-        GtkTreeIter iter;
+        struct trace_tree_info *info = data;
+
+        if (!filter_task_count(info->task_filter) &&
+            !filter_task_count(info->hide_tasks))
+                return;
+
+        info->filter_enabled ^= 1;
+
+        if (info->filter_enabled)
+                trace_view_update_filters(info->trace_tree,
+                                          info->task_filter,
+                                          info->hide_tasks);
+        else
+                trace_view_update_filters(info->trace_tree, NULL, NULL);
+}
+
+static void update_task_filter(struct trace_tree_info *info,
+                               struct filter_task *filter)
+{
+        struct filter_task_item *task;
+        gint pid = info->filter_task_selected;
+
+        task = filter_task_find_pid(filter, pid);
+
+        if (task)
+                filter_task_remove_pid(filter, pid);
+        else
+                filter_task_add_pid(filter, pid);
+
+        if (info->filter_enabled)
+                trace_view_update_filters(info->trace_tree,
+                                          info->task_filter,
+                                          info->hide_tasks);
+}
+
+static void filter_add_task_clicked(gpointer data)
+{
+        struct trace_tree_info *info = data;
+
+        update_task_filter(info, info->task_filter);
+}
+
+static void filter_hide_task_clicked(gpointer data)
+{
+        struct trace_tree_info *info = data;
+
+        update_task_filter(info, info->hide_tasks);
+}
+
+static void
+filter_clear_tasks_clicked (gpointer data)
+{
+        struct trace_tree_info *info = data;
+
+        trace_view_update_filters(info->trace_tree, NULL, NULL);
+        info->filter_enabled = 0;
+}
+
+static gboolean
+do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+        struct trace_tree_info *info = data;
+        static GtkWidget *menu;
+        static GtkWidget *menu_filter_enable;
+        static GtkWidget *menu_filter_add_task;
+        static GtkWidget *menu_filter_hide_task;
+        static GtkWidget *menu_filter_clear_tasks;
+        struct pevent *pevent;
+        struct record *record;
+        TraceViewRecord *vrec;
+        GtkTreeModel *model;
+        const char *comm;
+        gchar *text;
+        gint pid;
+        gint len;
+        guint64 offset;
+        gint row;
+        gint cpu;
+
+        if (!menu) {
+                menu = gtk_menu_new();
+
+                menu_filter_enable = gtk_menu_item_new_with_label("Enable Filter");
+                gtk_widget_show(menu_filter_enable);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_enable);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_enable), "activate",
+                                          G_CALLBACK (filter_list_clicked),
+                                          data);
+
+                menu_filter_add_task = gtk_menu_item_new_with_label("Add Task");
+                gtk_widget_show(menu_filter_add_task);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_add_task);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_add_task), "activate",
+                                          G_CALLBACK (filter_add_task_clicked),
+                                          data);
+
+                menu_filter_hide_task = gtk_menu_item_new_with_label("Hide Task");
+                gtk_widget_show(menu_filter_hide_task);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_hide_task);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_hide_task), "activate",
+                                          G_CALLBACK (filter_hide_task_clicked),
+                                          data);
+
+                menu_filter_clear_tasks = gtk_menu_item_new_with_label("Clear Task Filter");
+                gtk_widget_show(menu_filter_clear_tasks);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_clear_tasks);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_clear_tasks), "activate",
+                                          G_CALLBACK (filter_clear_tasks_clicked),
+                                          data);
+
+        }
+
+        row = trace_view_get_selected_row(GTK_WIDGET(info->trace_tree));
+        if (row >= 0) {
+
+                model = gtk_tree_view_get_model(GTK_TREE_VIEW(info->trace_tree));
+                vrec = trace_view_store_get_row(TRACE_VIEW_STORE(model), row);
+                offset = vrec->offset;
+
+                record = tracecmd_read_at(info->handle, offset, &cpu);
+
+                if (record) {
+                        pevent = tracecmd_get_pevent(info->handle);
+                        pid = pevent_data_pid(pevent, record);
+                        comm = pevent_data_comm_from_pid(pevent, pid);
+
+                        len = strlen(comm) + 50;
+
+                        text = g_malloc(len);
+                        g_assert(text);
+
+                        if (filter_task_find_pid(info->task_filter, pid))
+                                snprintf(text, len, "Remove %s-%d from filter", comm, pid);
+                        else
+                                snprintf(text, len, "Add %s-%d to filter", comm, pid);
+
+                        info->filter_task_selected = pid;
+
+                        gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_add_task),
+                                                text);
+
+                        if (filter_task_find_pid(info->hide_tasks, pid))
+                                snprintf(text, len, "Show %s-%d", comm, pid);
+                        else
+                                snprintf(text, len, "Hide %s-%d", comm, pid);
+
+                        gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_hide_task),
+                                                text);
+
+                        g_free(text);
+
+                        info->filter_task_selected = pid;
+
+                        gtk_widget_show(menu_filter_add_task);
+                        gtk_widget_show(menu_filter_hide_task);
+                        free_record(record);
+                }
+        } else {
+                gtk_widget_hide(menu_filter_add_task);
+                gtk_widget_hide(menu_filter_hide_task);
+        }
+
+        if (info->filter_enabled)
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_enable),
+                                        "Disable List Filter");
+        else
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_enable),
+                                        "Enable List Filter");
+
+        if (filter_task_count(info->task_filter) ||
+            filter_task_count(info->hide_tasks)) {
+                gtk_widget_set_sensitive(menu_filter_clear_tasks, TRUE);
+                gtk_widget_set_sensitive(menu_filter_enable, TRUE);
+        } else {
+                gtk_widget_set_sensitive(menu_filter_clear_tasks, FALSE);
+                gtk_widget_set_sensitive(menu_filter_enable, FALSE);
+        }
+
+        gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3,
+                       gtk_get_current_event_time());
+
+        return TRUE;
+}
 
-        store = gtk_list_store_new(1, G_TYPE_STRING);
-        gtk_list_store_append(store, &iter);
-        gtk_list_store_set(store, &iter, 0, "1", -1);
+static gboolean
+button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+        if (event->button == 3)
+                return do_tree_popup(widget, event, data);
 
-        return GTK_TREE_MODEL(store);
+        return FALSE;
 }
-#endif
 
 void trace_view(int argc, char **argv)
 {
-        static struct tracecmd_input *handle;
+        static struct tracecmd_input *handle = NULL;
         struct trace_tree_info tree_info;
         struct stat st;
         GtkWidget *trace_tree;
@@ -193,6 +439,7 @@ void trace_view(int argc, char **argv)
         GtkWidget *scrollwin;
         GtkWidget *label;
         GtkWidget *spin;
+        GtkWidget *statusbar;
         int ret;
         int c;
 
@@ -227,10 +474,17 @@ void trace_view(int argc, char **argv)
         if (input_file)
                 handle = tracecmd_open(input_file);
 
+        memset(&tree_info, 0, sizeof(tree_info));
+        tree_info.handle = handle;
+        tree_info.task_filter = filter_task_hash_alloc();
+        tree_info.hide_tasks = filter_task_hash_alloc();
+
         /* --- Main window --- */
 
         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
+        trace_dialog_register_window(window);
+
         /* --- Top Level Vbox --- */
 
         vbox = gtk_vbox_new(FALSE, 0);
@@ -255,12 +509,11 @@ void trace_view(int argc, char **argv)
 
         /* --- File - Load Option --- */
 
-        sub_item = gtk_menu_item_new_with_label("Load info");
+        sub_item = gtk_menu_item_new_with_label("Load data");
 
         /* Add them to the menu */
         gtk_menu_shell_append(GTK_MENU_SHELL (menu), sub_item);
 
-        /* We can attach the Quit menu item to our exit function */
         g_signal_connect_swapped (G_OBJECT (sub_item), "activate",
                                   G_CALLBACK (load_clicked),
                                   (gpointer) &tree_info);
@@ -269,6 +522,36 @@ void trace_view(int argc, char **argv)
         gtk_widget_show(sub_item);
 
 
+        /* --- File - Load Filter Option --- */
+
+        sub_item = gtk_menu_item_new_with_label("Load filters");
+
+        /* Add them to the menu */
+        gtk_menu_shell_append(GTK_MENU_SHELL (menu), sub_item);
+
+        g_signal_connect_swapped (G_OBJECT (sub_item), "activate",
+                                  G_CALLBACK (load_filters_clicked),
+                                  (gpointer) &tree_info);
+
+        /* We do need to show menu items */
+        gtk_widget_show(sub_item);
+
+
+        /* --- File - Save Filter Option --- */
+
+        sub_item = gtk_menu_item_new_with_label("Save filters");
+
+        /* Add them to the menu */
+        gtk_menu_shell_append(GTK_MENU_SHELL (menu), sub_item);
+
+        g_signal_connect_swapped (G_OBJECT (sub_item), "activate",
+                                  G_CALLBACK (save_filters_clicked),
+                                  (gpointer) &tree_info);
+
+        /* We do need to show menu items */
+        gtk_widget_show(sub_item);
+
+
         /* --- File - Quit Option --- */
 
         sub_item = gtk_menu_item_new_with_label("Quit");
@@ -385,6 +668,10 @@ void trace_view(int argc, char **argv)
         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
         gtk_widget_show(label);
 
+        gtk_signal_connect(GTK_OBJECT(trace_tree), "button_press_event",
+                           (GtkSignalFunc) button_press_event,
+                           (gpointer) &tree_info);
+
         trace_view_search_setup(GTK_BOX(hbox), GTK_TREE_VIEW(trace_tree));
 
         /* --- Top Level Hbox --- */
@@ -407,6 +694,13 @@ void trace_view(int argc, char **argv)
         gtk_widget_show(trace_tree);
 
 
+        /* --- Set up Status Bar --- */
+
+        statusbar = trace_status_bar_new();
+
+        gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
+        gtk_widget_show(statusbar);
+
         /**********************************************
          *   Main Window
          **********************************************/