modules/FvwmGtk/dialog.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 #include "config.h"
  18
  19 #include <stdio.h>
  20 #include <unistd.h>
  21
  22 #include <X11/Xlib.h>
  23 #include <X11/keysym.h>
  24 #include <X11/Xutil.h>
  25 #include <X11/Xproto.h>
  26 #include <X11/Xatom.h>
  27 #include <X11/Intrinsic.h>
  28
  29 #include <glib.h>
  30 #include <gtk/gtk.h>
  31 #include <gdk/gdkprivate.h>
  32
  33 #include "libs/fvwmlib.h"
  34 #include "libs/Module.h"
  35
  36 #include "menu.h"
  37 #include "expand.h"
  38
  39 extern int fvwm_fd[2];
  40 extern GHashTable *widgets;
  41 extern GtkWidget *current;
  42 extern unsigned long context;
  43
  44 GSList *radio_group = NULL;
  45 char *group_name = NULL;
  46 GtkWidget *menu = NULL;
  47 int option_menu_items = 0;
  48 int option_menu_active_item = 0;
  49 char *notebook_label = NULL;
  50
  51
  52 gpointer
  53 widget_get_value (GtkWidget *w)
  54 {
  55   static char buf[100];
  56
  57   if (GTK_IS_OPTION_MENU (w))
  58     {
  59       GtkWidget *menu = GTK_OPTION_MENU (w)->menu;
  60       GtkWidget *item;
  61
  62       if (menu == NULL)
  63         return NULL;
  64       item = gtk_menu_get_active (GTK_MENU (menu));
  65       if (item)
  66         {
  67           return gtk_object_get_data (GTK_OBJECT (item), "value");
  68         }
  69       else
  70         {
  71           return NULL;
  72         }
  73     }
  74   else if (GTK_IS_SCALE (w))
  75     {
  76       g_snprintf (buf, sizeof (buf), "%.*f",
  77                   GTK_RANGE (w)->digits,
  78                   gtk_range_get_adjustment (GTK_RANGE (w))->value);
  79       return buf;
  80     }
  81   else if (GTK_IS_COLOR_SELECTION (w))
  82     {
  83       double rgb[3];
  84       unsigned long red, green, blue;
  85
  86       gtk_color_selection_get_color (GTK_COLOR_SELECTION (w), rgb);
  87       red   = rgb[0] * 65536;
  88       if (red >= 65536)
  89         {
  90           red = 65535;
  91         }
  92       green = rgb[1] * 65536;
  93       if (green >= 65536)
  94         {
  95           green = 65535;
  96         }
  97       blue  = rgb[2] * 65536;
  98       if (blue >= 65536)
  99         {
 100           blue = 65535;
 101         }
 102       g_snprintf (buf, sizeof (buf), "rgb:%.4lx/%.4lx/%.4lx",
 103                 red, green, blue);
 104       return buf;
 105     }
 106   else if (GTK_IS_ENTRY (w))
 107     {
 108       /* this also catches spin buttons */
 109       return gtk_entry_get_text (GTK_ENTRY (w));
 110     }
 111   else if (GTK_IS_TOGGLE_BUTTON (w))
 112     {
 113       if (GTK_TOGGLE_BUTTON (w)->active)
 114         {
 115           return gtk_object_get_data (GTK_OBJECT (w), "on-value");
 116         }
 117       else
 118         {
 119           return gtk_object_get_data (GTK_OBJECT (w), "off-value");
 120         }
 121     }
 122
 123   return NULL;
 124 }
 125
 126
 127 /* generic callback added to all data widgets */
 128 static void
 129 update_value (GtkWidget *w)
 130 {
 131   char *val;
 132
 133   val = widget_get_value (w);
 134   if (val)
 135     {
 136       gtk_object_set_data_full (GTK_OBJECT (gtk_widget_get_toplevel (w)),
 137         gtk_widget_get_name (w), safestrdup (val), free);
 138     }
 139 }
 140
 141
 142 static void
 143 add_to_dialog (GtkWidget *w, int argc, char **argv)
 144 {
 145   int i;
 146   gboolean expand = FALSE;
 147   gboolean fill = FALSE;
 148   gboolean focus = FALSE;
 149   gboolean def = FALSE;
 150   gboolean can_def = FALSE;
 151   unsigned int padding = 0;
 152   GtkWidget *dialog;
 153
 154   dialog = gtk_widget_get_toplevel (w);
 155   for (i = argc - 1; i >= 0; i--)
 156     {
 157       if (strcmp (argv[i], "--") == 0)
 158         {
 159           for (i++; i < argc; i++)
 160             {
 161               if (strcasecmp (argv[i], "default") == 0)
 162                 {
 163                   can_def = TRUE;
 164                   def = TRUE;
 165                 }
 166               else if (strcasecmp (argv[i], "can-default") == 0)
 167                 {
 168                   can_def = TRUE;
 169                 }
 170               else if (strcasecmp (argv[i], "focus") == 0)
 171                 {
 172                   focus = TRUE;
 173                 }
 174               else if (strcasecmp (argv[i], "expand") == 0)
 175                 {
 176                   expand = TRUE;
 177                 }
 178               else if (strcasecmp (argv[i], "fill") == 0)
 179                 {
 180                   fill = TRUE;
 181                 }
 182               else
 183                 {
 184                   padding = atoi (argv[i]);
 185                 }
 186             }
 187           break;
 188         }
 189     }
 190   if (GTK_IS_NOTEBOOK (current))
 191     {
 192       gtk_notebook_append_page (GTK_NOTEBOOK (current), w,
 193                                 gtk_label_new (notebook_label));
 194     }
 195   else if (GTK_IS_BOX (current))
 196     {
 197       gtk_box_pack_start (GTK_BOX (current), w, expand, fill, padding);
 198     }
 199   else
 200     {
 201       gtk_container_add (GTK_CONTAINER (current), w);
 202     }
 203   if (focus)
 204     {
 205       gtk_widget_grab_focus (w);
 206     }
 207   if (can_def)
 208     {
 209       GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
 210     }
 211   if (def)
 212     {
 213       gtk_widget_grab_default (w);
 214     }
 215   update_value (w);
 216 }
 217
 218
 219 void
 220 send_values (GtkWidget *w)
 221 {
 222   GtkWidget *dialog;
 223   char **vals;
 224
 225   dialog = gtk_widget_get_toplevel (w);
 226   for (vals = (char **) gtk_object_get_data (GTK_OBJECT (w), "return_values");
 227        *vals; vals++)
 228     {
 229       char *val = recursive_replace (dialog, *vals);
 230       if (strcasecmp (val, "close") == 0)
 231         {
 232           gtk_widget_hide (dialog);
 233         }
 234       else
 235         {
 236           if (val[0] == '!')
 237             {
 238               system (val + 1);
 239             }
 240           else
 241             {
 242               SendText (fvwm_fd, val, context);
 243             }
 244         }
 245       free (val);
 246     }
 247 }
 248
 249 void
 250 open_dialog (int argc, char **argv)
 251 {
 252   GtkWidget *item;
 253   char *name;
 254
 255   g_return_if_fail (argc >= 2);
 256
 257   item = g_hash_table_lookup (widgets, argv[0]);
 258   if (item)
 259     {
 260       name = gtk_widget_get_name (item);
 261     }
 262   else
 263     {
 264       item = gtk_window_new (GTK_WINDOW_DIALOG);
 265       gtk_widget_set_name (item, argv[0]);
 266       name = gtk_widget_get_name (item);
 267       g_hash_table_insert (widgets, name, item);
 268       gtk_object_ref (GTK_OBJECT (item));
 269
 270       gtk_window_set_title (GTK_WINDOW (item), argv[1]);
 271       gtk_window_set_wmclass (GTK_WINDOW (item), argv[1], "FvwmGtk");
 272       gtk_object_set_data
 273         (GTK_OBJECT (item), "values",
 274          g_hash_table_new (g_str_hash, g_str_equal));
 275       gtk_signal_connect
 276         (GTK_OBJECT (item), "delete_event",
 277          GTK_SIGNAL_FUNC (gtk_widget_hide), current);
 278       if (argc >= 3 && strcasecmp ("center", argv[2]) == 0)
 279         {
 280           gtk_window_position (GTK_WINDOW (item), GTK_WIN_POS_CENTER);
 281         }
 282       else
 283         {
 284           gtk_window_position (GTK_WINDOW (item), GTK_WIN_POS_MOUSE);
 285         }
 286       if (argc >= 4)
 287         {
 288           int border_width;
 289
 290           border_width = atoi (argv[3]);
 291
 292           gtk_container_border_width (GTK_CONTAINER (item), border_width);
 293         }
 294     }
 295   if (GTK_IS_MENU (item))
 296     {
 297       fprintf (stderr, "%s is a menu\n", name);
 298     }
 299   current = item;
 300 }
 301
 302
 303 /* this applies to rows, columns and frames */
 304 void
 305 dialog_end_something (int argc, char **argv)
 306 {
 307   g_return_if_fail (current != NULL);
 308   current = GTK_WIDGET (current)->parent;
 309 }
 310
 311
 312 void
 313 dialog_label (int argc, char **argv)
 314 {
 315   GtkWidget *item;
 316
 317   g_return_if_fail (argc >= 1);
 318
 319   item = gtk_label_new (argv[0]);
 320   gtk_widget_show (item);
 321   add_to_dialog (item, argc, argv);
 322 }
 323
 324
 325 void
 326 dialog_notebook (int argc, char **argv)
 327 {
 328   g_return_if_fail (argc >= 1);
 329
 330   if (!GTK_IS_NOTEBOOK (current))
 331     {
 332       GtkWidget *nb = gtk_notebook_new ();
 333       gtk_widget_show (nb);
 334       add_to_dialog (nb, argc, argv);
 335       current = nb;
 336     }
 337   if (notebook_label)
 338     {
 339       free (notebook_label);
 340       notebook_label = NULL;
 341     }
 342   notebook_label = safestrdup (argv[0]);
 343 }
 344
 345
 346 void
 347 dialog_end_notebook (int argc, char **argv)
 348 {
 349   g_return_if_fail (current != NULL);
 350
 351   if (notebook_label)
 352     {
 353       free (notebook_label);
 354       notebook_label = NULL;
 355     }
 356   current = GTK_WIDGET (current)->parent;
 357 }
 358
 359
 360 void
 361 dialog_start_frame (int argc, char **argv)
 362 {
 363   GtkWidget *item;
 364
 365   g_return_if_fail (argc >= 1);
 366
 367   item = gtk_frame_new (argv[0]);
 368   if (argc >= 2)
 369     {
 370       int border_width;
 371
 372       border_width = atoi (argv[1]);
 373
 374       gtk_container_border_width (GTK_CONTAINER (item), border_width);
 375     }
 376   gtk_widget_show (item);
 377   add_to_dialog (item, argc, argv);
 378   current = item;
 379 }
 380
 381
 382 void
 383 dialog_button (int argc, char **argv)
 384 {
 385   GtkWidget *item;
 386   char **vals;
 387   int i;
 388
 389   g_return_if_fail (argc >= 2);
 390
 391   item = gtk_button_new_with_label (argv[0]);
 392
 393   vals = (char **) safemalloc (argc * sizeof (char *));
 394   for (i = 0; i < argc - 1; i++)
 395     {
 396       if (strcmp (argv[i+1], "--") == 0)
 397         {
 398           break;
 399         }
 400       vals[i] = safestrdup(argv[i + 1]);
 401     }
 402   vals[i] = NULL;
 403   gtk_object_set_data (GTK_OBJECT (item), "return_values", vals);
 404   gtk_signal_connect
 405     (GTK_OBJECT (item), "clicked",
 406      GTK_SIGNAL_FUNC (send_values), item);
 407   gtk_widget_show (item);
 408   add_to_dialog (item, argc, argv);
 409 }
 410
 411
 412 void
 413 dialog_checkbutton (int argc, char **argv)
 414 {
 415   GtkWidget *item;
 416
 417   g_return_if_fail (argc >= 4);
 418
 419   item = gtk_check_button_new_with_label (argv[1]);
 420   gtk_widget_set_name (item, argv[0]);
 421   gtk_object_set_data (GTK_OBJECT (item), "on-value", safestrdup (argv[2]));
 422   gtk_object_set_data (GTK_OBJECT (item), "off-value", safestrdup (argv[3]));
 423   if (argc >= 5 && strcasecmp (argv[4], "on") == 0)
 424     {
 425       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (item), TRUE);
 426     }
 427   else
 428     {
 429       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (item), FALSE);
 430     }
 431   gtk_signal_connect
 432     (GTK_OBJECT (item), "toggled",
 433      GTK_SIGNAL_FUNC (update_value), item);
 434
 435   gtk_widget_show (item);
 436   add_to_dialog (item, argc, argv);
 437 }
 438
 439
 440 void
 441 dialog_entry (int argc, char **argv)
 442 {
 443   GtkWidget *item;
 444
 445   g_return_if_fail (argc >= 1);
 446   item = gtk_entry_new ();
 447   gtk_widget_set_name (item, argv[0]);
 448   if (argc >= 2 && strcmp(argv[1], "--") != 0)
 449     {
 450       gtk_entry_set_text (GTK_ENTRY (item), argv[1]);
 451     }
 452   gtk_signal_connect
 453     (GTK_OBJECT (item), "changed",
 454      GTK_SIGNAL_FUNC (update_value), item);
 455   gtk_widget_show (item);
 456   add_to_dialog (item, argc, argv);
 457 }
 458
 459
 460 void
 461 dialog_radiobutton (int argc, char **argv)
 462 {
 463   GtkWidget *item;
 464
 465   g_return_if_fail (argc >= 2);
 466
 467   item = gtk_radio_button_new_with_label (radio_group, argv[0]);
 468   radio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (item));
 469   gtk_widget_set_name (item, group_name);
 470   gtk_object_set_data (GTK_OBJECT (item), "on-value", safestrdup (argv[1]));
 471   if (argc >= 3 && strcasecmp (argv[2], "on") == 0)
 472     {
 473       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (item), TRUE);
 474     }
 475   else
 476     {
 477       gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (item), FALSE);
 478     }
 479   gtk_signal_connect
 480     (GTK_OBJECT (item), "toggled",
 481      GTK_SIGNAL_FUNC (update_value), item);
 482
 483   gtk_widget_show (item);
 484   add_to_dialog (item, argc, argv);
 485 }
 486
 487
 488 void
 489 dialog_start_radiogroup (int argc, char **argv)
 490 {
 491   g_return_if_fail (argc >= 1);
 492
 493   if (group_name)
 494     {
 495       free (group_name);
 496     }
 497   group_name = safestrdup (argv[0]);
 498   radio_group = NULL;
 499 }
 500
 501
 502 void
 503 dialog_end_radiogroup (int argc, char **argv)
 504 {
 505   if (group_name)
 506     {
 507       free (group_name);
 508       group_name = NULL;
 509     }
 510   radio_group = NULL;
 511 }
 512
 513
 514 void
 515 dialog_color (int argc, char **argv)
 516 {
 517   GtkWidget *item;
 518
 519   g_return_if_fail (argc >= 1);
 520
 521   item = gtk_color_selection_new ();
 522   gtk_widget_set_name (item, argv[0]);
 523   if (argc >= 2)
 524     {
 525       XColor color;
 526       /* FIXME: get meaningful colormap */
 527       if (XParseColor (gdk_display,
 528                        DefaultColormap (gdk_display, gdk_screen),
 529                        argv[1],
 530                        &color))
 531         {
 532           double rgb[3];
 533           rgb[0] = (double) color.red   / 65536.0;
 534           rgb[1] = (double) color.green / 65536.0;
 535           rgb[2] = (double) color.blue  / 65536.0;
 536           gtk_color_selection_set_color (GTK_COLOR_SELECTION (item), rgb);
 537         }
 538     }
 539   gtk_signal_connect
 540     (GTK_OBJECT (item), "color_changed",
 541      GTK_SIGNAL_FUNC (update_value), item);
 542   gtk_widget_show (item);
 543   add_to_dialog (item, argc, argv);
 544 }
 545
 546
 547 void
 548 dialog_start_box (int argc, char **argv)
 549 {
 550   GtkWidget *item;
 551   int vertical = 0;
 552   int homogeneous = 0;
 553   int spacing = 0;
 554   unsigned int border_width = 0;
 555   int i;
 556   gboolean read_spacing = TRUE;
 557
 558   for (i = 0; i < argc; i++)
 559     {
 560       if (strcmp (argv[i], "--") == 0)
 561         {
 562           break;
 563         }
 564       else if (strcasecmp (argv[i], "homogeneous") == 0)
 565         {
 566           homogeneous = 1;
 567         }
 568       else if (strcasecmp (argv[i], "vertical") == 0)
 569         {
 570           vertical = 1;
 571         }
 572       else if (read_spacing)
 573         {
 574           spacing = atoi (argv[i]);
 575           read_spacing = FALSE;
 576         }
 577       else
 578         {
 579           border_width = atoi (argv[i]);
 580         }
 581     }
 582
 583   if (vertical)
 584     {
 585       item = gtk_vbox_new (homogeneous, spacing);
 586     }
 587   else
 588     {
 589       item = gtk_hbox_new (homogeneous, spacing);
 590     }
 591   gtk_container_border_width (GTK_CONTAINER (item), border_width);
 592   gtk_widget_show (item);
 593   add_to_dialog (item, argc, argv);
 594   current = item;
 595 }
 596
 597
 598 void
 599 dialog_separator (int argc, char **argv)
 600 {
 601   GtkWidget *item;
 602
 603   if (GTK_IS_HBOX (current))
 604     {
 605       item = gtk_vseparator_new ();
 606     }
 607   else
 608     {
 609       item = gtk_hseparator_new ();
 610     }
 611   gtk_widget_show (item);
 612   add_to_dialog (item, argc, argv);
 613 }
 614
 615
 616 void
 617 dialog_scale (int argc, char **argv)
 618 {
 619   unsigned int vertical = 0;
 620   unsigned int digits = 0;
 621   GtkWidget *item;
 622   GtkObject *adj;
 623   int i;
 624
 625   g_return_if_fail (argc >= 7);
 626
 627   i = 0;
 628   if (argc >= 8)
 629     {
 630       if (strcasecmp (argv[1], "vertical") == 0)
 631         {
 632           vertical = 1;
 633           i = 1;
 634         }
 635       else if (strcasecmp (argv[1], "horizontal") == 0)
 636         {
 637           vertical = 0;
 638           i = 1;
 639         }
 640     }
 641
 642   if (argc >= 8 + i)
 643     {
 644       digits = atoi (argv[i + 7]);
 645     }
 646
 647   adj = gtk_adjustment_new (atof (argv[i + 1]), atof (argv[i + 2]),
 648                             atof (argv[i + 3]), atof (argv[i + 4]),
 649                             atof (argv[i + 5]), atof (argv[i + 6]));
 650   if (vertical)
 651     {
 652       item = gtk_vscale_new (GTK_ADJUSTMENT (adj));
 653     }
 654   else
 655     {
 656       item = gtk_hscale_new (GTK_ADJUSTMENT (adj));
 657     }
 658   gtk_signal_connect_object
 659     (GTK_OBJECT (adj), "value_changed",
 660      GTK_SIGNAL_FUNC (update_value), GTK_OBJECT (item));
 661   gtk_widget_set_name (item, argv[0]);
 662   gtk_scale_set_digits (GTK_SCALE (item), digits);
 663   gtk_widget_show (item);
 664   add_to_dialog (item, argc, argv);
 665 }
 666
 667
 668 void
 669 dialog_spinbutton (int argc, char **argv)
 670 {
 671   GtkWidget *item;
 672   GtkObject *adj;
 673   unsigned int digits = 0;
 674
 675   g_return_if_fail (argc >= 8);
 676
 677   if (argc >= 9)
 678     {
 679       digits = atoi (argv[8]);
 680     }
 681
 682   adj = gtk_adjustment_new (atof (argv[1]), atof (argv[2]),
 683                             atof (argv[3]), atof (argv[4]),
 684                             atof (argv[5]), atof (argv[6]));
 685
 686   item = gtk_spin_button_new (GTK_ADJUSTMENT (adj), atof (argv[7]), digits);
 687   gtk_signal_connect_object
 688     (GTK_OBJECT (adj), "value_changed",
 689      GTK_SIGNAL_FUNC (update_value), GTK_OBJECT (item));
 690   gtk_widget_set_name (item, argv[0]);
 691   gtk_widget_show (item);
 692   add_to_dialog (item, argc, argv);
 693 }
 694
 695
 696 void
 697 dialog_start_option_menu (int argc, char **argv)
 698 {
 699   GtkWidget *item;
 700   g_return_if_fail (argc >= 1);
 701
 702   option_menu_active_item = -1;
 703   option_menu_items = 0;
 704   item = gtk_option_menu_new ();
 705   gtk_widget_set_name (item, argv[0]);
 706   menu = gtk_menu_new ();
 707   gtk_widget_show (menu);
 708   add_to_dialog (item, argc, argv);
 709   current = item;
 710 }
 711
 712
 713 void
 714 dialog_end_option_menu (int argc, char **argv)
 715 {
 716   gtk_signal_connect_object
 717     (GTK_OBJECT (menu), "deactivate",
 718      GTK_SIGNAL_FUNC (update_value), GTK_OBJECT (current));
 719   gtk_option_menu_set_menu (GTK_OPTION_MENU (current), menu);
 720   menu = NULL;
 721   if (option_menu_active_item > 0)
 722    {
 723      gtk_option_menu_set_history (GTK_OPTION_MENU (current),
 724                                   option_menu_active_item);
 725    }
 726   update_value (current);
 727   gtk_widget_show (current);
 728   current = current->parent;
 729 }
 730
 731
 732 void
 733 dialog_option_menu_item (int argc, char **argv)
 734 {
 735   GtkWidget *item;
 736
 737   g_return_if_fail (argc >= 2);
 738
 739   item = menu_item_new_with_pixmap_and_label ("", argv[0], NULL);
 740
 741   gtk_object_set_data (GTK_OBJECT (item), "value", safestrdup (argv[1]));
 742   gtk_widget_show (item);
 743
 744   if (argc >= 3 && strcasecmp (argv[2], "on") == 0)
 745     {
 746        option_menu_active_item = option_menu_items;
 747     }
 748
 749   gtk_menu_append (GTK_MENU (menu), item);
 750   option_menu_items++;
 751 }
 752
 753