static int gfio_server_running;
static const char *gfio_graph_font;
static unsigned int gfio_graph_limit = 100;
+static GdkColor white;
static void view_log(GtkWidget *w, gpointer data);
GtkWidget *error_label;
GtkWidget *results_notebook;
GtkWidget *results_window;
+ GtkUIManager *results_uimanager;
+ GtkWidget *results_vbox;
+ GtkWidget *results_menu;
GtkListStore *log_model;
GtkWidget *log_tree;
GtkWidget *log_view;
struct gfio_client *client;
int nr_job_files;
char **job_files;
+ struct graph *clat_graph;
+};
+
+struct end_results {
+ struct group_run_stats gs;
+ struct thread_stat ts;
};
struct gfio_client {
GtkWidget *err_entry;
unsigned int job_added;
struct thread_options o;
+
+ struct end_results *results;
+ unsigned int nr_results;
};
static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc);
static void gfio_update_thread_status_all(char *status_message, double perc);
void report_error(GError *error);
-static void iops_graph_y_axis_unit_change(struct graph *g, int power_of_ten)
-{
- switch (power_of_ten) {
- case 9: graph_y_title(g, "Billions of IOs / sec");
- break;
- case 6: graph_y_title(g, "Millions of IOs / sec");
- break;
- case 3: graph_y_title(g, "Thousands of IOs / sec");
- break;
- case 0:
- default: graph_y_title(g, "IOs / sec");
- break;
- }
-}
-
static struct graph *setup_iops_graph(void)
{
struct graph *g;
g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
- graph_title(g, "IOPS");
+ graph_title(g, "IOPS (IOs/sec)");
graph_x_title(g, "Time (secs)");
- graph_y_title(g, "IOs / sec");
graph_add_label(g, "Read IOPS");
graph_add_label(g, "Write IOPS");
graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13);
graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0);
line_graph_set_data_count_limit(g, gfio_graph_limit);
- graph_y_axis_unit_change_notify(g, iops_graph_y_axis_unit_change);
- graph_add_extra_space(g, 0.005, 0.005, 0.03, 0.03);
+ graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
return g;
}
-static void bandwidth_graph_y_axis_unit_change(struct graph *g, int power_of_ten)
-{
- switch (power_of_ten) {
- case 9: graph_y_title(g, "Petabytes / sec");
- break;
- case 6: graph_y_title(g, "Gigabytes / sec");
- break;
- case 3: graph_y_title(g, "Megabytes / sec");
- break;
- case 0:
- default: graph_y_title(g, "Kilobytes / sec");
- break;
- }
-}
-
static struct graph *setup_bandwidth_graph(void)
{
struct graph *g;
g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
- graph_title(g, "Bandwidth");
+ graph_title(g, "Bandwidth (bytes/sec)");
graph_x_title(g, "Time (secs)");
- graph_y_title(g, "Kbytes / sec");
graph_add_label(g, "Read Bandwidth");
graph_add_label(g, "Write Bandwidth");
graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13);
graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0);
+ graph_set_base_offset(g, 1);
line_graph_set_data_count_limit(g, 100);
- graph_y_axis_unit_change_notify(g, bandwidth_graph_y_axis_unit_change);
- graph_add_extra_space(g, 0.005, 0.005, 0.03, 0.03);
-
+ graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
return g;
}
gtk_widget_destroy(dialog);
}
+static void set_menu_entry_text(struct gui *ui, const char *path,
+ const char *text)
+{
+ GtkWidget *w;
+
+ w = gtk_ui_manager_get_widget(ui->uimanager, path);
+ if (w)
+ gtk_menu_item_set_label(GTK_MENU_ITEM(w), text);
+ else
+ fprintf(stderr, "gfio: can't find path %s\n", path);
+}
+
+
+static void set_menu_entry_visible(struct gui *ui, const char *path, int show)
+{
+ GtkWidget *w;
+
+ w = gtk_ui_manager_get_widget(ui->uimanager, path);
+ if (w)
+ gtk_widget_set_sensitive(w, show);
+ else
+ fprintf(stderr, "gfio: can't find path %s\n", path);
+}
+
+static void set_job_menu_visible(struct gui *ui, int visible)
+{
+ set_menu_entry_visible(ui, "/MainMenu/JobMenu", visible);
+}
+
+static void set_view_results_visible(struct gui *ui, int visible)
+{
+ set_menu_entry_visible(ui, "/MainMenu/ViewMenu/Results", visible);
+}
+
/*
* Update sensitivity of job buttons and job menu items, based on the
* state of the client.
{
unsigned int connect_state, send_state, start_state, edit_state;
const char *connect_str = NULL;
- GtkWidget *w;
switch (ge->state) {
default: {
gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], start_state);
gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), connect_str);
- /*
- * So the below doesn't work at all, how to set those menu items
- * invisibible...
- */
- w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Connect");
- gtk_widget_set_sensitive(w, connect_state);
- gtk_menu_item_set_label(GTK_MENU_ITEM(w), connect_str);
-
- w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Edit job");
- gtk_widget_set_sensitive(w, edit_state);
+ set_menu_entry_visible(ui, "/MainMenu/JobMenu/Connect", connect_state);
+ set_menu_entry_text(ui, "/MainMenu/JobMenu/Connect", connect_str);
- w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Send job");
- gtk_widget_set_sensitive(w, send_state);
+ set_menu_entry_visible(ui, "/MainMenu/JobMenu/Edit job", edit_state);
+ set_menu_entry_visible(ui, "/MainMenu/JobMenu/Send job", send_state);
+ set_menu_entry_visible(ui, "/MainMenu/JobMenu/Start job", start_state);
- w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Start job");
- gtk_widget_set_sensitive(w, start_state);
+ if (ge->client && ge->client->nr_results)
+ set_view_results_visible(ui, 1);
+ else
+ set_view_results_visible(ui, 0);
}
static void gfio_set_state(struct gui_entry *ge, unsigned int state)
ui->log_tree = tree_view;
}
+static struct graph *setup_clat_graph(char *title, unsigned int *ovals,
+ fio_fp64_t *plist,
+ unsigned int len,
+ double xdim, double ydim)
+{
+ struct graph *g;
+ int i;
+
+ g = graph_new(xdim, ydim, gfio_graph_font);
+ graph_title(g, title);
+ graph_x_title(g, "Percentile");
+
+ for (i = 0; i < len; i++) {
+ char fbuf[8];
+
+ sprintf(fbuf, "%2.2f%%", plist[i].u.f);
+ graph_add_label(g, fbuf);
+ graph_add_data(g, fbuf, (double) ovals[i]);
+ }
+
+ return g;
+}
+
static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
fio_fp64_t *plist,
unsigned int len,
return tree_view;
}
-static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
+static int on_expose_clat_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
+{
+ struct graph *g = p;
+ cairo_t *cr;
+
+ cr = gdk_cairo_create(w->window);
+#if 0
+ if (graph_has_tooltips(g)) {
+ g_object_set(w, "has-tooltip", TRUE, NULL);
+ g_signal_connect(w, "query-tooltip", G_CALLBACK(clat_graph_tooltip), g);
+ }
+#endif
+ cairo_set_source_rgb(cr, 0, 0, 0);
+ bar_graph_draw(g, cr);
+ cairo_destroy(cr);
+
+ return FALSE;
+}
+
+static gint on_config_clat_drawing_area(GtkWidget *w, GdkEventConfigure *event,
+ gpointer data)
+{
+ struct graph *g = data;
+
+ graph_set_size(g, w->allocation.width, w->allocation.height);
+ graph_set_size(g, w->allocation.width, w->allocation.height);
+ graph_set_position(g, 0, 0);
+ return TRUE;
+}
+
+static void gfio_show_clat_percentiles(struct gfio_client *gc,
+ GtkWidget *vbox, struct thread_stat *ts,
int ddir)
{
unsigned int *io_u_plat = ts->io_u_plat[ddir];
fio_fp64_t *plist = ts->percentile_list;
unsigned int *ovals, len, minv, maxv, scale_down;
const char *base;
- GtkWidget *tree_view, *frame, *hbox;
+ GtkWidget *tree_view, *frame, *hbox, *drawing_area, *completion_vbox;
char tmp[64];
len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
base = "usec";
}
+ sprintf(tmp, "Completion percentiles (%s)", base);
tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
+ gc->ge->clat_graph = setup_clat_graph(tmp, ovals, plist, len, 700.0, 300.0);
- sprintf(tmp, "Completion percentiles (%s)", base);
frame = gtk_frame_new(tmp);
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+ completion_vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), completion_vbox);
hbox = gtk_hbox_new(FALSE, 3);
- gtk_container_add(GTK_CONTAINER(frame), hbox);
+ gtk_container_add(GTK_CONTAINER(completion_vbox), hbox);
+ drawing_area = gtk_drawing_area_new();
+ gtk_widget_set_size_request(GTK_WIDGET(drawing_area), 700, 300);
+ gtk_widget_modify_bg(drawing_area, GTK_STATE_NORMAL, &white);
+ gtk_container_add(GTK_CONTAINER(completion_vbox), drawing_area);
+ g_signal_connect(G_OBJECT(drawing_area), "expose_event",
+ G_CALLBACK(on_expose_clat_drawing_area), gc->ge->clat_graph);
+ g_signal_connect(G_OBJECT(drawing_area), "configure_event",
+ G_CALLBACK(on_config_clat_drawing_area), gc->ge->clat_graph);
gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
out:
#define GFIO_SLAT 2
#define GFIO_LAT 4
-static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
+static void gfio_show_ddir_status(struct gfio_client *gc, GtkWidget *mbox,
+ struct group_run_stats *rs,
struct thread_stat *ts, int ddir)
{
const char *ddir_label[2] = { "Read", "Write" };
}
if (ts->clat_percentiles)
- gfio_show_clat_percentiles(main_vbox, ts, ddir);
+ gfio_show_clat_percentiles(gc, main_vbox, ts, ddir);
free(io_p);
return TRUE;
}
+static void results_close(GtkWidget *w, gpointer *data)
+{
+ struct gui_entry *ge = (struct gui_entry *) data;
+
+ gtk_widget_destroy(ge->results_window);
+}
+
+static GtkActionEntry results_menu_items[] = {
+ { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
+ { "GraphMenuAction", GTK_STOCK_FILE, "Graph", NULL, NULL, NULL},
+ { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(results_close) },
+};
+static gint results_nmenu_items = sizeof(results_menu_items) / sizeof(results_menu_items[0]);
+
+static const gchar *results_ui_string = " \
+ <ui> \
+ <menubar name=\"MainMenu\"> \
+ <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
+ <menuitem name=\"Close\" action=\"CloseFile\" /> \
+ </menu> \
+ <menu name=\"GraphMenu\" action=\"GraphMenuAction\"> \
+ </menu>\
+ </menubar> \
+ </ui> \
+";
+
+static GtkWidget *get_results_menubar(GtkWidget *window, struct gui_entry *ge)
+{
+ GtkActionGroup *action_group;
+ GtkWidget *widget;
+ GError *error = 0;
+
+ ge->results_uimanager = gtk_ui_manager_new();
+
+ action_group = gtk_action_group_new("ResultsMenu");
+ gtk_action_group_add_actions(action_group, results_menu_items, results_nmenu_items, ge);
+
+ gtk_ui_manager_insert_action_group(ge->results_uimanager, action_group, 0);
+ gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ge->results_uimanager), results_ui_string, -1, &error);
+
+ gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ge->results_uimanager));
+
+ widget = gtk_ui_manager_get_widget(ge->results_uimanager, "/MainMenu");
+ return widget;
+}
+
static GtkWidget *get_results_window(struct gui_entry *ge)
{
- GtkWidget *win, *notebook;
+ GtkWidget *win, *notebook, *vbox;
if (ge->results_window)
return ge->results_notebook;
g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge);
g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge);
+ vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(win), vbox);
+
+ ge->results_menu = get_results_menubar(win, ge);
+ gtk_box_pack_start(GTK_BOX(vbox), ge->results_menu, FALSE, FALSE, 0);
+
notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
- gtk_container_add(GTK_CONTAINER(win), notebook);
+ gtk_container_add(GTK_CONTAINER(vbox), notebook);
ge->results_window = win;
ge->results_notebook = notebook;
return ge->results_notebook;
}
-static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
- struct group_run_stats *rs)
+static void gfio_add_end_results(struct gfio_client *gc, struct thread_stat *ts,
+ struct group_run_stats *rs)
{
- GtkWidget *res_win, *box, *vbox, *entry, *scroll;
- struct gfio_client *gc = client->client_data;
+ unsigned int nr = gc->nr_results;
- gdk_threads_enter();
+ gc->results = realloc(gc->results, (nr + 1) * sizeof(struct end_results));
+ memcpy(&gc->results[nr].ts, ts, sizeof(*ts));
+ memcpy(&gc->results[nr].gs, rs, sizeof(*rs));
+ gc->nr_results++;
+}
- res_win = get_results_window(gc->ge);
+static void __gfio_display_end_results(GtkWidget *win, struct gfio_client *gc,
+ struct thread_stat *ts,
+ struct group_run_stats *rs)
+{
+ GtkWidget *box, *vbox, *entry, *scroll;
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
- gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, gtk_label_new(ts->name));
+ gtk_notebook_append_page(GTK_NOTEBOOK(win), scroll, gtk_label_new(ts->name));
gc->results_widget = vbox;
entry_set_int_value(entry, ts->pid);
if (ts->io_bytes[DDIR_READ])
- gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
+ gfio_show_ddir_status(gc, vbox, rs, ts, DDIR_READ);
if (ts->io_bytes[DDIR_WRITE])
- gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
+ gfio_show_ddir_status(gc, vbox, rs, ts, DDIR_WRITE);
gfio_show_latency_buckets(vbox, ts);
gfio_show_cpu_usage(vbox, ts);
gfio_show_io_depths(vbox, ts);
+}
+
+static void gfio_display_end_results(struct gfio_client *gc)
+{
+ GtkWidget *res_win;
+ int i;
+
+ res_win = get_results_window(gc->ge);
+
+ for (i = 0; i < gc->nr_results; i++) {
+ struct end_results *e = &gc->results[i];
+
+ __gfio_display_end_results(res_win, gc, &e->ts, &e->gs);
+ }
gtk_widget_show_all(gc->ge->results_window);
+}
+
+static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
+ struct group_run_stats *rs)
+{
+ struct gfio_client *gc = client->client_data;
+
+ gfio_add_end_results(gc, ts, rs);
+
+ gdk_threads_enter();
+ gfio_display_end_results(gc);
gdk_threads_leave();
}
gtk_widget_queue_draw(ui->window);
}
-static void gfio_quit_op(struct fio_client *client)
+static void gfio_quit_op(struct fio_client *client, struct fio_net_cmd *cmd)
{
struct gfio_client *gc = client->client_data;
gdk_threads_leave();
}
+static void gfio_client_iolog(struct fio_client *client, struct cmd_iolog_pdu *pdu)
+{
+ printf("got iolog: name=%s, type=%u, entries=%u\n", pdu->name, pdu->log_type, pdu->nr_samples);
+ free(pdu);
+}
+
struct client_ops gfio_client_ops = {
- .text_op = gfio_text_op,
+ .text = gfio_text_op,
.disk_util = gfio_disk_util_op,
.thread_status = gfio_thread_status_op,
.group_stats = gfio_group_stats_op,
.stop = gfio_client_stop,
.start = gfio_client_start,
.job_start = gfio_client_job_start,
+ .iolog = gfio_client_iolog,
.eta_msec = FIO_CLIENT_DEF_ETA_MSEC,
.stay_connected = 1,
+ .client_type = FIO_CLIENT_TYPE_GUI,
};
+/*
+ * FIXME: need more handling here
+ */
+static void ge_destroy(struct gui_entry *ge)
+{
+ struct gfio_client *gc = ge->client;
+
+ if (gc && gc->client) {
+ if (ge->state >= GE_STATE_CONNECTED)
+ fio_client_terminate(gc->client);
+
+ fio_put_client(gc->client);
+ }
+
+ flist_del(&ge->list);
+ free(ge);
+}
+
+static void ge_widget_destroy(GtkWidget *w, gpointer data)
+{
+}
+
+static void gfio_quit(struct gui *ui)
+{
+ struct gui_entry *ge;
+
+ while (!flist_empty(&ui->list)) {
+ ge = flist_entry(ui->list.next, struct gui_entry, list);
+ ge_destroy(ge);
+ }
+
+ gtk_main_quit();
+}
+
static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
__attribute__((unused)) gpointer data)
{
- gtk_main_quit();
+ gfio_quit(data);
}
static void *job_thread(void *arg)
i++;
}
+ free(ge->job_files);
+ ge->job_files = NULL;
ge->nr_job_files = 0;
return ret;
}
return ge;
}
-/*
- * FIXME: need more handling here
- */
-static void ge_destroy(GtkWidget *w, gpointer data)
-{
- struct gui_entry *ge = data;
- struct gfio_client *gc = ge->client;
-
- if (gc && gc->client) {
- if (ge->state >= GE_STATE_CONNECTED)
- fio_client_terminate(gc->client);
-
- fio_put_client(gc->client);
- }
-
- flist_del(&ge->list);
- free(ge);
-}
-
static struct gui_entry *get_new_ge_with_tab(const char *name)
{
struct gui_entry *ge;
ge = alloc_new_gui_entry(&main_ui);
ge->vbox = new_client_page(ge);
- g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_destroy), ge);
+ g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge);
ge->page_label = gtk_label_new(name);
ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(main_ui.notebook), ge->vbox, ge->page_label);
return;
}
- gtk_main_quit();
+ gfio_quit(ui);
}
static void file_add_recent(struct gui *ui, const gchar *uri)
{
- gtk_recent_manager_add_item(ui->recentmanager, uri);
+ GtkRecentData grd;
+
+ memset(&grd, 0, sizeof(grd));
+ grd.display_name = strdup("gfio");
+ grd.description = strdup("Fio job file");
+ grd.mime_type = strdup(GFIO_MIME);
+ grd.app_name = strdup(g_get_application_name());
+ grd.app_exec = strdup("gfio %f/%u");
+
+ gtk_recent_manager_add_full(ui->recentmanager, uri, &grd);
}
static gchar *get_filename_from_uri(const gchar *uri)
return 0;
}
-static void file_open(GtkWidget *w, gpointer data)
+static int do_file_open_with_tab(struct gui *ui, const gchar *uri)
{
- struct gui *ui = data;
- GtkWidget *dialog;
- GSList *filenames, *fn_glist;
- GtkFileFilter *filter;
- int port, type, server_start, ge_is_new = 0;
+ int port, type, server_start;
struct gui_entry *ge;
gint cur_page;
char *host;
+ int ret, ge_is_new = 0;
/*
* Creates new tab if current tab is the main window, or the
gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
+ if (get_connection_details(&host, &port, &type, &server_start)) {
+ if (ge_is_new)
+ gtk_widget_destroy(ge->vbox);
+
+ return 1;
+ }
+
+ ret = do_file_open(ge, uri, host, type, port);
+
+ free(host);
+
+ if (!ret) {
+ if (server_start)
+ gfio_start_server();
+ } else {
+ if (ge_is_new)
+ gtk_widget_destroy(ge->vbox);
+ }
+
+ return ret;
+}
+
+static void recent_open(GtkAction *action, gpointer data)
+{
+ struct gui *ui = (struct gui *) data;
+ GtkRecentInfo *info;
+ const gchar *uri;
+
+ info = g_object_get_data(G_OBJECT(action), "gtk-recent-info");
+ uri = gtk_recent_info_get_uri(info);
+
+ do_file_open_with_tab(ui, uri);
+}
+
+static void file_open(GtkWidget *w, gpointer data)
+{
+ struct gui *ui = data;
+ GtkWidget *dialog;
+ GSList *filenames, *fn_glist;
+ GtkFileFilter *filter;
+
dialog = gtk_file_chooser_dialog_new("Open File",
GTK_WINDOW(ui->window),
GTK_FILE_CHOOSER_ACTION_OPEN,
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
- if (ge_is_new)
- gtk_widget_destroy(ge->vbox);
-
gtk_widget_destroy(dialog);
return;
}
gtk_widget_destroy(dialog);
- if (get_connection_details(&host, &port, &type, &server_start)) {
- if (ge_is_new)
- gtk_widget_destroy(ge->vbox);
-
- goto done;
- }
-
filenames = fn_glist;
while (filenames != NULL) {
- do_file_open(ge, filenames->data, host, type, port);
- g_free(filenames->data);
+ if (do_file_open_with_tab(ui, filenames->data))
+ break;
filenames = g_slist_next(filenames);
}
- free(host);
- if (server_start)
- gfio_start_server();
-done:
g_slist_free(fn_glist);
-
}
static void file_save(GtkWidget *w, gpointer data)
start_job_clicked(w, ge);
}
+static void view_results(GtkWidget *w, gpointer data)
+{
+ struct gui *ui = (struct gui *) data;
+ struct gfio_client *gc;
+ struct gui_entry *ge;
+
+ ge = get_ge_from_cur_tab(ui);
+ if (!ge)
+ return;
+
+ if (ge->results_window)
+ return;
+
+ gc = ge->client;
+ if (gc && gc->nr_results)
+ gfio_display_end_results(gc);
+}
+
+
static void __update_graph_limits(struct gfio_graphs *g)
{
line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
{ "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
{ "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
{ "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
+ { "ViewResults", NULL, "Results", "<Control>R", NULL, G_CALLBACK(view_results) },
{ "ConnectJob", NULL, "Connect", "<Control>E", NULL, G_CALLBACK(connect_job_entry) },
{ "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) },
{ "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) },
<menuitem name=\"Start job\" action=\"StartJob\" /> \
</menu>\
<menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
+ <menuitem name=\"Results\" action=\"ViewResults\" /> \
+ <separator name=\"Separator7\"/> \
<menuitem name=\"Log\" action=\"ViewLog\" /> \
</menu>\
<menu name=\"Help\" action=\"HelpMenuAction\"> \
</ui> \
";
-static void set_job_menu_visible(struct gui *ui, int visible)
-{
- GtkWidget *job;
-
- job = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu");
- gtk_widget_set_sensitive(job, visible);
-}
-
static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
struct gui *ui)
{
- GtkActionGroup *action_group = gtk_action_group_new("Menu");
+ GtkActionGroup *action_group;
GError *error = 0;
action_group = gtk_action_group_new("Menu");
{
GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
- GdkColor white;
main_vbox = gtk_vbox_new(FALSE, 3);
/*
* Set up a drawing area and IOPS and bandwidth graphs
*/
- gdk_color_parse("white", &white);
ge->graphs.drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
{
GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
- GdkColor white;
main_vbox = gtk_vbox_new(FALSE, 3);
/*
* Set up a drawing area and IOPS and bandwidth graphs
*/
- gdk_color_parse("white", &white);
ui->graphs.drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
if (!page) {
set_job_menu_visible(ui, 0);
+ set_view_results_visible(ui, 0);
return TRUE;
}
return TRUE;
}
-static void recent_open(GtkAction *action, gpointer data)
-{
- struct gui *ui = (struct gui *) data;
- int port, type, server_start;
- struct gui_entry *ge;
- GtkRecentInfo *info;
- const gchar *uri;
- gint cur_page;
- char *host;
- int ret, ge_is_new = 0;
-
- /*
- * Creates new tab if current tab is the main window, or the
- * current tab already has a client.
- */
- cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
- ge = get_ge_from_page(cur_page, &ge_is_new);
- if (ge->client) {
- ge = get_new_ge_with_tab("Untitled");
- ge_is_new = 1;
- }
-
- gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
-
- info = g_object_get_data(G_OBJECT(action), "gtk-recent-info");
- uri = gtk_recent_info_get_uri(info);
-
- if (get_connection_details(&host, &port, &type, &server_start)) {
- if (ge_is_new)
- gtk_widget_destroy(ge->vbox);
-
- return;
- }
-
- ret = do_file_open(ge, uri, host, type, port);
-
- free(host);
-
- if (!ret) {
- if (server_start)
- gfio_start_server();
- } else {
- if (ge_is_new)
- gtk_widget_destroy(ge->vbox);
- }
-}
-
static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b)
{
time_t time_a = gtk_recent_info_get_visited(a);
g_list_free(items);
}
+static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx,
+ gint x, gint y, GtkSelectionData *data,
+ guint info, guint time)
+{
+ struct gui *ui = &main_ui;
+ gchar **uris;
+ GtkWidget *source;
+ int i;
+
+ source = gtk_drag_get_source_widget(ctx);
+ if (source && widget == gtk_widget_get_toplevel(source)) {
+ gtk_drag_finish(ctx, FALSE, FALSE, time);
+ return;
+ }
+
+ uris = gtk_selection_data_get_uris(data);
+ if (!uris) {
+ gtk_drag_finish(ctx, FALSE, FALSE, time);
+ return;
+ }
+
+ i = 0;
+ while (uris[i]) {
+ if (do_file_open_with_tab(ui, uris[i]))
+ break;
+ i++;
+ }
+
+ gtk_drag_finish(ctx, TRUE, FALSE, time);
+ g_strfreev(uris);
+}
+
static void init_ui(int *argc, char **argv[], struct gui *ui)
{
GtkSettings *settings;
settings = gtk_settings_get_default();
gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
g_type_init();
+ gdk_color_parse("white", &white);
ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
+ gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
vbox = new_main_page(ui);
+ gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
+ gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window));
+ g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui);
gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));