1 /* 2 * gfio - gui front end for fio - the flexible io tester 3 * 4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron (at) gmail.com> 5 * Copyright (C) 2012 Jens Axboe <axboe (at) kernel.dk> 6 * 7 * The license below covers all files distributed with fio unless otherwise 8 * noted in the file itself. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 */ 24 #include <locale.h> 25 #include <malloc.h> 26 #include <string.h> 27 28 #include <glib.h> 29 #include <cairo.h> 30 #include <gtk/gtk.h> 31 32 #include "fio.h" 33 #include "gfio.h" 34 #include "ghelpers.h" 35 #include "goptions.h" 36 #include "gerror.h" 37 #include "gclient.h" 38 #include "graph.h" 39 40 static int gfio_server_running; 41 static unsigned int gfio_graph_limit = 100; 42 43 GdkColor gfio_color_white; 44 GdkColor gfio_color_lightyellow; 45 const char *gfio_graph_font = GRAPH_DEFAULT_FONT; 46 47 typedef void (*clickfunction)(GtkWidget *widget, gpointer data); 48 49 static void connect_clicked(GtkWidget *widget, gpointer data); 50 static void start_job_clicked(GtkWidget *widget, gpointer data); 51 static void send_clicked(GtkWidget *widget, gpointer data); 52 53 static struct button_spec { 54 const char *buttontext; 55 clickfunction f; 56 const char *tooltiptext[2]; 57 const int start_sensitive; 58 } buttonspeclist[] = { 59 { 60 .buttontext = "Connect", 61 .f = connect_clicked, 62 .tooltiptext = { "Disconnect from host", "Connect to host" }, 63 .start_sensitive = 1, 64 }, 65 { 66 .buttontext = "Send", 67 .f = send_clicked, 68 .tooltiptext = { "Send job description to host", NULL }, 69 .start_sensitive = 0, 70 }, 71 { 72 .buttontext = "Start Job", 73 .f = start_job_clicked, 74 .tooltiptext = { "Start the current job on the server", NULL }, 75 .start_sensitive = 0, 76 }, 77 }; 78 79 static void setup_iops_graph(struct gfio_graphs *gg) 80 { 81 struct graph *g; 82 83 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font); 84 graph_title(g, "IOPS (IOs/sec)"); 85 graph_x_title(g, "Time (secs)"); 86 gg->read_iops = graph_add_label(g, "Read IOPS"); 87 gg->write_iops = graph_add_label(g, "Write IOPS"); 88 gg->trim_iops = graph_add_label(g, "Trim IOPS"); 89 graph_set_color(g, gg->read_iops, GFIO_READ_R, GFIO_READ_G, GFIO_READ_B); 90 graph_set_color(g, gg->write_iops, GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B); 91 graph_set_color(g, gg->trim_iops, GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B); 92 line_graph_set_data_count_limit(g, gfio_graph_limit); 93 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0); 94 graph_set_graph_all_zeroes(g, 0); 95 gg->iops_graph = g; 96 } 97 98 static void setup_bandwidth_graph(struct gfio_graphs *gg) 99 { 100 struct graph *g; 101 102 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font); 103 graph_title(g, "Bandwidth (bytes/sec)"); 104 graph_x_title(g, "Time (secs)"); 105 gg->read_bw = graph_add_label(g, "Read Bandwidth"); 106 gg->write_bw = graph_add_label(g, "Write Bandwidth"); 107 gg->trim_bw = graph_add_label(g, "Trim Bandwidth"); 108 graph_set_color(g, gg->read_bw, GFIO_READ_R, GFIO_READ_G, GFIO_READ_B); 109 graph_set_color(g, gg->write_bw, GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B); 110 graph_set_color(g, gg->trim_bw, GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B); 111 graph_set_base_offset(g, 1); 112 line_graph_set_data_count_limit(g, 100); 113 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0); 114 graph_set_graph_all_zeroes(g, 0); 115 gg->bandwidth_graph = g; 116 } 117 118 static void setup_graphs(struct gfio_graphs *g) 119 { 120 setup_iops_graph(g); 121 setup_bandwidth_graph(g); 122 } 123 124 void clear_ge_ui_info(struct gui_entry *ge) 125 { 126 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), ""); 127 gtk_label_set_text(GTK_LABEL(ge->probe.os), ""); 128 gtk_label_set_text(GTK_LABEL(ge->probe.arch), ""); 129 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), ""); 130 #if 0 131 /* should we empty it... */ 132 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), ""); 133 #endif 134 multitext_update_entry(&ge->eta.iotype, 0, ""); 135 multitext_update_entry(&ge->eta.bs, 0, ""); 136 multitext_update_entry(&ge->eta.ioengine, 0, ""); 137 multitext_update_entry(&ge->eta.iodepth, 0, ""); 138 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), ""); 139 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), ""); 140 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), ""); 141 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), ""); 142 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), ""); 143 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), ""); 144 } 145 146 static void set_menu_entry_text(struct gui *ui, const char *path, 147 const char *text) 148 { 149 GtkWidget *w; 150 151 w = gtk_ui_manager_get_widget(ui->uimanager, path); 152 if (w) 153 gtk_menu_item_set_label(GTK_MENU_ITEM(w), text); 154 else 155 fprintf(stderr, "gfio: can't find path %s\n", path); 156 } 157 158 159 static void set_menu_entry_visible(struct gui *ui, const char *path, int show) 160 { 161 GtkWidget *w; 162 163 w = gtk_ui_manager_get_widget(ui->uimanager, path); 164 if (w) 165 gtk_widget_set_sensitive(w, show); 166 else 167 fprintf(stderr, "gfio: can't find path %s\n", path); 168 } 169 170 static void set_job_menu_visible(struct gui *ui, int visible) 171 { 172 set_menu_entry_visible(ui, "/MainMenu/JobMenu", visible); 173 } 174 175 static void set_view_results_visible(struct gui *ui, int visible) 176 { 177 set_menu_entry_visible(ui, "/MainMenu/ViewMenu/Results", visible); 178 } 179 180 static const char *get_button_tooltip(struct button_spec *s, int sensitive) 181 { 182 if (s->tooltiptext[sensitive]) 183 return s->tooltiptext[sensitive]; 184 185 return s->tooltiptext[0]; 186 } 187 188 static GtkWidget *add_button(GtkWidget *buttonbox, 189 struct button_spec *buttonspec, gpointer data) 190 { 191 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext); 192 gboolean sens = buttonspec->start_sensitive; 193 194 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data); 195 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3); 196 197 sens = buttonspec->start_sensitive; 198 gtk_widget_set_tooltip_text(button, get_button_tooltip(buttonspec, sens)); 199 gtk_widget_set_sensitive(button, sens); 200 201 return button; 202 } 203 204 static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist, 205 int nbuttons) 206 { 207 int i; 208 209 for (i = 0; i < nbuttons; i++) 210 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge); 211 } 212 213 /* 214 * Update sensitivity of job buttons and job menu items, based on the 215 * state of the client. 216 */ 217 static void update_button_states(struct gui *ui, struct gui_entry *ge) 218 { 219 unsigned int connect_state, send_state, start_state, edit_state; 220 const char *connect_str = NULL; 221 222 switch (ge->state) { 223 default: 224 gfio_report_error(ge, "Bad client state: %u\n", ge->state); 225 /* fall through to new state */ 226 case GE_STATE_NEW: 227 connect_state = 1; 228 edit_state = 1; 229 connect_str = "Connect"; 230 send_state = 0; 231 start_state = 0; 232 break; 233 case GE_STATE_CONNECTED: 234 connect_state = 1; 235 edit_state = 1; 236 connect_str = "Disconnect"; 237 send_state = 1; 238 start_state = 0; 239 break; 240 case GE_STATE_JOB_SENT: 241 connect_state = 1; 242 edit_state = 1; 243 connect_str = "Disconnect"; 244 send_state = 0; 245 start_state = 1; 246 break; 247 case GE_STATE_JOB_STARTED: 248 connect_state = 1; 249 edit_state = 1; 250 connect_str = "Disconnect"; 251 send_state = 0; 252 start_state = 1; 253 break; 254 case GE_STATE_JOB_RUNNING: 255 connect_state = 1; 256 edit_state = 0; 257 connect_str = "Disconnect"; 258 send_state = 0; 259 start_state = 0; 260 break; 261 case GE_STATE_JOB_DONE: 262 connect_state = 1; 263 edit_state = 0; 264 connect_str = "Connect"; 265 send_state = 0; 266 start_state = 0; 267 break; 268 } 269 270 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_CONNECT], connect_state); 271 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_SEND], send_state); 272 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_START], start_state); 273 gtk_button_set_label(GTK_BUTTON(ge->button[GFIO_BUTTON_CONNECT]), connect_str); 274 gtk_widget_set_tooltip_text(ge->button[GFIO_BUTTON_CONNECT], get_button_tooltip(&buttonspeclist[GFIO_BUTTON_CONNECT], connect_state)); 275 276 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Connect", connect_state); 277 set_menu_entry_text(ui, "/MainMenu/JobMenu/Connect", connect_str); 278 279 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Edit job", edit_state); 280 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Send job", send_state); 281 set_menu_entry_visible(ui, "/MainMenu/JobMenu/Start job", start_state); 282 283 if (ge->client && ge->client->nr_results) 284 set_view_results_visible(ui, 1); 285 else 286 set_view_results_visible(ui, 0); 287 } 288 289 void gfio_set_state(struct gui_entry *ge, unsigned int state) 290 { 291 ge->state = state; 292 update_button_states(ge->ui, ge); 293 } 294 295 static void gfio_ui_setup_log(struct gui *ui) 296 { 297 GtkTreeSelection *selection; 298 GtkListStore *model; 299 GtkWidget *tree_view; 300 301 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); 302 303 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); 304 gtk_widget_set_can_focus(tree_view, FALSE); 305 306 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); 307 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE); 308 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE, 309 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL); 310 311 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE); 312 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE); 313 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE); 314 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE); 315 316 ui->log_model = model; 317 ui->log_tree = tree_view; 318 } 319 320 static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event, 321 gpointer data) 322 { 323 guint width = gtk_widget_get_allocated_width(w); 324 guint height = gtk_widget_get_allocated_height(w); 325 struct gfio_graphs *g = data; 326 327 graph_set_size(g->iops_graph, width / 2.0, height); 328 graph_set_position(g->iops_graph, width / 2.0, 0.0); 329 graph_set_size(g->bandwidth_graph, width / 2.0, height); 330 graph_set_position(g->bandwidth_graph, 0, 0); 331 return TRUE; 332 } 333 334 static void draw_graph(struct graph *g, cairo_t *cr) 335 { 336 line_graph_draw(g, cr); 337 cairo_stroke(cr); 338 } 339 340 static gboolean graph_tooltip(GtkWidget *w, gint x, gint y, 341 gboolean keyboard_mode, GtkTooltip *tooltip, 342 gpointer data) 343 { 344 struct gfio_graphs *g = data; 345 const char *text = NULL; 346 347 if (graph_contains_xy(g->iops_graph, x, y)) 348 text = graph_find_tooltip(g->iops_graph, x, y); 349 else if (graph_contains_xy(g->bandwidth_graph, x, y)) 350 text = graph_find_tooltip(g->bandwidth_graph, x, y); 351 352 if (text) { 353 gtk_tooltip_set_text(tooltip, text); 354 return TRUE; 355 } 356 357 return FALSE; 358 } 359 360 static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p) 361 { 362 struct gfio_graphs *g = p; 363 cairo_t *cr; 364 365 cr = gdk_cairo_create(gtk_widget_get_window(w)); 366 367 if (graph_has_tooltips(g->iops_graph) || 368 graph_has_tooltips(g->bandwidth_graph)) { 369 g_object_set(w, "has-tooltip", TRUE, NULL); 370 g_signal_connect(w, "query-tooltip", G_CALLBACK(graph_tooltip), g); 371 } 372 373 cairo_set_source_rgb(cr, 0, 0, 0); 374 draw_graph(g->iops_graph, cr); 375 draw_graph(g->bandwidth_graph, cr); 376 cairo_destroy(cr); 377 378 return FALSE; 379 } 380 381 /* 382 * FIXME: need more handling here 383 */ 384 static void ge_destroy(struct gui_entry *ge) 385 { 386 struct gfio_client *gc = ge->client; 387 388 if (gc) { 389 if (gc->client) { 390 if (ge->state >= GE_STATE_CONNECTED) 391 fio_client_terminate(gc->client); 392 393 fio_put_client(gc->client); 394 } 395 free(gc); 396 } 397 398 g_hash_table_remove(ge->ui->ge_hash, &ge->page_num); 399 400 free(ge->job_file); 401 free(ge->host); 402 free(ge); 403 } 404 405 static void ge_widget_destroy(GtkWidget *w, gpointer data) 406 { 407 struct gui_entry *ge = (struct gui_entry *) data; 408 409 ge_destroy(ge); 410 } 411 412 static void gfio_quit(struct gui *ui) 413 { 414 gtk_main_quit(); 415 } 416 417 static void quit_clicked(__attribute__((unused)) GtkWidget *widget, 418 gpointer data) 419 { 420 struct gui *ui = (struct gui *) data; 421 422 gfio_quit(ui); 423 } 424 425 static void *job_thread(void *arg) 426 { 427 struct gui *ui = arg; 428 429 ui->handler_running = 1; 430 fio_handle_clients(&gfio_client_ops); 431 ui->handler_running = 0; 432 return NULL; 433 } 434 435 static int send_job_file(struct gui_entry *ge) 436 { 437 struct gfio_client *gc = ge->client; 438 int ret = 0; 439 440 /* 441 * Prune old options, we are expecting the return options 442 * when the job file is parsed remotely and returned to us. 443 */ 444 while (!flist_empty(&gc->o_list)) { 445 struct gfio_client_options *gco; 446 447 gco = flist_first_entry(&gc->o_list, struct gfio_client_options, list); 448 flist_del(&gco->list); 449 free(gco); 450 } 451 452 ret = fio_client_send_ini(gc->client, ge->job_file, 0); 453 if (!ret) 454 return 0; 455 456 gfio_report_error(ge, "Failed to send file %s: %s\n", ge->job_file, strerror(-ret)); 457 return 1; 458 } 459 460 static void *server_thread(void *arg) 461 { 462 is_backend = 1; 463 gfio_server_running = 1; 464 fio_start_server(NULL); 465 gfio_server_running = 0; 466 return NULL; 467 } 468 469 static void gfio_start_server(struct gui *ui) 470 { 471 if (!gfio_server_running) { 472 gfio_server_running = 1; 473 pthread_create(&ui->server_t, NULL, server_thread, NULL); 474 pthread_detach(ui->server_t); 475 } 476 } 477 478 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget, 479 gpointer data) 480 { 481 struct gui_entry *ge = data; 482 struct gfio_client *gc = ge->client; 483 484 if (gc) 485 fio_start_client(gc->client); 486 } 487 488 static void file_open(GtkWidget *w, gpointer data); 489 490 struct connection_widgets 491 { 492 GtkWidget *hentry; 493 GtkWidget *combo; 494 GtkWidget *button; 495 }; 496 497 static void hostname_cb(GtkEntry *entry, gpointer data) 498 { 499 struct connection_widgets *cw = data; 500 int uses_net = 0, is_localhost = 0; 501 const gchar *text; 502 gchar *ctext; 503 504 /* 505 * Check whether to display the 'auto start backend' box 506 * or not. Show it if we are a localhost and using network, 507 * or using a socket. 508 */ 509 ctext = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(cw->combo)); 510 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4)) 511 uses_net = 1; 512 g_free(ctext); 513 514 if (uses_net) { 515 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry)); 516 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") || 517 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") || 518 !strcmp(text, "ip6-loopback")) 519 is_localhost = 1; 520 } 521 522 if (!uses_net || is_localhost) { 523 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1); 524 gtk_widget_set_sensitive(cw->button, 1); 525 } else { 526 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0); 527 gtk_widget_set_sensitive(cw->button, 0); 528 } 529 } 530 531 static int get_connection_details(struct gui_entry *ge) 532 { 533 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry; 534 struct connection_widgets cw; 535 struct gui *ui = ge->ui; 536 char *typeentry; 537 538 if (ge->host) 539 return 0; 540 541 dialog = gtk_dialog_new_with_buttons("Connection details", 542 GTK_WINDOW(ui->window), 543 GTK_DIALOG_DESTROY_WITH_PARENT, 544 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 545 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); 546 547 frame = gtk_frame_new("Hostname / socket name"); 548 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); 549 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 550 551 box = gtk_vbox_new(FALSE, 6); 552 gtk_container_add(GTK_CONTAINER(frame), box); 553 554 hbox = gtk_hbox_new(TRUE, 10); 555 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 556 cw.hentry = gtk_entry_new(); 557 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost"); 558 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0); 559 560 frame = gtk_frame_new("Port"); 561 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 562 box = gtk_vbox_new(FALSE, 10); 563 gtk_container_add(GTK_CONTAINER(frame), box); 564 565 hbox = gtk_hbox_new(TRUE, 4); 566 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 567 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT); 568 569 frame = gtk_frame_new("Type"); 570 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 571 box = gtk_vbox_new(FALSE, 10); 572 gtk_container_add(GTK_CONTAINER(frame), box); 573 574 hbox = gtk_hbox_new(TRUE, 4); 575 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 576 577 cw.combo = gtk_combo_box_text_new(); 578 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "IPv4"); 579 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "IPv6"); 580 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(cw.combo), "local socket"); 581 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0); 582 583 gtk_container_add(GTK_CONTAINER(hbox), cw.combo); 584 585 frame = gtk_frame_new("Options"); 586 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 587 box = gtk_vbox_new(FALSE, 10); 588 gtk_container_add(GTK_CONTAINER(frame), box); 589 590 hbox = gtk_hbox_new(TRUE, 4); 591 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0); 592 593 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend"); 594 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1); 595 gtk_widget_set_tooltip_text(cw.button, "When running fio locally, it is necessary to have the backend running on the same system. If this is checked, gfio will start the backend automatically for you if it isn't already running."); 596 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6); 597 598 /* 599 * Connect edit signal, so we can show/not-show the auto start button 600 */ 601 g_signal_connect(G_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw); 602 g_signal_connect(G_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw); 603 604 gtk_widget_show_all(dialog); 605 606 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { 607 gtk_widget_destroy(dialog); 608 return 1; 609 } 610 611 ge->host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry))); 612 ge->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry)); 613 614 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(cw.combo)); 615 if (!typeentry || !strncmp(typeentry, "IPv4", 4)) 616 ge->type = Fio_client_ipv4; 617 else if (!strncmp(typeentry, "IPv6", 4)) 618 ge->type = Fio_client_ipv6; 619 else 620 ge->type = Fio_client_socket; 621 g_free(typeentry); 622 623 ge->server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button)); 624 625 gtk_widget_destroy(dialog); 626 return 0; 627 } 628 629 static void gfio_set_client(struct gfio_client *gc, struct fio_client *client) 630 { 631 gc->client = fio_get_client(client); 632 client->client_data = gc; 633 } 634 635 static void gfio_client_added(struct gui_entry *ge, struct fio_client *client) 636 { 637 struct gfio_client_options *gco; 638 struct gfio_client *gc; 639 640 gc = calloc(1, sizeof(*gc)); 641 INIT_FLIST_HEAD(&gc->o_list); 642 gc->ge = ge; 643 ge->client = gc; 644 gfio_set_client(gc, client); 645 646 /* 647 * Just add a default set of options, need to consider how best 648 * to handle this 649 */ 650 gco = calloc(1, sizeof(*gco)); 651 INIT_FLIST_HEAD(&gco->list); 652 options_default_fill(&gco->o); 653 flist_add_tail(&gco->list, &gc->o_list); 654 gc->o_list_nr++; 655 } 656 657 static void gfio_clear_graph_data(struct gfio_graphs *g) 658 { 659 graph_clear_values(g->iops_graph); 660 graph_clear_values(g->bandwidth_graph); 661 } 662 663 static void connect_clicked(GtkWidget *widget, gpointer data) 664 { 665 struct gui_entry *ge = data; 666 struct gfio_client *gc = ge->client; 667 668 if (ge->state == GE_STATE_NEW) { 669 int ret; 670 671 if (!ge->job_file) 672 file_open(widget, ge->ui); 673 if (!ge->job_file) 674 return; 675 676 gc = ge->client; 677 678 if (!gc->client) { 679 struct fio_client *client; 680 681 if (get_connection_details(ge)) { 682 gfio_report_error(ge, "Failed to get connection details\n"); 683 return; 684 } 685 686 client = fio_client_add_explicit(&gfio_client_ops, ge->host, ge->type, ge->port); 687 if (!client) { 688 gfio_report_error(ge, "Failed to add client %s\n", ge->host); 689 free(ge->host); 690 ge->host = NULL; 691 return; 692 } 693 gfio_set_client(gc, client); 694 } 695 696 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running"); 697 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0); 698 ret = fio_client_connect(gc->client); 699 if (!ret) { 700 if (!ge->ui->handler_running) 701 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui); 702 gfio_set_state(ge, GE_STATE_CONNECTED); 703 gfio_clear_graph_data(&ge->graphs); 704 } else { 705 gfio_report_error(ge, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret)); 706 } 707 } else { 708 fio_client_terminate(gc->client); 709 gfio_set_state(ge, GE_STATE_NEW); 710 clear_ge_ui_info(ge); 711 } 712 } 713 714 static void send_clicked(GtkWidget *widget, gpointer data) 715 { 716 struct gui_entry *ge = data; 717 718 if (send_job_file(ge)) 719 gtk_widget_set_sensitive(ge->button[GFIO_BUTTON_START], 1); 720 } 721 722 static GtkWidget *new_client_page(struct gui_entry *ge); 723 724 static struct gui_entry *alloc_new_gui_entry(struct gui *ui) 725 { 726 struct gui_entry *ge; 727 728 ge = malloc(sizeof(*ge)); 729 memset(ge, 0, sizeof(*ge)); 730 ge->state = GE_STATE_NEW; 731 ge->ui = ui; 732 return ge; 733 } 734 735 static struct gui_entry *get_new_ge_with_tab(struct gui *ui, const char *name) 736 { 737 struct gui_entry *ge; 738 739 ge = alloc_new_gui_entry(ui); 740 741 ge->vbox = new_client_page(ge); 742 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge); 743 744 ge->page_label = gtk_label_new(name); 745 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), ge->vbox, ge->page_label); 746 747 g_hash_table_insert(ui->ge_hash, &ge->page_num, ge); 748 749 gtk_widget_show_all(ui->window); 750 return ge; 751 } 752 753 static void file_new(GtkWidget *w, gpointer data) 754 { 755 struct gui *ui = (struct gui *) data; 756 struct gui_entry *ge; 757 758 ge = get_new_ge_with_tab(ui, "Untitled"); 759 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num); 760 } 761 762 /* 763 * Return the 'ge' corresponding to the tab. If the active tab is the 764 * main tab, open a new tab. 765 */ 766 static struct gui_entry *get_ge_from_page(struct gui *ui, gint cur_page, 767 int *created) 768 { 769 if (!cur_page) { 770 if (created) 771 *created = 1; 772 return get_new_ge_with_tab(ui, "Untitled"); 773 } 774 775 if (created) 776 *created = 0; 777 778 return g_hash_table_lookup(ui->ge_hash, &cur_page); 779 } 780 781 static struct gui_entry *get_ge_from_cur_tab(struct gui *ui) 782 { 783 gint cur_page; 784 785 /* 786 * Main tab is tab 0, so any current page other than 0 holds 787 * a ge entry. 788 */ 789 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook)); 790 if (cur_page) 791 return get_ge_from_page(ui, cur_page, NULL); 792 793 return NULL; 794 } 795 796 static void file_close(GtkWidget *w, gpointer data) 797 { 798 struct gui *ui = (struct gui *) data; 799 struct gui_entry *ge; 800 801 /* 802 * Can't close the main tab 803 */ 804 ge = get_ge_from_cur_tab(ui); 805 if (ge) { 806 gtk_widget_destroy(ge->vbox); 807 return; 808 } 809 810 if (g_hash_table_size(ui->ge_hash)) { 811 gfio_report_info(ui, "Error", "The main page view cannot be closed\n"); 812 return; 813 } 814 815 gfio_quit(ui); 816 } 817 818 static void file_add_recent(struct gui *ui, const gchar *uri) 819 { 820 GtkRecentData grd; 821 822 memset(&grd, 0, sizeof(grd)); 823 grd.display_name = strdup("gfio"); 824 grd.description = strdup("Fio job file"); 825 grd.mime_type = strdup(GFIO_MIME); 826 grd.app_name = strdup(g_get_application_name()); 827 grd.app_exec = strdup("gfio %f/%u"); 828 829 gtk_recent_manager_add_full(ui->recentmanager, uri, &grd); 830 } 831 832 static gchar *get_filename_from_uri(const gchar *uri) 833 { 834 if (strncmp(uri, "file://", 7)) 835 return strdup(uri); 836 837 return strdup(uri + 7); 838 } 839 840 static int do_file_open(struct gui_entry *ge, const gchar *uri) 841 { 842 struct fio_client *client; 843 844 assert(!ge->job_file); 845 846 ge->job_file = get_filename_from_uri(uri); 847 848 client = fio_client_add_explicit(&gfio_client_ops, ge->host, ge->type, ge->port); 849 if (client) { 850 char *label = strdup(uri); 851 852 basename(label); 853 gtk_label_set_text(GTK_LABEL(ge->page_label), basename(label)); 854 free(label); 855 856 gfio_client_added(ge, client); 857 file_add_recent(ge->ui, uri); 858 return 0; 859 } 860 861 gfio_report_error(ge, "Failed to add client %s\n", ge->host); 862 free(ge->host); 863 ge->host = NULL; 864 free(ge->job_file); 865 ge->job_file = NULL; 866 return 1; 867 } 868 869 static int do_file_open_with_tab(struct gui *ui, const gchar *uri) 870 { 871 struct gui_entry *ge; 872 gint cur_page; 873 int ret, ge_is_new = 0; 874 875 /* 876 * Creates new tab if current tab is the main window, or the 877 * current tab already has a client. 878 */ 879 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook)); 880 ge = get_ge_from_page(ui, cur_page, &ge_is_new); 881 if (ge->client) { 882 ge = get_new_ge_with_tab(ui, "Untitled"); 883 ge_is_new = 1; 884 } 885 886 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num); 887 888 if (get_connection_details(ge)) { 889 if (ge_is_new) 890 gtk_widget_destroy(ge->vbox); 891 892 return 1; 893 } 894 895 ret = do_file_open(ge, uri); 896 897 if (!ret) { 898 if (ge->server_start) 899 gfio_start_server(ui); 900 } else { 901 if (ge_is_new) 902 gtk_widget_destroy(ge->vbox); 903 } 904 905 return ret; 906 } 907 908 static void recent_open(GtkAction *action, gpointer data) 909 { 910 struct gui *ui = (struct gui *) data; 911 GtkRecentInfo *info; 912 const gchar *uri; 913 914 info = g_object_get_data(G_OBJECT(action), "gtk-recent-info"); 915 uri = gtk_recent_info_get_uri(info); 916 917 do_file_open_with_tab(ui, uri); 918 } 919 920 static void file_open(GtkWidget *w, gpointer data) 921 { 922 struct gui *ui = data; 923 GtkWidget *dialog; 924 GtkFileFilter *filter; 925 gchar *filename; 926 927 dialog = gtk_file_chooser_dialog_new("Open File", 928 GTK_WINDOW(ui->window), 929 GTK_FILE_CHOOSER_ACTION_OPEN, 930 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 931 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 932 NULL); 933 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE); 934 935 filter = gtk_file_filter_new(); 936 gtk_file_filter_add_pattern(filter, "*.fio"); 937 gtk_file_filter_add_pattern(filter, "*.job"); 938 gtk_file_filter_add_pattern(filter, "*.ini"); 939 gtk_file_filter_add_mime_type(filter, GFIO_MIME); 940 gtk_file_filter_set_name(filter, "Fio job file"); 941 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); 942 943 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { 944 gtk_widget_destroy(dialog); 945 return; 946 } 947 948 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); 949 950 gtk_widget_destroy(dialog); 951 952 do_file_open_with_tab(ui, filename); 953 g_free(filename); 954 } 955 956 static void file_save(GtkWidget *w, gpointer data) 957 { 958 struct gui *ui = data; 959 GtkWidget *dialog; 960 961 dialog = gtk_file_chooser_dialog_new("Save File", 962 GTK_WINDOW(ui->window), 963 GTK_FILE_CHOOSER_ACTION_SAVE, 964 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 965 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, 966 NULL); 967 968 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); 969 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document"); 970 971 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { 972 char *filename; 973 974 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); 975 // save_job_file(filename); 976 g_free(filename); 977 } 978 gtk_widget_destroy(dialog); 979 } 980 981 static void view_log_destroy(GtkWidget *w, gpointer data) 982 { 983 struct gui *ui = (struct gui *) data; 984 985 g_object_ref(G_OBJECT(ui->log_tree)); 986 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree); 987 gtk_widget_destroy(w); 988 ui->log_view = NULL; 989 } 990 991 void gfio_view_log(struct gui *ui) 992 { 993 GtkWidget *win, *scroll, *vbox, *box; 994 995 if (ui->log_view) 996 return; 997 998 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL); 999 gtk_window_set_title(GTK_WINDOW(win), "Log"); 1000 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500); 1001 1002 scroll = gtk_scrolled_window_new(NULL, NULL); 1003 1004 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5); 1005 1006 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 1007 1008 box = gtk_hbox_new(TRUE, 0); 1009 gtk_box_pack_start(GTK_BOX(box), ui->log_tree, TRUE, TRUE, 0); 1010 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui); 1011 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box); 1012 1013 vbox = gtk_vbox_new(TRUE, 5); 1014 gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0); 1015 1016 gtk_container_add(GTK_CONTAINER(win), vbox); 1017 gtk_widget_show_all(win); 1018 } 1019 1020 static void view_log(GtkWidget *w, gpointer data) 1021 { 1022 struct gui *ui = (struct gui *) data; 1023 1024 gfio_view_log(ui); 1025 } 1026 1027 static void connect_job_entry(GtkWidget *w, gpointer data) 1028 { 1029 struct gui *ui = (struct gui *) data; 1030 struct gui_entry *ge; 1031 1032 ge = get_ge_from_cur_tab(ui); 1033 if (ge) 1034 connect_clicked(w, ge); 1035 } 1036 1037 static void send_job_entry(GtkWidget *w, gpointer data) 1038 { 1039 struct gui *ui = (struct gui *) data; 1040 struct gui_entry *ge; 1041 1042 ge = get_ge_from_cur_tab(ui); 1043 if (ge) 1044 send_clicked(w, ge); 1045 } 1046 1047 static void edit_job_entry(GtkWidget *w, gpointer data) 1048 { 1049 struct gui *ui = (struct gui *) data; 1050 struct gui_entry *ge; 1051 1052 ge = get_ge_from_cur_tab(ui); 1053 if (ge && ge->client) 1054 gopt_get_options_window(ui->window, ge->client); 1055 } 1056 1057 static void start_job_entry(GtkWidget *w, gpointer data) 1058 { 1059 struct gui *ui = (struct gui *) data; 1060 struct gui_entry *ge; 1061 1062 ge = get_ge_from_cur_tab(ui); 1063 if (ge) 1064 start_job_clicked(w, ge); 1065 } 1066 1067 static void view_results(GtkWidget *w, gpointer data) 1068 { 1069 struct gui *ui = (struct gui *) data; 1070 struct gfio_client *gc; 1071 struct gui_entry *ge; 1072 1073 ge = get_ge_from_cur_tab(ui); 1074 if (!ge) 1075 return; 1076 1077 if (ge->results_window) 1078 return; 1079 1080 gc = ge->client; 1081 if (gc && gc->nr_results) 1082 gfio_display_end_results(gc); 1083 } 1084 1085 static void __update_graph_settings(struct gfio_graphs *g) 1086 { 1087 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit); 1088 graph_set_font(g->iops_graph, gfio_graph_font); 1089 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit); 1090 graph_set_font(g->bandwidth_graph, gfio_graph_font); 1091 } 1092 1093 static void ge_update_settings_fn(gpointer key, gpointer value, gpointer data) 1094 { 1095 struct gui_entry *ge = (struct gui_entry *) value; 1096 GdkEvent *ev; 1097 1098 __update_graph_settings(&ge->graphs); 1099 1100 ev = gdk_event_new(GDK_EXPOSE); 1101 g_signal_emit_by_name(G_OBJECT(ge->graphs.drawing_area), GFIO_DRAW_EVENT, GTK_WIDGET(ge->graphs.drawing_area), ev, &ge->graphs); 1102 gdk_event_free(ev); 1103 } 1104 1105 static void update_graph_limits(void) 1106 { 1107 struct gui *ui = &main_ui; 1108 GdkEvent *ev; 1109 1110 __update_graph_settings(&ui->graphs); 1111 1112 ev = gdk_event_new(GDK_EXPOSE); 1113 g_signal_emit_by_name(G_OBJECT(ui->graphs.drawing_area), GFIO_DRAW_EVENT, GTK_WIDGET(ui->graphs.drawing_area), ev, &ui->graphs); 1114 gdk_event_free(ev); 1115 1116 g_hash_table_foreach(ui->ge_hash, ge_update_settings_fn, NULL); 1117 } 1118 1119 static void preferences(GtkWidget *w, gpointer data) 1120 { 1121 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font; 1122 GtkWidget *hbox, *spin, *entry, *spin_int; 1123 struct gui *ui = (struct gui *) data; 1124 int i; 1125 1126 dialog = gtk_dialog_new_with_buttons("Preferences", 1127 GTK_WINDOW(ui->window), 1128 GTK_DIALOG_DESTROY_WITH_PARENT, 1129 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 1130 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, 1131 NULL); 1132 1133 frame = gtk_frame_new("Graphing"); 1134 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); 1135 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 1136 vbox = gtk_vbox_new(FALSE, 6); 1137 gtk_container_add(GTK_CONTAINER(frame), vbox); 1138 1139 hbox = gtk_hbox_new(FALSE, 5); 1140 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); 1141 entry = gtk_label_new("Font face to use for graph labels"); 1142 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5); 1143 1144 font = gtk_font_button_new_with_font(gfio_graph_font); 1145 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5); 1146 1147 box = gtk_vbox_new(FALSE, 6); 1148 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5); 1149 1150 hbox = gtk_hbox_new(FALSE, 5); 1151 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5); 1152 entry = gtk_label_new("Maximum number of data points in graph (seconds)"); 1153 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5); 1154 1155 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit); 1156 1157 box = gtk_vbox_new(FALSE, 6); 1158 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5); 1159 1160 hbox = gtk_hbox_new(FALSE, 5); 1161 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5); 1162 entry = gtk_label_new("Client ETA request interval (msec)"); 1163 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5); 1164 1165 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec); 1166 frame = gtk_frame_new("Debug logging"); 1167 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); 1168 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); 1169 vbox = gtk_vbox_new(FALSE, 6); 1170 gtk_container_add(GTK_CONTAINER(frame), vbox); 1171 1172 box = gtk_hbox_new(FALSE, 6); 1173 gtk_container_add(GTK_CONTAINER(vbox), box); 1174 1175 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX); 1176 1177 for (i = 0; i < FD_DEBUG_MAX; i++) { 1178 if (i == 7) { 1179 box = gtk_hbox_new(FALSE, 6); 1180 gtk_container_add(GTK_CONTAINER(vbox), box); 1181 } 1182 1183 1184 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name); 1185 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help); 1186 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6); 1187 } 1188 1189 gtk_widget_show_all(dialog); 1190 1191 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { 1192 gtk_widget_destroy(dialog); 1193 return; 1194 } 1195 1196 for (i = 0; i < FD_DEBUG_MAX; i++) { 1197 int set; 1198 1199 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i])); 1200 if (set) 1201 fio_debug |= (1UL << i); 1202 } 1203 1204 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font))); 1205 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin)); 1206 update_graph_limits(); 1207 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int)); 1208 1209 gtk_widget_destroy(dialog); 1210 } 1211 1212 static void about_dialog(GtkWidget *w, gpointer data) 1213 { 1214 const char *authors[] = { 1215 "Jens Axboe <axboe (at) kernel.dk>", 1216 "Stephen Carmeron <stephenmcameron (at) gmail.com>", 1217 NULL 1218 }; 1219 const char *license[] = { 1220 "Fio is free software; you can redistribute it and/or modify " 1221 "it under the terms of the GNU General Public License as published by " 1222 "the Free Software Foundation; either version 2 of the License, or " 1223 "(at your option) any later version.\n", 1224 "Fio is distributed in the hope that it will be useful, " 1225 "but WITHOUT ANY WARRANTY; without even the implied warranty of " 1226 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the " 1227 "GNU General Public License for more details.\n", 1228 "You should have received a copy of the GNU General Public License " 1229 "along with Fio; if not, write to the Free Software Foundation, Inc., " 1230 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n" 1231 }; 1232 char *license_trans; 1233 1234 license_trans = g_strconcat(license[0], "\n", license[1], "\n", 1235 license[2], "\n", NULL); 1236 1237 gtk_show_about_dialog(NULL, 1238 "program-name", "gfio", 1239 "comments", "Gtk2 UI for fio", 1240 "license", license_trans, 1241 "website", "http://git.kernel.dk/?p=fio.git;a=summary", 1242 "authors", authors, 1243 "version", fio_version_string, 1244 "copyright", " 2012 Jens Axboe <axboe (at) kernel.dk>", 1245 "logo-icon-name", "fio", 1246 /* Must be last: */ 1247 "wrap-license", TRUE, 1248 NULL); 1249 1250 g_free(license_trans); 1251 } 1252 1253 static GtkActionEntry menu_items[] = { 1254 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL}, 1255 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL}, 1256 { "JobMenuAction", GTK_STOCK_FILE, "Job", NULL, NULL, NULL}, 1257 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL}, 1258 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) }, 1259 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(file_close) }, 1260 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) }, 1261 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) }, 1262 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) }, 1263 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) }, 1264 { "ViewResults", NULL, "Results", "<Control>R", NULL, G_CALLBACK(view_results) }, 1265 { "ConnectJob", NULL, "Connect", "<Control>D", NULL, G_CALLBACK(connect_job_entry) }, 1266 { "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) }, 1267 { "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) }, 1268 { "StartJob", NULL, "Start job", "<Control>L", NULL, G_CALLBACK(start_job_entry) }, 1269 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) }, 1270 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) }, 1271 }; 1272 static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]); 1273 1274 static const gchar *ui_string = " \ 1275 <ui> \ 1276 <menubar name=\"MainMenu\"> \ 1277 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \ 1278 <menuitem name=\"New\" action=\"NewFile\" /> \ 1279 <menuitem name=\"Open\" action=\"OpenFile\" /> \ 1280 <menuitem name=\"Close\" action=\"CloseFile\" /> \ 1281 <separator name=\"Separator1\"/> \ 1282 <menuitem name=\"Save\" action=\"SaveFile\" /> \ 1283 <separator name=\"Separator2\"/> \ 1284 <menuitem name=\"Preferences\" action=\"Preferences\" /> \ 1285 <separator name=\"Separator3\"/> \ 1286 <placeholder name=\"FileRecentFiles\"/> \ 1287 <separator name=\"Separator4\"/> \ 1288 <menuitem name=\"Quit\" action=\"Quit\" /> \ 1289 </menu> \ 1290 <menu name=\"JobMenu\" action=\"JobMenuAction\"> \ 1291 <menuitem name=\"Connect\" action=\"ConnectJob\" /> \ 1292 <separator name=\"Separator5\"/> \ 1293 <menuitem name=\"Edit job\" action=\"EditJob\" /> \ 1294 <menuitem name=\"Send job\" action=\"SendJob\" /> \ 1295 <separator name=\"Separator6\"/> \ 1296 <menuitem name=\"Start job\" action=\"StartJob\" /> \ 1297 </menu>\ 1298 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \ 1299 <menuitem name=\"Results\" action=\"ViewResults\" /> \ 1300 <separator name=\"Separator7\"/> \ 1301 <menuitem name=\"Log\" action=\"ViewLog\" /> \ 1302 </menu>\ 1303 <menu name=\"Help\" action=\"HelpMenuAction\"> \ 1304 <menuitem name=\"About\" action=\"About\" /> \ 1305 </menu> \ 1306 </menubar> \ 1307 </ui> \ 1308 "; 1309 1310 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager, 1311 struct gui *ui) 1312 { 1313 GtkActionGroup *action_group; 1314 GError *error = 0; 1315 1316 action_group = gtk_action_group_new("Menu"); 1317 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui); 1318 1319 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); 1320 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error); 1321 1322 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager)); 1323 1324 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu"); 1325 } 1326 1327 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar, 1328 GtkWidget *vbox, GtkUIManager *ui_manager) 1329 { 1330 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); 1331 } 1332 1333 static void combo_entry_changed(GtkComboBox *box, gpointer data) 1334 { 1335 struct gui_entry *ge = (struct gui_entry *) data; 1336 gint index; 1337 1338 index = gtk_combo_box_get_active(box); 1339 1340 multitext_set_entry(&ge->eta.iotype, index); 1341 multitext_set_entry(&ge->eta.bs, index); 1342 multitext_set_entry(&ge->eta.ioengine, index); 1343 multitext_set_entry(&ge->eta.iodepth, index); 1344 } 1345 1346 static void combo_entry_destroy(GtkWidget *widget, gpointer data) 1347 { 1348 struct gui_entry *ge = (struct gui_entry *) data; 1349 1350 multitext_free(&ge->eta.iotype); 1351 multitext_free(&ge->eta.bs); 1352 multitext_free(&ge->eta.ioengine); 1353 multitext_free(&ge->eta.iodepth); 1354 } 1355 1356 static GtkWidget *new_client_page(struct gui_entry *ge) 1357 { 1358 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box; 1359 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox; 1360 1361 main_vbox = gtk_vbox_new(FALSE, 3); 1362 1363 top_align = gtk_alignment_new(0, 0, 1, 0); 1364 top_vbox = gtk_vbox_new(FALSE, 3); 1365 gtk_container_add(GTK_CONTAINER(top_align), top_vbox); 1366 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0); 1367 1368 probe = gtk_frame_new("Job"); 1369 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3); 1370 probe_frame = gtk_vbox_new(FALSE, 3); 1371 gtk_container_add(GTK_CONTAINER(probe), probe_frame); 1372 1373 probe_box = gtk_hbox_new(FALSE, 3); 1374 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 1375 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host"); 1376 ge->probe.os = new_info_label_in_frame(probe_box, "OS"); 1377 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture"); 1378 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version"); 1379 1380 probe_box = gtk_hbox_new(FALSE, 3); 1381 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 1382 1383 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs"); 1384 g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge); 1385 g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge); 1386 ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO"); 1387 ge->eta.bs.entry = new_info_entry_in_frame(probe_box, "Blocksize (Read/Write)"); 1388 ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine"); 1389 ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth"); 1390 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs"); 1391 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files"); 1392 1393 probe_box = gtk_hbox_new(FALSE, 3); 1394 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 1395 ge->eta.read_bw = new_info_entry_in_frame_rgb(probe_box, "Read BW", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B); 1396 ge->eta.read_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B); 1397 ge->eta.write_bw = new_info_entry_in_frame_rgb(probe_box, "Write BW", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B); 1398 ge->eta.write_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B); 1399 ge->eta.trim_bw = new_info_entry_in_frame_rgb(probe_box, "Trim BW", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B); 1400 ge->eta.trim_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B); 1401 1402 /* 1403 * Only add this if we have a commit rate 1404 */ 1405 #if 0 1406 probe_box = gtk_hbox_new(FALSE, 3); 1407 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3); 1408 1409 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW"); 1410 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 1411 1412 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW"); 1413 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 1414 #endif 1415 1416 /* 1417 * Set up a drawing area and IOPS and bandwidth graphs 1418 */ 1419 ge->graphs.drawing_area = gtk_drawing_area_new(); 1420 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area), 1421 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM); 1422 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &gfio_color_lightyellow); 1423 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), GFIO_DRAW_EVENT, 1424 G_CALLBACK(on_expose_drawing_area), &ge->graphs); 1425 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event", 1426 G_CALLBACK(on_config_drawing_area), &ge->graphs); 1427 scrolled_window = gtk_scrolled_window_new(NULL, NULL); 1428 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), 1429 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 1430 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 1431 ge->graphs.drawing_area); 1432 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0); 1433 1434 setup_graphs(&ge->graphs); 1435 1436 /* 1437 * Set up alignments for widgets at the bottom of ui, 1438 * align bottom left, expand horizontally but not vertically 1439 */ 1440 bottom_align = gtk_alignment_new(0, 1, 1, 0); 1441 ge->buttonbox = gtk_hbox_new(FALSE, 0); 1442 gtk_container_add(GTK_CONTAINER(bottom_align), ge->buttonbox); 1443 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0); 1444 1445 add_buttons(ge, buttonspeclist, ARRAY_SIZE(buttonspeclist)); 1446 1447 /* 1448 * Set up thread status progress bar 1449 */ 1450 ge->thread_status_pb = gtk_progress_bar_new(); 1451 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0); 1452 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections"); 1453 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb); 1454 1455 1456 return main_vbox; 1457 } 1458 1459 static GtkWidget *new_main_page(struct gui *ui) 1460 { 1461 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box; 1462 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox; 1463 1464 main_vbox = gtk_vbox_new(FALSE, 3); 1465 1466 /* 1467 * Set up alignments for widgets at the top of ui, 1468 * align top left, expand horizontally but not vertically 1469 */ 1470 top_align = gtk_alignment_new(0, 0, 1, 0); 1471 top_vbox = gtk_vbox_new(FALSE, 0); 1472 gtk_container_add(GTK_CONTAINER(top_align), top_vbox); 1473 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0); 1474 1475 probe = gtk_frame_new("Run statistics"); 1476 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3); 1477 probe_frame = gtk_vbox_new(FALSE, 3); 1478 gtk_container_add(GTK_CONTAINER(probe), probe_frame); 1479 1480 probe_box = gtk_hbox_new(FALSE, 3); 1481 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3); 1482 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running"); 1483 ui->eta.read_bw = new_info_entry_in_frame_rgb(probe_box, "Read BW", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B); 1484 ui->eta.read_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_READ_R, GFIO_READ_G, GFIO_READ_B); 1485 ui->eta.write_bw = new_info_entry_in_frame_rgb(probe_box, "Write BW", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B); 1486 ui->eta.write_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_WRITE_R, GFIO_WRITE_G, GFIO_WRITE_B); 1487 ui->eta.trim_bw = new_info_entry_in_frame_rgb(probe_box, "Trim BW", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B); 1488 ui->eta.trim_iops = new_info_entry_in_frame_rgb(probe_box, "IOPS", GFIO_TRIM_R, GFIO_TRIM_G, GFIO_TRIM_B); 1489 1490 /* 1491 * Only add this if we have a commit rate 1492 */ 1493 #if 0 1494 probe_box = gtk_hbox_new(FALSE, 3); 1495 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3); 1496 1497 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW"); 1498 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 1499 1500 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW"); 1501 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS"); 1502 #endif 1503 1504 /* 1505 * Set up a drawing area and IOPS and bandwidth graphs 1506 */ 1507 ui->graphs.drawing_area = gtk_drawing_area_new(); 1508 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area), 1509 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM); 1510 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &gfio_color_lightyellow); 1511 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), GFIO_DRAW_EVENT, 1512 G_CALLBACK(on_expose_drawing_area), &ui->graphs); 1513 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event", 1514 G_CALLBACK(on_config_drawing_area), &ui->graphs); 1515 scrolled_window = gtk_scrolled_window_new(NULL, NULL); 1516 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), 1517 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 1518 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 1519 ui->graphs.drawing_area); 1520 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, 1521 TRUE, TRUE, 0); 1522 1523 setup_graphs(&ui->graphs); 1524 1525 /* 1526 * Set up alignments for widgets at the bottom of ui, 1527 * align bottom left, expand horizontally but not vertically 1528 */ 1529 bottom_align = gtk_alignment_new(0, 1, 1, 0); 1530 ui->buttonbox = gtk_hbox_new(FALSE, 0); 1531 gtk_container_add(GTK_CONTAINER(bottom_align), ui->buttonbox); 1532 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0); 1533 1534 /* 1535 * Set up thread status progress bar 1536 */ 1537 ui->thread_status_pb = gtk_progress_bar_new(); 1538 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0); 1539 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections"); 1540 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb); 1541 1542 return main_vbox; 1543 } 1544 1545 static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget, 1546 guint page, gpointer data) 1547 1548 { 1549 struct gui *ui = (struct gui *) data; 1550 struct gui_entry *ge; 1551 1552 if (!page) { 1553 set_job_menu_visible(ui, 0); 1554 set_view_results_visible(ui, 0); 1555 return TRUE; 1556 } 1557 1558 set_job_menu_visible(ui, 1); 1559 ge = get_ge_from_page(ui, page, NULL); 1560 if (ge) 1561 update_button_states(ui, ge); 1562 1563 return TRUE; 1564 } 1565 1566 static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b) 1567 { 1568 time_t time_a = gtk_recent_info_get_visited(a); 1569 time_t time_b = gtk_recent_info_get_visited(b); 1570 1571 return time_b - time_a; 1572 } 1573 1574 static void add_recent_file_items(struct gui *ui) 1575 { 1576 const gchar *gfio = g_get_application_name(); 1577 GList *items, *item; 1578 int i = 0; 1579 1580 if (ui->recent_ui_id) { 1581 gtk_ui_manager_remove_ui(ui->uimanager, ui->recent_ui_id); 1582 gtk_ui_manager_ensure_update(ui->uimanager); 1583 } 1584 ui->recent_ui_id = gtk_ui_manager_new_merge_id(ui->uimanager); 1585 1586 if (ui->actiongroup) { 1587 gtk_ui_manager_remove_action_group(ui->uimanager, ui->actiongroup); 1588 g_object_unref(ui->actiongroup); 1589 } 1590 ui->actiongroup = gtk_action_group_new("RecentFileActions"); 1591 1592 gtk_ui_manager_insert_action_group(ui->uimanager, ui->actiongroup, -1); 1593 1594 items = gtk_recent_manager_get_items(ui->recentmanager); 1595 items = g_list_sort(items, (GCompareFunc) compare_recent_items); 1596 1597 for (item = items; item && item->data; item = g_list_next(item)) { 1598 GtkRecentInfo *info = (GtkRecentInfo *) item->data; 1599 gchar *action_name; 1600 const gchar *label; 1601 GtkAction *action; 1602 1603 if (!gtk_recent_info_has_application(info, gfio)) 1604 continue; 1605 1606 /* 1607 * We only support local files for now 1608 */ 1609 if (!gtk_recent_info_is_local(info) || !gtk_recent_info_exists(info)) 1610 continue; 1611 1612 action_name = g_strdup_printf("RecentFile%u", i++); 1613 label = gtk_recent_info_get_display_name(info); 1614 1615 action = g_object_new(GTK_TYPE_ACTION, 1616 "name", action_name, 1617 "label", label, NULL); 1618 1619 g_object_set_data_full(G_OBJECT(action), "gtk-recent-info", 1620 gtk_recent_info_ref(info), 1621 (GDestroyNotify) gtk_recent_info_unref); 1622 1623 1624 g_signal_connect(action, "activate", G_CALLBACK(recent_open), ui); 1625 1626 gtk_action_group_add_action(ui->actiongroup, action); 1627 g_object_unref(action); 1628 1629 gtk_ui_manager_add_ui(ui->uimanager, ui->recent_ui_id, 1630 "/MainMenu/FileMenu/FileRecentFiles", 1631 label, action_name, 1632 GTK_UI_MANAGER_MENUITEM, FALSE); 1633 1634 g_free(action_name); 1635 1636 if (i == 8) 1637 break; 1638 } 1639 1640 g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL); 1641 g_list_free(items); 1642 } 1643 1644 static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx, 1645 gint x, gint y, GtkSelectionData *seldata, 1646 guint info, guint time, gpointer *data) 1647 { 1648 struct gui *ui = (struct gui *) data; 1649 gchar **uris; 1650 GtkWidget *source; 1651 1652 source = gtk_drag_get_source_widget(ctx); 1653 if (source && widget == gtk_widget_get_toplevel(source)) { 1654 gtk_drag_finish(ctx, FALSE, FALSE, time); 1655 return; 1656 } 1657 1658 uris = gtk_selection_data_get_uris(seldata); 1659 if (!uris) { 1660 gtk_drag_finish(ctx, FALSE, FALSE, time); 1661 return; 1662 } 1663 1664 if (uris[0]) 1665 do_file_open_with_tab(ui, uris[0]); 1666 1667 gtk_drag_finish(ctx, TRUE, FALSE, time); 1668 g_strfreev(uris); 1669 } 1670 1671 static void init_ui(int *argc, char **argv[], struct gui *ui) 1672 { 1673 GtkSettings *settings; 1674 GtkWidget *vbox; 1675 1676 /* Magical g*thread incantation, you just need this thread stuff. 1677 * Without it, the update that happens in gfio_update_thread_status 1678 * doesn't really happen in a timely fashion, you need expose events 1679 */ 1680 #if !GTK_CHECK_VERSION(2, 24, 0) 1681 if (!g_thread_supported()) 1682 g_thread_init(NULL); 1683 #endif 1684 1685 gdk_threads_init(); 1686 1687 gtk_init(argc, argv); 1688 settings = gtk_settings_get_default(); 1689 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting"); 1690 #if !GLIB_CHECK_VERSION(2, 36, 0) 1691 g_type_init(); 1692 #endif 1693 gdk_color_parse("#fffff4", &gfio_color_lightyellow); 1694 gdk_color_parse("white", &gfio_color_white); 1695 1696 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 1697 gtk_window_set_title(GTK_WINDOW(ui->window), "fio"); 1698 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768); 1699 1700 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), ui); 1701 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), ui); 1702 1703 ui->vbox = gtk_vbox_new(FALSE, 0); 1704 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox); 1705 1706 ui->uimanager = gtk_ui_manager_new(); 1707 ui->menu = get_menubar_menu(ui->window, ui->uimanager, ui); 1708 gfio_ui_setup(settings, ui->menu, ui->vbox, ui->uimanager); 1709 1710 ui->recentmanager = gtk_recent_manager_get_default(); 1711 add_recent_file_items(ui); 1712 1713 ui->notebook = gtk_notebook_new(); 1714 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui); 1715 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1); 1716 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook)); 1717 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook); 1718 1719 vbox = new_main_page(ui); 1720 gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 1, GDK_ACTION_COPY); 1721 gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window)); 1722 g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui); 1723 1724 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main")); 1725 1726 gfio_ui_setup_log(ui); 1727 1728 gtk_widget_show_all(ui->window); 1729 } 1730 1731 int main(int argc, char *argv[], char *envp[]) 1732 { 1733 if (initialize_fio(envp)) 1734 return 1; 1735 if (fio_init_options()) 1736 return 1; 1737 1738 gopt_init(); 1739 1740 memset(&main_ui, 0, sizeof(main_ui)); 1741 main_ui.ge_hash = g_hash_table_new(g_int_hash, g_int_equal); 1742 1743 init_ui(&argc, &argv, &main_ui); 1744 1745 gdk_threads_enter(); 1746 gtk_main(); 1747 gdk_threads_leave(); 1748 1749 g_hash_table_destroy(main_ui.ge_hash); 1750 1751 gopt_exit(); 1752 return 0; 1753 } 1754
