src/ui_misc.c

   1 /*
   2  * (SLIK) SimpLIstic sKin functions
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 - 2012 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #  include "config.h"
  15 #endif
  16 #include "intl.h"
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include <gtk/gtk.h>
  23 #include <gdk/gdkkeysyms.h>
  24
  25 #include "main.h"
  26 #include "ui_misc.h"
  27
  28 #include "history_list.h"
  29
  30
  31 /*
  32  *-----------------------------------------------------------------------------
  33  * widget and layout utilities
  34  *-----------------------------------------------------------------------------
  35  */
  36
  37 GtkWidget *pref_box_new(GtkWidget *parent_box, gboolean fill,
  38                         GtkOrientation orientation, gboolean padding)
  39 {
  40         GtkWidget *box;
  41
  42         if (orientation == GTK_ORIENTATION_HORIZONTAL)
  43                 {
  44                 box = gtk_hbox_new(FALSE, padding);
  45                 }
  46         else
  47                 {
  48                 box = gtk_vbox_new(FALSE, padding);
  49                 }
  50
  51         gtk_box_pack_start(GTK_BOX(parent_box), box, fill, fill, 0);
  52         gtk_widget_show(box);
  53
  54         return box;
  55 }
  56
  57 GtkWidget *pref_group_new(GtkWidget *parent_box, gboolean fill,
  58                           const gchar *text, GtkOrientation orientation)
  59 {
  60         GtkWidget *box;
  61         GtkWidget *vbox;
  62         GtkWidget *hbox;
  63         GtkWidget *label;
  64
  65         vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
  66
  67         /* add additional spacing if necessary */
  68         if (GTK_IS_VBOX(parent_box) && GTK_BOX(parent_box)->children != NULL)
  69                 {
  70                 pref_spacer(vbox, PREF_PAD_GROUP - PREF_PAD_GAP);
  71                 }
  72
  73         gtk_box_pack_start(GTK_BOX(parent_box), vbox, fill, fill, 0);
  74         gtk_widget_show(vbox);
  75
  76         label = gtk_label_new(text);
  77         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  78         pref_label_bold(label, TRUE, FALSE);
  79
  80         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
  81         gtk_widget_show(label);
  82
  83         hbox = gtk_hbox_new(FALSE, PREF_PAD_INDENT);
  84         gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
  85         gtk_widget_show(hbox);
  86
  87         /* indent using empty box */
  88         pref_spacer(hbox, 0);
  89
  90         if (orientation == GTK_ORIENTATION_HORIZONTAL)
  91                 {
  92                 box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
  93                 }
  94         else
  95                 {
  96                 box = gtk_vbox_new(FALSE, PREF_PAD_GAP);
  97                 }
  98         gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 0);
  99         gtk_widget_show(box);
 100
 101         g_object_set_data(G_OBJECT(box), "pref_group", vbox);
 102
 103         return box;
 104 }
 105
 106 GtkWidget *pref_group_parent(GtkWidget *child)
 107 {
 108         GtkWidget *parent;
 109
 110         parent = child;
 111         while (parent)
 112                 {
 113                 GtkWidget *group;
 114
 115                 group = g_object_get_data(G_OBJECT(parent), "pref_group");
 116                 if (group && GTK_IS_WIDGET(group)) return group;
 117
 118                 parent = gtk_widget_get_parent(parent);
 119                 }
 120
 121         return child;
 122 }
 123
 124 GtkWidget *pref_frame_new(GtkWidget *parent_box, gboolean fill,
 125                           const gchar *text,
 126                           GtkOrientation orientation, gboolean padding)
 127 {
 128         GtkWidget *box;
 129         GtkWidget *frame = NULL;
 130
 131         frame = gtk_frame_new(text);
 132         gtk_box_pack_start(GTK_BOX(parent_box), frame, fill, fill, 0);
 133         gtk_widget_show(frame);
 134
 135         if (orientation == GTK_ORIENTATION_HORIZONTAL)
 136                 {
 137                 box = gtk_hbox_new(FALSE, padding);
 138                 }
 139         else
 140                 {
 141                 box = gtk_vbox_new(FALSE, padding);
 142                 }
 143         gtk_container_add(GTK_CONTAINER(frame), box);
 144         gtk_container_set_border_width(GTK_CONTAINER(box), PREF_PAD_BORDER);
 145         gtk_widget_show(box);
 146
 147         return box;
 148 }
 149
 150 GtkWidget *pref_spacer(GtkWidget *parent_box, gboolean padding)
 151 {
 152         GtkWidget *spacer;
 153
 154         spacer = gtk_hbox_new(FALSE, 0);
 155         gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
 156         gtk_widget_show(spacer);
 157
 158         return spacer;
 159 }
 160
 161 GtkWidget *pref_line(GtkWidget *parent_box, gboolean padding)
 162 {
 163         GtkWidget *spacer;
 164
 165         if (GTK_IS_HBOX(parent_box))
 166                 {
 167                 spacer = gtk_vseparator_new();
 168                 }
 169         else
 170                 {
 171                 spacer = gtk_hseparator_new();
 172                 }
 173
 174         gtk_box_pack_start(GTK_BOX(parent_box), spacer, FALSE, FALSE, padding / 2);
 175         gtk_widget_show(spacer);
 176
 177         return spacer;
 178 }
 179
 180 GtkWidget *pref_label_new(GtkWidget *parent_box, const gchar *text)
 181 {
 182         GtkWidget *label;
 183
 184         label = gtk_label_new(text);
 185         gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
 186         gtk_widget_show(label);
 187
 188         return label;
 189 }
 190
 191 GtkWidget *pref_label_new_mnemonic(GtkWidget *parent_box, const gchar *text, GtkWidget *widget)
 192 {
 193         GtkWidget *label;
 194
 195         label = gtk_label_new_with_mnemonic(text);
 196         gtk_label_set_mnemonic_widget(GTK_LABEL(label), widget);
 197         gtk_box_pack_start(GTK_BOX(parent_box), label, FALSE, FALSE, 0);
 198         gtk_widget_show(label);
 199
 200         return label;
 201 }
 202
 203 void pref_label_bold(GtkWidget *label, gboolean bold, gboolean increase_size)
 204 {
 205         PangoAttrList *pal;
 206         PangoAttribute *pa;
 207
 208         if (!bold && !increase_size) return;
 209
 210         pal = pango_attr_list_new();
 211
 212         if (bold)
 213                 {
 214                 pa = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
 215                 pa->start_index = 0;
 216                 pa->end_index = G_MAXINT;
 217                 pango_attr_list_insert(pal, pa);
 218                 }
 219
 220         if (increase_size)
 221                 {
 222                 pa = pango_attr_scale_new(PANGO_SCALE_LARGE);
 223                 pa->start_index = 0;
 224                 pa->end_index = G_MAXINT;
 225                 pango_attr_list_insert(pal, pa);
 226                 }
 227
 228         gtk_label_set_attributes(GTK_LABEL(label), pal);
 229         pango_attr_list_unref(pal);
 230 }
 231
 232 GtkWidget *pref_button_new(GtkWidget *parent_box, const gchar *stock_id,
 233                            const gchar *text, gboolean hide_stock_text,
 234                            GCallback func, gpointer data)
 235 {
 236         GtkWidget *button;
 237
 238         if (stock_id && !text && !hide_stock_text)
 239                 {
 240                 button = gtk_button_new_from_stock(stock_id);
 241                 }
 242         else
 243                 {
 244                 GtkWidget *image = NULL;
 245                 GtkWidget *label = NULL;
 246
 247                 button = gtk_button_new();
 248
 249                 if (stock_id) image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_BUTTON);
 250                 if (text)
 251                         {
 252                         label = gtk_label_new_with_mnemonic(text);
 253                         gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
 254                         gtk_label_set_mnemonic_widget(GTK_LABEL(label), button);
 255                         }
 256
 257                 if (image && label)
 258                         {
 259                         GtkWidget *align;
 260                         GtkWidget *hbox;
 261
 262                         hbox = gtk_hbox_new(FALSE, PREF_PAD_BUTTON_ICON_GAP);
 263
 264                         align = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
 265                         gtk_container_add(GTK_CONTAINER(button), align);
 266                         gtk_widget_show(align);
 267
 268                         gtk_container_add(GTK_CONTAINER(align), hbox);
 269                         gtk_widget_show(hbox);
 270
 271                         gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
 272                         gtk_box_pack_end(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 273                         }
 274                 else
 275                         {
 276                         if (image)
 277                                 {
 278                                 gtk_container_add(GTK_CONTAINER(button), image);
 279                                 }
 280                         else if (label)
 281                                 {
 282                                 gtk_container_add(GTK_CONTAINER(button), label);
 283                                 }
 284                         }
 285
 286                 if (image) gtk_widget_show(image);
 287                 if (label) gtk_widget_show(label);
 288                 }
 289
 290         if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
 291
 292         if (parent_box)
 293                 {
 294                 gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
 295                 gtk_widget_show(button);
 296                 }
 297
 298         return button;
 299 }
 300
 301 static GtkWidget *real_pref_checkbox_new(GtkWidget *parent_box, const gchar *text, gboolean mnemonic_text,
 302                                          gboolean active, GCallback func, gpointer data)
 303 {
 304         GtkWidget *button;
 305
 306         if (mnemonic_text)
 307                 {
 308                 button = gtk_check_button_new_with_mnemonic(text);
 309                 }
 310         else
 311                 {
 312                 button = gtk_check_button_new_with_label(text);
 313                 }
 314         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
 315         if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
 316
 317         gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
 318         gtk_widget_show(button);
 319
 320         return button;
 321 }
 322
 323 GtkWidget *pref_checkbox_new(GtkWidget *parent_box, const gchar *text, gboolean active,
 324                              GCallback func, gpointer data)
 325 {
 326         return real_pref_checkbox_new(parent_box, text, FALSE, active, func, data);
 327 }
 328
 329 GtkWidget *pref_checkbox_new_mnemonic(GtkWidget *parent_box, const gchar *text, gboolean active,
 330                                       GCallback func, gpointer data)
 331 {
 332         return real_pref_checkbox_new(parent_box, text, TRUE, active, func, data);
 333 }
 334
 335 static void pref_checkbox_int_cb(GtkWidget *widget, gpointer data)
 336 {
 337         gboolean *result = data;
 338
 339         *result = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 340 }
 341
 342 GtkWidget *pref_checkbox_new_int(GtkWidget *parent_box, const gchar *text, gboolean active,
 343                                  gboolean *result)
 344 {
 345         GtkWidget *button;
 346
 347         button = pref_checkbox_new(parent_box, text, active,
 348                                    G_CALLBACK(pref_checkbox_int_cb), result);
 349         *result = active;
 350
 351         return button;
 352 }
 353
 354 static void pref_checkbox_link_sensitivity_cb(GtkWidget *button, gpointer data)
 355 {
 356         GtkWidget *widget = data;
 357
 358         gtk_widget_set_sensitive(widget, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
 359 }
 360
 361 void pref_checkbox_link_sensitivity(GtkWidget *button, GtkWidget *widget)
 362 {
 363         g_signal_connect(G_OBJECT(button), "toggled",
 364                          G_CALLBACK(pref_checkbox_link_sensitivity_cb), widget);
 365
 366         pref_checkbox_link_sensitivity_cb(button, widget);
 367 }
 368
 369 static void pref_checkbox_link_sensitivity_swap_cb(GtkWidget *button, gpointer data)
 370 {
 371         GtkWidget *widget = data;
 372
 373         gtk_widget_set_sensitive(widget, !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
 374 }
 375
 376 void pref_checkbox_link_sensitivity_swap(GtkWidget *button, GtkWidget *widget)
 377 {
 378         g_signal_connect(G_OBJECT(button), "toggled",
 379                          G_CALLBACK(pref_checkbox_link_sensitivity_swap_cb), widget);
 380
 381         pref_checkbox_link_sensitivity_swap_cb(button, widget);
 382 }
 383
 384 static GtkWidget *real_pref_radiobutton_new(GtkWidget *parent_box, GtkWidget *sibling,
 385                                             const gchar *text, gboolean mnemonic_text, gboolean active,
 386                                             GCallback func, gpointer data)
 387 {
 388         GtkWidget *button;
 389         GSList *group;
 390
 391         if (sibling)
 392                 {
 393                 group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(sibling));
 394                 }
 395         else
 396                 {
 397                 group = NULL;
 398                 }
 399
 400         if (mnemonic_text)
 401                 {
 402                 button = gtk_radio_button_new_with_mnemonic(group, text);
 403                 }
 404         else
 405                 {
 406                 button = gtk_radio_button_new_with_label(group, text);
 407                 }
 408
 409         if (active) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
 410         if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
 411
 412         gtk_box_pack_start(GTK_BOX(parent_box), button, FALSE, FALSE, 0);
 413         gtk_widget_show(button);
 414
 415         return button;
 416 }
 417
 418 GtkWidget *pref_radiobutton_new(GtkWidget *parent_box, GtkWidget *sibling,
 419                                 const gchar *text, gboolean active,
 420                                 GCallback func, gpointer data)
 421 {
 422         return real_pref_radiobutton_new(parent_box, sibling, text, FALSE, active, func, data);
 423 }
 424
 425 GtkWidget *pref_radiobutton_new_mnemonic(GtkWidget *parent_box, GtkWidget *sibling,
 426                                          const gchar *text, gboolean active,
 427                                          GCallback func, gpointer data)
 428 {
 429         return real_pref_radiobutton_new(parent_box, sibling, text, TRUE, active, func, data);
 430 }
 431
 432 #define PREF_RADIO_VALUE_KEY "pref_radio_value"
 433
 434 static void pref_radiobutton_int_cb(GtkWidget *widget, gpointer data)
 435 {
 436         gboolean *result = data;
 437
 438         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
 439                 {
 440                 *result = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), PREF_RADIO_VALUE_KEY));
 441                 }
 442 }
 443
 444 GtkWidget *pref_radiobutton_new_int(GtkWidget *parent_box, GtkWidget *sibling,
 445                                     const gchar *text, gboolean active,
 446                                     gboolean *result, gboolean value,
 447                                     GCallback func, gpointer data)
 448 {
 449         GtkWidget *button;
 450
 451         button = pref_radiobutton_new(parent_box, sibling, text, active,
 452                                       G_CALLBACK(pref_radiobutton_int_cb), result);
 453         g_object_set_data(G_OBJECT(button), PREF_RADIO_VALUE_KEY, GINT_TO_POINTER(value));
 454         if (active) *result = value;
 455
 456         return button;
 457 }
 458
 459 static GtkWidget *real_pref_spin_new(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
 460                                      gboolean mnemonic_text,
 461                                      gdouble min, gdouble max, gdouble step, gint digits,
 462                                      gdouble value,
 463                                      GCallback func, gpointer data)
 464 {
 465         GtkWidget *spin;
 466         GtkWidget *box;
 467         GtkWidget *label;
 468
 469         box = pref_box_new(parent_box, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 470
 471         spin = gtk_spin_button_new_with_range(min, max, step);
 472         gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), digits);
 473         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
 474
 475         if (func)
 476                 {
 477                 g_signal_connect(G_OBJECT(spin), "value_changed", G_CALLBACK(func), data);
 478                 }
 479
 480         if (text)
 481                 {
 482                 if (mnemonic_text)
 483                         {
 484                         label = pref_label_new_mnemonic(box, text, spin);
 485                         }
 486                 else
 487                         {
 488                         label = pref_label_new(box, text);
 489                         }
 490                 pref_link_sensitivity(label, spin);
 491                 }
 492
 493         gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
 494         gtk_widget_show(spin);
 495
 496         /* perhaps this should only be PREF_PAD_GAP distance from spinbutton ? */
 497         if (suffix)
 498                 {
 499                 label =  pref_label_new(box, suffix);
 500                 pref_link_sensitivity(label, spin);
 501                 }
 502
 503         return spin;
 504 }
 505
 506 GtkWidget *pref_spin_new(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
 507                          gdouble min, gdouble max, gdouble step, gint digits,
 508                          gdouble value,
 509                          GCallback func, gpointer data)
 510 {
 511         return real_pref_spin_new(parent_box, text, suffix, FALSE,
 512                                   min, max, step, digits, value, func, data);
 513 }
 514
 515 GtkWidget *pref_spin_new_mnemonic(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
 516                                   gdouble min, gdouble max, gdouble step, gint digits,
 517                                   gdouble value,
 518                                   GCallback func, gpointer data)
 519 {
 520         return real_pref_spin_new(parent_box, text, suffix, TRUE,
 521                                   min, max, step, digits, value, func, data);
 522 }
 523
 524 static void pref_spin_int_cb(GtkWidget *widget, gpointer data)
 525 {
 526         gint *var = data;
 527         *var = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
 528 }
 529
 530 GtkWidget *pref_spin_new_int(GtkWidget *parent_box, const gchar *text, const gchar *suffix,
 531                              gint min, gint max, gint step,
 532                              gint value, gint *value_var)
 533 {
 534         *value_var = value;
 535         return pref_spin_new(parent_box, text, suffix,
 536                              (gdouble)min, (gdouble)max, (gdouble)step, 0,
 537                              value,
 538                              G_CALLBACK(pref_spin_int_cb), value_var);
 539 }
 540
 541 #if 0
 542 void pref_spin_set_blocking(GtkWidget *spin, gdouble value, gpointer block_data)
 543 {
 544         g_signal_handlers_block_matched(G_OBJECT(spin), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, block_data);
 545         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
 546         g_signal_handlers_unblock_matched(G_OBJECT(spin), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, block_data);
 547 }
 548 #endif
 549
 550 static void pref_link_sensitivity_cb(GtkWidget *watch, GtkStateType prev_state, gpointer data)
 551 {
 552         GtkWidget *widget = data;
 553
 554 #if GTK_CHECK_VERSION(2,20,0)
 555         gtk_widget_set_sensitive(widget, gtk_widget_is_sensitive(watch));
 556 #else
 557         gtk_widget_set_sensitive(widget, GTK_WIDGET_IS_SENSITIVE(watch));
 558 #endif
 559 }
 560
 561 void pref_link_sensitivity(GtkWidget *widget, GtkWidget *watch)
 562 {
 563         g_signal_connect(G_OBJECT(watch), "state_changed",
 564                          G_CALLBACK(pref_link_sensitivity_cb), widget);
 565 }
 566
 567 void pref_signal_block_data(GtkWidget *widget, gpointer data)
 568 {
 569         g_signal_handlers_block_matched(widget, G_SIGNAL_MATCH_DATA,
 570                                         0, 0, NULL, NULL, data);
 571 }
 572
 573 void pref_signal_unblock_data(GtkWidget *widget, gpointer data)
 574 {
 575         g_signal_handlers_unblock_matched(widget, G_SIGNAL_MATCH_DATA,
 576                                           0, 0, NULL, NULL, data);
 577 }
 578
 579 GtkWidget *pref_table_new(GtkWidget *parent_box, gint columns, gint rows,
 580                           gboolean homogeneous, gboolean fill)
 581 {
 582         GtkWidget *table;
 583
 584         table = gtk_table_new(rows, columns, homogeneous);
 585         gtk_table_set_row_spacings(GTK_TABLE(table), PREF_PAD_GAP);
 586         gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_SPACE);
 587
 588         if (parent_box)
 589                 {
 590                 gtk_box_pack_start(GTK_BOX(parent_box), table, fill, fill, 0);
 591                 gtk_widget_show(table);
 592                 }
 593
 594         return table;
 595 }
 596
 597 GtkWidget *pref_table_box(GtkWidget *table, gint column, gint row,
 598                           GtkOrientation orientation, const gchar *text)
 599 {
 600         GtkWidget *box;
 601         GtkWidget *shell;
 602
 603         if (text)
 604                 {
 605                 shell = gtk_vbox_new(FALSE, 0);
 606                 box = pref_group_new(shell, TRUE, text, orientation);
 607                 }
 608         else
 609                 {
 610                 if (orientation == GTK_ORIENTATION_HORIZONTAL)
 611                         {
 612                         box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
 613                         }
 614                 else
 615                         {
 616                         box = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 617                         }
 618                 shell = box;
 619                 }
 620
 621         gtk_table_attach(GTK_TABLE(table), shell, column, column + 1, row, row + 1,
 622                          GTK_EXPAND | GTK_FILL, 0, 0, 0);
 623
 624         gtk_widget_show(shell);
 625
 626         return box;
 627 }
 628
 629 GtkWidget *pref_table_label(GtkWidget *table, gint column, gint row,
 630                             const gchar *text, gfloat alignment)
 631 {
 632         GtkWidget *label;
 633         GtkWidget *align;
 634
 635         align = gtk_alignment_new(alignment, 0.50, 0.0, 0.0);
 636         gtk_table_attach(GTK_TABLE(table), align, column, column + 1, row, row + 1,
 637                          GTK_FILL, 0, 0, 0);
 638         gtk_widget_show(align);
 639         label = gtk_label_new(text);
 640         gtk_container_add(GTK_CONTAINER(align), label);
 641         gtk_widget_show(label);
 642
 643         return label;
 644 }
 645
 646 GtkWidget *pref_table_button(GtkWidget *table, gint column, gint row,
 647                              const gchar *stock_id, const gchar *text, gboolean hide_stock_text,
 648                              GCallback func, gpointer data)
 649 {
 650         GtkWidget *button;
 651
 652         button = pref_button_new(NULL, stock_id, text, hide_stock_text, func, data);
 653         gtk_table_attach(GTK_TABLE(table), button, column, column + 1, row, row + 1,
 654                          GTK_FILL, 0, 0, 0);
 655         gtk_widget_show(button);
 656
 657         return button;
 658 }
 659
 660 #if 0
 661 static GtkWidget *pref_table_checkbox(GtkWidget *table, gint column, gint row,
 662                                       const gchar *text, gint active,
 663                                       GCallback func, gpointer data)
 664 {
 665         GtkWidget *button;
 666
 667         button = gtk_check_button_new_with_label(text);
 668         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
 669         if (func) g_signal_connect(G_OBJECT(button), "clicked", func, data);
 670
 671         gtk_table_attach(GTK_TABLE(table), button, column, column + 1, row, row + 1,
 672                          GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 673         gtk_widget_show(button);
 674
 675         return button;
 676 }
 677 #endif
 678
 679 GtkWidget *pref_table_spin(GtkWidget *table, gint column, gint row,
 680                            const gchar *text, const gchar *suffix,
 681                            gdouble min, gdouble max, gdouble step, gint digits,
 682                            gdouble value,
 683                            GCallback func, gpointer data)
 684 {
 685         GtkWidget *spin;
 686         GtkWidget *box;
 687         GtkWidget *label;
 688
 689         spin = gtk_spin_button_new_with_range(min, max, step);
 690         gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), digits);
 691         gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
 692         if (func)
 693                 {
 694                 g_signal_connect(G_OBJECT(spin), "value_changed", G_CALLBACK(func), data);
 695                 }
 696
 697         if (text)
 698                 {
 699                 label = pref_table_label(table, column, row, text, 1.0);
 700                 pref_link_sensitivity(label, spin);
 701                 column++;
 702                 }
 703
 704         if (suffix)
 705                 {
 706                 box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
 707                 gtk_box_pack_start(GTK_BOX(box), spin, FALSE, FALSE, 0);
 708                 gtk_widget_show(spin);
 709
 710                 label = pref_label_new(box, suffix);
 711                 pref_link_sensitivity(label, spin);
 712                 }
 713         else
 714                 {
 715                 box = spin;
 716                 }
 717
 718         gtk_table_attach(GTK_TABLE(table), box, column, column + 1, row, row + 1,
 719                          GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 720         gtk_widget_show(box);
 721
 722         return spin;
 723 }
 724
 725 GtkWidget *pref_table_spin_new_int(GtkWidget *table, gint column, gint row,
 726                                    const gchar *text, const gchar *suffix,
 727                                    gint min, gint max, gint step,
 728                                    gint value, gint *value_var)
 729 {
 730         *value_var = value;
 731         return pref_table_spin(table, column, row,
 732                                text, suffix,
 733                                (gdouble)min, (gdouble)max, (gdouble)step, 0,
 734                                value,
 735                                G_CALLBACK(pref_spin_int_cb), value_var);
 736 }
 737
 738
 739 #if ! GTK_CHECK_VERSION(2,12,0)
 740
 741 static void pref_toolbar_destroy_cb(GtkWidget *widget, gpointer data)
 742 {
 743         GtkTooltips *tips = data;
 744
 745         g_object_unref(G_OBJECT(tips));
 746 }
 747
 748 #endif
 749
 750 GtkWidget *pref_toolbar_new(GtkWidget *parent_box, GtkToolbarStyle style)
 751 {
 752         GtkWidget *tbar;
 753 #if ! GTK_CHECK_VERSION(2,12,0)
 754         GtkTooltips *tips;
 755 #endif
 756
 757         tbar = gtk_toolbar_new();
 758         gtk_toolbar_set_style(GTK_TOOLBAR(tbar), style);
 759
 760         if (parent_box)
 761                 {
 762                 gtk_box_pack_start(GTK_BOX(parent_box), tbar, FALSE, FALSE, 0);
 763                 gtk_widget_show(tbar);
 764                 }
 765
 766 #if ! GTK_CHECK_VERSION(2,12,0)
 767         tips = gtk_tooltips_new();
 768
 769         /* take ownership of tooltips */
 770 #  ifdef GTK_OBJECT_FLOATING
 771         /* GTK+ < 2.10 */
 772         g_object_ref(G_OBJECT(tips));
 773         gtk_object_sink(GTK_OBJECT(tips));
 774 #  else
 775         /* GTK+ >= 2.10 */
 776         g_object_ref_sink(G_OBJECT(tips));
 777 #  endif
 778
 779         g_object_set_data(G_OBJECT(tbar), "tooltips", tips);
 780         g_signal_connect(G_OBJECT(tbar), "destroy",
 781                          G_CALLBACK(pref_toolbar_destroy_cb), tips);
 782
 783         gtk_tooltips_enable(tips);
 784 #endif
 785
 786         return tbar;
 787 }
 788
 789 GtkWidget *pref_toolbar_button(GtkWidget *toolbar,
 790                                const gchar *stock_id, const gchar *label, gboolean toggle,
 791                                const gchar *description,
 792                                GCallback func, gpointer data)
 793 {
 794         GtkWidget *item;
 795
 796         if (toggle)
 797                 {
 798                 if (stock_id)
 799                         {
 800                         item = GTK_WIDGET(gtk_toggle_tool_button_new_from_stock(stock_id));
 801                         }
 802                 else
 803                         {
 804                         item = GTK_WIDGET(gtk_toggle_tool_button_new());
 805                         }
 806                 }
 807         else
 808                 {
 809                 if (stock_id)
 810                         {
 811                         item = GTK_WIDGET(gtk_tool_button_new_from_stock(stock_id));
 812                         }
 813                 else
 814                         {
 815                         item = GTK_WIDGET(gtk_tool_button_new(NULL, NULL));
 816                         }
 817                 }
 818         gtk_tool_button_set_use_underline(GTK_TOOL_BUTTON(item), TRUE);
 819
 820         if (label) gtk_tool_button_set_label(GTK_TOOL_BUTTON(item), label);
 821
 822         if (func) g_signal_connect(item, "clicked", func, data);
 823         gtk_container_add(GTK_CONTAINER(toolbar), item);
 824         gtk_widget_show(item);
 825
 826         if (description)
 827                 {
 828
 829 #if GTK_CHECK_VERSION(2,12,0)
 830
 831                 gtk_widget_set_tooltip_text(item, description);
 832
 833 #else
 834                 GtkTooltips *tips;
 835
 836                 tips = g_object_get_data(G_OBJECT(toolbar), "tooltips");
 837                 gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(item), tips, description, NULL);
 838 #endif
 839         }
 840
 841         return item;
 842 }
 843
 844 void pref_toolbar_button_set_icon(GtkWidget *button, GtkWidget *widget, const gchar *stock_id)
 845 {
 846         if (widget)
 847                 {
 848                 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button), widget);
 849                 }
 850         else if (stock_id)
 851                 {
 852                 gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(button), stock_id);
 853                 }
 854 }
 855
 856 GtkWidget *pref_toolbar_spacer(GtkWidget *toolbar)
 857 {
 858         GtkWidget *item;
 859
 860         item = GTK_WIDGET(gtk_separator_tool_item_new());
 861         gtk_container_add(GTK_CONTAINER(toolbar), item);
 862         gtk_widget_show(item);
 863
 864         return item;
 865 }
 866
 867
 868 /*
 869  *-----------------------------------------------------------------------------
 870  * date selection entry
 871  *-----------------------------------------------------------------------------
 872  */
 873
 874 #define DATE_SELECION_KEY "date_selection_data"
 875
 876
 877 typedef struct _DateSelection DateSelection;
 878 struct _DateSelection
 879 {
 880         GtkWidget *box;
 881
 882         GtkWidget *spin_d;
 883         GtkWidget *spin_m;
 884         GtkWidget *spin_y;
 885
 886         GtkWidget *button;
 887
 888         GtkWidget *window;
 889         GtkWidget *calendar;
 890 };
 891
 892
 893 static void date_selection_popup_hide(DateSelection *ds)
 894 {
 895         if (!ds->window) return;
 896
 897 #if GTK_CHECK_VERSION(2,20,0)
 898         if (gtk_widget_has_grab(ds->window))
 899 #else
 900         if (GTK_WIDGET_HAS_GRAB(ds->window))
 901 #endif
 902                 {
 903                 gtk_grab_remove(ds->window);
 904                 gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 905                 gdk_pointer_ungrab(GDK_CURRENT_TIME);
 906                 }
 907
 908         gtk_widget_hide(ds->window);
 909
 910         gtk_widget_destroy(ds->window);
 911         ds->window = NULL;
 912         ds->calendar = NULL;
 913
 914         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), FALSE);
 915 }
 916
 917 static gboolean date_selection_popup_release_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
 918 {
 919         DateSelection *ds = data;
 920
 921         date_selection_popup_hide(ds);
 922         return TRUE;
 923 }
 924
 925 static gboolean date_selection_popup_press_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
 926 {
 927         DateSelection *ds = data;
 928         gint x, y;
 929         gint w, h;
 930         gint xr, yr;
 931
 932         xr = (gint)event->x_root;
 933         yr = (gint)event->y_root;
 934
 935         gdk_window_get_origin(ds->window->window, &x, &y);
 936         gdk_drawable_get_size(ds->window->window, &w, &h);
 937
 938         if (xr < x || yr < y || xr > x + w || yr > y + h)
 939                 {
 940                 g_signal_connect(G_OBJECT(ds->window), "button_release_event",
 941                                  G_CALLBACK(date_selection_popup_release_cb), ds);
 942                 return TRUE;
 943                 }
 944
 945         return FALSE;
 946 }
 947
 948 static void date_selection_popup_sync(DateSelection *ds)
 949 {
 950         guint day, month, year;
 951
 952         gtk_calendar_get_date(GTK_CALENDAR(ds->calendar), &year, &month, &day);
 953         date_selection_set(ds->box, day, month + 1, year);
 954 }
 955
 956 static gboolean date_selection_popup_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
 957 {
 958         DateSelection *ds = data;
 959
 960         switch (event->keyval)
 961                 {
 962                 case GDK_Return:
 963                 case GDK_KP_Enter:
 964                 case GDK_Tab:
 965                 case GDK_ISO_Left_Tab:
 966                         date_selection_popup_sync(ds);
 967                         date_selection_popup_hide(ds);
 968                         break;
 969                 case GDK_Escape:
 970                         date_selection_popup_hide(ds);
 971                         break;
 972                 default:
 973                         break;
 974                 }
 975
 976         return FALSE;
 977 }
 978
 979 static void date_selection_day_cb(GtkWidget *widget, gpointer data)
 980 {
 981         DateSelection *ds = data;
 982
 983         date_selection_popup_sync(ds);
 984 }
 985
 986 static void date_selection_doubleclick_cb(GtkWidget *widget, gpointer data)
 987 {
 988         DateSelection *ds = data;
 989
 990         date_selection_popup_hide(ds);
 991 }
 992
 993 static void date_selection_popup(DateSelection *ds)
 994 {
 995         gint x, y;
 996         gint wx, wy;
 997         gint day, month, year;
 998
 999         if (ds->window) return;
1000
1001         ds->window = gtk_window_new(GTK_WINDOW_POPUP);
1002         gtk_window_set_resizable(GTK_WINDOW(ds->window), FALSE);
1003         g_signal_connect(G_OBJECT(ds->window), "button_press_event",
1004                          G_CALLBACK(date_selection_popup_press_cb), ds);
1005         g_signal_connect(G_OBJECT(ds->window), "key_press_event",
1006                          G_CALLBACK(date_selection_popup_keypress_cb), ds);
1007
1008         ds->calendar = gtk_calendar_new();
1009         gtk_container_add(GTK_CONTAINER(ds->window), ds->calendar);
1010         gtk_widget_show(ds->calendar);
1011
1012         date_selection_get(ds->box, &day, &month, &year);
1013         gtk_calendar_select_month(GTK_CALENDAR(ds->calendar), month - 1, year);
1014         gtk_calendar_select_day(GTK_CALENDAR(ds->calendar), day);
1015
1016         g_signal_connect(G_OBJECT(ds->calendar), "day_selected",
1017                          G_CALLBACK(date_selection_day_cb), ds);
1018         g_signal_connect(G_OBJECT(ds->calendar), "day_selected_double_click",
1019                         G_CALLBACK(date_selection_doubleclick_cb), ds);
1020
1021         gtk_widget_realize(ds->window);
1022
1023         gdk_window_get_origin(ds->button->window, &wx, &wy);
1024
1025         x = wx + ds->button->allocation.x + ds->button->allocation.width - ds->window->allocation.width;
1026         y = wy + ds->button->allocation.y + ds->button->allocation.height;
1027
1028         if (y + ds->window->allocation.height > gdk_screen_height())
1029                 {
1030                 y = wy + ds->button->allocation.y - ds->window->allocation.height;
1031                 }
1032         if (x < 0) x = 0;
1033         if (y < 0) y = 0;
1034
1035         gtk_window_move(GTK_WINDOW(ds->window), x, y);
1036         gtk_widget_show(ds->window);
1037
1038         gtk_widget_grab_focus(ds->calendar);
1039         gdk_pointer_grab(ds->window->window, TRUE,
1040                          GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK,
1041                          NULL, NULL, GDK_CURRENT_TIME);
1042         gdk_keyboard_grab(ds->window->window, TRUE, GDK_CURRENT_TIME);
1043         gtk_grab_add(ds->window);
1044
1045         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), TRUE);
1046 }
1047
1048 static void date_selection_button_cb(GtkWidget *widget, gpointer data)
1049 {
1050         DateSelection *ds = data;
1051
1052         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ds->button)) == (!ds->window))
1053                 {
1054                 date_selection_popup(ds);
1055                 }
1056 }
1057
1058 static void button_size_allocate_cb(GtkWidget *button, GtkAllocation *allocation, gpointer data)
1059 {
1060         GtkWidget *spin = data;
1061
1062         if (allocation->height > spin->requisition.height)
1063                 {
1064                 GtkAllocation button_allocation;
1065
1066                 button_allocation = button->allocation;
1067                 button_allocation.height = spin->requisition.height;
1068                 button_allocation.y = spin->allocation.y +
1069                         (spin->allocation.height - spin->requisition.height) / 2;
1070                 gtk_widget_size_allocate(button, &button_allocation);
1071                 }
1072 }
1073
1074 static void spin_increase(GtkWidget *spin, gint value)
1075 {
1076         GtkRequisition req;
1077
1078         gtk_widget_size_request(spin, &req);
1079         gtk_widget_set_size_request(spin, req.width + value, -1);
1080 }
1081
1082 static void date_selection_destroy_cb(GtkWidget *widget, gpointer data)
1083 {
1084         DateSelection *ds = data;
1085
1086         date_selection_popup_hide(ds);
1087
1088         g_free(ds);
1089 }
1090
1091 GtkWidget *date_selection_new(void)
1092 {
1093         DateSelection *ds;
1094         GtkWidget *arrow;
1095
1096         ds = g_new0(DateSelection, 1);
1097
1098         ds->box = gtk_hbox_new(FALSE, 2);
1099         g_signal_connect(G_OBJECT(ds->box), "destroy",
1100                          G_CALLBACK(date_selection_destroy_cb), ds);
1101
1102         /* FIXME: use option menu with text format of month instead of a spin button */
1103         ds->spin_m = pref_spin_new(ds->box, NULL, NULL, 1, 12, 1, 0, 1, NULL, NULL);
1104         ds->spin_d = pref_spin_new(ds->box, NULL, NULL, 1, 31, 1, 0, 1, NULL, NULL);
1105         ds->spin_y = pref_spin_new(ds->box, NULL, NULL, 1900, 9999, 1, 0, 1900, NULL, NULL);
1106         spin_increase(ds->spin_y, 5);
1107
1108         ds->button = gtk_toggle_button_new();
1109         g_signal_connect(G_OBJECT(ds->button), "size_allocate",
1110                          G_CALLBACK(button_size_allocate_cb), ds->spin_y);
1111
1112         arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
1113         gtk_container_add(GTK_CONTAINER(ds->button), arrow);
1114         gtk_widget_show(arrow);
1115
1116         gtk_box_pack_start(GTK_BOX(ds->box), ds->button, FALSE, FALSE, 0);
1117         g_signal_connect(G_OBJECT(ds->button), "clicked",
1118                          G_CALLBACK(date_selection_button_cb), ds);
1119         gtk_widget_show(ds->button);
1120
1121         g_object_set_data(G_OBJECT(ds->box), DATE_SELECION_KEY, ds);
1122
1123         return ds->box;
1124 }
1125
1126 void date_selection_set(GtkWidget *widget, gint day, gint month, gint year)
1127 {
1128         DateSelection *ds;
1129
1130         ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
1131         if (!ds) return;
1132
1133         gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_d), (gdouble)day);
1134         gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_m), (gdouble)month);
1135         gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_y), (gdouble)year);
1136 }
1137
1138
1139 void date_selection_get(GtkWidget *widget, gint *day, gint *month, gint *year)
1140 {
1141         DateSelection *ds;
1142
1143         ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
1144         if (!ds) return;
1145
1146         if (day) *day = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_d));
1147         if (month) *month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_m));
1148         if (year) *year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_y));
1149 }
1150
1151 void date_selection_time_set(GtkWidget *widget, time_t t)
1152 {
1153         struct tm *lt;
1154
1155         lt = localtime(&t);
1156         if (!lt) return;
1157
1158         date_selection_set(widget, lt->tm_mday, lt->tm_mon + 1, lt->tm_year + 1900);
1159 }
1160
1161 time_t date_selection_time_get(GtkWidget *widget)
1162 {
1163         struct tm lt;
1164         gint day = 0;
1165         gint month = 0;
1166         gint year = 0;
1167
1168         date_selection_get(widget, &day, &month ,&year);
1169
1170         lt.tm_sec = 0;
1171         lt.tm_min = 0;
1172         lt.tm_hour = 0;
1173         lt.tm_mday = day;
1174         lt.tm_mon = month - 1;
1175         lt.tm_year = year - 1900;
1176         lt.tm_isdst = 0;
1177
1178         return mktime(&lt);
1179 }
1180
1181
1182 /*
1183  *-----------------------------------------------------------------------------
1184  * Sizer, without using a GtkPaned
1185  *-----------------------------------------------------------------------------
1186  */
1187
1188 #define SIZER_DATA_KEY "sizer_data"
1189
1190 typedef struct _SizerData SizerData;
1191 struct _SizerData
1192 {
1193         GtkWidget *sizer;
1194         GtkWidget *parent;
1195         GtkWidget *bounding_widget;
1196         SizerPositionType position;
1197
1198         gint hsize_min;
1199         gint hsize_max;
1200         gint vsize_min;
1201         gint vsize_max;
1202
1203         gboolean in_drag;
1204         gint press_x;
1205         gint press_y;
1206         gint press_width;
1207         gint press_height;
1208
1209         gboolean handle_prelit;
1210 };
1211
1212
1213 static gint sizer_default_handle_size(void)
1214 {
1215         gint handle_size = 5;
1216         GtkWidget *paned;
1217         GtkStyle *style;
1218
1219         paned = gtk_hpaned_new();
1220
1221         style = gtk_rc_get_style(paned);
1222         gtk_widget_set_style(paned, style);
1223         gtk_widget_style_get(paned, "handle_size", &handle_size, NULL);
1224
1225         gtk_widget_destroy(paned);
1226
1227         return handle_size;
1228 }
1229
1230 static gboolean sizer_motion_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1231 {
1232         SizerData *sd = data;
1233         gint x, y;
1234         gint w, h;
1235
1236         if (!sd->in_drag) return FALSE;
1237
1238         x = sd->press_x - bevent->x_root;
1239         y = sd->press_y - bevent->y_root;
1240
1241         w = sd->press_width;
1242         h = sd->press_height;
1243
1244         if (sd->position & SIZER_POS_LEFT)
1245                 {
1246                 w += x;
1247                 }
1248         else if (sd->position & SIZER_POS_RIGHT)
1249                 {
1250                 w -= x;
1251                 }
1252
1253         if (sd->position & SIZER_POS_TOP)
1254                 {
1255                 h += y;
1256                 }
1257         else if (sd->position & SIZER_POS_BOTTOM)
1258                 {
1259                 h -= y;
1260                 }
1261
1262         if (sd->hsize_min >= 0) w = MAX(w, sd->hsize_min);
1263         if (sd->vsize_min >= 0) h = MAX(h, sd->vsize_min);
1264
1265         if (sd->bounding_widget)
1266                 {
1267                 w = CLAMP(w, sd->sizer->allocation.width, sd->bounding_widget->allocation.width);
1268                 h = CLAMP(h, sd->sizer->allocation.height, sd->bounding_widget->allocation.height);
1269                 }
1270         else
1271                 {
1272                 if (w < sd->sizer->allocation.width) w = sd->sizer->allocation.width;
1273                 if (h < sd->sizer->allocation.height) h = sd->sizer->allocation.height;
1274                 }
1275
1276         if (sd->hsize_max >= 0) w = MIN(w, sd->hsize_max);
1277         if (sd->vsize_max >= 0) h = MIN(h, sd->vsize_max);
1278
1279         if (w == sd->parent->allocation.width) w = -1;
1280         if (h == sd->parent->allocation.height) h = -1;
1281
1282         if (w > 0 || h > 0) gtk_widget_set_size_request(sd->parent, w, h);
1283
1284         return TRUE;
1285 }
1286
1287 static gboolean sizer_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1288 {
1289         SizerData *sd = data;
1290
1291         if (bevent->button != MOUSE_BUTTON_LEFT) return FALSE;
1292
1293         sd->in_drag = TRUE;
1294         sd->press_x = bevent->x_root;
1295         sd->press_y = bevent->y_root;
1296
1297         sd->press_width = sd->parent->allocation.width;
1298         sd->press_height = sd->parent->allocation.height;
1299
1300         gdk_pointer_grab(sd->sizer->window, FALSE,
1301                          GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
1302                          NULL, NULL, bevent->time);
1303         gtk_grab_add(sd->sizer);
1304
1305         return TRUE;
1306 }
1307
1308 static gboolean sizer_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1309 {
1310         SizerData *sd = data;
1311
1312         if (bevent->button != MOUSE_BUTTON_LEFT) return FALSE;
1313
1314 #if GTK_CHECK_VERSION(2,20,0)
1315         if (gdk_pointer_is_grabbed() && gtk_widget_has_grab(sd->sizer))
1316 #else
1317         if (gdk_pointer_is_grabbed() && GTK_WIDGET_HAS_GRAB(sd->sizer))
1318 #endif
1319                 {
1320                 gtk_grab_remove(sd->sizer);
1321                 gdk_pointer_ungrab(bevent->time);
1322                 }
1323
1324         sd->in_drag = FALSE;
1325
1326         return TRUE;
1327 }
1328
1329 static void sizer_set_prelight(SizerData *sd, gboolean prelit)
1330 {
1331         sd->handle_prelit = prelit;
1332         gtk_widget_queue_draw_area(sd->sizer, 0, 0,
1333                                    sd->sizer->allocation.width, sd->sizer->allocation.height);
1334 }
1335
1336 static gboolean sizer_enter_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
1337 {
1338         SizerData *sd = data;
1339
1340         sizer_set_prelight(sd, TRUE);
1341         return TRUE;
1342 }
1343
1344 static gboolean sizer_leave_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
1345 {
1346         SizerData *sd = data;
1347
1348         sizer_set_prelight(sd, FALSE);
1349         return TRUE;
1350 }
1351
1352 static gboolean sizer_expose_cb(GtkWidget *widget, GdkEventExpose *event, gpointer data)
1353 {
1354         SizerData *sd = data;
1355         GdkRectangle clip;
1356         GtkOrientation orientation;
1357         GtkStateType state;
1358
1359         gdk_region_get_clipbox(event->region, &clip);
1360
1361         if (sd->position & SIZER_POS_LEFT || sd->position & SIZER_POS_RIGHT)
1362                 {
1363                 orientation = GTK_ORIENTATION_VERTICAL;
1364                 }
1365         else
1366                 {
1367                 orientation = GTK_ORIENTATION_HORIZONTAL;
1368                 }
1369
1370         if (sd->handle_prelit)
1371                 {
1372                 state = GTK_STATE_PRELIGHT;
1373                 }
1374         else
1375                 {
1376                 state = widget->state;
1377                 }
1378
1379         gtk_paint_handle(widget->style, widget->window, state,
1380                          GTK_SHADOW_NONE, &clip, widget, "paned",
1381                          0, 0,
1382                          widget->allocation.width, widget->allocation.height,
1383                          orientation);
1384
1385         return TRUE;
1386 }
1387
1388 static void sizer_realize_cb(GtkWidget *widget, gpointer data)
1389 {
1390         SizerData *sd = data;
1391         GdkCursorType n;
1392
1393         n = 0;
1394         if (sd->position & SIZER_POS_TOP || sd->position & SIZER_POS_BOTTOM)
1395                 {
1396                 n = GDK_SB_V_DOUBLE_ARROW;
1397                 }
1398         if (sd->position & SIZER_POS_LEFT || sd->position & SIZER_POS_RIGHT)
1399                 {
1400                 n = (n != 0) ? GDK_FLEUR : GDK_SB_H_DOUBLE_ARROW;
1401                 }
1402
1403         if (n != 0 && widget->window)
1404                 {
1405                 GdkCursor *cursor;
1406                 cursor = gdk_cursor_new(n);
1407                 gdk_window_set_cursor(widget->window, cursor);
1408                 gdk_cursor_unref(cursor);
1409                 }
1410 }
1411
1412 static void sizer_destroy_cb(GtkWidget *widget, gpointer data)
1413 {
1414         SizerData *sd = data;
1415
1416         g_free(sd);
1417 }
1418
1419 GtkWidget *sizer_new(GtkWidget *parent, GtkWidget *bounding_widget,
1420                      SizerPositionType position)
1421 {
1422         SizerData *sd;
1423         gint handle_size;
1424
1425         sd = g_new0(SizerData, 1);
1426
1427         sd->sizer = gtk_event_box_new();
1428         sd->parent = parent;
1429         sd->bounding_widget = bounding_widget;
1430         sd->position = position;
1431         sd->hsize_min = -1;
1432         sd->hsize_max = -1;
1433         sd->vsize_min = -1;
1434         sd->vsize_max = -1;
1435
1436         sd->in_drag = FALSE;
1437         sd->handle_prelit = FALSE;
1438
1439         g_signal_connect(G_OBJECT(sd->sizer), "destroy",
1440                          G_CALLBACK(sizer_destroy_cb), sd);
1441
1442         g_signal_connect(G_OBJECT(sd->sizer), "motion_notify_event",
1443                          G_CALLBACK(sizer_motion_cb), sd);
1444         g_signal_connect(G_OBJECT(sd->sizer), "button_press_event",
1445                          G_CALLBACK(sizer_press_cb), sd);
1446         g_signal_connect(G_OBJECT(sd->sizer), "button_release_event",
1447                          G_CALLBACK(sizer_release_cb), sd);
1448
1449         g_signal_connect(G_OBJECT(sd->sizer), "enter_notify_event",
1450                          G_CALLBACK(sizer_enter_cb), sd);
1451         g_signal_connect(G_OBJECT(sd->sizer), "leave_notify_event",
1452                          G_CALLBACK(sizer_leave_cb), sd);
1453
1454         gtk_widget_set_events(sd->sizer, GDK_POINTER_MOTION_MASK |
1455                                          GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK |
1456                                          GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
1457
1458         g_signal_connect(sd->sizer, "realize",
1459                          G_CALLBACK(sizer_realize_cb), sd);
1460         g_signal_connect(sd->sizer, "expose_event",
1461                          G_CALLBACK(sizer_expose_cb), sd);
1462
1463         handle_size = sizer_default_handle_size();
1464
1465         gtk_widget_set_size_request(sd->sizer, handle_size, handle_size);
1466 #if 0
1467         /* use this if you add a shadow border to the handle */
1468         gtk_widget_set_size_request(sd->sizer, handle_size + sd->sizer->style->xthickness * 2,
1469                                                handle_size + sd->sizer->style->ythickness * 2);
1470 #endif
1471
1472         g_object_set_data(G_OBJECT(sd->sizer), SIZER_DATA_KEY,sd);
1473
1474         return sd->sizer;
1475 }
1476
1477 void sizer_set_limits(GtkWidget *sizer,
1478                       gint hsize_min, gint hsize_max,
1479                       gint vsize_min, gint vsize_max)
1480 {
1481         SizerData *sd;
1482
1483         sd = g_object_get_data(G_OBJECT(sizer), SIZER_DATA_KEY);
1484         if (!sd) return;
1485
1486         sd->hsize_min = hsize_min;
1487         sd->hsize_max = hsize_max;
1488         sd->vsize_min = vsize_min;
1489         sd->vsize_max = vsize_max;
1490 }
1491
1492
1493 /*
1494  *-----------------------------------------------------------------------------
1495  * storing data in a history list with key,data pairs
1496  *-----------------------------------------------------------------------------
1497  */
1498
1499 #define PREF_LIST_MARKER_INT "[INT]:"
1500 #define PREF_LIST_MARKER_DOUBLE "[DOUBLE]:"
1501 #define PREF_LIST_MARKER_STRING "[STRING]:"
1502
1503 static GList *pref_list_find(const gchar *group, const gchar *token)
1504 {
1505         GList *work;
1506         gint l;
1507
1508         l = strlen(token);
1509
1510         work = history_list_get_by_key(group);
1511         while (work)
1512                 {
1513                 const gchar *text = work->data;
1514
1515                 if (strncmp(text, token, l) == 0) return work;
1516
1517                 work = work->next;
1518                 }
1519
1520         return NULL;
1521 }
1522
1523 static gboolean pref_list_get(const gchar *group, const gchar *key, const gchar *marker, const gchar **result)
1524 {
1525         gchar *token;
1526         GList *work;
1527         gboolean ret;
1528
1529         if (!group || !key || !marker)
1530                 {
1531                 *result = NULL;
1532                 return FALSE;
1533                 }
1534
1535         token = g_strconcat(key, marker, NULL);
1536
1537         work = pref_list_find(group, token);
1538         if (work)
1539                 {
1540                 *result = (const gchar *)work->data + strlen(token);
1541                 if (strlen(*result) == 0) *result = NULL;
1542                 ret = TRUE;
1543                 }
1544         else
1545                 {
1546                 *result = NULL;
1547                 ret = FALSE;
1548                 }
1549
1550         g_free(token);
1551
1552         return ret;
1553 }
1554
1555 static void pref_list_set(const gchar *group, const gchar *key, const gchar *marker, const gchar *text)
1556 {
1557         gchar *token;
1558         gchar *path;
1559         GList *work;
1560
1561         if (!group || !key || !marker) return;
1562
1563         token = g_strconcat(key, marker, NULL);
1564         path = g_strconcat(token, text, NULL);
1565
1566         work = pref_list_find(group, token);
1567         if (work)
1568                 {
1569                 gchar *old_path = work->data;
1570
1571                 if (text)
1572                         {
1573                         work->data = path;
1574                         path = NULL;
1575
1576                         g_free(old_path);
1577                         }
1578                 else
1579                         {
1580                         history_list_item_remove(group, old_path);
1581                         }
1582                 }
1583         else if (text)
1584                 {
1585                 history_list_add_to_key(group, path, 0);
1586                 }
1587
1588         g_free(path);
1589         g_free(token);
1590 }
1591
1592 void pref_list_int_set(const gchar *group, const gchar *key, gint value)
1593 {
1594         gchar *text;
1595
1596         text = g_strdup_printf("%d", value);
1597         pref_list_set(group, key, PREF_LIST_MARKER_INT, text);
1598         g_free(text);
1599 }
1600
1601 gboolean pref_list_int_get(const gchar *group, const gchar *key, gint *result)
1602 {
1603         const gchar *text;
1604
1605         if (!group || !key)
1606                 {
1607                 *result = 0;
1608                 return FALSE;
1609                 }
1610
1611         if (pref_list_get(group, key, PREF_LIST_MARKER_INT, &text) && text)
1612                 {
1613                 *result = (gint)strtol(text, NULL, 10);
1614                 return TRUE;
1615                 }
1616
1617         *result = 0;
1618         return FALSE;
1619 }
1620
1621 void pref_list_double_set(const gchar *group, const gchar *key, gdouble value)
1622 {
1623         gchar text[G_ASCII_DTOSTR_BUF_SIZE];
1624
1625         g_ascii_dtostr(text, sizeof(text), value);
1626         pref_list_set(group, key, PREF_LIST_MARKER_DOUBLE, text);
1627 }
1628
1629 gboolean pref_list_double_get(const gchar *group, const gchar *key, gdouble *result)
1630 {
1631         const gchar *text;
1632
1633         if (!group || !key)
1634                 {
1635                 *result = 0;
1636                 return FALSE;
1637                 }
1638
1639         if (pref_list_get(group, key, PREF_LIST_MARKER_DOUBLE, &text) && text)
1640                 {
1641                 *result = g_ascii_strtod(text, NULL);
1642                 return TRUE;
1643                 }
1644
1645         *result = 0;
1646         return FALSE;
1647 }
1648
1649 void pref_list_string_set(const gchar *group, const gchar *key, const gchar *value)
1650 {
1651         pref_list_set(group, key, PREF_LIST_MARKER_STRING, value);
1652 }
1653
1654 gboolean pref_list_string_get(const gchar *group, const gchar *key, const gchar **result)
1655 {
1656         return pref_list_get(group, key, PREF_LIST_MARKER_STRING, result);
1657 }
1658
1659
1660 void pref_color_button_set_cb(GtkWidget *widget, gpointer data)
1661 {
1662         GdkColor *color = data;
1663
1664         gtk_color_button_get_color(GTK_COLOR_BUTTON(widget), color);
1665 }
1666
1667 GtkWidget *pref_color_button_new(GtkWidget *parent_box,
1668                                  const gchar *title, const GdkColor *color,
1669                                  GCallback func, gpointer data)
1670 {
1671         GtkWidget *button;
1672
1673         if (color)
1674                 {
1675                 button = gtk_color_button_new_with_color(color);
1676                 }
1677         else
1678                 {
1679                 button = gtk_color_button_new();
1680                 }
1681
1682         if (func) g_signal_connect(G_OBJECT(button), "color-set", func, data);
1683
1684         if (title)
1685                 {
1686                 GtkWidget *label;
1687                 GtkWidget *hbox;
1688
1689                 gtk_color_button_set_title(GTK_COLOR_BUTTON(button), title);
1690                 label = gtk_label_new(title);
1691
1692                 hbox = gtk_hbox_new(TRUE, 0);
1693                 gtk_box_pack_start(GTK_BOX(parent_box), hbox, TRUE, TRUE, 0);
1694
1695                 gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
1696                 gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
1697
1698                 gtk_widget_show_all(hbox);
1699                 }
1700         else
1701                 {
1702                 gtk_widget_show(button);
1703                 }
1704
1705         return button;
1706 }
1707
1708 /*
1709  *-----------------------------------------------------------------------------
1710  * text widget
1711  *-----------------------------------------------------------------------------
1712  */
1713
1714 gchar *text_widget_text_pull(GtkWidget *text_widget)
1715 {
1716         if (GTK_IS_TEXT_VIEW(text_widget))
1717                 {
1718                 GtkTextBuffer *buffer;
1719                 GtkTextIter start, end;
1720
1721                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_widget));
1722                 gtk_text_buffer_get_bounds(buffer, &start, &end);
1723
1724                 return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
1725                 }
1726         else if (GTK_IS_ENTRY(text_widget))
1727                 {
1728                 return g_strdup(gtk_entry_get_text(GTK_ENTRY(text_widget)));
1729                 }
1730         else
1731                 {
1732                 return NULL;
1733                 }
1734
1735 }
1736
1737 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */