1 files changed, 661 insertions, 294 deletions

diff --git a/trace-capture.c b/trace-capture.c
index d7133ba..f866b3e 100644
--- a/trace-capture.c
+++ b/trace-capture.c
@@ -25,6 +25,7 @@
 #include <stdarg.h>
 #include <fcntl.h>
 #include <ctype.h>
+#include <dirent.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -46,6 +47,13 @@
 
 #define PLUGIN_NONE "NONE"
 
+#define DIALOG_WIDTH    820
+#define DIALOG_HEIGHT   600
+
+#define CAP_STOP        "Stop"
+
+#define DEFAULT_MAX_BUF_SIZE 1000000
+
 struct trace_capture {
         struct pevent           *pevent;
         struct shark_info       *info;
@@ -54,9 +62,11 @@ struct trace_capture {
         GtkWidget               *file_entry;
         GtkWidget               *output_text;
         GtkTextBuffer           *output_buffer;
-        GtkWidget               *output_dialog;
+        GtkWidget               *event_view;
         GtkWidget               *plugin_combo;
-        GtkWidget               *stop_dialog;
+        GtkWidget               *settings_combo;
+        GtkWidget               *run_button;
+        GtkWidget               *max_num_entry;
         pthread_t               thread;
         gboolean                kill_thread;
         gboolean                capture_done;
@@ -76,6 +86,124 @@ static int is_just_ws(const char *str)
         return !str[i];
 }
 
+static gboolean settings_saved;
+
+static GString *get_home_settings_new(void)
+{
+        char *path = getenv("HOME");
+        GString *str;
+
+        str = g_string_new(path);
+        g_string_append(str, "/.trace-cmd/settings/");
+        return str;
+}
+
+static int create_home_settings(void)
+{
+        char *path = getenv("HOME");
+        GString *str;
+        struct stat st;
+        int ret;
+
+        str = g_string_new(path);
+        g_string_append(str, "/.trace-cmd");
+        ret = stat(str->str, &st);
+        if (ret < 0) {
+                ret = mkdir(str->str, 0755);
+                if (ret < 0) {
+                        warning("Can not create %s", str->str);
+                        goto out;
+                }
+        }
+
+        g_string_append(str, "/settings");
+        ret = stat(str->str, &st);
+        if (ret < 0) {
+                ret = mkdir(str->str, 0755);
+                if (ret < 0) {
+                        warning("Can not create %s", str->str);
+                        goto out;
+                }
+        }
+
+        ret = 0;
+ out:
+        g_string_free(str, TRUE);
+        return ret;
+}
+
+static GtkTreeModel *create_settings_model(gpointer data)
+{
+        struct dirent *dent;
+        GtkListStore *list;
+        GtkTreeIter iter;
+        struct stat st;
+        GString *str;
+        DIR *dir;
+        int ret;
+
+        list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
+
+        gtk_list_store_append(list, &iter);
+        gtk_list_store_set(list, &iter,
+                           0, "Current",
+                           1, "",
+                           -1);
+
+        /* Search for user settings first */
+        str = get_home_settings_new();
+        ret = stat(str->str, &st);
+        if (ret < 0 || !S_ISDIR(st.st_mode))
+                goto read_system;
+
+        dir = opendir(str->str);
+        if (!dir)
+                goto read_system;
+
+        while ((dent = readdir(dir))) {
+                const char *name = dent->d_name;
+                GString *file;
+                gchar *item;
+
+
+                if (strcmp(name, ".") == 0 ||
+                    strcmp(name, "..") == 0)
+                        continue;
+
+                if (strcmp(name + strlen(name) - 4, ".kss") != 0)
+                        continue;
+
+                file = g_string_new(str->str);
+                g_string_append_printf(file, "/%s", name);
+
+                /* Save the file name but remove the .kss extention */
+                item = g_strdup(name);
+                item[strlen(name) - 4] = 0;
+
+                gtk_list_store_append(list, &iter);
+                gtk_list_store_set(list, &iter,
+                                   0, item,
+                                   1, file->str,
+                                   -1);
+                g_free(item);
+                g_string_free(file, TRUE);
+        }
+
+read_system:
+        g_string_free(str, TRUE);
+
+        return GTK_TREE_MODEL(list);
+}
+
+static void refresh_settings(struct trace_capture *cap)
+{
+        GtkTreeModel *model;
+
+        model = create_settings_model(NULL);
+        gtk_combo_box_set_model(GTK_COMBO_BOX(cap->settings_combo), model);
+        g_object_unref(model);
+}
+
 static void ks_clear_capture_events(struct shark_info *info)
 {
         info->cap_all_events = FALSE;
@@ -99,15 +227,28 @@ void kernel_shark_clear_capture(struct shark_info *info)
         g_free(info->cap_plugin);
         info->cap_plugin = NULL;
 
+        g_free(info->cap_settings_name);
+        info->cap_settings_name = NULL;
+
         free(info->cap_file);
         info->cap_file = NULL;
+
+        g_free(info->cap_buffer_output);
+        info->cap_buffer_output = NULL;
 }
 
-static void end_capture(struct trace_capture *cap)
+static gboolean end_capture(struct trace_capture *cap)
 {
         const char *filename;
+        const char *val;
         int pid;
 
+        val = gtk_button_get_label(GTK_BUTTON(cap->run_button));
+        if (strcmp(val, CAP_STOP) != 0)
+                return FALSE;
+
+        gtk_button_set_label(GTK_BUTTON(cap->run_button), "Run");
+
         cap->capture_done = TRUE;
 
         pid = cap->command_pid;
@@ -141,6 +282,8 @@ static void end_capture(struct trace_capture *cap)
                 kernelshark_load_file(cap->info, filename);
                 cap->load_file = FALSE;
         }
+
+        return TRUE;
 }
 
 static char *get_tracing_dir(void)
@@ -163,93 +306,6 @@ static int is_latency(char *plugin)
                 strcmp(plugin, "preemptirqsoff") == 0;
 }
 
-static void close_command_display(struct trace_capture *cap)
-{
-        gtk_widget_destroy(cap->output_dialog);
-        cap->output_dialog = NULL;
-        cap->stop_dialog = NULL;
-}
-
-static void display_command_close(GtkWidget *widget, gint id, gpointer data)
-{
-        struct trace_capture *cap = data;
-
-        close_command_display(cap);
-}
-
-static void display_command_destroy(GtkWidget *widget, gpointer data)
-{
-        struct trace_capture *cap = data;
-
-        close_command_display(cap);
-}
-
-static void display_command(struct trace_capture *cap)
-{
-        GtkWidget *dialog;
-        GtkWidget *scrollwin;
-        GtkWidget *viewport;
-        GtkWidget *textview;
-        GtkTextBuffer *buffer;
-        const gchar *command;
-        GString *str;
-
-        command = gtk_entry_get_text(GTK_ENTRY(cap->command_entry));
-
-        if (!command || !strlen(command) || is_just_ws(command))
-                command = "trace-cmd";
-
-        str = g_string_new("");
-
-        g_string_printf(str, "(%s)", command);
-
-        dialog = gtk_dialog_new_with_buttons(str->str,
-                                             NULL,
-                                             GTK_DIALOG_MODAL,
-                                             "Close",
-                                             GTK_RESPONSE_ACCEPT,
-                                             NULL);
-
-        g_string_free(str, TRUE);
-
-        g_signal_connect(dialog, "response",
-                         G_CALLBACK(display_command_close),
-                         (gpointer)cap);
-
-        gtk_signal_connect (GTK_OBJECT(dialog), "delete_event",
-                            (GtkSignalFunc) display_command_destroy,
-                            (gpointer)cap);
-
-        scrollwin = gtk_scrolled_window_new(NULL, NULL);
-        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
-                                       GTK_POLICY_AUTOMATIC,
-                                       GTK_POLICY_AUTOMATIC);
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollwin, TRUE, TRUE, 0);
-        gtk_widget_show(scrollwin);
-
-        viewport = gtk_viewport_new(NULL, NULL);
-        gtk_widget_show(viewport);
-
-        gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
-
-        textview = gtk_text_view_new();
-        buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
-
-        gtk_container_add(GTK_CONTAINER(viewport), textview);
-        gtk_widget_show(textview);
-
-        cap->output_text = textview;
-        cap->output_buffer = buffer;
-
-        gtk_widget_set_size_request(GTK_WIDGET(dialog),
-                                    500, 600);
-
-        gtk_widget_show(dialog);
-
-        cap->output_dialog = dialog;
-
-}
-
 static int calculate_trace_cmd_words(struct trace_capture *cap)
 {
         int words = 4;          /* trace-cmd record -o file */
@@ -402,30 +458,31 @@ static void update_plugin(struct trace_capture *cap)
 
 }
 
-static void set_plugin(struct trace_capture *cap)
+/*
+ * The plugin and settings combo's are set by the first item
+ * in the model. The can share the same code to set the model.
+ *
+ * Return TRUE if set, FALSE if name was not found.
+ */
+static int set_combo(GtkComboBox *combo, const char *name)
 {
-        GtkComboBox *combo = GTK_COMBO_BOX(cap->plugin_combo);
         GtkTreeModel *model;
         GtkTreeIter iter;
         gchar *text;
-        const gchar *plugin = cap->info->cap_plugin;
-        gboolean ret = TRUE;
-
-        if (!plugin)
-                plugin = PLUGIN_NONE;
+        gboolean ret;
 
         model = gtk_combo_box_get_model(combo);
         if (!model)
-                return;
+                return FALSE;
 
         if (!gtk_tree_model_get_iter_first(model, &iter))
-                return;
+                return FALSE;
 
         do {
                 gtk_tree_model_get(model, &iter,
                                    0, &text,
                                    -1);
-                if (strcmp(text, plugin) == 0) {
+                if (strcmp(text, name) == 0) {
                         g_free(text);
                         break;
                 }
@@ -436,21 +493,65 @@ static void set_plugin(struct trace_capture *cap)
         } while (ret);
 
         if (ret) {
+                /* Found */
                 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo),
                                               &iter);
-                return;
+                return TRUE;
         }
 
+        /* set to first item (default) */
+        gtk_tree_model_get_iter_first(model, &iter);
+        gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo),
+                                      &iter);
+
+        return FALSE;
+}
+
+static void set_plugin(struct trace_capture *cap)
+{
+        GtkComboBox *combo = GTK_COMBO_BOX(cap->plugin_combo);
+        const gchar *plugin = cap->info->cap_plugin;
+
+        if (!plugin)
+                plugin = PLUGIN_NONE;
+
+        if (set_combo(combo, plugin))
+                return;
+
         /* Not found? */
         g_free(cap->info->cap_plugin);
         cap->info->cap_plugin = NULL;
+}
 
-        /* set to NONE */
-        if (!gtk_tree_model_get_iter_first(model, &iter))
+static void set_settings(struct trace_capture *cap)
+{
+        GtkComboBox *combo = GTK_COMBO_BOX(cap->settings_combo);
+        const gchar *name = cap->info->cap_settings_name;
+
+        if (!name)
+                name = "";
+
+        if (set_combo(combo, name))
                 return;
 
-        gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo),
-                                      &iter);
+        /* Not found? */
+        g_free(cap->info->cap_settings_name);
+        cap->info->cap_settings_name = NULL;
+}
+
+static void update_events(struct trace_capture *cap)
+{
+        struct shark_info *info = cap->info;
+
+        if (!cap->event_view)
+                return;
+
+        clear_capture_events(cap);
+
+        trace_extract_event_list_view(cap->event_view,
+                                      &info->cap_all_events,
+                                      &info->cap_systems,
+                                      &info->cap_events);
 }
 
 static void execute_command(struct trace_capture *cap)
@@ -464,6 +565,7 @@ static void execute_command(struct trace_capture *cap)
         int i;
 
         update_plugin(cap);
+        update_events(cap);
 
         ccommand = gtk_entry_get_text(GTK_ENTRY(cap->command_entry));
         if (!ccommand || !strlen(ccommand) || is_just_ws(ccommand)) {
@@ -524,47 +626,35 @@ static void execute_command(struct trace_capture *cap)
         g_free(cap->info->cap_plugin);
 }
 
-static gint
-delete_stop_dialog(GtkWidget *widget, GdkEvent *event, gpointer data)
-{
-        struct trace_capture *cap = data;
-        GtkWidget *dialog = cap->stop_dialog;
-
-        cap->stop_dialog = NULL;
-        if (!dialog)
-                return TRUE;
-
-        end_capture(cap);
-        gtk_widget_destroy(dialog);
-
-        return TRUE;
-}
-
-void end_stop_dialog(struct trace_capture *cap)
-{
-        GdkEvent dummy_event;
-        gboolean dummy_retval;
-        guint sigid;
-
-        if (!cap->stop_dialog)
-                return;
-
-        sigid = g_signal_lookup("delete-event", G_OBJECT_TYPE(cap->stop_dialog));
-        g_signal_emit(cap->stop_dialog, sigid, 0,
-                      cap->stop_dialog, &dummy_event , cap, &dummy_retval);
-}
-
 static void *monitor_pipes(void *data)
 {
         struct trace_capture *cap = data;
+        GtkTextIter start_iter;
+        GtkTextIter cut_iter;
         GtkTextIter iter;
         gchar buf[BUFSIZ+1];
         struct timeval tv;
+        const char *val;
         fd_set fds;
         gboolean eof;
+        int max_size;
+        int total;
+        int del;
         int ret;
         int r;
 
+        gdk_threads_enter();
+        /* get the max size */
+        val = gtk_entry_get_text(GTK_ENTRY(cap->max_num_entry));
+        max_size = atoi(val);
+
+        /* Clear the buffer */
+        gtk_text_buffer_get_start_iter(cap->output_buffer, &start_iter);
+        gtk_text_buffer_get_end_iter(cap->output_buffer, &cut_iter);
+        gtk_text_buffer_delete(cap->output_buffer, &start_iter, &cut_iter);
+        total = 0;
+        gdk_threads_leave();
+
         do {
                 FD_ZERO(&fds);
                 FD_SET(cap->command_input_fd, &fds);
@@ -578,7 +668,19 @@ static void *monitor_pipes(void *data)
                 while ((r = read(cap->command_input_fd, buf, BUFSIZ)) > 0) {
                         eof = FALSE;
                         buf[r] = 0;
+                        total += r;
+                        if (total > max_size)
+                                del = total - max_size;
+                        else
+                                del = 0;
                         gdk_threads_enter();
+                        if (del) {
+                                gtk_text_buffer_get_start_iter(cap->output_buffer, &start_iter);
+                                gtk_text_buffer_get_start_iter(cap->output_buffer, &cut_iter);
+                                gtk_text_iter_forward_chars(&cut_iter, del);
+                                gtk_text_buffer_delete(cap->output_buffer, &start_iter, &cut_iter);
+                                total -= del;
+                        }
                         gtk_text_buffer_get_end_iter(cap->output_buffer,
                                                      &iter);
                         gtk_text_buffer_insert(cap->output_buffer, &iter, buf, -1);
@@ -588,7 +690,7 @@ static void *monitor_pipes(void *data)
 
         if (eof) {
                 gdk_threads_enter();
-                end_stop_dialog(cap);
+                end_capture(cap);
                 gdk_threads_leave();
         }
 
@@ -682,80 +784,30 @@ static int trim_plugins(char **plugins)
         return len;
 }
 
-static void event_filter_callback(gboolean accept,
-                                  gboolean all_events,
-                                  gchar **systems,
-                                  gint *events,
-                                  gpointer data)
-{
-        struct trace_capture *cap = data;
-        int nr_sys, nr_events;
-        int i;
-
-        if (!accept)
-                return;
-
-        clear_capture_events(cap);
-
-        if (all_events) {
-                cap->info->cap_all_events = TRUE;
-                return;
-        }
-
-        if (systems) {
-                for (nr_sys = 0; systems[nr_sys]; nr_sys++)
-                        ;
-                cap->info->cap_systems = malloc_or_die(sizeof(*cap->info->cap_systems) *
-                                                       (nr_sys + 1));
-                for (i = 0; i < nr_sys; i++)
-                        cap->info->cap_systems[i] = strdup(systems[i]);
-                cap->info->cap_systems[i] = NULL;
-        }
-
-        if (events) {
-                for (nr_events = 0; events[nr_events] >= 0; nr_events++)
-                        ;
-                cap->info->cap_events = malloc_or_die(sizeof(*cap->info->cap_events) *
-                                                      (nr_events + 1));
-                for (i = 0; i < nr_events; i++)
-                        cap->info->cap_events[i] = events[i];
-                cap->info->cap_events[i] = -1;
-        }
-}
-
-static void event_button_clicked(GtkWidget *widget, gpointer data)
-{
-        struct trace_capture *cap = data;
-        struct pevent *pevent = cap->pevent;
-
-        trace_filter_pevent_dialog(pevent, cap->info->cap_all_events,
-                                   cap->info->cap_systems, cap->info->cap_events,
-                                   event_filter_callback, cap);
-}
-
 static void
 file_clicked (GtkWidget *widget, gpointer data)
 {
         struct trace_capture *cap = data;
         gchar *filename;
 
-        filename = trace_get_file_dialog("Trace File", "Save", FALSE);
+        filename = trace_get_file_dialog_filter("Trace File", "Save",
+                                         TRACE_DIALOG_FILTER_DATA, FALSE);
         if (!filename)
                 return;
 
         gtk_entry_set_text(GTK_ENTRY(cap->file_entry), filename);
 }
 
-static void execute_button_clicked(GtkWidget *widget, gpointer data)
+static void execute_button_clicked(struct trace_capture *cap)
 {
-        struct trace_capture *cap = data;
         struct stat st;
         GtkResponseType ret;
-        GtkWidget *dialog;
-        GtkWidget *label;
         const char *filename;
         char *tracecmd;
 
+        if (end_capture(cap))
+                return;
+
         tracecmd = find_tracecmd();
         if (!tracecmd) {
                 warning("trace-cmd not found in path");
@@ -774,30 +826,8 @@ static void execute_button_clicked(GtkWidget *widget, gpointer data)
                         return;
         }
 
-        display_command(cap);
-
+        gtk_button_set_label(GTK_BUTTON(cap->run_button), CAP_STOP);
         run_command(cap);
-
-        dialog = gtk_dialog_new_with_buttons("Stop Execution",
-                                             NULL,
-                                             GTK_DIALOG_MODAL,
-                                             "Stop",
-                                             GTK_RESPONSE_ACCEPT,
-                                             NULL);
-
-        cap->stop_dialog = dialog;
-
-        label = gtk_label_new("Hit Stop to end execution");
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, 0);
-        gtk_widget_show(label);
-
-        gtk_signal_connect(GTK_OBJECT (dialog), "delete_event",
-                           (GtkSignalFunc)delete_stop_dialog,
-                           (gpointer)cap);
-
-        gtk_dialog_run(GTK_DIALOG(dialog));
-
-        end_stop_dialog(cap);
 }
 
 static int load_events(struct trace_capture *cap,
@@ -844,12 +874,7 @@ static int load_events(struct trace_capture *cap,
                 if (!event)
                         continue;
 
-                if (!events)
-                        events = malloc_or_die(sizeof(*events) * 2);
-                else
-                        events = realloc(events, sizeof(*events) * (event_len + 2));
-                events[event_len++] = event->id;
-                events[event_len] = -1;
+                events = tracecmd_add_id(events, event->id, event_len++);
         }
 
         info->cap_events = events;
@@ -893,30 +918,21 @@ static int load_cap_events(struct trace_capture *cap,
         return 0;
 }
 
-static void load_settings_clicked(GtkWidget *widget, gpointer data)
+static void load_settings(struct trace_capture *cap, gchar *filename)
 {
-        struct trace_capture *cap = data;
         struct shark_info *info = cap->info;
         struct tracecmd_xml_system_node *syschild;
         struct tracecmd_xml_handle *handle;
         struct tracecmd_xml_system *system;
         const char *plugin;
         const char *name;
-        gchar *filename;
-
-        filename = trace_get_file_dialog("Load Filters", NULL, FALSE);
-        if (!filename)
-                return;
 
         handle = tracecmd_xml_open(filename);
         if (!handle) {
                 warning("Could not open %s", filename);
-                g_free(filename);
                 return;
         }
 
-        g_free(filename);
-
         system = tracecmd_xml_find_system(handle, "CaptureSettings");
         if (!system)
                 goto out;
@@ -930,8 +946,15 @@ static void load_settings_clicked(GtkWidget *widget, gpointer data)
 
         do {
                 name = tracecmd_xml_node_type(syschild);
-                if (strcmp(name, "Events") == 0)
+                if (strcmp(name, "Events") == 0) {
                         load_cap_events(cap, handle, syschild);
+                        trace_update_event_view(cap->event_view,
+                                                cap->pevent,
+                                                NULL,
+                                                info->cap_all_events,
+                                                info->cap_systems,
+                                                info->cap_events);
+                }
 
                 else if (strcmp(name, "Plugin") == 0) {
                         plugin = tracecmd_xml_node_value(handle, syschild);
@@ -958,6 +981,46 @@ static void load_settings_clicked(GtkWidget *widget, gpointer data)
         tracecmd_xml_close(handle);
 }
 
+static void settings_changed(GtkComboBox *combo,
+                             gpointer data)
+{
+        struct trace_capture *cap = data;
+        GtkTreeModel *model;
+        GtkTreeIter iter;
+        gchar *text;
+
+        model = gtk_combo_box_get_model(combo);
+        if (!model)
+                return;
+
+        if (!gtk_combo_box_get_active_iter(combo, &iter))
+                return;
+
+        gtk_tree_model_get(model, &iter,
+                           1, &text,
+                           -1);
+
+        if (text && strlen(text))
+                load_settings(cap, text);
+
+        g_free(text);
+}
+
+static void import_settings_clicked(GtkWidget *widget, gpointer data)
+{
+        struct trace_capture *cap = data;
+        gchar *filename;
+
+        filename = trace_get_file_dialog_filter("Import Settings", NULL,
+                                         TRACE_DIALOG_FILTER_SETTING, FALSE);
+        if (!filename)
+                return;
+
+        load_settings(cap, filename);
+
+        g_free(filename);
+}
+
 static void save_events(struct trace_capture *cap,
                         struct tracecmd_xml_handle *handle)
 {
@@ -989,27 +1052,20 @@ static void save_events(struct trace_capture *cap,
         tracecmd_xml_end_sub_system(handle);
 }
 
-static void save_settings_clicked(GtkWidget *widget, gpointer data)
+static void save_settings(struct trace_capture *cap, const char *filename)
 {
-        struct trace_capture *cap = data;
         struct shark_info *info = cap->info;
         struct tracecmd_xml_handle *handle;
-        gchar *filename;
         const char *file;
         const char *command;
 
-        filename = trace_get_file_dialog("Save Settings", "Save", TRUE);
-        if (!filename)
-                return;
-
         handle = tracecmd_xml_create(filename, VERSION_STRING);
         if (!handle) {
                 warning("Could not create %s", filename);
-                g_free(filename);
                 return;
         }
 
-        g_free(filename);
+        update_events(cap);
 
         tracecmd_xml_start_system(handle, "CaptureSettings");
 
@@ -1041,6 +1097,99 @@ static void save_settings_clicked(GtkWidget *widget, gpointer data)
         tracecmd_xml_close(handle);
 }
 
+static void save_settings_clicked(GtkWidget *widget, gpointer data)
+{
+        struct trace_capture *cap = data;
+        struct stat st;
+        GtkWidget *dialog;
+        GtkWidget *hbox;
+        GtkWidget *label;
+        GtkWidget *entry;
+        GString *file;
+        const char *name;
+        gint result;
+        int ret;
+
+        dialog = gtk_dialog_new_with_buttons("Save Settings",
+                                             NULL,
+                                             GTK_DIALOG_MODAL,
+                                             GTK_STOCK_OK,
+                                             GTK_RESPONSE_ACCEPT,
+                                             GTK_STOCK_CANCEL,
+                                             GTK_RESPONSE_REJECT,
+                                             NULL);
+
+        hbox = gtk_hbox_new(FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0);
+        gtk_widget_show(hbox);
+
+        label = gtk_label_new("Settings Name: ");
+        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+        gtk_widget_show(label);
+
+        entry = gtk_entry_new();
+        gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
+        gtk_widget_show(entry);
+
+ again:
+        result = gtk_dialog_run(GTK_DIALOG(dialog));
+        switch (result) {
+        case GTK_RESPONSE_ACCEPT:
+                name = gtk_entry_get_text(GTK_ENTRY(entry));
+                if (!name || is_just_ws(name)) {
+                        warning("Must enter a name");
+                        goto again;
+                }
+                /* Make sure home settings exists */
+                if (create_home_settings() < 0)
+                        break;
+                file = get_home_settings_new();
+                g_string_append_printf(file, "/%s.kss", name);
+                ret = stat(file->str, &st);
+                if (ret >= 0) {
+                        ret = trace_dialog(GTK_WINDOW(dialog), TRACE_GUI_ASK,
+                                           "The setting '%s' already exists.\n"
+                                           "Are you sure you want to replace it",
+                                           name);
+                        if (ret == GTK_RESPONSE_NO) {
+                                g_string_free(file, TRUE);
+                                goto again;
+                        }
+                }
+                save_settings(cap, file->str);
+
+                refresh_settings(cap);
+                g_free(cap->info->cap_settings_name);
+                cap->info->cap_settings_name = g_strdup(name);
+                set_settings(cap);
+
+                g_string_free(file, TRUE);
+                break;
+
+        case GTK_RESPONSE_REJECT:
+                break;
+        default:
+                break;
+        };
+
+        gtk_widget_destroy(dialog);
+}
+
+static void export_settings_clicked(GtkWidget *widget, gpointer data)
+{
+        struct trace_capture *cap = data;
+        gchar *filename;
+
+        filename = trace_get_file_dialog_filter("Save Settings", "Save",
+                                         TRACE_DIALOG_FILTER_SETTING, TRUE);
+        if (!filename)
+                return;
+
+        save_settings(cap, filename);
+
+        g_free(filename);
+}
+
 static GtkTreeModel *create_plugin_combo_model(gpointer data)
 {
         char **plugins = data;
@@ -1065,20 +1214,71 @@ static GtkTreeModel *create_plugin_combo_model(gpointer data)
         return GTK_TREE_MODEL(list);
 }
 
+static void insert_text(GtkEditable *buffer,
+                        gchar *new_text,
+                        gint new_text_length,
+                        gint *position,
+                        gpointer data)
+{
+        int i;
+        guint sigid;
+
+        /* Only allow 0-9 to be written to the entry */
+        for (i = 0; i < new_text_length; i++) {
+                if (new_text[i] < '0' || new_text[i] > '9') {
+                        sigid = g_signal_lookup("insert-text",
+                                                G_OBJECT_TYPE(buffer));
+                        g_signal_stop_emission(buffer, sigid, 0);
+                        return;
+                }
+        }
+}
+
+/*
+ * Trace Capture Dialog Window
+ *
+ *    +--------------------------------------------------------------------+
+ *    |  Dialog Window                                                     |
+ *    |  +-------------------------------+-------------------------------+ |
+ *    |  | Paned Window                  | +---------------------------+ | |
+ *    |  | +---------------------------+ | | Scroll window             | | |
+ *    |  | | Hbox                      | | | +-----------------------+ | | |
+ *    |  | |  Label   Plugin Combo     | | | | Event Tree            | | | |
+ *    |  | +---------------------------+ | | |                       | | | |
+ *    |  |                               | | |                       | | | |
+ *    |  |                               | | +-----------------------+ | | |
+ *    |  |                               | +---------------------------+ | |
+ *    |  +-------------------------------+-------------------------------+ |
+ *    +--------------------------------------------------------------------+
+ */
 static void tracing_dialog(struct shark_info *info, const char *tracing)
 {
         struct pevent *pevent;
         GtkWidget *dialog;
         GtkWidget *button;
-        GtkWidget *hbox;
         GtkWidget *combo;
         GtkWidget *label;
         GtkWidget *entry;
+        GtkWidget *frame;
+        GtkWidget *vbox;
+        GtkWidget *scrollwin;
+        GtkWidget *table;
+        GtkWidget *table2;
+        GtkWidget *event_tree;
+        GtkWidget *viewport;
+        GtkWidget *textview;
+        GtkWidget *hbox;
+        GtkTextBuffer *buffer;
+        GtkTextIter start_iter;
+        GtkTextIter end_iter;
         char **plugins;
         int nr_plugins;
         struct trace_capture cap;
         const gchar *file;
         const char *command;
+        const char *val;
+        GString *str;
+        gint result;
 
         memset(&cap, 0, sizeof(cap));
 
@@ -1105,42 +1305,146 @@ static void tracing_dialog(struct shark_info *info, const char *tracing)
                 return;
         }
 
-        dialog = gtk_dialog_new_with_buttons("Capture",
-                                             NULL,
-                                             GTK_DIALOG_MODAL,
-                                             "Done",
-                                             GTK_RESPONSE_ACCEPT,
-                                             NULL);
+        dialog = gtk_dialog_new();
+        gtk_window_set_title(GTK_WINDOW(dialog), "Capture");
+
+        button = gtk_button_new_with_label("Run");
+        gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button,
+                                       GTK_RESPONSE_ACCEPT);
+        gtk_widget_show(button);
+
+        cap.run_button = button;
+
+        gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE,
+                              GTK_RESPONSE_REJECT);
 
         cap.main_dialog = dialog;
 
+        /* --- Top Level Hpaned --- */
+        table = gtk_table_new(4, 2, FALSE);
+
+        /* It is possible that no pevents exist. */
         if (pevent) {
-                button = gtk_button_new_with_label("Select Events");
-                gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
-                                   button, TRUE, TRUE, 0);
-                gtk_widget_show(button);
-
-                g_signal_connect (button, "clicked",
-                                  G_CALLBACK (event_button_clicked),
-                                  (gpointer)&cap);
+
+                scrollwin = gtk_scrolled_window_new(NULL, NULL);
+                gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
+                                               GTK_POLICY_AUTOMATIC,
+                                               GTK_POLICY_AUTOMATIC);
+
+                gtk_table_attach(GTK_TABLE(table), scrollwin, 0, 1, 1, 2,
+                                 GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
+                gtk_widget_show(scrollwin);
+
+                event_tree = trace_create_event_list_view(pevent, NULL,
+                                                          cap.info->cap_all_events,
+                                                          cap.info->cap_systems,
+                                                          cap.info->cap_events);
+
+                gtk_container_add(GTK_CONTAINER(scrollwin), event_tree);
+                gtk_widget_show(event_tree);
+
+                cap.event_view = event_tree;
+
+        } else {
+                /* No events */
+                label = gtk_label_new("No events enabled on system");
+                gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
+                                 GTK_FILL, GTK_EXPAND|GTK_FILL,
+                                 0, 10);
+                gtk_widget_show(label);
+                cap.event_view = NULL;
         }
 
-        hbox = gtk_hbox_new(FALSE, 0);
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 0);
-        gtk_widget_show(hbox);
+        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0);
+        gtk_widget_show(table);
+
+        /*------------------ Frame Settings --------------------------- */
+
+        frame = gtk_frame_new("Settings");
+        gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1,
+                         GTK_FILL, 0, 0, 10);
+        gtk_widget_show(frame);
+
+        table2 = gtk_table_new(2, 3, FALSE);
+        gtk_container_add(GTK_CONTAINER(frame), table2);
+        gtk_widget_show(table2);
+
+        gtk_table_set_col_spacings(GTK_TABLE(table2), 5);
+
+        button = gtk_button_new_with_label("Save Settings");
+        gtk_table_attach_defaults(GTK_TABLE(table2), button, 0, 1, 0, 1);
+        gtk_widget_show(button);
+
+        g_signal_connect (button, "clicked",
+                          G_CALLBACK (save_settings_clicked),
+                          (gpointer)&cap);
+
+        button = gtk_button_new_with_label("Import Settings");
+        gtk_table_attach_defaults(GTK_TABLE(table2), button, 1, 2, 0, 1);
+        gtk_widget_show(button);
+
+        g_signal_connect (button, "clicked",
+                          G_CALLBACK (import_settings_clicked),
+                          (gpointer)&cap);
 
-        combo = trace_create_combo_box(hbox, "Plugin: ", create_plugin_combo_model, plugins);
+
+        button = gtk_button_new_with_label("Export Settings");
+        gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 0, 1);
+        gtk_widget_show(button);
+
+        g_signal_connect (button, "clicked",
+                          G_CALLBACK (export_settings_clicked),
+                          (gpointer)&cap);
+
+        if (cap.info->cap_settings_name)
+                set_settings(&cap);
+
+        label = gtk_label_new("Available Settings: ");
+        gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
+        gtk_widget_show(label);
+
+        combo = trace_create_combo_box(NULL, NULL,
+                                       create_settings_model, NULL);
+        gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 1, 2);
+
+        cap.settings_combo = combo;
+
+        g_signal_connect (combo, "changed",
+                          G_CALLBACK (settings_changed),
+                          (gpointer)&cap);
+
+
+
+        /*------------------ Frame Settings --------------------------- */
+
+        frame = gtk_frame_new("Execute");
+        gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 3, 4,
+                         GTK_FILL, 0, 0, 10);
+        gtk_widget_show(frame);
+
+        table2 = gtk_table_new(3, 3, FALSE);
+        gtk_container_add(GTK_CONTAINER(frame), table2);
+        gtk_widget_show(table2);
+
+        label = gtk_label_new("Plugin: ");
+        gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 0, 1);
+        gtk_widget_show(label);
+
+        combo = trace_create_combo_box(NULL, NULL, create_plugin_combo_model, plugins);
         cap.plugin_combo = combo;
 
+        gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 0, 1);
+
         if (cap.info->cap_plugin)
                 set_plugin(&cap);
 
+
         label = gtk_label_new("Command:");
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, 0);
+        gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2);
         gtk_widget_show(label);
 
         entry = gtk_entry_new();
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, TRUE, TRUE, 0);
+        gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 3, 1, 2);
         gtk_widget_show(entry);
 
         cap.command_entry = entry;
@@ -1148,20 +1452,12 @@ static void tracing_dialog(struct shark_info *info, const char *tracing)
         if (cap.info->cap_command)
                 gtk_entry_set_text(GTK_ENTRY(entry), cap.info->cap_command);
 
-        hbox = gtk_hbox_new(FALSE, 0);
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 0);
-        gtk_widget_show(hbox);
-
-        button = gtk_button_new_with_label("Save file: ");
-        gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
-        gtk_widget_show(button);
-
-        g_signal_connect (button, "clicked",
-                          G_CALLBACK (file_clicked),
-                          (gpointer)&cap);
+        label = gtk_label_new("Output file: ");
+        gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 2, 3);
+        gtk_widget_show(label);
 
         entry = gtk_entry_new();
-        gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
+        gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 2, 2, 3);
         gtk_widget_show(entry);
 
         if (cap.info->cap_file)
@@ -1172,34 +1468,108 @@ static void tracing_dialog(struct shark_info *info, const char *tracing)
         gtk_entry_set_text(GTK_ENTRY(entry), file);
         cap.file_entry = entry;
 
-        button = gtk_button_new_with_label("Execute");
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, TRUE, TRUE, 0);
+        button = gtk_button_new_with_label("Browse");
+        gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 2, 3);
         gtk_widget_show(button);
 
         g_signal_connect (button, "clicked",
-                          G_CALLBACK (execute_button_clicked),
+                          G_CALLBACK (file_clicked),
                           (gpointer)&cap);
 
 
-        button = gtk_button_new_with_label("Load Settings");
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, TRUE, TRUE, 0);
-        gtk_widget_show(button);
+        /*------------------ Command Output ------------------ */
 
-        g_signal_connect (button, "clicked",
-                          G_CALLBACK (load_settings_clicked),
-                          (gpointer)&cap);
+        vbox = gtk_vbox_new(FALSE, 0);
+        gtk_table_attach_defaults(GTK_TABLE(table), vbox, 1, 2, 0, 4);
+        gtk_widget_show(vbox);
+        gtk_widget_set_size_request(GTK_WIDGET(vbox), 500, 0);
 
 
-        button = gtk_button_new_with_label("Save Settings");
-        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, TRUE, TRUE, 0);
-        gtk_widget_show(button);
+        label = gtk_label_new("Output Display:");
+        gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+        gtk_widget_show(label);
 
-        g_signal_connect (button, "clicked",
-                          G_CALLBACK (save_settings_clicked),
+        scrollwin = gtk_scrolled_window_new(NULL, NULL);
+        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
+                                       GTK_POLICY_AUTOMATIC,
+                                       GTK_POLICY_AUTOMATIC);
+        gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
+        gtk_widget_show(scrollwin);
+
+        viewport = gtk_viewport_new(NULL, NULL);
+        gtk_widget_show(viewport);
+
+        gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
+
+        textview = gtk_text_view_new();
+        buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
+
+        gtk_container_add(GTK_CONTAINER(viewport), textview);
+        gtk_widget_show(textview);
+
+        cap.output_text = textview;
+        cap.output_buffer = buffer;
+
+        /* set the buffer from its previous setting */
+        if (info->cap_buffer_output)
+                gtk_text_buffer_set_text(buffer, info->cap_buffer_output,
+                                         strlen(info->cap_buffer_output));
+
+        hbox = gtk_hbox_new(FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
+        gtk_widget_show(hbox);
+
+        label = gtk_label_new("Max # of characters in output display: ");
+        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+        gtk_widget_show(label);
+
+        entry = gtk_entry_new();
+        gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
+        gtk_widget_show(entry);
+
+        cap.max_num_entry = entry;
+
+        if (!info->cap_max_buf_size)
+                info->cap_max_buf_size = DEFAULT_MAX_BUF_SIZE;
+
+        str = g_string_new("");
+        g_string_append_printf(str, "%d", info->cap_max_buf_size);
+        gtk_entry_set_text(GTK_ENTRY(entry), str->str);
+        g_string_free(str, TRUE);
+
+        g_signal_connect (entry, "insert-text",
+                          G_CALLBACK (insert_text),
                           (gpointer)&cap);
 
+
+        gtk_widget_set_size_request(GTK_WIDGET(dialog),
+                                    DIALOG_WIDTH, DIALOG_HEIGHT);
+
         gtk_widget_show(dialog);
-        gtk_dialog_run(GTK_DIALOG(dialog));
+
+ cont:
+        result = gtk_dialog_run(GTK_DIALOG(dialog));
+
+        if (result == GTK_RESPONSE_ACCEPT) {
+                execute_button_clicked(&cap);
+                goto cont;
+        }
+
+        /* Make sure no capture is running */
+        end_capture(&cap);
+
+        /* Get the max buffer size */
+        val = gtk_entry_get_text(GTK_ENTRY(entry));
+        info->cap_max_buf_size = atoi(val);
+
+        gtk_text_buffer_get_start_iter(cap.output_buffer, &start_iter);
+        gtk_text_buffer_get_end_iter(cap.output_buffer, &end_iter);
+
+        g_free(info->cap_buffer_output);
+        info->cap_buffer_output = gtk_text_buffer_get_text(cap.output_buffer,
+                                                           &start_iter,
+                                                           &end_iter,
+                                                           FALSE);
 
         /* save the plugin and file to reuse if we come back */
         update_plugin(&cap);
@@ -1214,12 +1584,9 @@ static void tracing_dialog(struct shark_info *info, const char *tracing)
         else
                 cap.info->cap_command = NULL;
 
-        gtk_widget_destroy(dialog);
+        update_events(&cap);
 
-        end_capture(&cap);
-
-        if (cap.output_dialog)
-                gtk_widget_destroy(cap.output_dialog);
+        gtk_widget_destroy(dialog);
 
         if (pevent)
                 pevent_free(pevent);