src/prefs_toolbar.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2002-2007 Hiroyuki Yamamoto & the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 /*
  21  * General functions for accessing address book files.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include "config.h"
  26 #endif
  27
  28 #include "defs.h"
  29
  30 #include <glib.h>
  31 #include <glib/gi18n.h>
  32 #include <gtk/gtk.h>
  33 #include <gtk/gtkoptionmenu.h>
  34 #include <gdk/gdkkeysyms.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37
  38 #include "stock_pixmap.h"
  39 #include "manage_window.h"
  40 #include "combobox.h"
  41 #include "gtkutils.h"
  42 #include "mainwindow.h"
  43 #include "alertpanel.h"
  44 #include "prefs_common.h"
  45
  46 #include "utils.h"
  47
  48 #include "toolbar.h"
  49 #include "prefs_toolbar.h"
  50 #include "prefswindow.h"
  51 #include "prefs_gtk.h"
  52
  53 enum
  54 {
  55         SET_ICON          = 0,
  56         SET_FILENAME      = 1,
  57         SET_TEXT          = 2,
  58         SET_EVENT         = 3,
  59         SET_ICON_TEXT     = 4,          /*!< "icon" text (separator) */
  60         SET_ICON_IS_TEXT  = 5,          /*!< icon is text representation */
  61         N_SET_COLUMNS
  62 };
  63
  64 enum
  65 {
  66         ITEM_FUNCTION     = 0,
  67         ITEM_USER_ACTION  = 1,
  68         ITEM_SEPARATOR    = 2
  69 };
  70
  71 static const gint ToolbarIcons[] =
  72 {
  73         STOCK_PIXMAP_ADDRESS_BOOK,
  74         STOCK_PIXMAP_ADDRESS_SEARCH,
  75         STOCK_PIXMAP_BOOK,
  76         STOCK_PIXMAP_CATEGORY,
  77         STOCK_PIXMAP_CHECK_SPELLING,
  78         STOCK_PIXMAP_CLOSE,
  79         STOCK_PIXMAP_DOWN_ARROW,
  80         STOCK_PIXMAP_UP_ARROW,
  81         STOCK_PIXMAP_EDIT_EXTERN,
  82         STOCK_PIXMAP_ERROR,
  83         STOCK_PIXMAP_EXEC,
  84         STOCK_PIXMAP_GROUP,
  85         STOCK_PIXMAP_INSERT_FILE,
  86         STOCK_PIXMAP_INTERFACE,
  87         STOCK_PIXMAP_JPILOT,
  88         STOCK_PIXMAP_LDAP,
  89         STOCK_PIXMAP_LINEWRAP_CURRENT,
  90         STOCK_PIXMAP_LINEWRAP_ALL,
  91         STOCK_PIXMAP_MAIL,
  92         STOCK_PIXMAP_MAIL_ATTACH,
  93         STOCK_PIXMAP_MAIL_COMPOSE,
  94         STOCK_PIXMAP_MAIL_FORWARD,
  95         STOCK_PIXMAP_MAIL_RECEIVE,
  96         STOCK_PIXMAP_MAIL_RECEIVE_ALL,
  97         STOCK_PIXMAP_MAIL_REPLY,
  98         STOCK_PIXMAP_MAIL_REPLY_TO_ALL,
  99         STOCK_PIXMAP_MAIL_REPLY_TO_AUTHOR,
 100         STOCK_PIXMAP_MAIL_SEND,
 101         STOCK_PIXMAP_MAIL_SEND_QUEUE,
 102         STOCK_PIXMAP_MAIL_SIGN,
 103         STOCK_PIXMAP_OPEN_MAIL,
 104         STOCK_PIXMAP_NEWS_COMPOSE,
 105         STOCK_PIXMAP_PASTE,
 106         STOCK_PIXMAP_PREFERENCES,
 107         STOCK_PIXMAP_PROPERTIES,
 108         STOCK_PIXMAP_VCARD,
 109         STOCK_PIXMAP_ONLINE,
 110         STOCK_PIXMAP_OFFLINE,
 111         STOCK_PIXMAP_NOTICE_WARN,               /* small warning */
 112         STOCK_PIXMAP_NOTICE_ERROR,              /* small error   */
 113         STOCK_PIXMAP_NOTICE_NOTE,               /* small message */
 114         STOCK_PIXMAP_GO_FOLDERS,
 115         STOCK_PIXMAP_MIME_TEXT_PLAIN,
 116         STOCK_PIXMAP_MIME_TEXT_HTML,
 117         STOCK_PIXMAP_MIME_APPLICATION,
 118         STOCK_PIXMAP_MIME_IMAGE,
 119         STOCK_PIXMAP_MIME_AUDIO,
 120         STOCK_PIXMAP_MIME_TEXT_ENRICHED,
 121         STOCK_PIXMAP_MIME_UNKNOWN,
 122         STOCK_PIXMAP_MIME_PDF,
 123         STOCK_PIXMAP_MIME_PS,
 124         STOCK_PIXMAP_MIME_TEXT_CALENDAR,
 125         STOCK_PIXMAP_MIME_PGP_SIG,
 126         STOCK_PIXMAP_PRINTER,
 127         STOCK_PIXMAP_PRIVACY_SIGNED,
 128         STOCK_PIXMAP_PRIVACY_PASSED,
 129         STOCK_PIXMAP_PRIVACY_FAILED,
 130         STOCK_PIXMAP_PRIVACY_UNKNOWN,
 131         STOCK_PIXMAP_PRIVACY_EXPIRED,
 132         STOCK_PIXMAP_PRIVACY_WARN,
 133         STOCK_PIXMAP_PRIVACY_EMBLEM_SIGNED,
 134         STOCK_PIXMAP_PRIVACY_EMBLEM_PASSED,
 135         STOCK_PIXMAP_PRIVACY_EMBLEM_FAILED,
 136         STOCK_PIXMAP_PRIVACY_EMBLEM_WARN,
 137         STOCK_PIXMAP_MIME_MESSAGE,
 138         STOCK_PIXMAP_SPAM_BTN,
 139         STOCK_PIXMAP_HAM_BTN,
 140         STOCK_PIXMAP_EMPTY,              /* last entry */
 141 };
 142
 143 typedef struct _ToolbarPage
 144 {
 145         PrefsPage  page;
 146
 147         GtkWidget *window;              /* do not modify */
 148
 149         ToolbarType source;
 150         GList     *combo_action_list;   /* list of internal functions    */
 151
 152         GtkWidget *list_view_set;       /* toolbar items treeview        */
 153         GtkWidget *item_text_entry;     /* item name                     */
 154         GtkWidget *item_type_combo;     /* item type selection widget    */
 155         GtkWidget *item_func_combo;     /* item internal function widget */
 156         GtkWidget *item_action_combo;   /* item user action widget       */
 157         GtkWidget *icon_button;         /* item icon chooser widget      */
 158
 159         GtkWidget *icon_chooser_win;
 160         GtkWidget *icon_chooser_view;
 161
 162         gchar *item_icon_file;          /* item icon file                */
 163
 164 } ToolbarPage;
 165
 166 #define ERROR_MSG _("Selected Action already set.\nPlease choose another Action from List")
 167 #define ERROR_MSG_NO_ICON _("Item has no icon defined.")
 168 #define ERROR_MSG_NO_TEXT _("Item has no text defined.")
 169
 170 static void prefs_toolbar_populate               (ToolbarPage *prefs_toolbar);
 171
 172 static void get_action_name                      (const gchar *entry,
 173                                                   gchar **menu);
 174
 175 static gboolean is_duplicate                     (ToolbarPage *prefs_toolbar,
 176                                                   gchar            *chosen_action);
 177 static void prefs_toolbar_save                   (PrefsPage        *_page);
 178
 179 static void prefs_toolbar_register               (GtkButton        *button,
 180                                                   ToolbarPage *prefs_toolbar);
 181 static void prefs_toolbar_substitute             (GtkButton        *button,
 182                                                   ToolbarPage *prefs_toolbar);
 183 static void prefs_toolbar_delete                 (GtkButton        *button,
 184                                                   ToolbarPage *prefs_toolbar);
 185
 186 static void prefs_toolbar_up                     (GtkButton        *button,
 187                                                   ToolbarPage *prefs_toolbar);
 188
 189 static void prefs_toolbar_down                   (GtkButton        *button,
 190                                                   ToolbarPage *prefs_toolbar);
 191
 192 static void action_selection_changed             (GtkComboBox *action_combo,
 193                                                   ToolbarPage *prefs_toolbar);
 194
 195 static void func_selection_changed               (GtkComboBox *action_combo,
 196                                                   ToolbarPage *prefs_toolbar);
 197
 198 static void prefs_toolbar_create                 (ToolbarPage *prefs_toolbar);
 199
 200 static GtkWidget *create_set_list_view           (ToolbarPage *prefs_toolbar);
 201
 202 static gboolean set_list_selected                (GtkTreeSelection *selector,
 203                                                   GtkTreeModel *model,
 204                                                   GtkTreePath *path,
 205                                                   gboolean currently_selected,
 206                                                   ToolbarPage *prefs_toolbar);
 207
 208 static void icon_chooser_create                  (GtkButton *button,
 209                                                   ToolbarPage *prefs_toolbar);
 210
 211 static void prefs_toolbar_create_widget(PrefsPage *_page, GtkWindow *window, gpointer data)
 212 {
 213         ToolbarPage *prefs_toolbar = (ToolbarPage *) _page;
 214         gchar *win_titles[3];
 215         win_titles[TOOLBAR_MAIN]    = _("Main toolbar configuration");
 216         win_titles[TOOLBAR_COMPOSE] = _("Compose toolbar configuration");
 217         win_titles[TOOLBAR_MSGVIEW] = _("Message view toolbar configuration");
 218
 219         prefs_toolbar->window = GTK_WIDGET(window);
 220
 221         toolbar_read_config_file(prefs_toolbar->source);
 222
 223         prefs_toolbar_create(prefs_toolbar);
 224         prefs_toolbar_populate(prefs_toolbar);
 225 }
 226
 227 static void prefs_toolbar_save(PrefsPage *_page)
 228 {
 229         ToolbarPage *prefs_toolbar = (ToolbarPage *) _page;
 230         GtkTreeView *list_view = GTK_TREE_VIEW(prefs_toolbar->list_view_set);
 231         GtkTreeModel *model = gtk_tree_view_get_model(list_view);
 232         GtkTreeIter iter;
 233
 234         toolbar_clear_list(prefs_toolbar->source);
 235
 236         if (!gtk_tree_model_iter_n_children(model, NULL)
 237         ||  !gtk_tree_model_get_iter_first(model, &iter))
 238                 toolbar_set_default(prefs_toolbar->source);
 239         else {
 240                 do {
 241                         ToolbarItem *item;
 242                         gchar *fname, *text, *event;
 243
 244                         item = g_new0(ToolbarItem, 1);
 245
 246                         gtk_tree_model_get(model, &iter,
 247                                            SET_FILENAME, &fname,
 248                                            SET_TEXT, &text,
 249                                            SET_EVENT, &event,
 250                                            -1);
 251
 252                         /* XXX: remember that G_TYPE_STRING returned by model
 253                          * is owned by caller of gtk_tree_model_get() */
 254                         item->file  = fname;
 255                         item->text  = text;
 256                         item->index = toolbar_ret_val_from_descr(event);
 257                         g_free(event);
 258
 259                         /* TODO: save A_SYL_ACTIONS only if they are still active */
 260                         toolbar_set_list_item(item, prefs_toolbar->source);
 261
 262                         g_free(item->file);
 263                         g_free(item->text);
 264                         g_free(item);
 265                 } while (gtk_tree_model_iter_next(model, &iter));
 266         }
 267
 268         toolbar_save_config_file(prefs_toolbar->source);
 269
 270         if (prefs_toolbar->source == TOOLBAR_MAIN)
 271                 main_window_reflect_prefs_all_real(TRUE);
 272         else if (prefs_toolbar->source == TOOLBAR_COMPOSE)
 273                 compose_reflect_prefs_pixmap_theme();
 274         else if (prefs_toolbar->source == TOOLBAR_MSGVIEW)
 275                 messageview_reflect_prefs_pixmap_theme();
 276 }
 277
 278 static void prefs_toolbar_destroy_widget(PrefsPage *_page)
 279 {
 280         ToolbarPage *prefs_toolbar = (ToolbarPage *) _page;
 281
 282         g_list_free(prefs_toolbar->combo_action_list);
 283         prefs_toolbar->combo_action_list = NULL;
 284 }
 285
 286 static void prefs_toolbar_set_displayed(ToolbarPage *prefs_toolbar)
 287 {
 288         GSList *cur;
 289         GtkTreeView *list_view_set = GTK_TREE_VIEW(prefs_toolbar->list_view_set);
 290         GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model
 291                                                 (list_view_set));
 292         GSList *toolbar_list = toolbar_get_list(prefs_toolbar->source);
 293         GtkTreeIter iter;
 294
 295         gtk_list_store_clear(store);
 296
 297         /* set currently active toolbar entries */
 298         for (cur = toolbar_list; cur != NULL; cur = cur->next) {
 299                 ToolbarItem *item = (ToolbarItem*) cur->data;
 300
 301                 gtk_list_store_append(store, &iter);
 302
 303                 if (item->index != A_SEPARATOR) {
 304                         GdkPixbuf *pix;
 305                         StockPixmap icon = stock_pixmap_get_icon(item->file);
 306
 307                         stock_pixbuf_gdk(prefs_toolbar->window, icon, &pix);
 308
 309                         gtk_list_store_set(store, &iter,
 310                                            SET_ICON, pix,
 311                                            SET_FILENAME, item->file,
 312                                            SET_TEXT, item->text,
 313                                            SET_EVENT, toolbar_ret_descr_from_val(item->index),
 314                                            SET_ICON_TEXT, NULL,
 315                                            SET_ICON_IS_TEXT, FALSE,
 316                                            -1);
 317                 } else {
 318                         gtk_list_store_set(store, &iter,
 319                                            SET_ICON, NULL,
 320                                            SET_FILENAME, toolbar_ret_descr_from_val(A_SEPARATOR),
 321                                            SET_TEXT, (const gchar *) "",
 322                                            SET_EVENT, toolbar_ret_descr_from_val(A_SEPARATOR),
 323                                            SET_ICON_TEXT, (const gchar *) SEPARATOR_PIXMAP,
 324                                            SET_ICON_IS_TEXT, TRUE,
 325                                            -1);
 326                 }
 327         }
 328
 329         /* select first */
 330         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
 331         gtk_tree_selection_select_iter(gtk_tree_view_get_selection
 332                                                 (list_view_set),
 333                                        &iter);
 334 }
 335
 336 static void prefs_toolbar_populate(ToolbarPage *prefs_toolbar)
 337 {
 338         GSList *cur;
 339         gchar *act, *act_name;
 340
 341         prefs_toolbar->combo_action_list = toolbar_get_action_items(prefs_toolbar->source);
 342         combobox_set_popdown_strings(GTK_COMBO_BOX(prefs_toolbar->item_func_combo),
 343                                      prefs_toolbar->combo_action_list);
 344
 345         /* get currently defined sylpheed actions */
 346         if (prefs_common.actions_list != NULL) {
 347                 for (cur = prefs_common.actions_list; cur != NULL; cur = cur->next) {
 348                         act = (gchar *)cur->data;
 349                         get_action_name(act, &act_name);
 350
 351                         gtk_combo_box_append_text(
 352                                 GTK_COMBO_BOX(prefs_toolbar->item_action_combo),
 353                                 act_name);
 354
 355                         g_free(act_name);
 356                 }
 357
 358         }
 359
 360         gtk_combo_box_set_active(GTK_COMBO_BOX(prefs_toolbar->item_func_combo), 0);
 361         gtk_combo_box_set_active(GTK_COMBO_BOX(prefs_toolbar->item_action_combo), 0);
 362
 363         prefs_toolbar_set_displayed(prefs_toolbar);
 364
 365         toolbar_clear_list(prefs_toolbar->source);
 366 }
 367
 368 static gboolean is_duplicate(ToolbarPage *prefs_toolbar, gchar *chosen_action)
 369 {
 370         GtkTreeView *list_view_set = GTK_TREE_VIEW
 371                                         (prefs_toolbar->list_view_set);
 372         GtkTreeModel *model_set = gtk_tree_view_get_model(list_view_set);
 373         gchar *entry;
 374         GtkTreeIter iter;
 375         gboolean result;
 376
 377         g_return_val_if_fail(chosen_action != NULL, TRUE);
 378
 379         if (!gtk_tree_model_iter_n_children(model_set, NULL))
 380                 return FALSE;
 381
 382         if (!gtk_tree_model_get_iter_first(model_set, &iter))
 383                 return FALSE;
 384
 385         result = FALSE;
 386         do {
 387                 gtk_tree_model_get(model_set, &iter,
 388                                    SET_EVENT, &entry,
 389                                    -1);
 390                 if (g_utf8_collate(chosen_action, entry) == 0)
 391                         result = TRUE;
 392                 g_free(entry);
 393         } while (!result && gtk_tree_model_iter_next(model_set, &iter));
 394
 395         return result;
 396 }
 397
 398 static void prefs_toolbar_default(GtkButton *button, ToolbarPage *prefs_toolbar)
 399 {
 400         toolbar_clear_list(prefs_toolbar->source);
 401         toolbar_set_default(prefs_toolbar->source);
 402         prefs_toolbar_set_displayed(prefs_toolbar);
 403 }
 404
 405 /*!
 406  *\return       String that should be freed by caller.
 407  */
 408 static void get_action_name(const gchar *entry, gchar **menu)
 409 {
 410         gchar *act, *act_p;
 411
 412         *menu = NULL;
 413
 414         if (prefs_common.actions_list != NULL) {
 415
 416                 act = g_strdup(entry);
 417                 act_p = strstr(act, ": ");
 418                 if (act_p != NULL)
 419                         act_p[0] = 0x00;
 420                 /* freed by calling func */
 421                 *menu = act;
 422         }
 423 }
 424
 425 static void prefs_toolbar_register(GtkButton *button, ToolbarPage *prefs_toolbar)
 426 {
 427         GtkTreeView *list_view_set   = GTK_TREE_VIEW(prefs_toolbar->list_view_set);
 428         gint item_type = gtk_combo_box_get_active(GTK_COMBO_BOX(prefs_toolbar->item_type_combo));
 429         GtkListStore *store_set;
 430         GtkTreeIter iter;
 431
 432         store_set = GTK_LIST_STORE(gtk_tree_view_get_model(list_view_set));
 433
 434         /* SEPARATOR or other ? */
 435         if (item_type == ITEM_SEPARATOR) {
 436                 gtk_list_store_append(store_set, &iter);
 437                 gtk_list_store_set(store_set, &iter,
 438                                    SET_ICON, NULL,
 439                                    SET_FILENAME, prefs_toolbar->item_icon_file,
 440                                    SET_TEXT, NULL,
 441                                    SET_EVENT, toolbar_ret_descr_from_val(A_SEPARATOR),
 442                                    SET_ICON_TEXT, (const gchar *) SEPARATOR_PIXMAP,
 443                                    SET_ICON_IS_TEXT, TRUE,
 444                                    -1);
 445         } else {
 446                 GdkPixbuf *pixbuf;
 447                 gchar *event, *text;
 448
 449                 if (prefs_toolbar->item_icon_file == NULL) {
 450                         alertpanel_error(ERROR_MSG_NO_ICON);
 451                         return;
 452                 }
 453                 stock_pixbuf_gdk(prefs_toolbar->window,
 454                                  stock_pixmap_get_icon(prefs_toolbar->item_icon_file),
 455                                  &pixbuf);
 456                 if(pixbuf == NULL) {
 457                         alertpanel_error(ERROR_MSG_NO_ICON);
 458                         return;
 459                 }
 460
 461                 if (item_type == ITEM_FUNCTION) {
 462                         event = gtk_combo_box_get_active_text(GTK_COMBO_BOX(
 463                                                 prefs_toolbar->item_func_combo));
 464
 465                         if (is_duplicate(prefs_toolbar, event)) {
 466                                 alertpanel_error(ERROR_MSG);
 467                                 g_free(event);
 468                                 return;
 469                         }
 470                 } else
 471                         event = toolbar_ret_descr_from_val(A_SYL_ACTIONS);
 472
 473                 text = gtk_editable_get_chars(
 474                         GTK_EDITABLE(prefs_toolbar->item_text_entry), 0 , -1);
 475
 476                 if (text != NULL) {
 477                         gtk_list_store_append(store_set, &iter);
 478                         gtk_list_store_set(store_set, &iter,
 479                                            SET_ICON, pixbuf,
 480                                            SET_FILENAME, prefs_toolbar->item_icon_file,
 481                                            SET_TEXT, text,
 482                                            SET_EVENT, event,
 483                                            SET_ICON_TEXT, NULL,
 484                                            SET_ICON_IS_TEXT, FALSE,
 485                                            -1);
 486                 } else {
 487                         alertpanel_error(ERROR_MSG_NO_TEXT);
 488                         return;
 489                 }
 490
 491                 g_free(text);
 492                 if(item_type != ITEM_USER_ACTION)
 493                         g_free(event);
 494         }
 495
 496         gtk_tree_selection_select_iter(gtk_tree_view_get_selection
 497                                                 (list_view_set),
 498                                        &iter);
 499 }
 500
 501 static void prefs_toolbar_substitute(GtkButton *button, ToolbarPage *prefs_toolbar)
 502 {
 503         GtkTreeView *list_view_set   = GTK_TREE_VIEW(prefs_toolbar->list_view_set);
 504         GtkListStore *store_set   = GTK_LIST_STORE(gtk_tree_view_get_model(list_view_set));
 505         gint item_type = gtk_combo_box_get_active(GTK_COMBO_BOX(prefs_toolbar->item_type_combo));
 506         GtkTreeSelection *sel_set;
 507         GtkTreeIter iter_set;
 508
 509         if (!gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store_set), NULL))
 510                 return;
 511
 512         sel_set = gtk_tree_view_get_selection(list_view_set);
 513         if (!gtk_tree_selection_get_selected(sel_set, NULL, &iter_set))
 514                 return;
 515
 516         if (item_type == ITEM_SEPARATOR) {
 517                 gtk_list_store_set(store_set, &iter_set,
 518                                    SET_ICON, NULL,
 519                                    SET_TEXT, NULL,
 520                                    SET_EVENT, toolbar_ret_descr_from_val(A_SEPARATOR),
 521                                    SET_FILENAME, prefs_toolbar->item_icon_file,
 522                                    SET_ICON_TEXT, (const gchar *) SEPARATOR_PIXMAP,
 523                                    SET_ICON_IS_TEXT, TRUE,
 524                                    -1);
 525         } else {
 526                 GdkPixbuf *pixbuf;
 527                 gchar *icon_event, *set_event, *text;
 528
 529                 if (prefs_toolbar->item_icon_file == NULL) {
 530                         alertpanel_error(ERROR_MSG_NO_ICON);
 531                         return;
 532                 }
 533                 stock_pixbuf_gdk(prefs_toolbar->window,
 534                                  stock_pixmap_get_icon(prefs_toolbar->item_icon_file),
 535                                  &pixbuf);
 536                 if(pixbuf == NULL) {
 537                         alertpanel_error(ERROR_MSG_NO_ICON);
 538                         return;
 539                 }
 540
 541                 gtk_tree_model_get(GTK_TREE_MODEL(store_set), &iter_set,
 542                                                   SET_EVENT, &set_event,
 543                                                   -1);
 544
 545                 if (item_type == ITEM_FUNCTION) {
 546                         icon_event = gtk_combo_box_get_active_text(GTK_COMBO_BOX(
 547                                                 prefs_toolbar->item_func_combo));
 548
 549                         if (is_duplicate(prefs_toolbar, icon_event)
 550                         && g_utf8_collate(icon_event, set_event) != 0){
 551                                 alertpanel_error(ERROR_MSG);
 552                                 g_free(icon_event);
 553                                 g_free(set_event);
 554                                 return;
 555                         }
 556                 } else
 557                         icon_event = toolbar_ret_descr_from_val(A_SYL_ACTIONS);
 558
 559                 text = gtk_editable_get_chars(
 560                         GTK_EDITABLE(prefs_toolbar->item_text_entry), 0 , -1);
 561
 562                 /* change the row */
 563                 if (text != NULL) {
 564                         gtk_list_store_set(store_set, &iter_set,
 565                                            SET_ICON, pixbuf,
 566                                            SET_FILENAME, prefs_toolbar->item_icon_file,
 567                                            SET_TEXT, text,
 568                                            SET_EVENT, icon_event,
 569                                            SET_ICON_TEXT, NULL,
 570                                            SET_ICON_IS_TEXT, FALSE,
 571                                            -1);
 572                 } else
 573                         alertpanel_error(ERROR_MSG_NO_TEXT);
 574
 575                 g_free(text);
 576                 g_free(set_event);
 577                 if(item_type != ITEM_USER_ACTION)
 578                         g_free(icon_event);
 579         }
 580 }
 581
 582 static void prefs_toolbar_delete(GtkButton *button, ToolbarPage *prefs_toolbar)
 583 {
 584         GtkTreeView *list_view_set = GTK_TREE_VIEW(prefs_toolbar->list_view_set);
 585         GtkTreeModel *store_set = gtk_tree_view_get_model(list_view_set);
 586         GtkTreeIter iter_set;
 587         GtkTreePath *path;
 588
 589         if (!gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store_set), NULL))
 590                 return;
 591
 592         if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection
 593                                                         (list_view_set),
 594                                              NULL,
 595                                              &iter_set))
 596                 return;
 597
 598         /* select prev list item, if deleted was first select next */
 599         path = gtk_tree_model_get_path(store_set, &iter_set);
 600         gtk_tree_path_prev(path);
 601
 602         gtk_list_store_remove(GTK_LIST_STORE(store_set), &iter_set);
 603
 604         gtk_tree_selection_select_path(
 605                         gtk_tree_view_get_selection(list_view_set),
 606                         path);
 607
 608         gtk_tree_path_free(path);
 609 }
 610
 611 static void prefs_toolbar_up(GtkButton *button, ToolbarPage *prefs_toolbar)
 612 {
 613         GtkTreePath *prev, *sel;
 614         GtkTreeIter isel;
 615         GtkListStore *store = NULL;
 616         GtkTreeModel *model = NULL;
 617         GtkTreeIter iprev;
 618
 619         if (!gtk_tree_selection_get_selected
 620                 (gtk_tree_view_get_selection
 621                         (GTK_TREE_VIEW(prefs_toolbar->list_view_set)),
 622                  &model,
 623                  &isel))
 624                 return;
 625         store = (GtkListStore *)model;
 626
 627         sel = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &isel);
 628         if (!sel)
 629                 return;
 630
 631         /* no move if we're at row 0... */
 632         prev = gtk_tree_path_copy(sel);
 633         if (!gtk_tree_path_prev(prev)) {
 634                 gtk_tree_path_free(prev);
 635                 gtk_tree_path_free(sel);
 636                 return;
 637         }
 638
 639         gtk_tree_model_get_iter(GTK_TREE_MODEL(store),
 640                                 &iprev, prev);
 641         gtk_tree_path_free(sel);
 642         gtk_tree_path_free(prev);
 643
 644         gtk_list_store_swap(store, &iprev, &isel);
 645 }
 646
 647 static void prefs_toolbar_down(GtkButton *button, ToolbarPage *prefs_toolbar)
 648 {
 649         GtkListStore *store = NULL;
 650         GtkTreeModel *model = NULL;
 651         GtkTreeIter next, sel;
 652
 653         if (!gtk_tree_selection_get_selected
 654                 (gtk_tree_view_get_selection
 655                         (GTK_TREE_VIEW(prefs_toolbar->list_view_set)),
 656                  &model,
 657                  &sel))
 658                 return;
 659
 660         store = (GtkListStore *)model;
 661         next = sel;
 662         if (!gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &next))
 663                 return;
 664
 665         gtk_list_store_swap(store, &next, &sel);
 666 }
 667
 668 static void item_type_changed(GtkComboBox *item_type_combo,
 669                                 ToolbarPage *prefs_toolbar)
 670 {
 671         gint active = gtk_combo_box_get_active(item_type_combo);
 672
 673         switch(active) {
 674         case ITEM_FUNCTION:
 675                 gtk_widget_show(prefs_toolbar->item_func_combo);
 676                 gtk_widget_hide(prefs_toolbar->item_action_combo);
 677                 gtk_combo_box_set_active(
 678                         GTK_COMBO_BOX(prefs_toolbar->item_func_combo), 0);
 679                 gtk_button_set_label(GTK_BUTTON(prefs_toolbar->icon_button), "");
 680                 gtk_widget_set_sensitive(prefs_toolbar->item_text_entry, TRUE);
 681                 gtk_widget_set_sensitive(prefs_toolbar->item_func_combo, TRUE);
 682                 gtk_widget_set_sensitive(prefs_toolbar->icon_button, TRUE);
 683
 684                 func_selection_changed(GTK_COMBO_BOX(prefs_toolbar->item_func_combo),
 685                                         prefs_toolbar);
 686                 break;
 687         case ITEM_USER_ACTION:
 688                 gtk_widget_show(prefs_toolbar->item_action_combo);
 689                 gtk_widget_hide(prefs_toolbar->item_func_combo);
 690                 gtk_combo_box_set_active(
 691                         GTK_COMBO_BOX(prefs_toolbar->item_action_combo), 0);
 692                 gtk_button_set_label(GTK_BUTTON(prefs_toolbar->icon_button), "");
 693                 gtk_widget_set_sensitive(prefs_toolbar->item_text_entry, FALSE);
 694                 gtk_widget_set_sensitive(prefs_toolbar->item_action_combo, TRUE);
 695                 gtk_widget_set_sensitive(prefs_toolbar->icon_button, TRUE);
 696
 697                 action_selection_changed(GTK_COMBO_BOX(prefs_toolbar->item_action_combo),
 698                                         prefs_toolbar);
 699                 break;
 700         case ITEM_SEPARATOR:
 701                 gtk_button_set_label(GTK_BUTTON(prefs_toolbar->icon_button), _("None"));
 702                 gtk_button_set_image(GTK_BUTTON(prefs_toolbar->icon_button), NULL);
 703                 g_free(prefs_toolbar->item_icon_file);
 704                 prefs_toolbar->item_icon_file = NULL;
 705                 gtk_combo_box_set_active(
 706                         GTK_COMBO_BOX(prefs_toolbar->item_func_combo), -1);
 707                 gtk_combo_box_set_active(
 708                         GTK_COMBO_BOX(prefs_toolbar->item_action_combo), -1);
 709                 gtk_entry_set_text(GTK_ENTRY(prefs_toolbar->item_text_entry), "");
 710                 gtk_widget_set_sensitive(prefs_toolbar->item_action_combo, FALSE);
 711                 gtk_widget_set_sensitive(prefs_toolbar->item_text_entry, FALSE);
 712                 gtk_widget_set_sensitive(prefs_toolbar->item_func_combo, FALSE);
 713                 gtk_widget_set_sensitive(prefs_toolbar->icon_button, FALSE);
 714                 break;
 715         }
 716
 717 }
 718
 719 static void action_selection_changed(GtkComboBox *action_combo,
 720                                 ToolbarPage *prefs_toolbar)
 721 {
 722         gchar *text = gtk_combo_box_get_active_text(GTK_COMBO_BOX(
 723                            prefs_toolbar->item_action_combo));
 724
 725         if(text != NULL) { /* action */
 726                 gtk_entry_set_text(GTK_ENTRY(prefs_toolbar->item_text_entry), text);
 727                 g_free(text);
 728         }
 729 }
 730
 731 static void func_selection_changed(GtkComboBox *action_combo,
 732                                 ToolbarPage *prefs_toolbar)
 733 {
 734         gchar *text = gtk_combo_box_get_active_text(GTK_COMBO_BOX(
 735                            prefs_toolbar->item_func_combo));
 736
 737         if(text != NULL) { /* action */
 738                 int action = -1;
 739                 action = toolbar_ret_val_from_descr(text);
 740                 if (action >= 0)
 741                         gtk_entry_set_text(GTK_ENTRY(prefs_toolbar->item_text_entry),
 742                                         toolbar_get_short_text(action));
 743                 g_free(text);
 744                 if (action >= 0) {
 745                         StockPixmap stockp = toolbar_get_icon(action);
 746                         if (stockp >= 0)  {
 747                                 g_free(prefs_toolbar->item_icon_file);
 748                                 prefs_toolbar->item_icon_file = g_strdup(stock_pixmap_get_name(stockp));
 749
 750                                 gtk_button_set_image(GTK_BUTTON(prefs_toolbar->icon_button),
 751                                      stock_pixmap_widget(prefs_toolbar->window, stockp));
 752                         }
 753                 }
 754         }
 755 }
 756
 757 static void prefs_toolbar_create(ToolbarPage *prefs_toolbar)
 758 {
 759         GtkWidget *main_vbox;
 760         GtkWidget *toolbar_item_hbox;
 761         GtkWidget *icon_vbox;
 762         GtkWidget *icon_label;
 763         GtkWidget *icon_button;
 764         GtkWidget *icon_hbox;
 765         GtkWidget *item_type_combo;
 766         GtkWidget *item_action_combo;
 767         GtkWidget *item_func_combo;
 768         GtkWidget *reg_hbox;
 769         GtkWidget *arrow;
 770         GtkWidget *btn_hbox;
 771 #ifdef MAEMO
 772         GtkWidget *hbox;
 773 #endif
 774         GtkWidget *reg_btn;
 775         GtkWidget *subst_btn;
 776         GtkWidget *del_btn;
 777         GtkWidget *default_btn;
 778         GtkWidget *vbox_frame;
 779         GtkWidget *table;
 780         GtkWidget *label_icon_text;
 781         GtkWidget *item_text_entry;
 782         GtkWidget *vbox_toolbar_items;
 783         GtkWidget *hbox_bottom;
 784         GtkWidget *scrolledwindow_list_view_set;
 785         GtkWidget *list_view_set;
 786         GtkWidget *label;
 787
 788         GtkWidget *btn_vbox;
 789         GtkWidget *up_btn;
 790         GtkWidget *down_btn;
 791
 792         debug_print("Creating custom toolbar window...\n");
 793
 794         main_vbox = gtk_vbox_new(FALSE, 0);
 795         gtk_widget_show(main_vbox);
 796
 797         vbox_frame = gtk_frame_new(_("Toolbar item"));
 798         gtk_widget_show(vbox_frame);
 799         gtk_box_pack_start(GTK_BOX(main_vbox), vbox_frame, FALSE, TRUE, 0);
 800
 801         toolbar_item_hbox = gtk_hbox_new (FALSE, 4);
 802         gtk_widget_show(toolbar_item_hbox);
 803         gtk_container_add(GTK_CONTAINER (vbox_frame), toolbar_item_hbox);
 804
 805         table = gtk_table_new (3, 3, FALSE);
 806         gtk_box_pack_start(GTK_BOX(toolbar_item_hbox), table,
 807                            TRUE, TRUE, 0);
 808         gtk_container_set_border_width (GTK_CONTAINER (table), 8);
 809         gtk_table_set_row_spacings (GTK_TABLE (table), 8);
 810         gtk_table_set_col_spacings (GTK_TABLE (table), 8);
 811
 812         /* toolbar item type */
 813         label = gtk_label_new(_("Item type"));
 814         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 815         gtk_widget_show(label);
 816         gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
 817                          (GtkAttachOptions) (GTK_FILL),
 818                          (GtkAttachOptions) (0), 0, 0);
 819
 820         item_type_combo = combobox_text_new(FALSE, _("Internal Function"),
 821                                 _("User Action"), _("Separator"), NULL);
 822         gtk_widget_set_size_request(item_type_combo, 200, -1);
 823         gtk_table_attach(GTK_TABLE(table), item_type_combo, 1, 3, 0, 1,
 824                          (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 825                          (GtkAttachOptions) (0), 0, 0);
 826
 827         /* available actions */
 828         label = gtk_label_new(_("Event executed on click"));
 829         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 830         gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
 831                           (GtkAttachOptions) (GTK_FILL),
 832                           (GtkAttachOptions) (0), 0, 0);
 833
 834         item_action_combo = gtk_combo_box_new_text();
 835         gtk_widget_set_size_request(item_action_combo, 200, -1);
 836         gtk_table_attach (GTK_TABLE (table), item_action_combo, 1, 3, 1, 2,
 837                           (GtkAttachOptions) (GTK_FILL),
 838                           (GtkAttachOptions) (0), 0, 0);
 839
 840         /* available internal functions */
 841         item_func_combo = gtk_combo_box_new_text();
 842         gtk_widget_set_size_request(item_func_combo, 200, -1);
 843         gtk_table_attach (GTK_TABLE (table), item_func_combo, 1, 3, 1, 2,
 844                           (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 845                           (GtkAttachOptions) (0), 0, 0);
 846
 847         /* toolbar item description */
 848         label_icon_text = gtk_label_new(_("Toolbar text"));
 849         gtk_misc_set_alignment(GTK_MISC(label_icon_text), 0, 0.5);
 850         gtk_widget_show (label_icon_text);
 851         gtk_table_attach (GTK_TABLE (table), label_icon_text, 0, 1, 2, 3,
 852                           (GtkAttachOptions) (GTK_FILL),
 853                           (GtkAttachOptions) (0), 0, 0);
 854
 855         item_text_entry = gtk_entry_new();
 856         gtk_table_attach (GTK_TABLE (table), item_text_entry, 1, 3, 2, 3,
 857                           (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 858                           (GtkAttachOptions) (0), 0, 0);
 859
 860         icon_vbox = gtk_vbox_new(FALSE, VBOX_BORDER);
 861         gtk_widget_show(icon_vbox);
 862
 863         icon_label = gtk_label_new(_("Icon"));
 864         gtk_widget_set_size_request(icon_label, 100, -1);
 865         gtk_box_pack_start(GTK_BOX(icon_vbox), icon_label, FALSE, FALSE, 0);
 866
 867         icon_hbox = gtk_hbox_new(FALSE, 0);
 868         gtk_widget_show(icon_hbox);
 869
 870         label = gtk_label_new("");
 871         gtk_box_pack_start(GTK_BOX(icon_hbox), label, TRUE, TRUE, 0);
 872
 873         icon_button = gtk_button_new();
 874         gtk_widget_show(icon_button);
 875         gtk_widget_set_size_request(icon_button, 50, 50);
 876         g_signal_connect(G_OBJECT(icon_button), "clicked",
 877                          G_CALLBACK(icon_chooser_create), prefs_toolbar);
 878         gtk_box_pack_start(GTK_BOX(icon_hbox), icon_button, FALSE, FALSE, 8);
 879
 880         label = gtk_label_new("");
 881         gtk_box_pack_start(GTK_BOX(icon_hbox), label, TRUE, TRUE, 0);
 882
 883         gtk_box_pack_start(GTK_BOX(icon_vbox), icon_hbox, FALSE, FALSE, 0);
 884
 885         gtk_box_pack_start(GTK_BOX(toolbar_item_hbox), icon_vbox, FALSE, FALSE, 0);
 886
 887         /* register / substitute / delete */
 888         reg_hbox = gtk_hbox_new(FALSE, 4);
 889         gtk_box_pack_start(GTK_BOX(main_vbox), reg_hbox, FALSE, FALSE, 0);
 890         gtk_container_set_border_width(GTK_CONTAINER(reg_hbox), 10);
 891
 892         arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 893         gtk_box_pack_start(GTK_BOX(reg_hbox), arrow, FALSE, FALSE, 0);
 894         gtk_widget_set_size_request(arrow, -1, 16);
 895
 896         btn_hbox = gtk_hbox_new(TRUE, 4);
 897         gtk_box_pack_start(GTK_BOX(reg_hbox), btn_hbox, FALSE, FALSE, 0);
 898
 899         reg_btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
 900         gtk_box_pack_start(GTK_BOX(btn_hbox), reg_btn, FALSE, TRUE, 0);
 901         g_signal_connect(G_OBJECT(reg_btn), "clicked",
 902                          G_CALLBACK(prefs_toolbar_register),
 903                          prefs_toolbar);
 904
 905         subst_btn = gtkut_get_replace_btn(_("Replace"));
 906         gtk_box_pack_start(GTK_BOX(btn_hbox), subst_btn, FALSE, TRUE, 0);
 907         g_signal_connect(G_OBJECT(subst_btn), "clicked",
 908                          G_CALLBACK(prefs_toolbar_substitute),
 909                          prefs_toolbar);
 910
 911         del_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
 912         gtk_box_pack_start(GTK_BOX(btn_hbox), del_btn, FALSE, TRUE, 0);
 913         g_signal_connect(G_OBJECT(del_btn), "clicked",
 914                          G_CALLBACK(prefs_toolbar_delete),
 915                           prefs_toolbar);
 916
 917         default_btn = gtk_button_new_with_label(_(" Use default "));
 918 #ifndef MAEMO
 919         gtk_box_pack_end(GTK_BOX(reg_hbox), default_btn, FALSE, TRUE, 0);
 920 #else
 921         hbox = gtk_hbox_new(FALSE, 0);
 922         gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
 923         gtk_box_pack_start(GTK_BOX(hbox), default_btn, FALSE, FALSE, 0);
 924 #endif
 925         g_signal_connect(G_OBJECT(default_btn), "clicked",
 926                          G_CALLBACK(prefs_toolbar_default),
 927                          prefs_toolbar);
 928
 929         /* currently active toolbar items */
 930         vbox_toolbar_items = gtk_vbox_new(FALSE, VBOX_BORDER);
 931         gtk_box_pack_start(GTK_BOX(main_vbox), vbox_toolbar_items, TRUE, TRUE, 0);
 932
 933         hbox_bottom = gtk_hbox_new(FALSE, 0);
 934         gtk_container_add(GTK_CONTAINER(vbox_toolbar_items), hbox_bottom);
 935
 936         scrolledwindow_list_view_set = gtk_scrolled_window_new(NULL, NULL);
 937         gtk_box_pack_start(GTK_BOX(hbox_bottom), scrolledwindow_list_view_set, TRUE, TRUE, 0);
 938         gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow_list_view_set), 1);
 939         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_list_view_set),
 940                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 941         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_list_view_set),
 942                                             GTK_SHADOW_IN);
 943
 944         list_view_set = create_set_list_view(prefs_toolbar);
 945         gtk_widget_show(list_view_set);
 946         gtk_container_add(GTK_CONTAINER(scrolledwindow_list_view_set), list_view_set);
 947         gtk_widget_set_size_request(list_view_set, 225, 120);
 948
 949         btn_vbox = gtk_vbox_new(FALSE, 8);
 950         gtk_widget_show(btn_vbox);
 951         gtk_box_pack_start(GTK_BOX(hbox_bottom), btn_vbox, FALSE, FALSE, 5);
 952
 953         up_btn = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
 954         gtk_widget_show(up_btn);
 955         gtk_box_pack_start(GTK_BOX(btn_vbox), up_btn, FALSE, FALSE, 2);
 956
 957         down_btn = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
 958         gtk_widget_show(down_btn);
 959         gtk_box_pack_start(GTK_BOX(btn_vbox), down_btn, FALSE, FALSE, 0);
 960
 961         g_signal_connect(G_OBJECT(item_type_combo), "changed",
 962                          G_CALLBACK(item_type_changed), prefs_toolbar);
 963         g_signal_connect(G_OBJECT(item_action_combo), "changed",
 964                          G_CALLBACK(action_selection_changed), prefs_toolbar);
 965         g_signal_connect(G_OBJECT(item_func_combo), "changed",
 966                          G_CALLBACK(func_selection_changed), prefs_toolbar);
 967         g_signal_connect(G_OBJECT(up_btn), "clicked",
 968                          G_CALLBACK(prefs_toolbar_up), prefs_toolbar);
 969         g_signal_connect(G_OBJECT(down_btn), "clicked",
 970                          G_CALLBACK(prefs_toolbar_down), prefs_toolbar);
 971
 972         gtk_widget_show_all(main_vbox);
 973
 974         prefs_toolbar->list_view_set    = list_view_set;
 975         prefs_toolbar->item_text_entry  = item_text_entry;
 976         prefs_toolbar->item_type_combo  = item_type_combo;
 977         prefs_toolbar->item_func_combo  = item_func_combo;
 978         prefs_toolbar->item_action_combo= item_action_combo;
 979         prefs_toolbar->icon_button      = icon_button;
 980         prefs_toolbar->item_icon_file   = NULL;
 981
 982         prefs_toolbar->page.widget = main_vbox;
 983 }
 984
 985 ToolbarPage *prefs_toolbar_mainwindow;
 986 ToolbarPage *prefs_toolbar_composewindow;
 987 ToolbarPage *prefs_toolbar_messageview;
 988
 989 void prefs_toolbar_init(void)
 990 {
 991         ToolbarPage *page;
 992         static gchar *mainpath[3], *messagepath[3], *composepath[3];
 993
 994         mainpath[0] = _("Customize Toolbars");
 995         mainpath[1] = _("Main Window");
 996         mainpath[2] = NULL;
 997
 998         page = g_new0(ToolbarPage, 1);
 999         page->page.path = mainpath;
1000         page->page.create_widget = prefs_toolbar_create_widget;
1001         page->page.destroy_widget = prefs_toolbar_destroy_widget;
1002         page->page.save_page = prefs_toolbar_save;
1003         page->source = TOOLBAR_MAIN;
1004         page->page.weight = 50.0;
1005         prefs_gtk_register_page((PrefsPage *) page);
1006         prefs_toolbar_mainwindow = page;
1007
1008         messagepath[0] = _("Customize Toolbars");
1009         messagepath[1] = _("Message Window");
1010         messagepath[2] = NULL;
1011
1012         page = g_new0(ToolbarPage, 1);
1013         page->page.path = messagepath;
1014         page->page.create_widget = prefs_toolbar_create_widget;
1015         page->page.destroy_widget = prefs_toolbar_destroy_widget;
1016         page->page.save_page = prefs_toolbar_save;
1017         page->source = TOOLBAR_MSGVIEW;
1018         page->page.weight = 45.0;
1019         prefs_gtk_register_page((PrefsPage *) page);
1020         prefs_toolbar_messageview = page;
1021
1022         composepath[0] = _("Customize Toolbars");
1023         composepath[1] = _("Compose Window");
1024         composepath[2] = NULL;
1025
1026         page = g_new0(ToolbarPage, 1);
1027         page->page.path = composepath;
1028         page->page.create_widget = prefs_toolbar_create_widget;
1029         page->page.destroy_widget = prefs_toolbar_destroy_widget;
1030         page->page.save_page = prefs_toolbar_save;
1031         page->source = TOOLBAR_COMPOSE;
1032         page->page.weight = 40.0;
1033         prefs_gtk_register_page((PrefsPage *) page);
1034         prefs_toolbar_composewindow = page;
1035 }
1036
1037 void prefs_toolbar_done(void)
1038 {
1039         prefs_gtk_unregister_page((PrefsPage *) prefs_toolbar_mainwindow);
1040         g_free(prefs_toolbar_mainwindow->item_icon_file);
1041         g_free(prefs_toolbar_mainwindow);
1042         prefs_gtk_unregister_page((PrefsPage *) prefs_toolbar_composewindow);
1043         g_free(prefs_toolbar_composewindow->item_icon_file);
1044         g_free(prefs_toolbar_composewindow);
1045         prefs_gtk_unregister_page((PrefsPage *) prefs_toolbar_messageview);
1046         g_free(prefs_toolbar_messageview->item_icon_file);
1047         g_free(prefs_toolbar_messageview);
1048 }
1049
1050 static void set_visible_if_not_text(GtkTreeViewColumn *col,
1051                                     GtkCellRenderer   *renderer,
1052                                     GtkTreeModel      *model,
1053                                     GtkTreeIter       *iter,
1054                                     gpointer           user_data)
1055 {
1056         gboolean is_text;
1057         GdkPixbuf *pixbuf;
1058
1059         gtk_tree_model_get(model, iter, SET_ICON_IS_TEXT, &is_text, -1);
1060         if (is_text) {
1061                 g_object_set(renderer, "visible", FALSE, NULL);
1062         } else {
1063                 pixbuf = NULL;
1064                 gtk_tree_model_get(model, iter,
1065                                    SET_ICON, &pixbuf,
1066                                    -1);
1067                 /* note getting a pixbuf from a tree model increases
1068                  * its refcount ... */
1069                 g_object_unref(pixbuf);
1070
1071                 g_object_set(renderer, "visible", TRUE, NULL);
1072                 g_object_set(renderer, "pixbuf",  pixbuf, NULL);
1073         }
1074 }
1075
1076 static GtkWidget *create_set_list_view(ToolbarPage *prefs_toolbar)
1077 {
1078         GtkTreeView *list_view;
1079         GtkListStore *store;
1080         GtkCellRenderer *renderer;
1081         GtkTreeViewColumn *column;
1082         GtkTreeSelection *selector;
1083
1084         store = gtk_list_store_new(N_SET_COLUMNS,
1085                                    GDK_TYPE_PIXBUF,
1086                                    G_TYPE_STRING,
1087                                    G_TYPE_STRING,
1088                                    G_TYPE_STRING,
1089                                    G_TYPE_STRING,
1090                                    G_TYPE_BOOLEAN,
1091                                    -1);
1092         list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)));
1093         g_object_unref(G_OBJECT(store));
1094
1095         column = gtk_tree_view_column_new();
1096         gtk_tree_view_column_set_title(column, _("Icon"));
1097         renderer = gtk_cell_renderer_pixbuf_new();
1098         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1099
1100         /* tell pixbuf renderer it is only visible if
1101          * the icon is not represented by text */
1102         gtk_tree_view_column_set_cell_data_func(column, renderer,
1103                                                 set_visible_if_not_text,
1104                                                 NULL, NULL);
1105
1106         renderer = gtk_cell_renderer_text_new();
1107         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1108
1109         /* tell the text renderer it is only visible if the icon
1110          * is represented by an image */
1111         gtk_tree_view_column_set_attributes(column, renderer,
1112                                             "visible", SET_ICON_IS_TEXT,
1113                                             "text", SET_ICON_TEXT,
1114                                             NULL);
1115
1116         gtk_tree_view_append_column(list_view, column);
1117
1118         column = gtk_tree_view_column_new();
1119         gtk_tree_view_column_set_title(column, _("Icon text"));
1120         renderer = gtk_cell_renderer_text_new();
1121         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1122         gtk_tree_view_column_set_attributes(column, renderer,
1123                                             "text", SET_TEXT,
1124                                             NULL);
1125         gtk_tree_view_append_column(list_view, column);
1126
1127         column = gtk_tree_view_column_new();
1128         gtk_tree_view_column_set_title(column, _("Mapped event"));
1129         renderer = gtk_cell_renderer_text_new();
1130         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1131         gtk_tree_view_column_set_attributes(column, renderer,
1132                                             "text", SET_EVENT,
1133                                             NULL);
1134         gtk_tree_view_append_column(list_view, column);
1135
1136         /* various other tree view attributes */
1137         gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere);
1138
1139         selector = gtk_tree_view_get_selection(list_view);
1140         gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
1141         gtk_tree_selection_set_select_function
1142                 (selector, (GtkTreeSelectionFunc) set_list_selected,
1143                  prefs_toolbar, NULL);
1144
1145         return GTK_WIDGET(list_view);
1146
1147 }
1148
1149 static gboolean set_list_selected(GtkTreeSelection *selector,
1150                                   GtkTreeModel *model,
1151                                   GtkTreePath *path,
1152                                   gboolean currently_selected,
1153                                   ToolbarPage *prefs_toolbar)
1154 {
1155
1156         GtkTreeIter iter;
1157         gchar *icon_text, *icon_file, *descr;
1158         GList *cur;
1159         GSList *cur2;
1160         gint item_num;
1161         GdkPixbuf *pix;
1162
1163         if (currently_selected || !gtk_tree_model_get_iter(model, &iter, path))
1164                 return TRUE;
1165
1166         gtk_tree_model_get(model, &iter,
1167                            SET_ICON, &pix,
1168                            SET_TEXT, &icon_text,
1169                            SET_EVENT, &descr,
1170                            SET_FILENAME, &icon_file,
1171                            -1);
1172
1173         g_free(prefs_toolbar->item_icon_file);
1174         prefs_toolbar->item_icon_file = icon_file;
1175         gtk_button_set_image(GTK_BUTTON(prefs_toolbar->icon_button),
1176                              gtk_image_new_from_pixbuf(pix));
1177
1178         if (g_utf8_collate(toolbar_ret_descr_from_val(A_SEPARATOR), descr) == 0) {
1179                 gtk_button_set_label(GTK_BUTTON(prefs_toolbar->icon_button),
1180                                     _("None"));
1181                 g_free(prefs_toolbar->item_icon_file);
1182                 prefs_toolbar->item_icon_file = NULL;
1183                 gtk_combo_box_set_active(GTK_COMBO_BOX(prefs_toolbar->item_type_combo),
1184                                         ITEM_SEPARATOR);
1185                 g_free(icon_text);
1186                 g_free(descr);
1187
1188                 return TRUE;
1189         }
1190
1191         gtk_button_set_label(GTK_BUTTON(prefs_toolbar->icon_button), "");
1192         gtk_entry_set_text(GTK_ENTRY(prefs_toolbar->item_text_entry),
1193                            icon_text);
1194
1195         if (g_utf8_collate(toolbar_ret_descr_from_val(A_SYL_ACTIONS), descr) == 0) {
1196                 gtk_combo_box_set_active(GTK_COMBO_BOX(
1197                         prefs_toolbar->item_type_combo), ITEM_USER_ACTION);
1198
1199                 for(cur2 = prefs_common.actions_list, item_num = 0; cur2 != NULL;
1200                     cur2 = cur2->next) {
1201                         gchar *item_string;
1202                         get_action_name((gchar *)cur2->data, &item_string);
1203
1204                         if(g_utf8_collate(item_string, icon_text) == 0) {
1205                                 gtk_combo_box_set_active(
1206                                         GTK_COMBO_BOX(prefs_toolbar->item_action_combo),
1207                                         item_num);
1208                                 g_free(item_string);
1209                                 break;
1210                         }
1211                         else {
1212                                 item_num++;
1213                                 g_free(item_string);
1214                         }
1215                 }
1216
1217                 gtk_widget_show(prefs_toolbar->item_action_combo);
1218                 gtk_widget_hide(prefs_toolbar->item_func_combo);
1219
1220                 g_free(icon_text);
1221                 g_free(descr);
1222
1223                 return TRUE;
1224         }
1225
1226         /* scan combo list for selected description an set combo item accordingly */
1227         for (cur = prefs_toolbar->combo_action_list, item_num = 0; cur != NULL;
1228              cur = cur->next) {
1229                 gchar *item_str = (gchar*)cur->data;
1230                 if (g_utf8_collate(item_str, descr) == 0) {
1231                         gtk_combo_box_set_active(
1232                                 GTK_COMBO_BOX(prefs_toolbar->item_func_combo),
1233                                 item_num);
1234
1235                         break;
1236                 }
1237                 else
1238                         item_num++;
1239         }
1240
1241         gtk_combo_box_set_active(GTK_COMBO_BOX(
1242                         prefs_toolbar->item_type_combo),ITEM_FUNCTION);
1243         gtk_widget_hide(prefs_toolbar->item_action_combo);
1244         gtk_widget_show(prefs_toolbar->item_func_combo);
1245
1246         g_free(icon_text);
1247         g_free(descr);
1248
1249         return TRUE;
1250 }
1251
1252 static void icon_chooser_ok_clicked(GtkButton *button,
1253                                         ToolbarPage *prefs_toolbar)
1254 {
1255         GtkTreeModel *model;
1256         GtkTreeIter iter;
1257         GList *list;
1258         GdkPixbuf *pix;
1259         gchar *icon_file;
1260
1261         g_return_if_fail(prefs_toolbar != NULL);
1262
1263         model = gtk_icon_view_get_model(GTK_ICON_VIEW(prefs_toolbar->icon_chooser_view));
1264         list = gtk_icon_view_get_selected_items(GTK_ICON_VIEW(prefs_toolbar->icon_chooser_view));
1265         if(list == NULL)
1266                 return;
1267
1268         if(!gtk_tree_model_get_iter(model, &iter, (GtkTreePath *)list->data)) {
1269                 gtk_tree_path_free(list->data);
1270                 g_list_free(list);
1271                 return;
1272         }
1273
1274         gtk_tree_model_get(model, &iter,
1275                            SET_ICON, &pix,
1276                            SET_FILENAME, &icon_file,
1277                            -1);
1278
1279         g_free(prefs_toolbar->item_icon_file);
1280         prefs_toolbar->item_icon_file = icon_file;
1281         gtk_button_set_image(GTK_BUTTON(prefs_toolbar->icon_button),
1282                              gtk_image_new_from_pixbuf(pix));
1283
1284         gtk_widget_destroy(prefs_toolbar->icon_chooser_win);
1285         prefs_toolbar->icon_chooser_win = NULL;
1286         prefs_toolbar->icon_chooser_view = NULL;
1287
1288         gtk_tree_path_free(list->data);
1289         g_list_free(list);
1290 }
1291
1292 static void icon_chooser_cancel_clicked(GtkButton *button,
1293                                         ToolbarPage *prefs_toolbar)
1294 {
1295         g_return_if_fail(prefs_toolbar != NULL);
1296
1297         gtk_widget_destroy(prefs_toolbar->icon_chooser_win);
1298         prefs_toolbar->icon_chooser_win = NULL;
1299         prefs_toolbar->icon_chooser_view = NULL;
1300 }
1301
1302 static gboolean icon_chooser_key_pressed(GtkWidget *widget, GdkEventKey *event,
1303                         ToolbarPage *prefs_toolbar)
1304 {
1305         if (event && event->keyval == GDK_Escape) {
1306                 icon_chooser_cancel_clicked(NULL, prefs_toolbar);
1307                 return TRUE;
1308         }
1309
1310         return FALSE;
1311 }
1312
1313 static gboolean icon_list_key_pressed(GtkWidget *widget, GdkEventKey *event,
1314                         ToolbarPage *prefs_toolbar)
1315 {
1316         if (event) {
1317                 if (event->keyval == GDK_KP_Enter ||
1318                     event->keyval == GDK_Return ||
1319                     event->keyval == GDK_space) {
1320                         icon_chooser_ok_clicked(NULL, prefs_toolbar);
1321                         return TRUE;
1322                 }
1323         }
1324         return FALSE;
1325 }
1326
1327 static gboolean ok_cb(gpointer data)
1328 {
1329         ToolbarPage *prefs_toolbar = (ToolbarPage *)data;
1330         icon_chooser_ok_clicked(NULL, prefs_toolbar);
1331         return FALSE;
1332 }
1333
1334 static gboolean icon_list_button_release(GtkWidget *widget,
1335                                                GdkEventButton *event,
1336                                                ToolbarPage *prefs_toolbar )
1337 {
1338         static guint id = -1;
1339         if (id >= 0) {
1340                 g_source_remove(id);
1341                 id = -1;
1342         }
1343         id = g_timeout_add(100, ok_cb, prefs_toolbar);
1344         return FALSE;
1345 }
1346
1347 static gboolean icon_window_button_press(GtkWidget *widget,
1348                                                GdkEventButton *event,
1349                                                ToolbarPage *prefs_toolbar )
1350 {
1351         GtkWidget *event_widget, *button;
1352         gboolean restore = TRUE;
1353
1354         button = prefs_toolbar->icon_button;
1355
1356         /* Test where mouse was clicked */
1357         event_widget = gtk_get_event_widget((GdkEvent *)event);
1358         if (event_widget != widget) {
1359                 while (event_widget) {
1360                         if (event_widget == widget)
1361                                 return FALSE;
1362                         else if (event_widget == prefs_toolbar->icon_chooser_win) {
1363                                 restore = FALSE;
1364                                 break;
1365                         }
1366                         event_widget = event_widget->parent;
1367                 }
1368         }
1369
1370         if (restore) {
1371                 icon_chooser_cancel_clicked(NULL, prefs_toolbar);
1372                 return TRUE;
1373         }
1374         return FALSE;
1375 }
1376
1377 static void icon_chooser_activated(GtkTreeView *treeview, GtkTreePath *path,
1378                                 ToolbarPage *prefs_toolbar)
1379 {
1380         icon_chooser_ok_clicked(NULL, prefs_toolbar);
1381 }
1382
1383 static void icon_chooser_create(GtkButton *button, ToolbarPage *prefs_toolbar)
1384 {
1385         GtkWidget *icon_chooser_win;
1386         GtkWidget *scrollwin;
1387         GtkWidget *icon_view;
1388         GtkListStore *store;
1389         GtkTreeIter iter;
1390         gint i, x, y;
1391
1392         store = gtk_list_store_new(2,
1393                                    GDK_TYPE_PIXBUF,
1394                                    G_TYPE_STRING,
1395                                    -1);
1396
1397         gtk_list_store_clear(store);
1398
1399         for (i = 0; ToolbarIcons[i] != STOCK_PIXMAP_EMPTY; i++) {
1400                 GdkPixbuf *pixbuf;
1401                 stock_pixbuf_gdk(prefs_toolbar->window, ToolbarIcons[i], &pixbuf);
1402
1403                 gtk_list_store_append(store, &iter);
1404                 gtk_list_store_set(store, &iter,
1405                                    SET_ICON, pixbuf,
1406                                    SET_FILENAME, stock_pixmap_get_name((StockPixmap) ToolbarIcons[i]),
1407                                    -1);
1408         }
1409
1410         icon_chooser_win = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_toolbar");
1411         gtk_window_set_title(GTK_WINDOW(icon_chooser_win), _("Toolbar item icon"));
1412 #ifndef MAEMO
1413         gtk_window_set_decorated(GTK_WINDOW(icon_chooser_win), FALSE);
1414 #endif
1415         gdk_window_get_origin(GTK_WIDGET(prefs_toolbar->icon_button)->window,
1416                         &x, &y);
1417         x += GTK_WIDGET(prefs_toolbar->icon_button)->allocation.x;
1418         y += GTK_WIDGET(prefs_toolbar->icon_button)->allocation.y;
1419         y += 50;
1420         x -= 300-50;
1421         gtk_window_move(GTK_WINDOW(icon_chooser_win), x, y);
1422         gtk_window_set_resizable(GTK_WINDOW(icon_chooser_win), FALSE);
1423         gtk_widget_set_size_request(icon_chooser_win, 300, 320);
1424
1425         scrollwin = gtk_scrolled_window_new(NULL, NULL);
1426         gtk_container_add(GTK_CONTAINER(icon_chooser_win), scrollwin);
1427         gtk_widget_show(scrollwin);
1428         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
1429                                 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1430         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin),
1431                                 GTK_SHADOW_OUT);
1432
1433         icon_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(store));
1434         gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(icon_view), GTK_SELECTION_SINGLE);
1435         gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), SET_ICON);
1436         gtk_container_add(GTK_CONTAINER(scrollwin), GTK_WIDGET(icon_view));
1437
1438         g_signal_connect(G_OBJECT(icon_chooser_win), "key_press_event",
1439                          G_CALLBACK(icon_chooser_key_pressed), prefs_toolbar);
1440         g_signal_connect(G_OBJECT(icon_view), "item-activated",
1441                          G_CALLBACK(icon_chooser_activated), prefs_toolbar);
1442         g_signal_connect(G_OBJECT(icon_chooser_win),
1443                          "button-press-event",
1444                          G_CALLBACK(icon_window_button_press),
1445                          prefs_toolbar );
1446         g_signal_connect(G_OBJECT(icon_view),
1447                          "button-release-event",
1448                          G_CALLBACK(icon_list_button_release),
1449                          prefs_toolbar );
1450         g_signal_connect(G_OBJECT(icon_view), "key_press_event",
1451                          G_CALLBACK(icon_list_key_pressed), prefs_toolbar);
1452
1453         gtk_widget_show_all(icon_chooser_win);
1454         gtk_widget_grab_focus(GTK_WIDGET(icon_view));
1455         gtk_window_set_modal(GTK_WINDOW(icon_chooser_win), TRUE);
1456
1457         prefs_toolbar->icon_chooser_win         = icon_chooser_win;
1458         prefs_toolbar->icon_chooser_view        = icon_view;
1459 }