goptions.c

   1 #include <locale.h>
   2 #include <malloc.h>
   3 #include <string.h>
   4
   5 #include <glib.h>
   6 #include <cairo.h>
   7 #include <gtk/gtk.h>
   8
   9 #include "fio.h"
  10 #include "gfio.h"
  11 #include "ghelpers.h"
  12 #include "parse.h"
  13
  14 struct gopt {
  15         GtkWidget *box;
  16         unsigned int opt_index;
  17         unsigned int opt_type;
  18 };
  19
  20 struct gopt_combo {
  21         struct gopt gopt;
  22         GtkWidget *combo;
  23 };
  24
  25 struct gopt_int {
  26         struct gopt gopt;
  27         GtkWidget *spin;
  28 };
  29
  30 struct gopt_bool {
  31         struct gopt gopt;
  32         GtkWidget *check;
  33 };
  34
  35 struct gopt_str {
  36         struct gopt gopt;
  37         GtkWidget *entry;
  38 };
  39
  40 #define GOPT_RANGE_SPIN 4
  41
  42 struct gopt_range {
  43         struct gopt gopt;
  44         GtkWidget *spins[GOPT_RANGE_SPIN];
  45 };
  46
  47 static GtkWidget *widgets[FIO_MAX_OPTS];
  48
  49 /*
  50  * Mark children as invisible, if needed.
  51  */
  52 static void gopt_set_children_visible(struct fio_option *parent, gboolean visible)
  53 {
  54         struct fio_option *o;
  55         int i;
  56
  57         /*
  58          * This isn't super fast, but it should not be an issue. If it is, we
  59          * can speed it up by caching the lookup at least. Or we can do it
  60          * once, at init time.
  61          */
  62         for (i = 0; fio_options[i].name; i++) {
  63                 o = &fio_options[i];
  64                 if (!o->parent)
  65                         continue;
  66
  67                 if (strcmp(parent->name, o->parent))
  68                         continue;
  69
  70                 /*
  71                  * This doesn't work for either the box or the widget itself...
  72                  */
  73                 gtk_widget_set_sensitive(widgets[i], visible);
  74         }
  75 }
  76
  77 static void gopt_str_changed(GtkEntry *entry, gpointer data)
  78 {
  79         struct gopt_str *s = (struct gopt_str *) data;
  80         struct fio_option *o = &fio_options[s->gopt.opt_index];
  81         const gchar *text;
  82         int set;
  83
  84         text = gtk_entry_get_text(GTK_ENTRY(s->entry));
  85         set = strcmp(text, "") != 0;
  86         gopt_set_children_visible(o, set);
  87 }
  88
  89 static void gopt_mark_index(struct gopt *gopt, GtkWidget *widget, unsigned int idx)
  90 {
  91         gopt->opt_index = idx;
  92         widgets[idx] = widget;
  93 }
  94
  95 static struct gopt *gopt_new_str_store(struct fio_option *o, const char *text, unsigned int idx)
  96 {
  97         struct gopt_str *s;
  98         GtkWidget *label;
  99
 100         s = malloc(sizeof(*s));
 101
 102         s->gopt.box = gtk_hbox_new(FALSE, 3);
 103         label = gtk_label_new(o->name);
 104         gtk_box_pack_start(GTK_BOX(s->gopt.box), label, FALSE, FALSE, 0);
 105
 106         s->entry = gtk_entry_new();
 107         gopt_mark_index(&s->gopt, s->gopt.box, idx);
 108         if (text)
 109                 gtk_entry_set_text(GTK_ENTRY(s->entry), text);
 110         gtk_entry_set_editable(GTK_ENTRY(s->entry), 1);
 111         g_signal_connect(GTK_OBJECT(s->entry), "changed", G_CALLBACK(gopt_str_changed), s);
 112
 113         if (o->def)
 114                 gtk_entry_set_text(GTK_ENTRY(s->entry), o->def);
 115
 116         gtk_box_pack_start(GTK_BOX(s->gopt.box), s->entry, FALSE, FALSE, 0);
 117         return &s->gopt;
 118 }
 119
 120 static void gopt_combo_changed(GtkComboBox *box, gpointer data)
 121 {
 122         struct gopt_combo *c = (struct gopt_combo *) data;
 123         struct fio_option *o = &fio_options[c->gopt.opt_index];
 124
 125         printf("combo %s changed\n", o->name);
 126 }
 127
 128 static struct gopt_combo *__gopt_new_combo(struct fio_option *o, unsigned int idx)
 129 {
 130         struct gopt_combo *c;
 131         GtkWidget *label;
 132
 133         c = malloc(sizeof(*c));
 134
 135         c->gopt.box = gtk_hbox_new(FALSE, 3);
 136         label = gtk_label_new(o->name);
 137         gtk_box_pack_start(GTK_BOX(c->gopt.box), label, FALSE, FALSE, 0);
 138
 139         c->combo = gtk_combo_box_new_text();
 140         gopt_mark_index(&c->gopt, c->gopt.box, idx);
 141         gtk_box_pack_start(GTK_BOX(c->gopt.box), c->combo, FALSE, FALSE, 0);
 142
 143         g_signal_connect(GTK_OBJECT(c->combo), "changed", G_CALLBACK(gopt_combo_changed), c);
 144
 145         return c;
 146 }
 147
 148 static struct gopt *gopt_new_combo_str(struct fio_option *o, const char *text, unsigned int idx)
 149 {
 150         struct gopt_combo *combo;
 151         struct value_pair *vp;
 152         int i, active = 0;
 153
 154         combo = __gopt_new_combo(o, idx);
 155
 156         i = 0;
 157         vp = &o->posval[0];
 158         while (vp->ival) {
 159                 gtk_combo_box_append_text(GTK_COMBO_BOX(combo->combo), vp->ival);
 160                 if (o->def && !strcmp(vp->ival, o->def))
 161                         active = i;
 162                 if (text && !strcmp(vp->ival, text))
 163                         active = i;
 164                 vp++;
 165                 i++;
 166         }
 167
 168         gtk_combo_box_set_active(GTK_COMBO_BOX(combo->combo), active);
 169         return &combo->gopt;
 170 }
 171
 172 static struct gopt *gopt_new_combo_int(struct fio_option *o, unsigned int *ip, unsigned int idx)
 173 {
 174         struct gopt_combo *combo;
 175         struct value_pair *vp;
 176         int i, active = 0;
 177
 178         combo = __gopt_new_combo(o, idx);
 179
 180         i = 0;
 181         vp = &o->posval[0];
 182         while (vp->ival) {
 183                 gtk_combo_box_append_text(GTK_COMBO_BOX(combo->combo), vp->ival);
 184                 if (ip && vp->oval == *ip)
 185                         active = i;
 186                 vp++;
 187                 i++;
 188         }
 189
 190         gtk_combo_box_set_active(GTK_COMBO_BOX(combo->combo), active);
 191         return &combo->gopt;
 192 }
 193
 194 static void gopt_int_changed(GtkSpinButton *spin, gpointer data)
 195 {
 196         struct gopt_int *i = (struct gopt_int *) data;
 197         struct fio_option *o = &fio_options[i->gopt.opt_index];
 198
 199         printf("int %s changed\n", o->name);
 200 }
 201
 202 static struct gopt_int *__gopt_new_int(struct fio_option *o, unsigned long long *p,
 203                                        unsigned int idx)
 204 {
 205         unsigned long long defval;
 206         struct gopt_int *i;
 207         guint maxval, interval;
 208         GtkWidget *label;
 209
 210         i = malloc(sizeof(*i));
 211         i->gopt.box = gtk_hbox_new(FALSE, 3);
 212         label = gtk_label_new(o->name);
 213         gtk_box_pack_start(GTK_BOX(i->gopt.box), label, FALSE, FALSE, 0);
 214
 215         maxval = o->maxval;
 216         if (!maxval)
 217                 maxval = UINT_MAX;
 218
 219         defval = 0;
 220         if (p)
 221                 defval = *p;
 222         else if (o->def) {
 223                 long long val;
 224
 225                 check_str_bytes(o->def, &val, NULL);
 226                 defval = val;
 227         }
 228
 229         interval = 1.0;
 230         if (o->interval)
 231                 interval = o->interval;
 232
 233         i->spin = gtk_spin_button_new_with_range(o->minval, maxval, interval);
 234         gopt_mark_index(&i->gopt, i->gopt.box, idx);
 235         gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(i->spin), GTK_UPDATE_IF_VALID);
 236         gtk_spin_button_set_value(GTK_SPIN_BUTTON(i->spin), defval);
 237
 238         gtk_box_pack_start(GTK_BOX(i->gopt.box), i->spin, FALSE, FALSE, 0);
 239
 240         g_signal_connect(G_OBJECT(i->spin), "value-changed", G_CALLBACK(gopt_int_changed), i);
 241
 242         return i;
 243 }
 244
 245 static struct gopt *gopt_new_int(struct fio_option *o, unsigned int *ip, unsigned int idx)
 246 {
 247         unsigned long long ullp;
 248         struct gopt_int *i;
 249
 250         if (ip) {
 251                 ullp = *ip;
 252                 i = __gopt_new_int(o, &ullp, idx);
 253         } else
 254                 i = __gopt_new_int(o, NULL, idx);
 255
 256         return &i->gopt;
 257 }
 258
 259 static struct gopt *gopt_new_ullong(struct fio_option *o, unsigned long long *p,
 260                                     unsigned int idx)
 261 {
 262         struct gopt_int *i;
 263
 264         i = __gopt_new_int(o, p, idx);
 265         return &i->gopt;
 266 }
 267
 268 static void gopt_bool_toggled(GtkToggleButton *button, gpointer data)
 269 {
 270         struct gopt_bool *b = (struct gopt_bool *) data;
 271         struct fio_option *o = &fio_options[b->gopt.opt_index];
 272         gboolean set;
 273
 274         set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b->check));
 275         gopt_set_children_visible(o, set);
 276 }
 277
 278 static struct gopt *gopt_new_bool(struct fio_option *o, unsigned int *val, unsigned int idx)
 279 {
 280         struct gopt_bool *b;
 281         GtkWidget *label;
 282         int defstate = 0;
 283
 284         b = malloc(sizeof(*b));
 285         b->gopt.box = gtk_hbox_new(FALSE, 3);
 286         label = gtk_label_new(o->name);
 287         gtk_box_pack_start(GTK_BOX(b->gopt.box), label, FALSE, FALSE, 0);
 288
 289         b->check = gtk_check_button_new();
 290         gopt_mark_index(&b->gopt, b->gopt.box, idx);
 291         if (val)
 292                 defstate = *val;
 293         else if (o->def && !strcmp(o->def, "1"))
 294                 defstate = 1;
 295
 296         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b->check), defstate);
 297         g_signal_connect(G_OBJECT(b->check), "toggled", G_CALLBACK(gopt_bool_toggled), b);
 298
 299         gtk_box_pack_start(GTK_BOX(b->gopt.box), b->check, FALSE, FALSE, 0);
 300         return &b->gopt;
 301 }
 302
 303 /*
 304  * These are paired 0/1 and 2/3. 0/2 are min values, 1/3 are max values.
 305  * If the max is made smaller than min, adjust min down.
 306  * If the min is made larger than max, adjust the max.
 307  */
 308 static void range_value_changed(GtkSpinButton *spin, gpointer data)
 309 {
 310         struct gopt_range *r = (struct gopt_range *) data;
 311         int changed = -1, i;
 312         gint val, mval;
 313
 314         for (i = 0; i < GOPT_RANGE_SPIN; i++) {
 315                 if (GTK_SPIN_BUTTON(r->spins[i]) == spin) {
 316                         changed = i;
 317                         break;
 318                 }
 319         }
 320
 321         assert(changed != -1);
 322
 323         /*
 324          * Min changed
 325          */
 326         if (changed == 0 || changed == 2) {
 327                 GtkWidget *mspin = r->spins[changed + 1];
 328
 329                 val = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(r->spins[changed]));
 330                 mval = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(mspin));
 331                 if (val > mval)
 332                         gtk_spin_button_set_value(GTK_SPIN_BUTTON(mspin), val);
 333         } else {
 334                 GtkWidget *mspin = r->spins[changed - 1];
 335
 336                 val = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(r->spins[changed]));
 337                 mval = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(mspin));
 338                 if (val < mval)
 339                         gtk_spin_button_set_value(GTK_SPIN_BUTTON(mspin), val);
 340         }
 341 }
 342
 343 static struct gopt *gopt_new_int_range(struct fio_option *o, unsigned int **ip,
 344                                        unsigned int idx)
 345 {
 346         struct gopt_range *r;
 347         gint maxval, defval;
 348         GtkWidget *label;
 349         guint interval;
 350         int i;
 351
 352         r = malloc(sizeof(*r));
 353         r->gopt.box = gtk_hbox_new(FALSE, 3);
 354         gopt_mark_index(&r->gopt, r->gopt.box, idx);
 355         label = gtk_label_new(o->name);
 356         gtk_box_pack_start(GTK_BOX(r->gopt.box), label, FALSE, FALSE, 0);
 357
 358         maxval = o->maxval;
 359         if (!maxval)
 360                 maxval = INT_MAX;
 361
 362         defval = 0;
 363         if (o->def) {
 364                 long long val;
 365
 366                 check_str_bytes(o->def, &val, NULL);
 367                 defval = val;
 368         }
 369
 370         interval = 1.0;
 371         if (o->interval)
 372                 interval = o->interval;
 373
 374         for (i = 0; i < GOPT_RANGE_SPIN; i++) {
 375                 r->spins[i] = gtk_spin_button_new_with_range(o->minval, maxval, interval);
 376                 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(r->spins[i]), GTK_UPDATE_IF_VALID);
 377                 if (ip)
 378                         gtk_spin_button_set_value(GTK_SPIN_BUTTON(r->spins[i]), *ip[i]);
 379                 else
 380                         gtk_spin_button_set_value(GTK_SPIN_BUTTON(r->spins[i]), defval);
 381
 382                 gtk_box_pack_start(GTK_BOX(r->gopt.box), r->spins[i], FALSE, FALSE, 0);
 383                 g_signal_connect(G_OBJECT(r->spins[i]), "value-changed", G_CALLBACK(range_value_changed), r);
 384         }
 385
 386         return &r->gopt;
 387 }
 388
 389 static void gopt_add_option(GtkWidget *hbox, struct fio_option *o,
 390                             unsigned int opt_index, struct thread_options *to)
 391 {
 392         struct gopt *go = NULL;
 393
 394         switch (o->type) {
 395         case FIO_OPT_STR_VAL:
 396         case FIO_OPT_STR_VAL_TIME: {
 397                 unsigned long long *ullp = NULL;
 398
 399                 if (o->off1)
 400                         ullp = td_var(to, o->off1);
 401
 402                 go = gopt_new_ullong(o, ullp, opt_index);
 403                 break;
 404                 }
 405         case FIO_OPT_INT: {
 406                 unsigned int *ip = NULL;
 407
 408                 if (o->off1)
 409                         ip = td_var(to, o->off1);
 410
 411                 go = gopt_new_int(o, ip, opt_index);
 412                 break;
 413                 }
 414         case FIO_OPT_STR_SET:
 415         case FIO_OPT_BOOL: {
 416                 unsigned int *ip = NULL;
 417
 418                 if (o->off1)
 419                         ip = td_var(to, o->off1);
 420
 421                 go = gopt_new_bool(o, ip, opt_index);
 422                 break;
 423                 }
 424         case FIO_OPT_STR: {
 425                 unsigned int *ip = NULL;
 426
 427                 if (o->off1)
 428                         ip = td_var(to, o->off1);
 429
 430                 go = gopt_new_combo_int(o, ip, opt_index);
 431                 break;
 432                 }
 433         case FIO_OPT_STR_STORE: {
 434                 char *text = NULL;
 435
 436                 if (o->off1) {
 437                         char **p = td_var(to, o->off1);
 438                         text = *p;
 439                 }
 440
 441                 if (!o->posval[0].ival) {
 442                         go = gopt_new_str_store(o, text, opt_index);
 443                         break;
 444                 }
 445
 446                 go = gopt_new_combo_str(o, text, opt_index);
 447                 break;
 448                 }
 449         case FIO_OPT_STR_MULTI:
 450                 go = gopt_new_combo_str(o, NULL, opt_index);
 451                 break;
 452         case FIO_OPT_RANGE: {
 453                 unsigned int *ip[4] = { td_var(to, o->off1),
 454                                         td_var(to, o->off2),
 455                                         td_var(to, o->off3),
 456                                         td_var(to, o->off4) };
 457
 458                 go = gopt_new_int_range(o, ip, opt_index);
 459                 break;
 460                 }
 461         /* still need to handle this one */
 462         case FIO_OPT_FLOAT_LIST:
 463                 break;
 464         case FIO_OPT_DEPRECATED:
 465                 break;
 466         default:
 467                 printf("ignore type %u\n", o->type);
 468                 break;
 469         }
 470
 471         if (go) {
 472                 if (o->help)
 473                         gtk_widget_set_tooltip_text(go->box, o->help);
 474
 475                 gtk_box_pack_start(GTK_BOX(hbox), go->box, FALSE, FALSE, 5);
 476                 go->opt_type = o->type;
 477         }
 478 }
 479
 480 static void gopt_add_options(GtkWidget **vboxes, struct thread_options *to)
 481 {
 482         GtkWidget *hbox = NULL;
 483         int i;
 484
 485         for (i = 0; fio_options[i].name; i++) {
 486                 struct fio_option *o = &fio_options[i];
 487                 unsigned int mask = o->category;
 488                 struct opt_group *og;
 489
 490                 while ((og = opt_group_from_mask(&mask)) != NULL) {
 491                         GtkWidget *vbox = vboxes[ffz(~og->mask)];
 492
 493                         hbox = gtk_hbox_new(FALSE, 3);
 494                         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
 495                         gopt_add_option(hbox, o, i, to);
 496                 }
 497         }
 498 }
 499
 500 static GtkWidget *gopt_add_group_tab(GtkWidget *notebook, struct opt_group *og)
 501 {
 502         GtkWidget *box, *vbox, *scroll;
 503
 504         scroll = gtk_scrolled_window_new(NULL, NULL);
 505         gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
 506         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 507
 508         vbox = gtk_vbox_new(FALSE, 3);
 509         box = gtk_hbox_new(FALSE, 0);
 510         gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
 511         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
 512         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll, gtk_label_new(og->name));
 513
 514         return vbox;
 515 }
 516
 517 static void gopt_add_group_tabs(GtkWidget *notebook, GtkWidget **vbox)
 518 {
 519         struct opt_group *og;
 520         unsigned int i = 0;
 521
 522         do {
 523                 unsigned int mask = (1U << i);
 524
 525                 og = opt_group_from_mask(&mask);
 526                 if (!og)
 527                         break;
 528                 vbox[i] = gopt_add_group_tab(notebook, og);
 529                 i++;
 530         } while (1);
 531 }
 532
 533 void gopt_get_options_window(GtkWidget *window, struct thread_options *o)
 534 {
 535         GtkWidget *dialog, *notebook;
 536         GtkWidget *vboxes[__FIO_OPT_G_NR];
 537
 538         dialog = gtk_dialog_new_with_buttons("Fio options",
 539                         GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT,
 540                         GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 541                         GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
 542
 543         gtk_widget_set_size_request(GTK_WIDGET(dialog), 1024, 768);
 544
 545         notebook = gtk_notebook_new();
 546         gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
 547         gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
 548         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 5);
 549
 550         gopt_add_group_tabs(notebook, vboxes);
 551
 552         gopt_add_options(vboxes, o);
 553
 554         gtk_widget_show_all(dialog);
 555
 556         gtk_dialog_run(GTK_DIALOG(dialog));
 557
 558         gtk_widget_destroy(dialog);
 559 }