gnome/gwidget.c

   1 /*
   2  * Widgets for the GNOME edition of the Midnight Commander
   3  *
   4  * Copyright (C) 1997 The Free Software Foundation
   5  *
   6  * Author: Miguel de Icaza (miguel@gnu.org)
   7  *
   8  */
   9
  10 #include <config.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <ctype.h>
  15 #include "x.h"
  16 #include "gwidget.h"
  17 #include "dlg.h"
  18
  19 GtkWidget *
  20 get_gtk_widget (Widget_Item *p)
  21 {
  22         GtkWidget *w = GTK_WIDGET (p->widget->wdata);
  23
  24         if (GNOME_IS_ENTRY (w))
  25                 return (gnome_entry_gtk_entry ((GnomeEntry *)(w)));
  26         else
  27                 return (GTK_WIDGET (p->widget->wdata));
  28 }
  29
  30 void
  31 x_dialog_stop (Dlg_head *h)
  32 {
  33         if (h->grided & DLG_GNOME_APP)
  34                 return;
  35         gtk_main_quit ();
  36 }
  37
  38 void
  39 x_focus_widget (Widget_Item *p)
  40 {
  41         GtkWidget *w = get_gtk_widget (p);
  42
  43         gtk_widget_grab_focus (w);
  44 }
  45
  46 void
  47 x_unfocus_widget (Widget_Item *p)
  48 {
  49         GtkWidget *w = get_gtk_widget (p);
  50         GtkWidget *toplevel = gtk_widget_get_toplevel (w);
  51
  52         /* Only happens if the widget is not yet added to its container */
  53         /* I am not yet sure why this happens */
  54         if (GTK_IS_WINDOW (toplevel))
  55                 gtk_window_set_focus (GTK_WINDOW (gtk_widget_get_toplevel (w)), NULL);
  56 }
  57
  58 void
  59 x_destroy_cmd (void *w)
  60 {
  61         Widget *widget = (Widget *) w;
  62
  63         if (!widget->wdata)
  64                 return;
  65         gtk_widget_destroy (GTK_WIDGET(widget->wdata));
  66 }
  67
  68 /* Buttons */
  69 static void
  70 gbutton_callback (GtkWidget *w, void *data)
  71 {
  72         WButton *b = data;
  73         Dlg_head *h = (Dlg_head *) b->widget.parent;
  74         int stop = 0;
  75
  76         if (b->callback)
  77                 stop = (*b->callback)(b->action, b->callback_data);
  78
  79         if (!b->callback || stop){
  80                 h->ret_value = b->action;
  81                 dlg_stop (h);
  82         }
  83 }
  84
  85 char *
  86 stock_from_text (char *text)
  87 {
  88         char *stock;
  89
  90         if ( g_strcasecmp (text, _("ok")) == 0)
  91                 stock = GNOME_STOCK_BUTTON_OK;
  92         else if ( g_strcasecmp (text, _("cancel")) == 0)
  93                 stock = GNOME_STOCK_BUTTON_CANCEL;
  94         else if ( g_strcasecmp (text, _("help")) == 0)
  95                 stock = GNOME_STOCK_BUTTON_HELP;
  96         else if ( g_strcasecmp (text, _("yes")) == 0)
  97                 stock = GNOME_STOCK_BUTTON_YES;
  98         else if ( g_strcasecmp (text, _("no")) == 0)
  99                 stock = GNOME_STOCK_BUTTON_NO;
 100         else if ( g_strcasecmp (text, _("exit")) == 0)
 101                 stock = GNOME_STOCK_BUTTON_CLOSE;
 102         else if ( g_strcasecmp (text, _("abort")) == 0)
 103                 stock = GNOME_STOCK_BUTTON_CANCEL;
 104         else
 105                 stock = 0;
 106
 107         return stock;
 108 }
 109
 110 int
 111 x_create_button (Dlg_head *h, widget_data parent, WButton *b)
 112 {
 113         GtkWidget *button;
 114         char *stock;
 115         int tag;
 116
 117         stock = stock_from_text (b->text);
 118
 119         if (stock){
 120                 button = gnome_stock_button (stock);
 121         } else
 122                 button = gtk_button_new_with_label (b->text);
 123
 124         if (b->flags == DEFPUSH_BUTTON){
 125                 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 126                 gtk_widget_grab_default (button);
 127         }
 128         gtk_widget_show (button);
 129         tag = gtk_signal_connect (GTK_OBJECT(button), "clicked", (GtkSignalFunc) gbutton_callback, b);
 130         gtk_object_set_data (GTK_OBJECT (button), "click-signal-tag", (void *) tag);
 131         b->widget.wdata = (widget_data) button;
 132
 133         return 1;
 134 }
 135
 136 static void
 137 x_set_text (GtkWidget *w, gpointer data)
 138 {
 139         if (!GTK_IS_LABEL (w))
 140                 return;
 141         gtk_label_set (GTK_LABEL(w), data);
 142 }
 143
 144 void
 145 x_button_set (WButton *b, char *text)
 146 {
 147         GtkWidget *button = GTK_WIDGET (b->widget.wdata);
 148
 149         gtk_container_foreach (GTK_CONTAINER (button), x_set_text, text);
 150 }
 151
 152 /* Radio buttons */
 153
 154 void
 155 x_radio_focus_item (WRadio *radio)
 156 {
 157         GList  *children = GTK_BOX (radio->widget.wdata)->children;
 158         int    i;
 159
 160         for (i = 0; i < radio->count; i++){
 161                 if (i == radio->pos){
 162                         GtkBoxChild *bc = (GtkBoxChild *) children->data;
 163
 164                         gtk_widget_grab_focus (GTK_WIDGET (bc->widget));
 165                         break;
 166                 }
 167                 children = children->next;
 168         }
 169 }
 170
 171 void
 172 x_radio_toggle (WRadio *radio)
 173 {
 174         GList  *children = GTK_BOX (radio->widget.wdata)->children;
 175         int    i;
 176
 177         for (i = 0; i < radio->count; i++){
 178                 GtkBoxChild *bc = (GtkBoxChild *) children->data;
 179
 180                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bc->widget), (i == radio->sel) ? 1 : 0);
 181                 children = children->next;
 182         }
 183 }
 184
 185 static void
 186 radio_toggle (GtkObject *object, WRadio *r)
 187 {
 188         int idx = (int) gtk_object_get_data (object, "index");
 189
 190         if (!GTK_TOGGLE_BUTTON (object)->active)
 191                 return;
 192
 193         g_return_if_fail (idx != 0);
 194         idx--;
 195         r->sel = idx;
 196 }
 197
 198 static char *
 199 remove_hotkey (char *text)
 200 {
 201         char *t = g_strdup (text);
 202         char *p = strchr (t,'&');
 203
 204         if (p)
 205                 strcpy (p, p+1);
 206
 207         return t;
 208 }
 209
 210 int
 211 x_create_radio (Dlg_head *h, widget_data parent, WRadio *r)
 212 {
 213         GtkWidget *w, *vbox;
 214         int i;
 215
 216         vbox = gtk_vbox_new (0, 0);
 217         for (i = 0; i < r->count; i++){
 218                 char *text = remove_hotkey (_(r->texts [i]));
 219
 220                 if (i == 0){
 221                         w = gtk_radio_button_new_with_label (NULL, text);
 222                         r->first_gtk_radio = w;
 223                 } else
 224                         w = gtk_radio_button_new_with_label_from_widget (r->first_gtk_radio, text);
 225
 226                 g_free (text);
 227                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), (i == r->sel));
 228                 gtk_signal_connect (GTK_OBJECT (w), "toggled", GTK_SIGNAL_FUNC (radio_toggle), r);
 229                 gtk_object_set_data (GTK_OBJECT (w), "index", (void *) (i+1));
 230                 gtk_box_pack_start_defaults (GTK_BOX (vbox), w);
 231         }
 232         gtk_widget_show_all (vbox);
 233
 234         r->widget.wdata = (widget_data) vbox;
 235
 236         return 1;
 237 }
 238
 239 static void
 240 x_check_changed (GtkToggleButton *t, WCheck *c)
 241 {
 242         c->state ^= C_BOOL;
 243         c->state ^= C_CHANGE;
 244 }
 245
 246 /* Check buttons */
 247 int
 248 x_create_check (Dlg_head *h, widget_data parent, WCheck *c)
 249 {
 250         GtkWidget *w;
 251
 252         w = gtk_check_button_new_with_label (c->text);
 253         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), (c->state & C_BOOL));
 254         gtk_signal_connect (GTK_OBJECT (w), "toggled", GTK_SIGNAL_FUNC (x_check_changed), c);
 255         gtk_widget_show (w);
 256         c->widget.wdata = (widget_data) w;
 257         return 1;
 258 }
 259
 260 /* Input lines */
 261 static void
 262 entry_click (GtkWidget *widget, GdkEvent *event, WInput *in)
 263 {
 264         dlg_select_widget (in->widget.parent, in);
 265         in->first = 0;
 266 }
 267
 268 static void
 269 entry_release (GtkEditable *entry, GdkEvent *event, WInput *in)
 270 {
 271         in->point = entry->current_pos;
 272         in->mark  = (entry->current_pos == entry->selection_start_pos) ?
 273                 entry->selection_end_pos : entry->selection_start_pos;
 274         if (in->point != in->mark)
 275                 in->first = 1;
 276 }
 277
 278 int
 279 x_create_input (Dlg_head *h, widget_data parent, WInput *in)
 280 {
 281         GtkWidget *gnome_entry;
 282         GtkEntry *entry;
 283
 284         /* The widget might have been initialized manually.
 285          * Look in gscreen.c for an example
 286          */
 287         if (in->widget.wdata)
 288                 return 1;
 289
 290 #ifdef USE_GNOME_ENTRY
 291         gnome_entry = gnome_entry_new (in->widget.tkname);
 292 #else
 293         entry = GTK_ENTRY (gnome_entry = gtk_entry_new ());
 294         gtk_entry_set_visibility (entry, !in->is_password);
 295 #endif
 296         gtk_widget_show (gnome_entry);
 297         in->widget.wdata = (widget_data) gnome_entry;
 298
 299 #ifdef USE_GNOME_ENTRY
 300         entry = GTK_ENTRY (gnome_entry_gtk_entry (GNOME_ENTRY (gnome_entry)));
 301 #endif
 302         gtk_entry_set_text (entry, in->buffer);
 303         gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
 304         gtk_entry_set_position (entry, in->point);
 305
 306         gtk_signal_connect (GTK_OBJECT (entry), "button_press_event",
 307                             GTK_SIGNAL_FUNC (entry_click), in);
 308
 309         gtk_signal_connect (GTK_OBJECT (entry), "button_release_event",
 310                             GTK_SIGNAL_FUNC (entry_release), in);
 311         return 1;
 312 }
 313
 314 void
 315 x_update_input (WInput *in)
 316 {
 317         GnomeEntry *gnome_entry;
 318         GtkEntry   *entry;
 319         char       *text;
 320         int        draw = 0;
 321
 322         /* If the widget has not been initialized yet (done by WIDGET_INIT) */
 323         if (!in->widget.wdata)
 324                 return;
 325
 326 #ifdef USE_GNOME_ENTRY
 327         gnome_entry = GNOME_ENTRY (in->widget.wdata);
 328         entry = GTK_ENTRY (gnome_entry_gtk_entry (gnome_entry));
 329 #else
 330         entry = GTK_ENTRY (in->widget.wdata);
 331 #endif
 332
 333         if (in->first == -1){
 334                 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 0);
 335                 in->first = 0;
 336         }
 337
 338         text = gtk_entry_get_text (GTK_ENTRY (entry));
 339
 340         if (text && strcmp (text, in->buffer)){
 341                 gtk_entry_set_text (entry, in->buffer);
 342                 draw = 1;
 343         }
 344
 345         if (GTK_EDITABLE (entry)->current_pos != in->point){
 346                 gtk_entry_set_position (entry, in->point);
 347                 draw = 1;
 348         }
 349
 350         if (draw){
 351 #ifdef USE_GNOME_ENTRY
 352                 gtk_widget_draw (GTK_WIDGET (gnome_entry), NULL);
 353 #else
 354                 gtk_widget_draw (GTK_WIDGET (entry), NULL);
 355 #endif
 356                 gtk_editable_changed (GTK_EDITABLE (entry));
 357                 gtk_widget_queue_draw (GTK_WIDGET (entry));
 358         }
 359 }
 360
 361 /* Listboxes */
 362 static GtkWidget *
 363 listbox_pull (widget_data data)
 364 {
 365         return GTK_BIN (data)->child;
 366 }
 367
 368 void
 369 x_listbox_select_nth (WListbox *l, int nth)
 370 {
 371         static int inside;
 372         GtkCList *clist;
 373
 374         if (inside)
 375                 return;
 376
 377         if (!l->widget.wdata)
 378                 return;
 379
 380         inside = 1;
 381         clist = GTK_CLIST (listbox_pull (l->widget.wdata));
 382
 383         gtk_clist_select_row (clist, nth, 0);
 384         if (gtk_clist_row_is_visible (clist, nth) != GTK_VISIBILITY_FULL)
 385                 gtk_clist_moveto (clist, nth, 0, 0.5, 0.0);
 386
 387         inside = 0;
 388 }
 389
 390 void
 391 x_listbox_delete_nth (WListbox *l, int nth)
 392 {
 393         gtk_clist_remove (GTK_CLIST (listbox_pull (l->widget.wdata)), nth);
 394 }
 395
 396 static void
 397 listbox_select (GtkWidget *widget, int row, int column, GdkEvent *event, WListbox *l)
 398 {
 399         Dlg_head *h = l->widget.parent;
 400         static int inside;
 401
 402         if (inside)
 403                 return;
 404         inside = 1;
 405
 406         listbox_select_by_number (l, row);
 407
 408         if (!event){
 409                 inside = 0;
 410                 return;
 411         }
 412
 413
 414         if (event->type == GDK_2BUTTON_PRESS){
 415                 switch (l->action){
 416                 case listbox_nothing:
 417                         break;
 418
 419                 case listbox_finish:
 420                         h->running   = 0;
 421                         h->ret_value = B_ENTER;
 422                         gtk_main_quit ();
 423                         return;
 424
 425                 case listbox_cback:
 426                         if ((*l->cback)(l) == listbox_finish){
 427                                 gtk_main_quit ();
 428                                 return;
 429                         }
 430                 }
 431         }
 432
 433         /* Send an artificial DLG_POST_KEY */
 434         if (event->type == GDK_BUTTON_PRESS)
 435                 (*l->widget.parent->callback)(l->widget.parent, 0, DLG_POST_KEY);
 436
 437         inside = 0;
 438 }
 439
 440 int
 441 x_create_listbox (Dlg_head *h, widget_data parent, WListbox *l)
 442 {
 443         GtkWidget *listbox, *sw;
 444         GtkRequisition req;
 445         WLEntry *p;
 446         int i;
 447
 448         listbox = gtk_clist_new (1);
 449         sw = gtk_scrolled_window_new (NULL, NULL);
 450         gtk_container_add (GTK_CONTAINER (sw), listbox);
 451
 452         gtk_clist_set_selection_mode (GTK_CLIST (listbox), GTK_SELECTION_BROWSE);
 453         gtk_widget_size_request (listbox, &req);
 454         gtk_widget_set_usize (listbox, req.width, req.height + 20*8);
 455         gtk_signal_connect (GTK_OBJECT (listbox), "select_row",
 456                             GTK_SIGNAL_FUNC (listbox_select), l);
 457         l->widget.wdata = (widget_data) sw;
 458         gtk_widget_show (listbox);
 459
 460         g_warning ("FIXME: actually compute the real size of the listbox");
 461         l->height = 8;
 462
 463         for (p = l->list, i = 0; i < l->count; i++, p = p->next){
 464                 char *text [1];
 465
 466                 text [0] = p->text;
 467                 gtk_clist_append (GTK_CLIST (listbox), text);
 468         }
 469         x_listbox_select_nth (l, l->pos);
 470         return 1;
 471 }
 472
 473 void
 474 x_list_insert (WListbox *l, WLEntry *p, WLEntry *e)
 475 {
 476         int pos = 0, i;
 477         char *text [1];
 478
 479         if (!l->widget.wdata)
 480                 return;
 481
 482         for (i = 0; i < l->count; i++){
 483                 if (p == e)
 484                         break;
 485                 p = p->next;
 486                 pos++;
 487         }
 488
 489         if (p != e){
 490                 printf ("x_list_insert: should not happen!\n");
 491                 return;
 492         }
 493         text [0] = e->text;
 494         gtk_clist_append (GTK_CLIST (listbox_pull (l->widget.wdata)), text);
 495 }
 496
 497 /* Labels */
 498 int
 499 x_create_label (Dlg_head *g, widget_data parent, WLabel *l)
 500 {
 501         GtkWidget *label;
 502
 503         /* Tempo-hack */
 504         if (*l->text == 0){
 505                 if (0)
 506                         label = gtk_label_new (l->widget.tkname);
 507                 else
 508                         label = gtk_label_new ("");
 509         } else
 510                 label = gtk_label_new (l->text);
 511         gtk_widget_show (label);
 512         l->widget.wdata = (widget_data) label;
 513
 514         return 1;
 515 }
 516
 517 void
 518 x_label_set_text (WLabel *label, char *text)
 519 {
 520         if (label->widget.wdata)
 521                 gtk_label_set (GTK_LABEL (label->widget.wdata), text);
 522 }
 523
 524 /* Buttonbar */
 525 static void
 526 buttonbar_clicked (GtkWidget *widget, WButtonBar *bb)
 527 {
 528         GtkBox *box = GTK_BOX (widget->parent);
 529         GList *children = box->children;
 530         int i;
 531
 532         /* Find out which button we are (number) */
 533         for (i = 0; children; children = children->next, i++){
 534                 if (((GtkBoxChild *)children->data)->widget == widget){
 535                         if (bb->labels [i].function)
 536                                 (*bb->labels [i].function)(bb->labels [i].data);
 537                         return;
 538                 }
 539         }
 540         printf ("Mhm, should not happen or The Cow is out\n");
 541 }
 542
 543 int
 544 x_create_buttonbar (Dlg_head *h, widget_data parent, WButtonBar *bb)
 545 {
 546         GtkWidget *hbox;
 547         int i;
 548
 549         hbox = gtk_hbox_new (0, 0);
 550 #if 0
 551         for (i = 0; i < 10; i++){
 552                 char buffer [40];
 553                 GtkButton *b;
 554
 555                 g_snprintf (buffer, sizeof (buffer), "F%d %s", i+1, bb->labels [i].text ? bb->labels [i].text : "      ");
 556                 b = (GtkButton *) gtk_button_new_with_label (buffer);
 557                 gtk_signal_connect (GTK_OBJECT (b), "clicked",
 558                                     GTK_SIGNAL_FUNC (buttonbar_clicked), bb);
 559                 gtk_widget_show (GTK_WIDGET (b));
 560                 gtk_box_pack_start_defaults (GTK_BOX (hbox), (GtkWidget *)b);
 561         }
 562         gtk_widget_show (hbox);
 563 #endif
 564         bb->widget.wdata = (widget_data) hbox;
 565         return 1;
 566 }
 567
 568 void
 569 x_redefine_label (WButtonBar *bb, int idx)
 570 {
 571 #if 0
 572         GtkBox *box = GTK_BOX (bb->widget.wdata);
 573         GtkBoxChild *bc = (GtkBoxChild *)g_list_nth (box->children, idx)->data;
 574         GtkButton *button = GTK_BUTTON (bc->widget);
 575         GtkWidget *label = gtk_label_new (bb->labels [idx].text);
 576
 577         gtk_widget_show (label);
 578         gtk_container_remove (GTK_CONTAINER (button), button->child);
 579         gtk_container_add (GTK_CONTAINER (button), label);
 580 #endif
 581 }
 582
 583 /* Gauges */
 584 int
 585 x_create_gauge (Dlg_head *h, widget_data parent, WGauge *g)
 586 {
 587         GtkWidget *pbar;
 588
 589         pbar = gtk_progress_bar_new ();
 590         gtk_widget_show (pbar);
 591         g->widget.wdata = (widget_data) pbar;
 592
 593         return 1;
 594 }
 595
 596 void
 597 x_gauge_show (WGauge *g)
 598 {
 599         gtk_widget_show (GTK_WIDGET (g->widget.wdata));
 600 }
 601
 602 void
 603 x_gauge_set_value (WGauge *g, int max, int current)
 604 {
 605         gtk_progress_bar_update (GTK_PROGRESS_BAR (g->widget.wdata), ((gfloat) current / (gfloat) max));
 606 }