2012-04-01 [colin] 3.8.0cvs36
[claws.git] / src / toolbar.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001-2011 Hiroyuki Yamamoto and 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 <stdio.h>
33 #include <stdlib.h>
34 #include <dirent.h>
35 #include <sys/stat.h>
36 #include <math.h>
37 #include <setjmp.h>
38
39 #include "main.h"
40 #include "mainwindow.h"
41 #include "summaryview.h"
42 #include "compose.h"
43 #include "utils.h"
44 #include "xml.h"
45 #include "mgutils.h"
46 #include "prefs_gtk.h"
47 #include "codeconv.h"
48 #include "stock_pixmap.h"
49 #include "manage_window.h"
50 #include "gtkutils.h"
51 #include "toolbar.h"
52 #include "menu.h"
53 #include "inc.h"
54 #include "action.h"
55 #include "prefs_actions.h"
56 #include "prefs_common.h"
57 #include "prefs_toolbar.h"
58 #include "alertpanel.h"
59 #include "imap.h"
60 #ifdef USE_NEW_ADDRBOOK
61         #include "addressbook-dbus.h"
62 #endif
63
64 /* elements */
65 #define TOOLBAR_TAG_INDEX        "toolbar"
66 #define TOOLBAR_TAG_ITEM         "item"
67 #define TOOLBAR_TAG_SEPARATOR    "separator"
68
69 #define TOOLBAR_ICON_FILE   "file"    
70 #define TOOLBAR_ICON_TEXT   "text"     
71 #define TOOLBAR_ICON_ACTION "action"    
72
73 static void toolbar_init(Toolbar * toolbar);
74 static gboolean      toolbar_is_duplicate               (gint           action,
75                                                  ToolbarType    source);
76 static void   toolbar_parse_item                (XMLFile        *file,
77                                                  ToolbarType    source);
78
79 static gint   toolbar_ret_val_from_text         (const gchar    *text);
80 static gchar *toolbar_ret_text_from_val         (gint           val);
81
82 static void   toolbar_set_default_main          (void);
83 static void   toolbar_set_default_compose       (void);
84 static void   toolbar_set_default_msgview       (void);
85
86 static void     toolbar_style                   (ToolbarType     type, 
87                                                  guint           action, 
88                                                  gpointer        data);
89
90 static MainWindow *get_mainwin                  (gpointer data);
91 static void activate_compose_button             (Toolbar        *toolbar,
92                                                  ToolbarStyle    style,
93                                                  ComposeButtonType type);
94
95 /* toolbar callbacks */
96 static void toolbar_reply                       (gpointer        data, 
97                                                  guint           action);
98 static void toolbar_learn                       (gpointer        data, 
99                                                  guint           action);
100 static void toolbar_delete_cb                   (GtkWidget      *widget,
101                                                  gpointer        data);
102 static void toolbar_trash_cb                    (GtkWidget      *widget,
103                                                  gpointer        data);
104
105 static void toolbar_compose_cb                  (GtkWidget      *widget,
106                                                  gpointer        data);
107
108 static void toolbar_learn_cb                    (GtkWidget      *widget,
109                                                  gpointer        data);
110
111 static void toolbar_reply_cb                    (GtkWidget      *widget,
112                                                  gpointer        data);
113
114 static void toolbar_reply_to_all_cb             (GtkWidget      *widget,
115                                                  gpointer        data);
116
117 static void toolbar_reply_to_list_cb            (GtkWidget      *widget,
118                                                  gpointer        data);
119
120 static void toolbar_reply_to_sender_cb          (GtkWidget      *widget,
121                                                  gpointer        data);
122
123 static void toolbar_forward_cb                  (GtkWidget      *widget,
124                                                  gpointer        data);
125
126 static void toolbar_prev_unread_cb              (GtkWidget      *widget,
127                                                  gpointer        data);
128 static void toolbar_next_unread_cb              (GtkWidget      *widget,
129                                                  gpointer        data);
130
131 static void toolbar_ignore_thread_cb            (GtkWidget      *widget,
132                                                  gpointer        data);
133
134 static void toolbar_watch_thread_cb             (GtkWidget      *widget,
135                                                  gpointer        data);
136
137 static void toolbar_print_cb                    (GtkWidget      *widget,
138                                                  gpointer        data);
139
140 static void toolbar_actions_execute_cb          (GtkWidget      *widget,
141                                                  gpointer        data);
142 static void toolbar_plugins_execute_cb      (GtkWidget      *widget,
143                              gpointer        data);
144
145
146 static void toolbar_send_cb                     (GtkWidget      *widget,
147                                                  gpointer        data);
148 static void toolbar_send_later_cb               (GtkWidget      *widget,
149                                                  gpointer        data);
150 static void toolbar_draft_cb                    (GtkWidget      *widget,
151                                                  gpointer        data);
152 static void toolbar_close_cb                    (GtkWidget      *widget,
153                                                  gpointer        data);
154 static void toolbar_preferences_cb              (GtkWidget      *widget,
155                                                  gpointer        data);
156 static void toolbar_open_mail_cb                (GtkWidget      *widget,
157                                                  gpointer        data);
158 static void toolbar_insert_cb                   (GtkWidget      *widget,
159                                                  gpointer        data);
160 static void toolbar_attach_cb                   (GtkWidget      *widget,
161                                                  gpointer        data);
162 static void toolbar_sig_cb                      (GtkWidget      *widget,
163                                                  gpointer        data);
164 static void toolbar_ext_editor_cb               (GtkWidget      *widget,
165                                                  gpointer        data);
166 static void toolbar_linewrap_current_cb         (GtkWidget      *widget,
167                                                  gpointer        data);
168 static void toolbar_linewrap_all_cb             (GtkWidget      *widget,
169                                                  gpointer        data);
170 static void toolbar_addrbook_cb                 (GtkWidget      *widget, 
171                                                  gpointer        data);
172 #ifdef USE_ENCHANT
173 static void toolbar_check_spelling_cb           (GtkWidget      *widget, 
174                                                  gpointer        data);
175 #endif
176 static void toolbar_cancel_inc_cb               (GtkWidget      *widget,
177                                                  gpointer        data);
178
179 struct {
180         gchar *index_str;
181         const gchar *descr;
182 } toolbar_text [] = {
183         { "A_RECEIVE_ALL",      N_("Receive Mail from all Accounts")       },
184         { "A_RECEIVE_CUR",      N_("Receive Mail from current Account")    },
185         { "A_SEND_QUEUED",      N_("Send Queued Messages")                 },
186         { "A_COMPOSE_EMAIL",    N_("Compose Email")                        },
187         { "A_COMPOSE_NEWS",     N_("Compose News")                         },
188         { "A_REPLY_MESSAGE",    N_("Reply to Message")                     },
189         { "A_REPLY_SENDER",     N_("Reply to Sender")                      },
190         { "A_REPLY_ALL",        N_("Reply to All")                         },
191         { "A_REPLY_ML",         N_("Reply to Mailing-list")                },
192         { "A_OPEN_MAIL",        N_("Open email")                           },
193         { "A_FORWARD",          N_("Forward Message")                      }, 
194         { "A_TRASH",            N_("Trash Message")                        },
195         { "A_DELETE_REAL",      N_("Delete Message")                       },
196         { "A_EXECUTE",          N_("Execute")                              },
197         { "A_GOTO_PREV",        N_("Go to Previous Unread Message")        },
198         { "A_GOTO_NEXT",        N_("Go to Next Unread Message")            },
199         { "A_IGNORE_THREAD",    N_("Ignore thread")                        },
200         { "A_WATCH_THREAD",     N_("Watch thread")                         },
201         { "A_PRINT",            N_("Print")                                },
202         { "A_LEARN_SPAM",       N_("Learn Spam or Ham")                    },
203         { "A_GO_FOLDERS",       N_("Open folder/Go to folder list")        },
204         { "A_PREFERENCES",      N_("Preferences")                          },
205
206         { "A_SEND",             N_("Send Message")                         },
207         { "A_SENDL",            N_("Put into queue folder and send later") },
208         { "A_DRAFT",            N_("Save to draft folder")                 },
209         { "A_INSERT",           N_("Insert file")                          },   
210         { "A_ATTACH",           N_("Attach file")                          },
211         { "A_SIG",              N_("Insert signature")                     },
212         { "A_EXTEDITOR",        N_("Edit with external editor")            },
213         { "A_LINEWRAP_CURRENT", N_("Wrap long lines of current paragraph") }, 
214         { "A_LINEWRAP_ALL",     N_("Wrap all long lines")                  }, 
215         { "A_ADDRBOOK",         N_("Address book")                         },
216 #ifdef USE_ENCHANT
217         { "A_CHECK_SPELLING",   N_("Check spelling")                       },
218 #endif
219         { "A_CLAWS_ACTIONS",    N_("Claws Mail Actions Feature")           }, 
220         { "A_CANCEL_INC",       N_("Cancel receiving")                     },
221         { "A_CLOSE",            N_("Close window")                         },
222         { "A_SEPARATOR",        N_("Separator")                         },
223         { "A_CLAWS_PLUGINS",    N_("Claws Mail Plugins")       },
224 };
225
226 /* struct holds configuration files and a list of
227  * currently active toolbar items 
228  * TOOLBAR_MAIN, TOOLBAR_COMPOSE and TOOLBAR_MSGVIEW
229  * give us an index
230  */
231 struct {
232         const gchar  *conf_file;
233         GSList       *item_list;
234 } toolbar_config[3] = {
235         { "toolbar_main.xml",    NULL},
236         { "toolbar_compose.xml", NULL}, 
237         { "toolbar_msgview.xml", NULL}
238 };
239
240 gint toolbar_ret_val_from_descr(const gchar *descr)
241 {
242         gint i;
243
244         for (i = 0; i < N_ACTION_VAL; i++) {
245                 if (g_utf8_collate(gettext(toolbar_text[i].descr), descr) == 0)
246                                 return i;
247         }
248         
249         return -1;
250 }
251
252 gchar *toolbar_ret_descr_from_val(gint val)
253 {
254         cm_return_val_if_fail(val >=0 && val < N_ACTION_VAL, NULL);
255
256         return gettext(toolbar_text[val].descr);
257 }
258
259 static gint toolbar_ret_val_from_text(const gchar *text)
260 {
261         gint i;
262         
263         for (i = 0; i < N_ACTION_VAL; i++) {
264                 if (g_utf8_collate(toolbar_text[i].index_str, text) == 0)
265                                 return i;
266         }
267
268         return -1;
269 }
270
271 static gchar *toolbar_ret_text_from_val(gint val)
272 {
273         cm_return_val_if_fail(val >=0 && val < N_ACTION_VAL, NULL);
274
275         return toolbar_text[val].index_str;
276 }
277
278 static gboolean toolbar_is_duplicate(gint action, ToolbarType source)
279 {
280         GSList *cur;
281
282         if ((action == A_SEPARATOR) || (action == A_CLAWS_ACTIONS) || (action == A_CLAWS_PLUGINS))
283                 return FALSE;
284
285         for (cur = toolbar_config[source].item_list; cur != NULL; cur = cur->next) {
286                 ToolbarItem *item = (ToolbarItem*) cur->data;
287                 
288                 if (item->index == action)
289                         return TRUE;
290         }
291         return FALSE;
292 }
293
294 /* depending on toolbar type this function 
295    returns a list of available toolbar events being 
296    displayed by prefs_toolbar
297 */
298 GList *toolbar_get_action_items(ToolbarType source)
299 {
300         GList *items = NULL;
301         gint i = 0;
302         
303         if (source == TOOLBAR_MAIN) {
304                 gint main_items[]   = { A_RECEIVE_ALL,   A_RECEIVE_CUR,   A_SEND_QUEUED,
305                                         A_COMPOSE_EMAIL, A_REPLY_MESSAGE, A_REPLY_SENDER, 
306                                         A_REPLY_ALL,     A_REPLY_ML,      A_OPEN_MAIL,  A_FORWARD, 
307                                         A_TRASH , A_DELETE_REAL,       A_EXECUTE,       A_GOTO_PREV, 
308                                         A_GOTO_NEXT,    A_IGNORE_THREAD,  A_WATCH_THREAD,       A_PRINT,
309                                         A_ADDRBOOK,     A_LEARN_SPAM, A_GO_FOLDERS, 
310                                         A_CANCEL_INC,   A_PREFERENCES };
311
312                 for (i = 0; i < sizeof main_items / sizeof main_items[0]; i++)  {
313                         items = g_list_append(items, gettext(toolbar_text[main_items[i]].descr));
314                 }       
315         }
316         else if (source == TOOLBAR_COMPOSE) {
317                 gint comp_items[] =   { A_SEND,          A_SENDL,        A_DRAFT,
318                                         A_INSERT,        A_ATTACH,       A_SIG,
319                                         A_EXTEDITOR,     A_LINEWRAP_CURRENT,     
320                                         A_LINEWRAP_ALL,  A_ADDRBOOK,
321 #ifdef USE_ENCHANT
322                                         A_CHECK_SPELLING, 
323 #endif
324                                         A_CLOSE };      
325
326                 for (i = 0; i < sizeof comp_items / sizeof comp_items[0]; i++) 
327                         items = g_list_append(items, gettext(toolbar_text[comp_items[i]].descr));
328         }
329         else if (source == TOOLBAR_MSGVIEW) {
330                 gint msgv_items[] =   { A_COMPOSE_EMAIL, A_REPLY_MESSAGE, A_REPLY_SENDER,
331                                         A_REPLY_ALL,     A_REPLY_ML,      A_FORWARD,
332                                         A_TRASH, A_DELETE_REAL,       A_GOTO_PREV,        A_GOTO_NEXT,
333                                         A_ADDRBOOK,      A_LEARN_SPAM, A_CLOSE };       
334
335                 for (i = 0; i < sizeof msgv_items / sizeof msgv_items[0]; i++) 
336                         items = g_list_append(items, gettext(toolbar_text[msgv_items[i]].descr));
337         }
338
339         return items;
340 }
341
342 static void toolbar_parse_item(XMLFile *file, ToolbarType source)
343 {
344         GList *attr;
345         gchar *name, *value;
346         ToolbarItem *item = NULL;
347         gboolean rewrite = FALSE;
348
349         attr = xml_get_current_tag_attr(file);
350         item = g_new0(ToolbarItem, 1);
351         while( attr ) {
352                 name = ((XMLAttr *)attr->data)->name;
353                 value = ((XMLAttr *)attr->data)->value;
354                 
355                 if (g_utf8_collate(name, TOOLBAR_ICON_FILE) == 0) 
356                         item->file = g_strdup (value);
357                 else if (g_utf8_collate(name, TOOLBAR_ICON_TEXT) == 0)
358                         item->text = g_strdup (*value ? gettext(value):"");
359                 else if (g_utf8_collate(name, TOOLBAR_ICON_ACTION) == 0)
360                         item->index = toolbar_ret_val_from_text(value);
361                 if (item->index == -1 && !strcmp(value, "A_DELETE")) {
362                         /* switch button */
363                         item->index = A_TRASH;
364                         g_free(item->file);
365                         item->file = g_strdup("trash_btn");
366                         g_free(item->text);
367                         item->text = g_strdup(Q_("Toolbar|Trash"));
368                         rewrite = TRUE;
369                 }
370                 if (item->index == -1 && !strcmp(value, "A_SYL_ACTIONS")) {
371                         /* switch button */
372                         item->index = A_CLAWS_ACTIONS;
373                         rewrite = TRUE;
374                 }
375                 attr = g_list_next(attr);
376         }
377         if (item->index != -1) {
378                 
379                 if (!toolbar_is_duplicate(item->index, source)) 
380                         toolbar_config[source].item_list = g_slist_append(toolbar_config[source].item_list,
381                                                                          item);
382         }
383         if (rewrite) {
384                 toolbar_save_config_file(source);
385         }
386 }
387
388 const gchar *toolbar_get_short_text(int action) {
389         switch(action) {
390         case A_GO_FOLDERS:      return _("Folders");
391         case A_OPEN_MAIL:       return _("Open");
392         case A_RECEIVE_ALL:     return _("Get Mail");
393         case A_RECEIVE_CUR:     return _("Get");
394         case A_SEND_QUEUED:     return _("Send");
395         case A_COMPOSE_EMAIL:   return Q_("Toolbar|Compose");
396         case A_COMPOSE_NEWS:    return Q_("Toolbar|Compose");
397         case A_REPLY_MESSAGE:   return _("Reply");
398         case A_REPLY_ALL:       return _("All");
399         case A_REPLY_SENDER:    return Q_("Toolbar|Sender");
400         case A_REPLY_ML:        return _("List");
401         case A_FORWARD:         return _("Forward");
402         case A_TRASH:           return Q_("Toolbar|Trash");
403         case A_DELETE_REAL:     return _("Delete");
404         case A_LEARN_SPAM:      return _("Spam");
405         case A_GOTO_PREV:       return _("Prev");
406         case A_GOTO_NEXT:       return _("Next");
407         case A_IGNORE_THREAD:   return _("Ignore thread");
408         case A_WATCH_THREAD:    return _("Watch thread");
409         case A_PRINT:           return _("Print");
410         case A_CLOSE:           return _("Close");
411         case A_PREFERENCES:     return _("Preferences");
412         case A_SEND:            return _("Send");
413         case A_SENDL:           return _("Send later");
414         case A_DRAFT:           return _("Draft");
415         case A_INSERT:          return _("Insert");
416         case A_ATTACH:          return _("Attach");
417         case A_SIG:             return _("Insert sig.");
418         case A_EXTEDITOR:       return _("Edit");
419         case A_LINEWRAP_CURRENT:return _("Wrap para.");
420         case A_LINEWRAP_ALL:    return _("Wrap all");
421         case A_ADDRBOOK:        return _("Address");
422         case A_CANCEL_INC:      return _("Stop");
423         case A_EXECUTE:         return _("Execute");
424         #ifdef USE_ENCHANT
425         case A_CHECK_SPELLING:  return _("Check spelling");
426         #endif
427         default:                return "";
428         }
429 }
430
431 gint toolbar_get_icon(int action) {
432         switch(action) {
433         case A_GO_FOLDERS:      return STOCK_PIXMAP_GO_FOLDERS;
434         case A_OPEN_MAIL:       return STOCK_PIXMAP_OPEN_MAIL;
435         case A_RECEIVE_ALL:     return STOCK_PIXMAP_MAIL_RECEIVE_ALL;
436         case A_RECEIVE_CUR:     return STOCK_PIXMAP_MAIL_RECEIVE;
437         case A_SEND_QUEUED:     return STOCK_PIXMAP_MAIL_SEND_QUEUE;
438         case A_COMPOSE_EMAIL:   return STOCK_PIXMAP_MAIL_COMPOSE;
439         case A_COMPOSE_NEWS:    return STOCK_PIXMAP_NEWS_COMPOSE;
440         case A_REPLY_MESSAGE:   return STOCK_PIXMAP_MAIL_REPLY;
441         case A_REPLY_ALL:       return STOCK_PIXMAP_MAIL_REPLY_TO_ALL;
442         case A_REPLY_SENDER:    return STOCK_PIXMAP_MAIL_REPLY_TO_AUTHOR;
443         case A_REPLY_ML:        return STOCK_PIXMAP_MAIL_REPLY_TO_LIST;
444         case A_FORWARD:         return STOCK_PIXMAP_MAIL_FORWARD;
445         case A_TRASH:           return STOCK_PIXMAP_TRASH;
446         case A_DELETE_REAL:     return STOCK_PIXMAP_DELETE;
447         case A_LEARN_SPAM:      return STOCK_PIXMAP_SPAM_BTN;
448         case A_GOTO_PREV:       return STOCK_PIXMAP_UP_ARROW;
449         case A_GOTO_NEXT:       return STOCK_PIXMAP_DOWN_ARROW;
450         case A_IGNORE_THREAD:   return STOCK_PIXMAP_IGNORETHREAD;
451         case A_WATCH_THREAD:    return STOCK_PIXMAP_WATCHTHREAD;
452         case A_PRINT:           return STOCK_PIXMAP_PRINTER;
453         case A_CLOSE:           return STOCK_PIXMAP_CLOSE;
454         case A_PREFERENCES:     return STOCK_PIXMAP_PREFERENCES;
455         case A_SEND:            return STOCK_PIXMAP_MAIL_SEND;
456         case A_SENDL:           return STOCK_PIXMAP_MAIL_SEND_QUEUE;
457         case A_DRAFT:           return STOCK_PIXMAP_MAIL;
458         case A_INSERT:          return STOCK_PIXMAP_INSERT_FILE;
459         case A_ATTACH:          return STOCK_PIXMAP_MAIL_ATTACH;
460         case A_SIG:             return STOCK_PIXMAP_MAIL_SIGN;
461         case A_EXTEDITOR:       return STOCK_PIXMAP_EDIT_EXTERN;
462         case A_LINEWRAP_CURRENT:return STOCK_PIXMAP_LINEWRAP_CURRENT;
463         case A_LINEWRAP_ALL:    return STOCK_PIXMAP_LINEWRAP_ALL;
464         case A_ADDRBOOK:        return STOCK_PIXMAP_ADDRESS_BOOK;
465         case A_CANCEL_INC:      return STOCK_PIXMAP_CANCEL;
466         case A_EXECUTE:         return STOCK_PIXMAP_EXEC;
467         #ifdef USE_ENCHANT
468         case A_CHECK_SPELLING:  return STOCK_PIXMAP_CHECK_SPELLING;
469         #endif
470         default:                return -1;
471         }
472 }
473
474 static void toolbar_set_default_main(void) 
475 {
476         struct {
477                 gint action;
478         } default_toolbar[] = {
479 #ifdef GENERIC_UMPC
480                 { A_GO_FOLDERS},
481                 { A_OPEN_MAIL},         
482                 { A_SEPARATOR}, 
483 #endif
484                 { A_RECEIVE_ALL},
485                 { A_SEPARATOR}, 
486                 { A_SEND_QUEUED},
487                 { A_COMPOSE_EMAIL},
488                 { A_SEPARATOR},
489                 { A_REPLY_MESSAGE}, 
490 #ifndef GENERIC_UMPC
491                 { A_REPLY_ALL},
492                 { A_REPLY_SENDER},
493 #endif
494                 { A_FORWARD},
495                 { A_SEPARATOR},
496                 { A_TRASH},
497 #ifndef GENERIC_UMPC
498                 { A_LEARN_SPAM},
499 #endif
500                 { A_SEPARATOR},
501                 { A_GOTO_NEXT}
502         };
503         
504         gint i;
505         
506         for (i = 0; i < sizeof(default_toolbar) / sizeof(default_toolbar[0]); i++) {
507                 
508                 ToolbarItem *toolbar_item = g_new0(ToolbarItem, 1);
509                 
510                 if (default_toolbar[i].action != A_SEPARATOR) {
511                         
512                         gchar *file = NULL;
513                         if (toolbar_get_icon(default_toolbar[i].action) > -1) {
514                                 file = stock_pixmap_get_name((StockPixmap)toolbar_get_icon(default_toolbar[i].action));
515                         }
516                         
517                         toolbar_item->file  = g_strdup(file);
518                         toolbar_item->index = default_toolbar[i].action;
519                         toolbar_item->text  = g_strdup(toolbar_get_short_text(default_toolbar[i].action));
520                 } else {
521
522                         toolbar_item->file  = g_strdup(TOOLBAR_TAG_SEPARATOR);
523                         toolbar_item->index = A_SEPARATOR;
524                 }
525                 
526                 if (toolbar_item->index != -1) {
527                         if ( !toolbar_is_duplicate(toolbar_item->index, TOOLBAR_MAIN)) 
528                                 toolbar_config[TOOLBAR_MAIN].item_list = 
529                                         g_slist_append(toolbar_config[TOOLBAR_MAIN].item_list, toolbar_item);
530                 }       
531         }
532 }
533
534 static void toolbar_set_default_compose(void)
535 {
536         struct {
537                 gint action;
538         } default_toolbar[] = {
539 #ifdef GENERIC_UMPC
540                 { A_CLOSE},
541                 { A_SEPARATOR}, 
542 #endif
543                 { A_SEND},
544                 { A_SENDL},
545                 { A_DRAFT},
546                 { A_SEPARATOR}, 
547 #ifndef GENERIC_UMPC
548                 { A_INSERT},
549 #endif
550                 { A_ATTACH},
551                 { A_SEPARATOR},
552                 { A_ADDRBOOK}
553         };
554         
555         gint i;
556
557         for (i = 0; i < sizeof(default_toolbar) / sizeof(default_toolbar[0]); i++) {
558                 
559                 ToolbarItem *toolbar_item = g_new0(ToolbarItem, 1);
560                 
561                 if (default_toolbar[i].action != A_SEPARATOR) {
562                         
563                         gchar *file = NULL;
564                         if (toolbar_get_icon(default_toolbar[i].action) > -1) {
565                                 file = stock_pixmap_get_name((StockPixmap)toolbar_get_icon(default_toolbar[i].action));
566                         }
567                         toolbar_item->file  = g_strdup(file);
568                         toolbar_item->index = default_toolbar[i].action;
569                         toolbar_item->text  = g_strdup(toolbar_get_short_text(default_toolbar[i].action));
570                 } else {
571
572                         toolbar_item->file  = g_strdup(TOOLBAR_TAG_SEPARATOR);
573                         toolbar_item->index = A_SEPARATOR;
574                 }
575                 
576                 if (toolbar_item->index != -1) {
577                         if ( !toolbar_is_duplicate(toolbar_item->index, TOOLBAR_COMPOSE)) 
578                                 toolbar_config[TOOLBAR_COMPOSE].item_list = 
579                                         g_slist_append(toolbar_config[TOOLBAR_COMPOSE].item_list, toolbar_item);
580                 }       
581         }
582 }
583
584 static void toolbar_set_default_msgview(void)
585 {
586         struct {
587                 gint action;
588         } default_toolbar[] = {
589 #ifdef GENERIC_UMPC
590                 { A_CLOSE},
591                 { A_SEPARATOR}, 
592 #endif
593                 { A_REPLY_MESSAGE}, 
594                 { A_REPLY_ALL},
595                 { A_REPLY_SENDER},
596                 { A_FORWARD},
597                 { A_SEPARATOR},
598                 { A_TRASH},
599 #ifndef GENERIC_UMPC
600                 { A_LEARN_SPAM},
601 #endif
602                 { A_GOTO_NEXT}
603         };
604         
605         gint i;
606
607         for (i = 0; i < sizeof(default_toolbar) / sizeof(default_toolbar[0]); i++) {
608                 
609                 ToolbarItem *toolbar_item = g_new0(ToolbarItem, 1);
610                 
611                 if (default_toolbar[i].action != A_SEPARATOR) {
612                         gchar *file = NULL;
613                         if (toolbar_get_icon(default_toolbar[i].action) > -1) {
614                                 file = stock_pixmap_get_name((StockPixmap)toolbar_get_icon(default_toolbar[i].action));
615                         }
616                         
617                         toolbar_item->file  = g_strdup(file);
618                         toolbar_item->index = default_toolbar[i].action;
619                         toolbar_item->text  = g_strdup(toolbar_get_short_text(default_toolbar[i].action));
620                 } else {
621
622                         toolbar_item->file  = g_strdup(TOOLBAR_TAG_SEPARATOR);
623                         toolbar_item->index = A_SEPARATOR;
624                 }
625                 
626                 if (toolbar_item->index != -1) {
627                         if ( !toolbar_is_duplicate(toolbar_item->index, TOOLBAR_MSGVIEW)) 
628                                 toolbar_config[TOOLBAR_MSGVIEW].item_list = 
629                                         g_slist_append(toolbar_config[TOOLBAR_MSGVIEW].item_list, toolbar_item);
630                 }       
631         }
632 }
633
634 void toolbar_set_default(ToolbarType source)
635 {
636         if (source == TOOLBAR_MAIN)
637                 toolbar_set_default_main();
638         else if  (source == TOOLBAR_COMPOSE)
639                 toolbar_set_default_compose();
640         else if  (source == TOOLBAR_MSGVIEW)
641                 toolbar_set_default_msgview();
642 }
643
644 void toolbar_save_config_file(ToolbarType source)
645 {
646         GSList *cur;
647         FILE *fp;
648         PrefFile *pfile;
649         gchar *fileSpec = NULL;
650
651         debug_print("save Toolbar Configuration to %s\n", toolbar_config[source].conf_file);
652
653         fileSpec = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, toolbar_config[source].conf_file, NULL );
654         pfile = prefs_write_open(fileSpec);
655         if( pfile ) {
656                 fp = pfile->fp;
657                 if (fprintf(fp, "<?xml version=\"1.0\" encoding=\"%s\" ?>\n", CS_INTERNAL) < 0)
658                         goto fail;
659
660                 if (fprintf(fp, "<%s>\n", TOOLBAR_TAG_INDEX) < 0)
661                         goto fail;
662
663                 for (cur = toolbar_config[source].item_list; cur != NULL; cur = cur->next) {
664                         ToolbarItem *toolbar_item = (ToolbarItem*) cur->data;
665                         
666                         if (toolbar_item->index != A_SEPARATOR) {
667                                 if (fprintf(fp, "\t<%s %s=\"%s\" %s=\"",
668                                         TOOLBAR_TAG_ITEM, 
669                                         TOOLBAR_ICON_FILE, toolbar_item->file,
670                                         TOOLBAR_ICON_TEXT) < 0)
671                                         goto fail;
672                                 if (xml_file_put_escape_str(fp, toolbar_item->text) < 0)
673                                         goto fail;
674                                 if (fprintf(fp, "\" %s=\"%s\"/>\n",
675                                         TOOLBAR_ICON_ACTION, 
676                                         toolbar_ret_text_from_val(toolbar_item->index)) < 0)
677                                         goto fail;
678                         } else {
679                                 if (fprintf(fp, "\t<%s/>\n", TOOLBAR_TAG_SEPARATOR) < 0)
680                                         goto fail;
681                         }
682                 }
683
684                 if (fprintf(fp, "</%s>\n", TOOLBAR_TAG_INDEX) < 0)
685                         goto fail;
686         
687                 g_free( fileSpec );
688                 if (prefs_file_close (pfile) < 0 ) 
689                         g_warning("failed to write toolbar configuration to file\n");
690                 return;
691                 
692 fail:
693                 FILE_OP_ERROR(fileSpec, "fprintf");
694                 g_free( fileSpec );
695                 prefs_file_close_revert (pfile);
696         } else
697                 g_warning("failed to open toolbar configuration file for writing\n");
698 }
699
700 void toolbar_read_config_file(ToolbarType source)
701 {
702         XMLFile *file   = NULL;
703         gchar *fileSpec = NULL;
704         GList *attr;
705         gboolean retVal;
706         jmp_buf    jumper;
707
708         debug_print("read Toolbar Configuration from %s\n", toolbar_config[source].conf_file);
709
710         fileSpec = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, toolbar_config[source].conf_file, NULL );
711         file = xml_open_file(fileSpec);
712         g_free(fileSpec);
713
714         toolbar_clear_list(source);
715
716         if (file) {
717                 if ((setjmp(jumper))
718                 || (xml_get_dtd(file))
719                 || (xml_parse_next_tag(file))
720                 || (!xml_compare_tag(file, TOOLBAR_TAG_INDEX))) {
721                         xml_close_file(file);
722                         return;
723                 }
724
725                 attr = xml_get_current_tag_attr(file);
726                 
727                 retVal = TRUE;
728                 for (;;) {
729                         if (!file->level) 
730                                 break;
731                         /* Get item tag */
732                         if (xml_parse_next_tag(file)) 
733                                 longjmp(jumper, 1);
734
735                         /* Get next tag (icon, icon_text or icon_action) */
736                         if (xml_compare_tag(file, TOOLBAR_TAG_ITEM)) {
737                                 toolbar_parse_item(file, source);
738                         } else if (xml_compare_tag(file, TOOLBAR_TAG_SEPARATOR)) {
739                                 ToolbarItem *item = g_new0(ToolbarItem, 1);
740                         
741                                 item->file   = g_strdup(TOOLBAR_TAG_SEPARATOR);
742                                 item->index  = A_SEPARATOR;
743                                 toolbar_config[source].item_list = 
744                                         g_slist_append(toolbar_config[source].item_list, item);
745                         }
746
747                 }
748                 xml_close_file(file);
749         }
750
751         if ((!file) || (g_slist_length(toolbar_config[source].item_list) == 0)) {
752
753                 if (source == TOOLBAR_MAIN) 
754                         toolbar_set_default(TOOLBAR_MAIN);
755                 else if (source == TOOLBAR_COMPOSE) 
756                         toolbar_set_default(TOOLBAR_COMPOSE);
757                 else if (source == TOOLBAR_MSGVIEW) 
758                         toolbar_set_default(TOOLBAR_MSGVIEW);
759                 else {          
760                         g_warning("failed to write Toolbar Configuration to %s\n", toolbar_config[source].conf_file);
761                         return;
762                 }
763
764                 toolbar_save_config_file(source);
765         }
766 }
767
768 /*
769  * clears list of toolbar items read from configuration files
770  */
771 void toolbar_clear_list(ToolbarType source)
772 {
773         while (toolbar_config[source].item_list != NULL) {
774                 ToolbarItem *item = (ToolbarItem*) toolbar_config[source].item_list->data;
775                 
776                 toolbar_config[source].item_list = 
777                         g_slist_remove(toolbar_config[source].item_list, item);
778
779                 g_free(item->file);
780                 g_free(item->text);
781                 g_free(item);   
782         }
783         g_slist_free(toolbar_config[source].item_list);
784 }
785
786
787 /* 
788  * return list of Toolbar items
789  */
790 GSList *toolbar_get_list(ToolbarType source)
791 {
792         GSList *list = NULL;
793
794         if ((source == TOOLBAR_MAIN) || (source == TOOLBAR_COMPOSE) || (source == TOOLBAR_MSGVIEW))
795                 list = toolbar_config[source].item_list;
796
797         return list;
798 }
799
800 void toolbar_set_list_item(ToolbarItem *t_item, ToolbarType source)
801 {
802         ToolbarItem *toolbar_item = g_new0(ToolbarItem, 1);
803
804         toolbar_item->file  = g_strdup(t_item->file);
805         toolbar_item->text  = g_strdup(t_item->text);
806         toolbar_item->index = t_item->index;
807         
808         toolbar_config[source].item_list = 
809                 g_slist_append(toolbar_config[source].item_list,
810                                toolbar_item);
811 }
812
813 static void toolbar_action_execute(GtkWidget    *widget,
814                             GSList       *action_list, 
815                             gpointer     data,
816                             gint         source) 
817 {
818         GSList *cur;
819         gint i = 0;
820
821         for (cur = action_list; cur != NULL;  cur = cur->next) {
822                 ToolbarClawsActions *act = (ToolbarClawsActions*)cur->data;
823
824                 if (widget == act->widget) {
825                         i = prefs_actions_find_by_name(act->name);
826
827                         if (i != -1) 
828                                 break;
829                 }
830         }
831
832         if (i != -1) 
833                 actions_execute(data, i, widget, source);
834         else
835                 g_warning ("Error: did not find Claws Action to execute");
836 }
837
838 gboolean toolbar_check_action_btns(ToolbarType type)
839 {
840         GSList *temp, *curr, *list = toolbar_config[type].item_list;
841         gboolean modified = FALSE;
842         
843         curr = list;
844         while (curr != NULL) {
845                 ToolbarItem *toolbar_item = (ToolbarItem *) curr->data;
846                 temp = curr;
847                 curr = curr->next;
848                 
849                 if (toolbar_item->index != A_CLAWS_ACTIONS)
850                         continue;
851
852                 if (prefs_actions_find_by_name(toolbar_item->text) == -1) {
853                         list = g_slist_delete_link(list, temp);
854                         g_free(toolbar_item->file);
855                         g_free(toolbar_item->text);
856                         g_free(toolbar_item);
857                         modified = TRUE;
858                 }
859         }
860         
861         return modified;
862 }
863
864 #if !(GTK_CHECK_VERSION(2,12,0))
865 #define CLAWS_SET_TOOL_ITEM_TIP(widget,tip) { \
866         gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(widget), GTK_TOOLTIPS(toolbar_tips),    \
867                         tip, NULL);                                                             \
868 }
869 #else
870 #define CLAWS_SET_TOOL_ITEM_TIP(widget,tip) { \
871         gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), tip);                             \
872 }
873 #endif  
874
875 #if !(GTK_CHECK_VERSION(2,12,0))
876 #define CLAWS_SET_ARROW_TIP(widget,tip) { \
877         gtk_menu_tool_button_set_arrow_tooltip(GTK_MENU_TOOL_BUTTON(widget), GTK_TOOLTIPS(toolbar_tips),        \
878                         tip, NULL);                                                             \
879 }
880 #else
881 #define CLAWS_SET_ARROW_TIP(widget,tip) { \
882         gtk_menu_tool_button_set_arrow_tooltip_text(GTK_MENU_TOOL_BUTTON(widget), tip);                         \
883 }
884 #endif  
885
886 static void activate_compose_button (Toolbar           *toolbar,
887                                      ToolbarStyle      style,
888                                      ComposeButtonType type)
889 {
890 #if !(GTK_CHECK_VERSION(2,12,0))
891         GtkTooltips *toolbar_tips = toolbar->tooltips;
892 #endif
893         if ((!toolbar->compose_mail_btn))
894                 return;
895
896         if (type == COMPOSEBUTTON_NEWS) {
897                 gtk_tool_button_set_icon_widget(
898                         GTK_TOOL_BUTTON(toolbar->compose_mail_btn),
899                         toolbar->compose_news_icon);
900 #ifndef GENERIC_UMPC
901                 CLAWS_SET_TOOL_ITEM_TIP(GTK_TOOL_ITEM(toolbar->compose_mail_btn), _("Compose News message"));
902 #endif  
903                 gtk_widget_show(toolbar->compose_news_icon);
904         } else {
905                 gtk_tool_button_set_icon_widget(
906                         GTK_TOOL_BUTTON(toolbar->compose_mail_btn),
907                         toolbar->compose_mail_icon);
908 #ifndef GENERIC_UMPC
909                 CLAWS_SET_TOOL_ITEM_TIP(GTK_TOOL_ITEM(toolbar->compose_mail_btn), _("Compose Email"));
910 #endif  
911                 gtk_widget_show(toolbar->compose_mail_icon);
912         }
913         toolbar->compose_btn_type = type;
914 }
915
916 void toolbar_set_compose_button(Toolbar            *toolbar, 
917                                 ComposeButtonType  compose_btn_type)
918 {
919         if (toolbar->compose_btn_type != compose_btn_type)
920                 activate_compose_button(toolbar, 
921                                         prefs_common.toolbar_style,
922                                         compose_btn_type);
923 }
924
925 static void activate_learn_button (Toolbar           *toolbar,
926                                      ToolbarStyle      style,
927                                      LearnButtonType type)
928 {
929 #if !(GTK_CHECK_VERSION(2,12,0))
930         GtkTooltips *toolbar_tips = toolbar->tooltips;
931 #endif
932         if ((!toolbar->learn_spam_btn))
933                 return;
934
935         if (type == LEARN_SPAM) {
936                 gtk_tool_button_set_icon_widget(
937                         GTK_TOOL_BUTTON(toolbar->learn_spam_btn),
938                         toolbar->learn_spam_icon);
939                 gtk_tool_button_set_label(
940                         GTK_TOOL_BUTTON(toolbar->learn_spam_btn),
941                         _("Spam"));
942 #ifndef GENERIC_UMPC
943                 CLAWS_SET_TOOL_ITEM_TIP(GTK_TOOL_ITEM(toolbar->learn_spam_btn), _("Learn spam"));       
944 #endif
945                 gtk_widget_show(toolbar->learn_spam_icon);
946         } else {
947                 gtk_tool_button_set_icon_widget(
948                         GTK_TOOL_BUTTON(toolbar->learn_spam_btn),
949                         toolbar->learn_ham_icon);
950                 gtk_tool_button_set_label(
951                         GTK_TOOL_BUTTON(toolbar->learn_spam_btn),
952                         _("Ham"));
953 #ifndef GENERIC_UMPC
954                 CLAWS_SET_TOOL_ITEM_TIP(GTK_TOOL_ITEM(toolbar->learn_spam_btn), _("Learn ham"));
955 #endif  
956                 gtk_widget_show(toolbar->learn_ham_icon);
957         }
958         toolbar->learn_btn_type = type; 
959 }
960
961 void toolbar_set_learn_button(Toolbar            *toolbar, 
962                                 LearnButtonType  learn_btn_type)
963 {
964         if (toolbar->learn_btn_type != learn_btn_type)
965                 activate_learn_button(toolbar, 
966                                         prefs_common.toolbar_style,
967                                         learn_btn_type);
968 }
969
970 void toolbar_toggle(guint action, gpointer data)
971 {
972         MainWindow *mainwin = (MainWindow*)data;
973         GList *list;
974         GList *cur;
975
976         cm_return_if_fail(mainwin != NULL);
977
978         toolbar_style(TOOLBAR_MAIN, action, mainwin);
979
980         list = compose_get_compose_list();
981         for (cur = list; cur != NULL; cur = cur->next) {
982                 toolbar_style(TOOLBAR_COMPOSE, action, cur->data);
983         }
984         list = messageview_get_msgview_list();
985         for (cur = list; cur != NULL; cur = cur->next) {
986                 toolbar_style(TOOLBAR_MSGVIEW, action, cur->data);
987         }
988         
989 }
990
991 void toolbar_set_style(GtkWidget *toolbar_wid, GtkWidget *handlebox_wid, guint action)
992 {
993         switch ((ToolbarStyle)action) {
994         case TOOLBAR_NONE:
995                 gtk_widget_hide(handlebox_wid);
996                 break;
997         case TOOLBAR_ICON:
998                 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar_wid),
999                                       GTK_TOOLBAR_ICONS);
1000                 break;
1001         case TOOLBAR_TEXT:
1002                 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar_wid),
1003                                       GTK_TOOLBAR_TEXT);
1004                 break;
1005         case TOOLBAR_BOTH:
1006                 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar_wid),
1007                                       GTK_TOOLBAR_BOTH);
1008                 break;
1009         case TOOLBAR_BOTH_HORIZ:
1010                 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar_wid),
1011                                       GTK_TOOLBAR_BOTH_HORIZ);
1012                 break;
1013         default:
1014                 return;
1015         }
1016
1017         prefs_common.toolbar_style = (ToolbarStyle)action;
1018         gtk_widget_set_size_request(handlebox_wid, 1, -1);
1019         
1020         if (prefs_common.toolbar_style != TOOLBAR_NONE) {
1021                 gtk_widget_show(handlebox_wid);
1022                 gtk_widget_queue_resize(handlebox_wid);
1023         }
1024 }
1025 /*
1026  * Change the style of toolbar
1027  */
1028 static void toolbar_style(ToolbarType type, guint action, gpointer data)
1029 {
1030         GtkWidget  *handlebox_wid;
1031         GtkWidget  *toolbar_wid;
1032         MainWindow *mainwin = (MainWindow*)data;
1033         Compose    *compose = (Compose*)data;
1034         MessageView *msgview = (MessageView*)data;
1035         
1036         cm_return_if_fail(data != NULL);
1037         
1038         switch (type) {
1039         case TOOLBAR_MAIN:
1040                 handlebox_wid = mainwin->handlebox;
1041                 toolbar_wid = mainwin->toolbar->toolbar;
1042                 break;
1043         case TOOLBAR_COMPOSE:
1044                 handlebox_wid = compose->handlebox;
1045                 toolbar_wid = compose->toolbar->toolbar;
1046                 break;
1047         case TOOLBAR_MSGVIEW: 
1048                 handlebox_wid = msgview->handlebox;
1049                 toolbar_wid = msgview->toolbar->toolbar;
1050                 break;
1051         default:
1052
1053                 return;
1054         }
1055         toolbar_set_style(toolbar_wid, handlebox_wid, action);
1056 }
1057
1058 /* Toolbar handling */
1059 static void toolbar_inc_cb(GtkWidget    *widget,
1060                            gpointer      data)
1061 {
1062         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1063         MainWindow *mainwin;
1064
1065         cm_return_if_fail(toolbar_item != NULL);
1066
1067         switch (toolbar_item->type) {
1068         case TOOLBAR_MAIN:
1069                 mainwin = (MainWindow*)toolbar_item->parent;    
1070                 inc_mail_cb(mainwin, 0, NULL);
1071                 break;
1072         default:
1073                 break;
1074         }
1075 }
1076
1077 static void toolbar_inc_all_cb(GtkWidget        *widget,
1078                                gpointer          data)
1079 {
1080         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1081         MainWindow *mainwin;
1082
1083         cm_return_if_fail(toolbar_item != NULL);
1084
1085         switch (toolbar_item->type) {
1086         case TOOLBAR_MAIN:
1087                 mainwin = (MainWindow*)toolbar_item->parent;
1088                 inc_all_account_mail_cb(mainwin, 0, NULL);
1089                 break;
1090         default:
1091                 break;
1092         }
1093 }
1094
1095 static void toolbar_send_queued_cb(GtkWidget *widget,gpointer data)
1096 {
1097         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1098         MainWindow *mainwin;
1099
1100         cm_return_if_fail(toolbar_item != NULL);
1101
1102         switch (toolbar_item->type) {
1103         case TOOLBAR_MAIN:
1104                 mainwin = (MainWindow*)toolbar_item->parent;
1105                 send_queue_cb(mainwin, 0, NULL);
1106                 break;
1107         default:
1108                 break;
1109         }
1110 }
1111
1112 static void toolbar_exec_cb(GtkWidget   *widget,
1113                             gpointer     data)
1114 {
1115         MainWindow *mainwin = get_mainwin(data);
1116
1117         cm_return_if_fail(mainwin != NULL);
1118         summary_execute(mainwin->summaryview);
1119 }
1120
1121 /*
1122  * Delete current/selected(s) message(s)
1123  */
1124 static void toolbar_trash_cb(GtkWidget *widget, gpointer data)
1125 {
1126         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1127         MainWindow *mainwin;
1128
1129         cm_return_if_fail(toolbar_item != NULL);
1130         cm_return_if_fail(toolbar_item->parent);
1131         
1132         switch (toolbar_item->type) {
1133         case TOOLBAR_MSGVIEW:
1134                 messageview_delete((MessageView *)toolbar_item->parent);
1135                 break;
1136         case TOOLBAR_MAIN:
1137                 mainwin = (MainWindow *)toolbar_item->parent;
1138                 summary_delete_trash(mainwin->summaryview);
1139                 break;
1140         default: 
1141                 debug_print("toolbar event not supported\n");
1142                 break;
1143         }
1144 }
1145
1146 /*
1147  * Delete current/selected(s) message(s)
1148  */
1149 static void toolbar_delete_cb(GtkWidget *widget, gpointer data)
1150 {
1151         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1152         MainWindow *mainwin;
1153
1154         cm_return_if_fail(toolbar_item != NULL);
1155         cm_return_if_fail(toolbar_item->parent);
1156         
1157         switch (toolbar_item->type) {
1158         case TOOLBAR_MSGVIEW:
1159                 messageview_delete((MessageView *)toolbar_item->parent);
1160                 break;
1161         case TOOLBAR_MAIN:
1162                 mainwin = (MainWindow *)toolbar_item->parent;
1163                 summary_delete(mainwin->summaryview);
1164                 break;
1165         default: 
1166                 debug_print("toolbar event not supported\n");
1167                 break;
1168         }
1169 }
1170
1171
1172 /*
1173  * Compose new message
1174  */
1175 static void toolbar_compose_cb(GtkWidget *widget, gpointer data)
1176 {
1177         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1178         MainWindow *mainwin;
1179         MessageView *msgview;
1180
1181         cm_return_if_fail(toolbar_item != NULL);
1182
1183         switch (toolbar_item->type) {
1184         case TOOLBAR_MAIN:
1185                 mainwin = (MainWindow*)toolbar_item->parent;
1186                 if (mainwin->toolbar->compose_btn_type == COMPOSEBUTTON_NEWS) 
1187                         compose_news_cb(mainwin, 0, NULL);
1188                 else
1189                         compose_mail_cb(mainwin, 0, NULL);
1190                 break;
1191         case TOOLBAR_MSGVIEW:
1192                 msgview = (MessageView*)toolbar_item->parent;
1193                 compose_new_with_folderitem(NULL, 
1194                                             msgview->msginfo->folder, NULL);
1195                 break;  
1196         default:
1197                 debug_print("toolbar event not supported\n");
1198         }
1199 }
1200
1201 static void toolbar_learn(gpointer data, guint as_spam)
1202 {
1203         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1204         MainWindow *mainwin;
1205         MessageView *msgview;
1206
1207         cm_return_if_fail(toolbar_item != NULL);
1208
1209         switch (toolbar_item->type) {
1210         case TOOLBAR_MAIN:
1211                 mainwin = (MainWindow*)toolbar_item->parent;
1212                 if (as_spam) 
1213                         mainwindow_learn(mainwin, TRUE);
1214                 else
1215                         mainwindow_learn(mainwin, FALSE);
1216                 break;
1217         case TOOLBAR_MSGVIEW:
1218                 msgview = (MessageView*)toolbar_item->parent;
1219                 if (as_spam) 
1220                         messageview_learn(msgview, TRUE);
1221                 else
1222                         messageview_learn(msgview, FALSE);
1223                 break;
1224         default:
1225                 debug_print("toolbar event not supported\n");
1226         }
1227 }
1228
1229 static void toolbar_learn_cb(GtkWidget *widget, gpointer data)
1230 {
1231         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1232         MainWindow *mainwin;
1233         MessageView *msgview;
1234
1235         cm_return_if_fail(toolbar_item != NULL);
1236
1237         switch (toolbar_item->type) {
1238         case TOOLBAR_MAIN:
1239                 mainwin = (MainWindow*)toolbar_item->parent;
1240                 if (mainwin->toolbar->learn_btn_type == LEARN_SPAM) 
1241                         mainwindow_learn(mainwin, TRUE);
1242                 else
1243                         mainwindow_learn(mainwin, FALSE);
1244                 break;
1245         case TOOLBAR_MSGVIEW:
1246                 msgview = (MessageView*)toolbar_item->parent;
1247                 if (msgview->toolbar->learn_btn_type == LEARN_SPAM) 
1248                         messageview_learn(msgview, TRUE);
1249                 else
1250                         messageview_learn(msgview, FALSE);
1251                 break;
1252         default:
1253                 debug_print("toolbar event not supported\n");
1254         }
1255 }
1256
1257
1258 /*
1259  * Reply Message
1260  */
1261 static void toolbar_reply_cb(GtkWidget *widget, gpointer data)
1262 {
1263         toolbar_reply(data, (prefs_common.reply_with_quote ? 
1264                       COMPOSE_REPLY_WITH_QUOTE : COMPOSE_REPLY_WITHOUT_QUOTE));
1265 }
1266
1267
1268 /*
1269  * Reply message to Sender and All recipients
1270  */
1271 static void toolbar_reply_to_all_cb(GtkWidget *widget, gpointer data)
1272 {
1273         toolbar_reply(data,
1274                       (prefs_common.reply_with_quote ? COMPOSE_REPLY_TO_ALL_WITH_QUOTE 
1275                       : COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE));
1276 }
1277
1278
1279 /*
1280  * Reply to Mailing List
1281  */
1282 static void toolbar_reply_to_list_cb(GtkWidget *widget, gpointer data)
1283 {
1284         toolbar_reply(data, 
1285                       (prefs_common.reply_with_quote ? COMPOSE_REPLY_TO_LIST_WITH_QUOTE 
1286                       : COMPOSE_REPLY_TO_LIST_WITHOUT_QUOTE));
1287 }
1288
1289
1290 /*
1291  * Reply to sender of message
1292  */ 
1293 static void toolbar_reply_to_sender_cb(GtkWidget *widget, gpointer data)
1294 {
1295         toolbar_reply(data, 
1296                       (prefs_common.reply_with_quote ? COMPOSE_REPLY_TO_SENDER_WITH_QUOTE 
1297                       : COMPOSE_REPLY_TO_SENDER_WITHOUT_QUOTE));
1298 }
1299
1300 /*
1301  * Open addressbook
1302  */ 
1303 static void toolbar_addrbook_cb(GtkWidget *widget, gpointer data)
1304 {
1305         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1306         Compose *compose;
1307
1308         cm_return_if_fail(toolbar_item != NULL);
1309
1310         switch (toolbar_item->type) {
1311         case TOOLBAR_MAIN:
1312         case TOOLBAR_MSGVIEW:
1313                 compose = NULL;
1314                 break;
1315         case TOOLBAR_COMPOSE:
1316                 compose = (Compose *)toolbar_item->parent;
1317                 break;
1318         default:
1319                 return;
1320         }
1321 #ifndef USE_NEW_ADDRBOOK
1322         addressbook_open(compose);
1323 #else
1324         GError* error = NULL;
1325         addressbook_connect_signals(compose);
1326         addressbook_dbus_open(TRUE, &error);
1327         if (error) {
1328                 g_warning("%s", error->message);
1329                 g_error_free(error);
1330         }
1331 #endif
1332 }
1333
1334
1335 /*
1336  * Forward current/selected(s) message(s)
1337  */
1338 static void toolbar_forward_cb(GtkWidget *widget, gpointer data)
1339 {
1340         toolbar_reply(data, (COMPOSE_FORWARD));
1341 }
1342
1343 /*
1344  * Goto Prev Unread Message
1345  */
1346 static void toolbar_prev_unread_cb(GtkWidget *widget, gpointer data)
1347 {
1348         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1349         MainWindow *mainwin;
1350         MessageView *msgview;
1351
1352         cm_return_if_fail(toolbar_item != NULL);
1353
1354         switch (toolbar_item->type) {
1355         case TOOLBAR_MAIN:
1356                 mainwin = (MainWindow*)toolbar_item->parent;
1357                 summary_select_prev_unread(mainwin->summaryview);
1358                 break;
1359                 
1360         case TOOLBAR_MSGVIEW:
1361                 msgview = (MessageView*)toolbar_item->parent;
1362                 msgview->updating = TRUE;
1363                 summary_select_prev_unread(msgview->mainwin->summaryview);
1364                 msgview->updating = FALSE;
1365
1366                 if (msgview->deferred_destroy) {
1367                         debug_print("messageview got away!\n");
1368                         messageview_destroy(msgview);
1369                         return;
1370                 }
1371                 
1372                 /* Now we need to update the messageview window */
1373                 if (msgview->mainwin->summaryview->selected) {
1374 #ifndef GENERIC_UMPC
1375                         MsgInfo * msginfo = summary_get_selected_msg(msgview->mainwin->summaryview);
1376                        
1377                         if (msginfo)
1378                                 messageview_show(msgview, msginfo, 
1379                                          msgview->all_headers);
1380 #endif
1381                 } else {
1382                         gtk_widget_destroy(msgview->window);
1383                 }
1384                 break;
1385         default:
1386                 debug_print("toolbar event not supported\n");
1387         }
1388 }
1389
1390 /*
1391  * Goto Next Unread Message
1392  */
1393 static void toolbar_next_unread_cb(GtkWidget *widget, gpointer data)
1394 {
1395         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1396         MainWindow *mainwin;
1397         MessageView *msgview;
1398
1399         cm_return_if_fail(toolbar_item != NULL);
1400
1401         switch (toolbar_item->type) {
1402         case TOOLBAR_MAIN:
1403                 mainwin = (MainWindow*)toolbar_item->parent;
1404                 summary_select_next_unread(mainwin->summaryview);
1405                 break;
1406                 
1407         case TOOLBAR_MSGVIEW:
1408                 msgview = (MessageView*)toolbar_item->parent;
1409                 msgview->updating = TRUE;
1410                 summary_select_next_unread(msgview->mainwin->summaryview);
1411                 msgview->updating = FALSE;
1412
1413                 if (msgview->deferred_destroy) {
1414                         debug_print("messageview got away!\n");
1415                         messageview_destroy(msgview);
1416                         return;
1417                 }
1418
1419                 /* Now we need to update the messageview window */
1420                 if (msgview->mainwin->summaryview->selected) {
1421 #ifndef GENERIC_UMPC
1422                         MsgInfo * msginfo = summary_get_selected_msg(msgview->mainwin->summaryview);
1423                         
1424                         if (msginfo)
1425                                 messageview_show(msgview, msginfo, 
1426                                          msgview->all_headers);
1427 #endif
1428                 } else {
1429                         gtk_widget_destroy(msgview->window);
1430                 }
1431                 break;
1432         default:
1433                 debug_print("toolbar event not supported\n");
1434         }
1435 }
1436
1437 static void toolbar_ignore_thread_cb(GtkWidget *widget, gpointer data)
1438 {
1439         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1440         MainWindow *mainwin;
1441
1442         cm_return_if_fail(toolbar_item != NULL);
1443
1444         switch (toolbar_item->type) {
1445         case TOOLBAR_MAIN:
1446                 mainwin = (MainWindow *) toolbar_item->parent;
1447                 summary_toggle_ignore_thread(mainwin->summaryview);
1448                 break;
1449         case TOOLBAR_MSGVIEW:
1450                 /* TODO: see toolbar_next_unread_cb() if you need
1451                  * this in the message view */
1452                 break;
1453         default:
1454                 debug_print("toolbar event not supported\n");
1455                 break;
1456         }
1457 }
1458
1459 static void toolbar_watch_thread_cb(GtkWidget *widget, gpointer data)
1460 {
1461         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1462         MainWindow *mainwin;
1463
1464         cm_return_if_fail(toolbar_item != NULL);
1465
1466         switch (toolbar_item->type) {
1467         case TOOLBAR_MAIN:
1468                 mainwin = (MainWindow *) toolbar_item->parent;
1469                 summary_toggle_watch_thread(mainwin->summaryview);
1470                 break;
1471         case TOOLBAR_MSGVIEW:
1472                 /* TODO: see toolbar_next_unread_cb() if you need
1473                  * this in the message view */
1474                 break;
1475         default:
1476                 debug_print("toolbar event not supported\n");
1477                 break;
1478         }
1479 }
1480
1481 static void toolbar_cancel_inc_cb(GtkWidget *widget, gpointer data)
1482 {
1483         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1484
1485         cm_return_if_fail(toolbar_item != NULL);
1486         inc_cancel_all();
1487         imap_cancel_all();
1488 }
1489
1490
1491 static void toolbar_print_cb(GtkWidget *widget, gpointer data)
1492 {
1493         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1494         MainWindow *mainwin;
1495
1496         cm_return_if_fail(toolbar_item != NULL);
1497
1498         switch (toolbar_item->type) {
1499         case TOOLBAR_MAIN:
1500                 mainwin = (MainWindow *) toolbar_item->parent;
1501                 summary_print(mainwin->summaryview);
1502                 break;
1503         case TOOLBAR_MSGVIEW:
1504                 /* TODO: see toolbar_next_unread_cb() if you need
1505                  * this in the message view */
1506                 break;
1507         default:
1508                 debug_print("toolbar event not supported\n");
1509                 break;
1510         }
1511 }
1512
1513 static void toolbar_send_cb(GtkWidget *widget, gpointer data)
1514 {
1515         compose_toolbar_cb(A_SEND, data);
1516 }
1517
1518 static void toolbar_send_later_cb(GtkWidget *widget, gpointer data)
1519 {
1520         compose_toolbar_cb(A_SENDL, data);
1521 }
1522
1523 static void toolbar_draft_cb(GtkWidget *widget, gpointer data)
1524 {
1525         compose_toolbar_cb(A_DRAFT, data);
1526 }
1527
1528 static void toolbar_close_cb(GtkWidget *widget, gpointer data)
1529 {
1530         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1531         MainWindow *mainwin;
1532         MessageView *messageview;
1533         Compose *compose;
1534
1535         cm_return_if_fail(toolbar_item != NULL);
1536
1537         switch (toolbar_item->type) {
1538         case TOOLBAR_MAIN:
1539                 mainwin = (MainWindow *) toolbar_item->parent;
1540                 app_will_exit(NULL, mainwin);
1541                 break;
1542         case TOOLBAR_MSGVIEW:
1543                 messageview = (MessageView *)toolbar_item->parent;
1544                 messageview_destroy(messageview);
1545                 break;
1546         case TOOLBAR_COMPOSE:
1547                 compose = (Compose *)toolbar_item->parent;
1548                 compose_close_toolbar(compose);
1549                 break;
1550         }
1551 }
1552
1553 static void toolbar_preferences_cb(GtkWidget *widget, gpointer data)
1554 {
1555         prefs_gtk_open();
1556 }
1557
1558 static void toolbar_open_mail_cb(GtkWidget *widget, gpointer data)
1559 {
1560         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1561         MainWindow *mainwin;
1562
1563         cm_return_if_fail(toolbar_item != NULL);
1564
1565         switch (toolbar_item->type) {
1566         case TOOLBAR_MAIN:
1567                 mainwin = (MainWindow *) toolbar_item->parent;
1568                 summary_open_row(NULL, mainwin->summaryview);
1569                 break;
1570         case TOOLBAR_MSGVIEW:
1571                 debug_print("toolbar event not supported\n");
1572                 break;
1573         case TOOLBAR_COMPOSE:
1574                 debug_print("toolbar event not supported\n");
1575                 break;
1576         }
1577 }
1578
1579 static void toolbar_insert_cb(GtkWidget *widget, gpointer data)
1580 {
1581         compose_toolbar_cb(A_INSERT, data);
1582 }
1583
1584 static void toolbar_attach_cb(GtkWidget *widget, gpointer data)
1585 {
1586         compose_toolbar_cb(A_ATTACH, data);
1587 }
1588
1589 static void toolbar_sig_cb(GtkWidget *widget, gpointer data)
1590 {
1591         compose_toolbar_cb(A_SIG, data);
1592 }
1593
1594 static void toolbar_ext_editor_cb(GtkWidget *widget, gpointer data)
1595 {
1596         compose_toolbar_cb(A_EXTEDITOR, data);
1597 }
1598
1599 static void toolbar_linewrap_current_cb(GtkWidget *widget, gpointer data)
1600 {
1601         compose_toolbar_cb(A_LINEWRAP_CURRENT, data);
1602 }
1603
1604 static void toolbar_linewrap_all_cb(GtkWidget *widget, gpointer data)
1605 {
1606         compose_toolbar_cb(A_LINEWRAP_ALL, data);
1607 }
1608
1609 #ifdef USE_ENCHANT
1610 static void toolbar_check_spelling_cb(GtkWidget *widget, gpointer data)
1611 {
1612         compose_toolbar_cb(A_CHECK_SPELLING, data);
1613 }
1614 #endif
1615 /*
1616  * Execute actions from toolbar
1617  */
1618 static void toolbar_actions_execute_cb(GtkWidget *widget, gpointer data)
1619 {
1620         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1621         GSList *action_list;
1622         MainWindow *mainwin;
1623         Compose *compose;
1624         MessageView *msgview;
1625         gpointer parent = toolbar_item->parent;
1626
1627         cm_return_if_fail(toolbar_item != NULL);
1628
1629         switch (toolbar_item->type) {
1630         case TOOLBAR_MAIN:
1631                 mainwin = (MainWindow*)parent;
1632                 action_list = mainwin->toolbar->action_list;
1633                 break;
1634         case TOOLBAR_COMPOSE:
1635                 compose = (Compose*)parent;
1636                 action_list = compose->toolbar->action_list;
1637                 break;
1638         case TOOLBAR_MSGVIEW:
1639                 msgview = (MessageView*)parent;
1640                 action_list = msgview->toolbar->action_list;
1641                 break;
1642         default:
1643                 debug_print("toolbar event not supported\n");
1644                 return;
1645         }
1646         toolbar_action_execute(widget, action_list, parent, toolbar_item->type);        
1647 }
1648
1649 static void toolbar_plugins_execute_cb(GtkWidget *widget, gpointer data)
1650 {
1651         ToolbarItem *toolbar_item = data;
1652         prefs_toolbar_execute_plugin_item(toolbar_item->parent, toolbar_item->type, toolbar_item->text);
1653 }
1654
1655 static MainWindow *get_mainwin(gpointer data)
1656 {
1657         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1658         MainWindow *mainwin = NULL;
1659         MessageView *msgview;
1660
1661         cm_return_val_if_fail(toolbar_item != NULL, NULL);
1662
1663         switch(toolbar_item->type) {
1664         case TOOLBAR_MAIN:
1665                 mainwin = (MainWindow*)toolbar_item->parent;
1666                 break;
1667         case TOOLBAR_MSGVIEW:
1668                 msgview = (MessageView*)toolbar_item->parent;
1669                 mainwin = (MainWindow*)msgview->mainwin;
1670                 break;
1671         default:
1672                 break;
1673         }
1674
1675         return mainwin;
1676 }
1677
1678 static void toolbar_go_folders_cb(GtkWidget *widget, gpointer data)
1679 {
1680         ToolbarItem *toolbar_item = (ToolbarItem*)data;
1681         MainWindow *mainwin = NULL;
1682         switch(toolbar_item->type) {
1683         case TOOLBAR_MAIN:
1684                 mainwin = (MainWindow*)toolbar_item->parent;
1685                 break;
1686         default:
1687                 g_warning("wrong toolbar type\n");
1688                 return;
1689         }
1690
1691         if (!mainwin->in_folder) {
1692                 FolderItem *item = folderview_get_selected_item(mainwin->folderview);
1693                 if (item) {
1694                         folderview_select(mainwin->folderview, item);
1695                 }
1696         } else {
1697                 gtk_widget_grab_focus(mainwin->folderview->ctree);
1698                 mainwindow_exit_folder(mainwin);
1699         }
1700 }
1701
1702 static void toolbar_buttons_cb(GtkWidget   *widget, 
1703                                ToolbarItem *item)
1704 {
1705         gint num_items;
1706         gint i;
1707         struct {
1708                 gint   index;
1709                 void (*func)(GtkWidget *widget, gpointer data);
1710         } callbacks[] = {
1711                 { A_RECEIVE_ALL,        toolbar_inc_all_cb              },
1712                 { A_RECEIVE_CUR,        toolbar_inc_cb                  },
1713                 { A_SEND_QUEUED,        toolbar_send_queued_cb          },
1714                 { A_COMPOSE_EMAIL,      toolbar_compose_cb              },
1715                 { A_COMPOSE_NEWS,       toolbar_compose_cb              },
1716                 { A_REPLY_MESSAGE,      toolbar_reply_cb                },
1717                 { A_REPLY_SENDER,       toolbar_reply_to_sender_cb      },
1718                 { A_REPLY_ALL,          toolbar_reply_to_all_cb         },
1719                 { A_REPLY_ML,           toolbar_reply_to_list_cb        },
1720                 { A_FORWARD,            toolbar_forward_cb              },
1721                 { A_TRASH,              toolbar_trash_cb                },
1722                 { A_DELETE_REAL,        toolbar_delete_cb               },
1723                 { A_EXECUTE,            toolbar_exec_cb                 },
1724                 { A_GOTO_PREV,          toolbar_prev_unread_cb          },
1725                 { A_GOTO_NEXT,          toolbar_next_unread_cb          },
1726                 { A_IGNORE_THREAD,      toolbar_ignore_thread_cb        },
1727                 { A_WATCH_THREAD,       toolbar_watch_thread_cb         },
1728                 { A_PRINT,              toolbar_print_cb                },
1729                 { A_LEARN_SPAM,         toolbar_learn_cb                },
1730                 { A_GO_FOLDERS,         toolbar_go_folders_cb           },
1731
1732                 { A_SEND,               toolbar_send_cb                 },
1733                 { A_SENDL,              toolbar_send_later_cb           },
1734                 { A_DRAFT,              toolbar_draft_cb                },
1735                 { A_OPEN_MAIL,          toolbar_open_mail_cb            },
1736                 { A_CLOSE,              toolbar_close_cb                },
1737                 { A_PREFERENCES,        toolbar_preferences_cb          },
1738                 { A_INSERT,             toolbar_insert_cb               },
1739                 { A_ATTACH,             toolbar_attach_cb               },
1740                 { A_SIG,                toolbar_sig_cb                  },
1741                 { A_EXTEDITOR,          toolbar_ext_editor_cb           },
1742                 { A_LINEWRAP_CURRENT,   toolbar_linewrap_current_cb     },
1743                 { A_LINEWRAP_ALL,       toolbar_linewrap_all_cb         },
1744                 { A_ADDRBOOK,           toolbar_addrbook_cb             },
1745 #ifdef USE_ENCHANT
1746                 { A_CHECK_SPELLING,     toolbar_check_spelling_cb       },
1747 #endif
1748                 { A_CLAWS_ACTIONS,      toolbar_actions_execute_cb      },
1749                 { A_CANCEL_INC,         toolbar_cancel_inc_cb           },
1750                 { A_CLAWS_PLUGINS,  toolbar_plugins_execute_cb  },
1751         };
1752
1753         num_items = sizeof(callbacks)/sizeof(callbacks[0]);
1754
1755         for (i = 0; i < num_items; i++) {
1756                 if (callbacks[i].index == item->index) {
1757                         callbacks[i].func(widget, item);
1758                         return;
1759                 }
1760         }
1761 }
1762 #ifndef GENERIC_UMPC
1763 #define TOOLBAR_ITEM(item,icon,text,tooltip) {                                                          \
1764         item = GTK_WIDGET(gtk_tool_button_new(icon, text));                                             \
1765         gtkut_widget_set_can_focus(gtk_bin_get_child(GTK_BIN(item)), FALSE);                            \
1766         gtk_tool_item_set_homogeneous(GTK_TOOL_ITEM(item), FALSE);                                      \
1767         gtk_tool_item_set_is_important(GTK_TOOL_ITEM(item), TRUE);                                      \
1768         g_signal_connect (G_OBJECT(item), "clicked", G_CALLBACK(toolbar_buttons_cb), toolbar_item);     \
1769         gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), -1);                              \
1770         CLAWS_SET_TOOL_ITEM_TIP(GTK_TOOL_ITEM(item),                                                    \
1771                         tooltip);                                                                       \
1772 }
1773
1774 #define TOOLBAR_MENUITEM(item,icon,text,tooltip,menutip) {                                              \
1775         GtkWidget *child = NULL, *btn = NULL, *arr = NULL;                                              \
1776         GList *gchild = NULL;                                                                           \
1777         item = GTK_WIDGET(gtk_menu_tool_button_new(icon, text));                                        \
1778         gtk_tool_item_set_homogeneous(GTK_TOOL_ITEM(item), FALSE);                              \
1779         gtk_tool_item_set_is_important(GTK_TOOL_ITEM(item), TRUE);                                      \
1780         g_signal_connect (G_OBJECT(item), "clicked", G_CALLBACK(toolbar_buttons_cb), toolbar_item);     \
1781         gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), -1);                              \
1782         CLAWS_SET_TOOL_ITEM_TIP(GTK_TOOL_ITEM(item),                                                    \
1783                         tooltip);                                                                       \
1784         CLAWS_SET_ARROW_TIP(GTK_MENU_TOOL_BUTTON(item), menutip);                                       \
1785         child = gtk_bin_get_child(GTK_BIN(item));                                                       \
1786         gchild = gtk_container_get_children(                                                            \
1787                         GTK_CONTAINER(child));                                                          \
1788         btn = (GtkWidget *)gchild->data;                                                                \
1789         gtkut_widget_set_can_focus(btn, FALSE);                                                         \
1790         arr = (GtkWidget *)(gchild->next?gchild->next->data:NULL);                                      \
1791         gtkut_widget_set_can_focus(arr, FALSE);                                                         \
1792         g_list_free(gchild);                                                                            \
1793         gchild = gtk_container_get_children(GTK_CONTAINER(arr));                                        \
1794         gtk_widget_set_size_request(GTK_WIDGET(gchild->data), 9, -1);                                   \
1795         g_list_free(gchild);                                                                            \
1796 }
1797 #else
1798 #define TOOLBAR_ITEM(item,icon,text,tooltip) {                                                          \
1799         item = GTK_WIDGET(gtk_tool_button_new(icon, text));                                             \
1800         gtkut_widget_set_can_focus(gtk_bin_get_child(GTK_BIN(item)), FALSE);                            \
1801         gtk_tool_item_set_homogeneous(GTK_TOOL_ITEM(item), FALSE);                                      \
1802         gtk_tool_item_set_is_important(GTK_TOOL_ITEM(item), TRUE);                                      \
1803         g_signal_connect (G_OBJECT(item), "clicked", G_CALLBACK(toolbar_buttons_cb), toolbar_item);     \
1804         gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), -1);                              \
1805 }
1806
1807 #define TOOLBAR_MENUITEM(item,icon,text,tooltip,menutip) {                                              \
1808         GtkWidget *child = NULL, *btn = NULL, *arr = NULL;                                              \
1809         GList *gchild = NULL;                                                                           \
1810         item = GTK_WIDGET(gtk_menu_tool_button_new(icon, text));                                        \
1811         gtk_tool_item_set_homogeneous(GTK_TOOL_ITEM(item), FALSE);                              \
1812         gtk_tool_item_set_is_important(GTK_TOOL_ITEM(item), TRUE);                                      \
1813         g_signal_connect (G_OBJECT(item), "clicked", G_CALLBACK(toolbar_buttons_cb), toolbar_item);     \
1814         gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), -1);                              \
1815         child = gtk_bin_get_child(GTK_BIN(item));                                                       \
1816         gchild = gtk_container_get_children(                                                            \
1817                         GTK_CONTAINER(child));                                                          \
1818         btn = (GtkWidget *)gchild->data;                                                                \
1819         gtkut_widget_set_can_focus(btn, FALSE);                                                         \
1820         arr = (GtkWidget *)(gchild->next?gchild->next->data:NULL);                                      \
1821         gtkut_widget_set_can_focus(arr, FALSE);                                                         \
1822         g_list_free(gchild);                                                                            \
1823         gchild = gtk_container_get_children(GTK_CONTAINER(arr));                                        \
1824         gtk_widget_set_size_request(GTK_WIDGET(gchild->data), 9, -1);                                   \
1825         g_list_free(gchild);                                                                            \
1826 }
1827 #endif
1828
1829 #define ADD_MENU_ITEM(name,cb,data) {                                                   \
1830         item = gtk_menu_item_new_with_mnemonic(name);                                   \
1831         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);                              \
1832         g_signal_connect(G_OBJECT(item), "activate",                                    \
1833                          G_CALLBACK(cb),                                                \
1834                            toolbar_item);                                               \
1835         g_object_set_data(G_OBJECT(item), "int-value", GINT_TO_POINTER(data));          \
1836         gtk_widget_show(item);                                                          \
1837 }
1838
1839 static void toolbar_reply_menu_cb(GtkWidget *widget, gpointer data)
1840 {
1841         gpointer int_value = g_object_get_data(G_OBJECT(widget), "int-value");
1842         ToolbarItem *toolbar_item = (ToolbarItem *)data;
1843         
1844         toolbar_reply(toolbar_item, GPOINTER_TO_INT(int_value));
1845 }
1846
1847 static void toolbar_learn_menu_cb(GtkWidget *widget, gpointer data)
1848 {
1849         gpointer int_value = g_object_get_data(G_OBJECT(widget), "int-value");
1850         ToolbarItem *toolbar_item = (ToolbarItem *)data;
1851         
1852         toolbar_learn(toolbar_item, GPOINTER_TO_INT(int_value));
1853 }
1854
1855 /**
1856  * Create a new toolbar with specified type
1857  * if a callback list is passed it will be used before the 
1858  * common callback list
1859  **/
1860 Toolbar *toolbar_create(ToolbarType      type, 
1861                         GtkWidget       *container,
1862                         gpointer         data)
1863 {
1864         ToolbarItem *toolbar_item;
1865
1866         GtkWidget *toolbar;
1867         GtkWidget *icon_wid = NULL;
1868         GtkWidget *icon_news;
1869         GtkWidget *icon_ham;
1870         GtkWidget *item;
1871         ToolbarClawsActions *action_item;
1872         GSList *cur;
1873         GSList *toolbar_list;
1874         Toolbar *toolbar_data;
1875         GtkWidget *menu;
1876 #ifndef GENERIC_UMPC
1877 #if !(GTK_CHECK_VERSION(2,12,0))
1878         GtkTooltips *toolbar_tips = gtk_tooltips_new();
1879 #endif
1880 #endif  
1881         toolbar_read_config_file(type);
1882         toolbar_list = toolbar_get_list(type);
1883
1884         toolbar_data = g_new0(Toolbar, 1); 
1885
1886         toolbar = gtk_toolbar_new();
1887
1888 #if (GTK_CHECK_VERSION(2,16,0))
1889         gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
1890 #else
1891         gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
1892 #endif
1893         gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
1894         gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolbar), TRUE);
1895         
1896         for (cur = toolbar_list; cur != NULL; cur = cur->next) {
1897
1898                 if (g_ascii_strcasecmp(((ToolbarItem*)cur->data)->file, TOOLBAR_TAG_SEPARATOR) == 0) {
1899                         gtk_toolbar_insert(GTK_TOOLBAR(toolbar), gtk_separator_tool_item_new(), -1);
1900                         continue;
1901                 }
1902                 
1903                 toolbar_item = g_new0(ToolbarItem, 1); 
1904                 toolbar_item->index = ((ToolbarItem*)cur->data)->index;
1905                 toolbar_item->file = g_strdup(((ToolbarItem*)cur->data)->file);
1906                 toolbar_item->text = g_strdup(((ToolbarItem*)cur->data)->text);
1907                 toolbar_item->parent = data;
1908                 toolbar_item->type = type;
1909
1910                 /* collect toolbar items in list to keep track */
1911                 toolbar_data->item_list = 
1912                         g_slist_append(toolbar_data->item_list, 
1913                                        toolbar_item);
1914                 icon_wid = stock_pixmap_widget(container, stock_pixmap_get_icon(toolbar_item->file));
1915                         
1916                 switch (toolbar_item->index) {
1917
1918                 case A_GO_FOLDERS:
1919                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Go to folder list"));
1920                         toolbar_data->folders_btn = item;
1921                         break;
1922                 case A_RECEIVE_ALL:
1923                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
1924                                 _("Receive Mail from all Accounts"),
1925                                 _("Receive Mail from selected Account"));
1926                         toolbar_data->getall_btn = item;
1927                         break;
1928                 case A_RECEIVE_CUR:
1929                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text, _("Receive Mail from current Account"));
1930                         toolbar_data->get_btn = item;
1931                         break;
1932                 case A_SEND_QUEUED:
1933                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Send Queued Messages"));
1934                         toolbar_data->send_btn = item; 
1935                         break;
1936                 case A_CLOSE:
1937                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Close window"));
1938                         toolbar_data->close_window_btn = item; 
1939                         break;
1940                 case A_PREFERENCES:
1941                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Open preferences"));
1942                         toolbar_data->preferences_btn = item; 
1943                         break;
1944                 case A_OPEN_MAIL:
1945                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Open email"));
1946                         toolbar_data->open_mail_btn = item; 
1947                         break;
1948                 case A_COMPOSE_EMAIL:
1949 #ifndef GENERIC_UMPC
1950                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
1951                                 _("Compose Email"),
1952                                 _("Compose with selected Account"));
1953                         toolbar_data->compose_mail_btn = item; 
1954                         toolbar_data->compose_mail_icon = icon_wid; 
1955                         g_object_ref(toolbar_data->compose_mail_icon);
1956
1957                         icon_news = stock_pixmap_widget(container, STOCK_PIXMAP_NEWS_COMPOSE);
1958                         toolbar_data->compose_news_icon = icon_news; 
1959                         g_object_ref(toolbar_data->compose_news_icon);
1960 #else
1961                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
1962                                 _("Compose Email"));
1963                         toolbar_data->compose_mail_btn = item; 
1964                         toolbar_data->compose_mail_icon = icon_wid; 
1965
1966                         icon_news = stock_pixmap_widget(container, STOCK_PIXMAP_NEWS_COMPOSE);
1967                         toolbar_data->compose_news_icon = icon_news; 
1968 #endif
1969                         break;
1970                 case A_LEARN_SPAM:
1971                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
1972                                 _("Spam"),
1973                                 _("Learn as..."));
1974                         toolbar_data->learn_spam_btn = item; 
1975                         toolbar_data->learn_spam_icon = icon_wid; 
1976                         g_object_ref(toolbar_data->learn_spam_icon);
1977
1978                         icon_ham = stock_pixmap_widget(container, STOCK_PIXMAP_HAM_BTN);
1979                         toolbar_data->learn_ham_icon = icon_ham; 
1980                         g_object_ref(toolbar_data->learn_ham_icon);
1981
1982                         menu = gtk_menu_new();
1983                         ADD_MENU_ITEM(_("Learn as _Spam"), toolbar_learn_menu_cb, TRUE);
1984                         ADD_MENU_ITEM(_("Learn as _Ham"), toolbar_learn_menu_cb, FALSE);
1985                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolbar_data->learn_spam_btn), menu);
1986                         break;
1987                 case A_REPLY_MESSAGE:
1988 #ifndef GENERIC_UMPC
1989                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
1990                                 _("Reply to Message"),
1991                                 _("Reply to Message options"));
1992                         toolbar_data->reply_btn = item;
1993
1994                         menu = gtk_menu_new();
1995                         ADD_MENU_ITEM(_("_Reply with quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_WITH_QUOTE);
1996                         ADD_MENU_ITEM(_("Reply without _quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_WITHOUT_QUOTE);
1997                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolbar_data->reply_btn), menu);
1998 #else
1999                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
2000                                 _("Reply to Message"));
2001                         toolbar_data->reply_btn = item;
2002 #endif
2003                         break;
2004                 case A_REPLY_SENDER:
2005 #ifndef GENERIC_UMPC
2006                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
2007                                 _("Reply to Sender"),
2008                                 _("Reply to Sender options"));
2009                         toolbar_data->replysender_btn = item;
2010
2011                         menu = gtk_menu_new();
2012                         ADD_MENU_ITEM(_("_Reply with quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_TO_SENDER_WITH_QUOTE);
2013                         ADD_MENU_ITEM(_("Reply without _quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_TO_SENDER_WITHOUT_QUOTE);
2014                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolbar_data->replysender_btn), menu);
2015 #else
2016                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
2017                                 _("Reply to Sender"));
2018                         toolbar_data->replysender_btn = item;
2019 #endif
2020                         break;
2021                 case A_REPLY_ALL:
2022 #ifndef GENERIC_UMPC
2023                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
2024                                 _("Reply to All"),
2025                                 _("Reply to All options"));
2026                         toolbar_data->replyall_btn = item;
2027
2028                         menu = gtk_menu_new();
2029                         ADD_MENU_ITEM(_("_Reply with quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_TO_ALL_WITH_QUOTE);
2030                         ADD_MENU_ITEM(_("Reply without _quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE);
2031                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolbar_data->replyall_btn), menu);
2032 #else
2033                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
2034                                 _("Reply to All"));
2035                         toolbar_data->replyall_btn = item;
2036 #endif
2037                         break;
2038                 case A_REPLY_ML:
2039 #ifndef GENERIC_UMPC
2040                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
2041                                 _("Reply to Mailing-list"),
2042                                 _("Reply to Mailing-list options"));
2043                         toolbar_data->replylist_btn = item;
2044
2045                         menu = gtk_menu_new();
2046                         ADD_MENU_ITEM(_("_Reply with quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_TO_LIST_WITH_QUOTE);
2047                         ADD_MENU_ITEM(_("Reply without _quote"), toolbar_reply_menu_cb, COMPOSE_REPLY_TO_LIST_WITHOUT_QUOTE);
2048                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolbar_data->replylist_btn), menu);
2049 #else
2050                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
2051                                 _("Reply to Mailing-list"));
2052                         toolbar_data->replylist_btn = item;
2053 #endif
2054                         break;
2055                 case A_FORWARD:
2056 #ifndef GENERIC_UMPC
2057                         TOOLBAR_MENUITEM(item,icon_wid,toolbar_item->text,
2058                                 _("Forward Message"),
2059                                 _("Forward Message options"));
2060                         toolbar_data->fwd_btn = item;
2061
2062                         menu = gtk_menu_new();
2063                         ADD_MENU_ITEM(_("_Forward"), toolbar_reply_menu_cb, COMPOSE_FORWARD_INLINE);
2064                         ADD_MENU_ITEM(_("For_ward as attachment"), toolbar_reply_menu_cb, COMPOSE_FORWARD_AS_ATTACH);
2065                         ADD_MENU_ITEM(_("Redirec_t"), toolbar_reply_menu_cb, COMPOSE_REDIRECT);
2066                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolbar_data->fwd_btn), menu);
2067 #else
2068                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
2069                                 _("Forward Message"));
2070                         toolbar_data->fwd_btn = item;
2071 #endif
2072                         break;
2073                 case A_TRASH:
2074                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Trash Message"));
2075                         toolbar_data->trash_btn = item;
2076                         break;
2077                 case A_DELETE_REAL:
2078                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Delete Message"));
2079                         toolbar_data->delete_btn = item;
2080                         break;
2081                 case A_EXECUTE:
2082                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Execute"));
2083                         toolbar_data->exec_btn = item;
2084                         break;
2085                 case A_GOTO_PREV:
2086                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Go to Previous Unread Message"));
2087                         toolbar_data->prev_btn = item;
2088                         break;
2089                 case A_GOTO_NEXT:
2090                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Go to Next Unread Message"));
2091                         toolbar_data->next_btn = item;
2092                         break;
2093                 
2094                 /* Compose Toolbar */
2095                 case A_SEND:
2096                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Send Message"));
2097                         toolbar_data->send_btn = item;
2098                         break;
2099                 case A_SENDL:
2100                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Put into queue folder and send later"));
2101                         toolbar_data->sendl_btn = item;
2102                         break;
2103                 case A_DRAFT:
2104                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Save to draft folder"));
2105                         toolbar_data->draft_btn = item; 
2106                         break;
2107                 case A_INSERT:
2108                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Insert file"));
2109                         toolbar_data->insert_btn = item; 
2110                         break;
2111                 case A_ATTACH:
2112                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Attach file"));
2113                         toolbar_data->attach_btn = item;
2114                         break;
2115                 case A_SIG:
2116                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Insert signature"));
2117                         toolbar_data->sig_btn = item;
2118                         break;
2119                 case A_EXTEDITOR:
2120                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Edit with external editor"));
2121                         toolbar_data->exteditor_btn = item;
2122                         break;
2123                 case A_LINEWRAP_CURRENT:
2124                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Wrap long lines of current paragraph"));
2125                         toolbar_data->linewrap_current_btn = item;
2126                         break;
2127                 case A_LINEWRAP_ALL:
2128                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Wrap all long lines"));
2129                         toolbar_data->linewrap_all_btn = item;
2130                         break;
2131                 case A_ADDRBOOK:
2132                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Address book"));
2133                         toolbar_data->addrbook_btn = item;
2134                         break;
2135 #ifdef USE_ENCHANT
2136                 case A_CHECK_SPELLING:
2137                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Check spelling"));
2138                         toolbar_data->spellcheck_btn = item;
2139                         break;
2140 #endif
2141
2142                 case A_CLAWS_ACTIONS:
2143                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,toolbar_item->text);
2144                         action_item = g_new0(ToolbarClawsActions, 1);
2145                         action_item->widget = item;
2146                         action_item->name   = g_strdup(toolbar_item->text);
2147
2148                         toolbar_data->action_list = 
2149                                 g_slist_append(toolbar_data->action_list,
2150                                                action_item);
2151                         break;
2152                 case A_CANCEL_INC:
2153                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,_("Cancel receiving"));
2154                         toolbar_data->cancel_inc_btn = item;
2155                         break;
2156                 case A_CLAWS_PLUGINS:
2157                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text, toolbar_item->text);
2158                         break;
2159                 default:
2160                         TOOLBAR_ITEM(item,icon_wid,toolbar_item->text,
2161                                 toolbar_ret_descr_from_val(toolbar_item->index));
2162                         /* find and set the tool tip text */
2163                         break;
2164                 }
2165
2166         }
2167         toolbar_data->toolbar = toolbar;
2168 #ifndef GENERIC_UMPC
2169 #if !(GTK_CHECK_VERSION(2,12,0))
2170         toolbar_data->tooltips = toolbar_tips;
2171 #endif
2172 #endif
2173         gtk_widget_show_all(toolbar);
2174
2175         if (type == TOOLBAR_MAIN) {
2176 #ifdef GENERIC_UMPC
2177                 MainWindow *mainwin = mainwindow_get_mainwindow();
2178                 GtkWidget *progressbar = gtk_progress_bar_new();
2179                 item = GTK_WIDGET(gtk_tool_item_new());
2180                 gtk_container_add (GTK_CONTAINER (item), progressbar);
2181                 gtk_widget_show(item);
2182                 gtk_widget_set_size_request(progressbar, 84, -1);
2183                 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), -1);
2184                 mainwin->progressbar = progressbar;
2185 #endif
2186                 activate_compose_button(toolbar_data, 
2187                                         prefs_common.toolbar_style, 
2188                                         toolbar_data->compose_btn_type);
2189         }
2190         if (type != TOOLBAR_COMPOSE)
2191                 activate_learn_button(toolbar_data, prefs_common.toolbar_style,
2192                                 LEARN_SPAM);
2193         
2194 #ifndef MAEMO
2195         gtk_container_add(GTK_CONTAINER(container), toolbar);
2196         gtk_container_set_border_width(GTK_CONTAINER(container), 0);
2197 #else
2198         if ( GTK_IS_WINDOW(container) ) {
2199                 hildon_window_add_toolbar (HILDON_WINDOW(container), GTK_TOOLBAR(toolbar));
2200                 gtk_widget_show_all (container);
2201         } else {
2202                 gtk_container_add(GTK_CONTAINER(container), toolbar);
2203                 gtk_container_set_border_width(GTK_CONTAINER(container), 2);
2204         }
2205 #endif
2206         return toolbar_data; 
2207 }
2208
2209 /**
2210  * Free toolbar structures
2211  */ 
2212 void toolbar_destroy(Toolbar * toolbar) {
2213
2214         TOOLBAR_DESTROY_ITEMS(toolbar->item_list);      
2215         TOOLBAR_DESTROY_ACTIONS(toolbar->action_list);
2216 }
2217
2218 void toolbar_update(ToolbarType type, gpointer data)
2219 {
2220         Toolbar *toolbar_data;
2221         GtkWidget *handlebox;
2222         MainWindow *mainwin = (MainWindow*)data;
2223         Compose    *compose = (Compose*)data;
2224         MessageView *msgview = (MessageView*)data;
2225
2226 #ifndef GENERIC_UMPC
2227         switch(type) {
2228         case TOOLBAR_MAIN:
2229                 toolbar_data = mainwin->toolbar;
2230                 handlebox    = mainwin->handlebox;
2231                 break;
2232         case TOOLBAR_COMPOSE:
2233                 toolbar_data = compose->toolbar;
2234                 handlebox    = compose->handlebox;
2235                 break;
2236         case TOOLBAR_MSGVIEW:
2237                 toolbar_data = msgview->toolbar;
2238                 handlebox    = msgview->handlebox;
2239                 break;
2240         default:
2241                 return;
2242         }
2243
2244         gtk_container_remove(GTK_CONTAINER(handlebox), 
2245                              GTK_WIDGET(toolbar_data->toolbar));
2246
2247         toolbar_init(toolbar_data);
2248         toolbar_data = toolbar_create(type, handlebox, data);
2249 #else
2250         switch(type) {
2251         case TOOLBAR_MAIN:
2252                 toolbar_data = mainwin->toolbar;
2253                 handlebox    = mainwin->window;
2254                 break;
2255         case TOOLBAR_COMPOSE:
2256                 toolbar_data = compose->toolbar;
2257                 handlebox    = compose->window;
2258                 break;
2259         case TOOLBAR_MSGVIEW:
2260                 toolbar_data = msgview->toolbar;
2261                 handlebox    = msgview->window;
2262                 break;
2263         default:
2264                 return;
2265         }
2266 #ifdef MAEMO
2267         hildon_window_remove_toolbar(HILDON_WINDOW(handlebox), GTK_TOOLBAR(toolbar_data->toolbar));
2268 #endif
2269         toolbar_init(toolbar_data);
2270         toolbar_data = toolbar_create(type, handlebox, data);
2271 #endif
2272
2273         switch(type) {
2274         case TOOLBAR_MAIN:
2275                 mainwin->toolbar = toolbar_data;
2276                 break;
2277         case TOOLBAR_COMPOSE:
2278                 compose->toolbar = toolbar_data;
2279                 break;
2280         case TOOLBAR_MSGVIEW:
2281                 msgview->toolbar = toolbar_data;
2282                 break;
2283         }
2284
2285         toolbar_style(type, prefs_common.toolbar_style, data);
2286
2287         if (type == TOOLBAR_MAIN) {
2288                 toolbar_main_set_sensitive((MainWindow*)data);
2289                 account_set_menu_only_toolbar();
2290         }
2291 }
2292
2293 #if !GTK_CHECK_VERSION(2,14,0)
2294 /* Work around http://bugzilla.gnome.org/show_bug.cgi?id=56070 */
2295 #define GTK_BUTTON_SET_SENSITIVE(widget,sensitive) {            \
2296         gboolean in_btn1 = FALSE, in_btn2 = FALSE;              \
2297         if (GTK_IS_BUTTON(widget))                              \
2298                 in_btn1 = GTK_BUTTON(widget)->in_button;        \
2299         else if (GTK_IS_MENU_TOOL_BUTTON(widget)) {             \
2300                 GtkWidget *child = gtk_bin_get_child(           \
2301                         GTK_BIN(widget));                       \
2302                 GList *gchild = gtk_container_get_children(     \
2303                         GTK_CONTAINER(child));                  \
2304                 GtkWidget *btn = (GtkWidget *)gchild->data;     \
2305                 GtkWidget *arr = (GtkWidget *)                  \
2306                         (gchild->next?gchild->next->data:NULL); \
2307                 g_list_free(gchild);                            \
2308                 if (GTK_IS_BUTTON(btn))                         \
2309                         in_btn1 = GTK_BUTTON(btn)->in_button;   \
2310                 if (GTK_IS_BUTTON(arr))                         \
2311                         in_btn2 = GTK_BUTTON(arr)->in_button;   \
2312         }                                                       \
2313         else if (GTK_IS_TOOL_ITEM(widget)) {                    \
2314                 GtkWidget *child = gtk_bin_get_child(           \
2315                         GTK_BIN(widget));                       \
2316                 if (GTK_IS_BUTTON(child))                       \
2317                         in_btn1 = GTK_BUTTON(child)->in_button; \
2318         }                                                       \
2319         gtk_widget_set_sensitive(widget, sensitive);            \
2320         if (GTK_IS_BUTTON(widget))                              \
2321                 GTK_BUTTON(widget)->in_button = in_btn1;        \
2322         else if (GTK_IS_MENU_TOOL_BUTTON(widget)) {             \
2323                 GtkWidget *child = gtk_bin_get_child(           \
2324                         GTK_BIN(widget));                       \
2325                 GList *gchild = gtk_container_get_children(     \
2326                         GTK_CONTAINER(child));                  \
2327                 GtkWidget *btn = (GtkWidget *)gchild->data;     \
2328                 GtkWidget *arr = (GtkWidget *)                  \
2329                         (gchild->next?gchild->next->data:NULL); \
2330                 g_list_free(gchild);                            \
2331                 if (GTK_IS_BUTTON(btn))                         \
2332                         GTK_BUTTON(btn)->in_button = in_btn1;   \
2333                 if (GTK_IS_BUTTON(arr))                         \
2334                         GTK_BUTTON(arr)->in_button = in_btn2;   \
2335         }                                                       \
2336         else if (GTK_IS_TOOL_ITEM(widget)) {                    \
2337                 GtkWidget *child = gtk_bin_get_child(           \
2338                         GTK_BIN(widget));                       \
2339                 if (GTK_IS_BUTTON(child))                       \
2340                         GTK_BUTTON(child)->in_button = in_btn1; \
2341         }                                                       \
2342 }
2343 #else
2344 #define GTK_BUTTON_SET_SENSITIVE(widget,sensitive) {            \
2345         gtk_widget_set_sensitive(widget, sensitive);            \
2346 }
2347 #endif
2348
2349 void toolbar_main_set_sensitive(gpointer data)
2350 {
2351         SensitiveCond state;
2352         gboolean sensitive;
2353         MainWindow *mainwin = (MainWindow*)data;
2354         Toolbar *toolbar = mainwin->toolbar;
2355         GSList *cur;
2356         GSList *entry_list = NULL;
2357         
2358         typedef struct _Entry Entry;
2359         struct _Entry {
2360                 GtkWidget *widget;
2361                 SensitiveCond cond;
2362                 gboolean empty;
2363         };
2364
2365 #define SET_WIDGET_COND(w, c)     \
2366 { \
2367         Entry *e = g_new0(Entry, 1); \
2368         e->widget = w; \
2369         e->cond   = c; \
2370         entry_list = g_slist_append(entry_list, e); \
2371 }
2372
2373         
2374         if (toolbar->get_btn)
2375                 SET_WIDGET_COND(toolbar->get_btn, 
2376                         M_HAVE_ACCOUNT|M_UNLOCKED|M_HAVE_RETRIEVABLE_ACCOUNT);
2377
2378         if (toolbar->getall_btn) {
2379                 SET_WIDGET_COND(toolbar->getall_btn, 
2380                         M_HAVE_ACCOUNT|M_UNLOCKED|M_HAVE_ANY_RETRIEVABLE_ACCOUNT);
2381         }
2382         if (toolbar->send_btn) {
2383                 SET_WIDGET_COND(toolbar->send_btn,
2384                         M_HAVE_QUEUED_MAILS);
2385         }
2386         if (toolbar->compose_mail_btn) {
2387                 SET_WIDGET_COND(toolbar->compose_mail_btn, 
2388                         M_HAVE_ACCOUNT);
2389         }
2390         if (toolbar->close_window_btn) {
2391                 SET_WIDGET_COND(toolbar->close_window_btn, 
2392                         M_UNLOCKED);
2393         }
2394         if (toolbar->open_mail_btn) {
2395                 SET_WIDGET_COND(toolbar->open_mail_btn, 
2396                         M_TARGET_EXIST|M_SUMMARY_ISLIST);
2397         }
2398         if (toolbar->reply_btn) {
2399                 SET_WIDGET_COND(toolbar->reply_btn,
2400                         M_HAVE_ACCOUNT|M_TARGET_EXIST|M_SUMMARY_ISLIST);
2401         }
2402         if (toolbar->replyall_btn) {
2403                 SET_WIDGET_COND(toolbar->replyall_btn,
2404                         M_HAVE_ACCOUNT|M_TARGET_EXIST|M_SUMMARY_ISLIST);
2405         }
2406         if (toolbar->replylist_btn) {
2407                 SET_WIDGET_COND(toolbar->replylist_btn,
2408                         M_HAVE_ACCOUNT|M_TARGET_EXIST|M_SUMMARY_ISLIST);
2409         }
2410         if (toolbar->replysender_btn) {
2411                 SET_WIDGET_COND(toolbar->replysender_btn,
2412                         M_HAVE_ACCOUNT|M_TARGET_EXIST|M_SUMMARY_ISLIST);
2413         }
2414         if (toolbar->fwd_btn) {
2415                 SET_WIDGET_COND(toolbar->fwd_btn, 
2416                         M_HAVE_ACCOUNT|M_TARGET_EXIST|M_SUMMARY_ISLIST);
2417         }
2418
2419         if (prefs_common.next_unread_msg_dialog == NEXTUNREADMSGDIALOG_ASSUME_NO) {
2420                 SET_WIDGET_COND(toolbar->next_btn, M_MSG_EXIST|M_SUMMARY_ISLIST);
2421         } else {
2422                 SET_WIDGET_COND(toolbar->next_btn, 0);
2423         }
2424         
2425         if (toolbar->trash_btn)
2426                 SET_WIDGET_COND(toolbar->trash_btn,
2427                         M_TARGET_EXIST|M_ALLOW_DELETE|M_NOT_NEWS);
2428
2429         if (toolbar->delete_btn)
2430                 SET_WIDGET_COND(toolbar->delete_btn,
2431                         M_TARGET_EXIST|M_ALLOW_DELETE);
2432
2433         if (toolbar->exec_btn)
2434                 SET_WIDGET_COND(toolbar->exec_btn, 
2435                         M_DELAY_EXEC);
2436         
2437         if (toolbar->learn_spam_btn)
2438                 SET_WIDGET_COND(toolbar->learn_spam_btn, 
2439                         M_TARGET_EXIST|M_CAN_LEARN_SPAM|M_SUMMARY_ISLIST);
2440
2441         if (toolbar->cancel_inc_btn)
2442                 SET_WIDGET_COND(toolbar->cancel_inc_btn,
2443                                 M_INC_ACTIVE);
2444
2445         for (cur = toolbar->action_list; cur != NULL;  cur = cur->next) {
2446                 ToolbarClawsActions *act = (ToolbarClawsActions*)cur->data;
2447                 
2448                 SET_WIDGET_COND(act->widget, M_TARGET_EXIST|M_UNLOCKED);
2449         }
2450
2451 #undef SET_WIDGET_COND
2452
2453         state = main_window_get_current_state(mainwin);
2454
2455         for (cur = entry_list; cur != NULL; cur = cur->next) {
2456                 Entry *e = (Entry*) cur->data;
2457
2458                 if (e->widget != NULL) {
2459                         sensitive = ((e->cond & state) == e->cond);
2460                         GTK_BUTTON_SET_SENSITIVE(e->widget, sensitive); 
2461                 }
2462         }
2463         
2464         while (entry_list != NULL) {
2465                 Entry *e = (Entry*) entry_list->data;
2466
2467                 g_free(e);
2468                 entry_list = g_slist_remove(entry_list, e);
2469         }
2470
2471         g_slist_free(entry_list);
2472
2473         activate_compose_button(toolbar, 
2474                                 prefs_common.toolbar_style,
2475                                 toolbar->compose_btn_type);
2476         
2477 }
2478
2479 void toolbar_comp_set_sensitive(gpointer data, gboolean sensitive)
2480 {
2481         Compose *compose = (Compose*)data;
2482         GSList *items = compose->toolbar->action_list;
2483
2484         if (compose->toolbar->send_btn)
2485                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->send_btn, sensitive);
2486         if (compose->toolbar->sendl_btn)
2487                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->sendl_btn, sensitive);
2488         if (compose->toolbar->draft_btn )
2489                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->draft_btn , sensitive);
2490         if (compose->toolbar->insert_btn )
2491                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->insert_btn , sensitive);
2492         if (compose->toolbar->attach_btn)
2493                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->attach_btn, sensitive);
2494         if (compose->toolbar->sig_btn)
2495                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->sig_btn, sensitive);
2496         if (compose->toolbar->exteditor_btn)
2497                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->exteditor_btn, sensitive);
2498         if (compose->toolbar->linewrap_current_btn)
2499                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->linewrap_current_btn, sensitive);
2500         if (compose->toolbar->linewrap_all_btn)
2501                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->linewrap_all_btn, sensitive);
2502         if (compose->toolbar->addrbook_btn)
2503                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->addrbook_btn, sensitive);
2504 #ifdef USE_ENCHANT
2505         if (compose->toolbar->spellcheck_btn)
2506                 GTK_BUTTON_SET_SENSITIVE(compose->toolbar->spellcheck_btn, sensitive);
2507 #endif
2508         for (; items != NULL; items = g_slist_next(items)) {
2509                 ToolbarClawsActions *item = (ToolbarClawsActions *)items->data;
2510                 GTK_BUTTON_SET_SENSITIVE(item->widget, sensitive);
2511         }
2512 }
2513
2514 /**
2515  * Initialize toolbar structure
2516  **/
2517 static void toolbar_init(Toolbar * toolbar)
2518 {
2519
2520         toolbar->toolbar                = NULL;
2521         toolbar->folders_btn            = NULL;
2522         toolbar->get_btn                = NULL;
2523         toolbar->getall_btn             = NULL;
2524         toolbar->send_btn               = NULL;
2525         toolbar->compose_mail_btn       = NULL;
2526         toolbar->compose_mail_icon      = NULL;
2527         toolbar->compose_news_icon      = NULL;
2528         toolbar->reply_btn              = NULL;
2529         toolbar->replysender_btn        = NULL;
2530         toolbar->replyall_btn           = NULL;
2531         toolbar->replylist_btn          = NULL;
2532         toolbar->fwd_btn                = NULL;
2533         toolbar->trash_btn              = NULL;
2534         toolbar->delete_btn             = NULL;
2535         toolbar->prev_btn               = NULL;
2536         toolbar->next_btn               = NULL;
2537         toolbar->exec_btn               = NULL;
2538         toolbar->open_mail_btn          = NULL;
2539         toolbar->close_window_btn       = NULL;
2540         /* compose buttons */ 
2541         toolbar->sendl_btn              = NULL;
2542         toolbar->draft_btn              = NULL;
2543         toolbar->insert_btn             = NULL;
2544         toolbar->attach_btn             = NULL;
2545         toolbar->sig_btn                = NULL; 
2546         toolbar->exteditor_btn          = NULL; 
2547         toolbar->linewrap_current_btn   = NULL; 
2548         toolbar->linewrap_all_btn       = NULL; 
2549         toolbar->addrbook_btn           = NULL; 
2550 #ifdef USE_ENCHANT
2551         toolbar->spellcheck_btn         = NULL;
2552 #endif
2553
2554         toolbar_destroy(toolbar);
2555 }
2556
2557 /*
2558  */
2559 static void toolbar_reply(gpointer data, guint action)
2560 {
2561         ToolbarItem *toolbar_item = (ToolbarItem*)data;
2562         MainWindow *mainwin;
2563         MessageView *msgview;
2564         GSList *msginfo_list = NULL;
2565
2566         cm_return_if_fail(toolbar_item != NULL);
2567
2568         switch (toolbar_item->type) {
2569         case TOOLBAR_MAIN:
2570                 mainwin = (MainWindow*)toolbar_item->parent;
2571                 msginfo_list = summary_get_selection(mainwin->summaryview);
2572                 msgview = (MessageView*)mainwin->messageview;
2573                 break;
2574         case TOOLBAR_MSGVIEW:
2575                 msgview = (MessageView*)toolbar_item->parent;
2576                 cm_return_if_fail(msgview != NULL);     
2577                 msginfo_list = g_slist_append(msginfo_list, msgview->msginfo);
2578                 break;
2579         default:
2580                 return;
2581         }
2582
2583         cm_return_if_fail(msgview != NULL);
2584         cm_return_if_fail(msginfo_list != NULL);
2585         compose_reply_from_messageview(msgview, msginfo_list, action);
2586         g_slist_free(msginfo_list);
2587
2588         /* TODO: update reply state ion summaryview */
2589 }
2590
2591
2592 /* exported functions */
2593
2594 void inc_mail_cb(gpointer data, guint action, GtkWidget *widget)
2595 {
2596         MainWindow *mainwin = (MainWindow*)data;
2597
2598         inc_mail(mainwin, prefs_common.newmail_notify_manu);
2599 }
2600
2601 void inc_all_account_mail_cb(gpointer data, guint action, GtkWidget *widget)
2602 {
2603         MainWindow *mainwin = (MainWindow*)data;
2604
2605         inc_all_account_mail(mainwin, FALSE, prefs_common.newmail_notify_manu);
2606 }
2607
2608 void send_queue_cb(gpointer data, guint action, GtkWidget *widget)
2609 {
2610         GList *list;
2611         gboolean found;
2612         gboolean got_error = FALSE;
2613         gchar *errstr = NULL;
2614
2615         if (prefs_common.work_offline)
2616                 if (alertpanel(_("Offline warning"), 
2617                                _("You're working offline. Override?"),
2618                                GTK_STOCK_NO, GTK_STOCK_YES,
2619                                NULL) != G_ALERTALTERNATE)
2620                 return;
2621
2622         /* ask for confirmation before sending queued messages only
2623            in online mode and if there is at least one message queued
2624            in any of the folder queue
2625         */
2626         if (prefs_common.confirm_send_queued_messages) {
2627                 found = FALSE;
2628                 /* check if there's a queued message */
2629                 for (list = folder_get_list(); !found && list != NULL; list = list->next) {
2630                         Folder *folder = list->data;
2631
2632                         found = !procmsg_queue_is_empty(folder->queue);
2633                 }
2634                 /* if necessary, ask for confirmation before sending */
2635                 if (found && !prefs_common.work_offline) {
2636                         if (alertpanel(_("Send queued messages"), 
2637                                    _("Send all queued messages?"),
2638                                    GTK_STOCK_CANCEL, _("_Send"),
2639                                    NULL) != G_ALERTALTERNATE)
2640                                 return;
2641                 }
2642         }
2643
2644         for (list = folder_get_list(); list != NULL; list = list->next) {
2645                 Folder *folder = list->data;
2646
2647                 if (folder->queue) {
2648                         if (procmsg_send_queue(folder->queue, 
2649                                                prefs_common.savemsg,
2650                                                &errstr) < 0)
2651                                 got_error = TRUE;
2652                 }
2653         }
2654         if (got_error) {
2655                 if (!errstr)
2656                         alertpanel_error_log(_("Some errors occurred while "
2657                                            "sending queued messages."));
2658                 else {
2659                         alertpanel_error_log(_("Some errors occurred "
2660                                         "while sending queued messages:\n%s"), errstr);
2661                         g_free(errstr);
2662                 }
2663         }
2664 }
2665
2666 void compose_mail_cb(gpointer data, guint action, GtkWidget *widget)
2667 {
2668         MainWindow *mainwin = (MainWindow*)data;
2669         PrefsAccount *ac = NULL;
2670         FolderItem *item = mainwin->summaryview->folder_item;   
2671         GList * list;
2672         GList * cur;
2673         
2674         if (item) {
2675                 ac = account_find_from_item(item);
2676                 if (ac && ac->protocol != A_NNTP) {
2677                         compose_new_with_folderitem(ac, item, NULL);            /* CLAWS */
2678                         return;
2679                 }
2680         }
2681
2682         /*
2683          * CLAWS - use current account
2684          */
2685         if (cur_account && (cur_account->protocol != A_NNTP)) {
2686                 compose_new_with_folderitem(cur_account, item, NULL);
2687                 return;
2688         }
2689
2690         /*
2691          * CLAWS - just get the first one
2692          */
2693         list = account_get_list();
2694         for (cur = list ; cur != NULL ; cur = g_list_next(cur)) {
2695                 ac = (PrefsAccount *) cur->data;
2696                 if (ac->protocol != A_NNTP) {
2697                         compose_new_with_folderitem(ac, item, NULL);
2698                         return;
2699                 }
2700         }
2701 }
2702
2703 void compose_news_cb(gpointer data, guint action, GtkWidget *widget)
2704 {
2705         MainWindow *mainwin = (MainWindow*)data;
2706         PrefsAccount * ac = NULL;
2707         GList * list;
2708         GList * cur;
2709
2710         if (mainwin->summaryview->folder_item) {
2711                 ac = mainwin->summaryview->folder_item->folder->account;
2712                 if (ac && ac->protocol == A_NNTP) {
2713                         compose_new_with_folderitem(ac,
2714                                     mainwin->summaryview->folder_item, NULL);
2715                         return;
2716                 }
2717         }
2718
2719         list = account_get_list();
2720         for(cur = list ; cur != NULL ; cur = g_list_next(cur)) {
2721                 ac = (PrefsAccount *) cur->data;
2722                 if (ac->protocol == A_NNTP) {
2723                         compose_new_with_folderitem(ac,
2724                                     mainwin->summaryview->folder_item, NULL);
2725                         return;
2726                 }
2727         }
2728 }