2007-01-21 [colin] 2.7.1cvs43
[claws.git] / src / gtk / colorlabel.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001-2007 Hiroyuki Yamamoto & The Claws Mail Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 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, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 /* (alfons) - based on a contribution by Satoshi Nagayasu; revised for colorful 
21  * menu and more Sylpheed integration. The idea to put the code in a separate
22  * file is just that it make it easier to allow "user changeable" label colors.
23  */
24
25 #include "defs.h"
26
27 #include <glib.h>
28 #include <glib/gi18n.h>
29 #include <gtk/gtk.h>
30 #include <gtk/gtkwidget.h>
31 #include <gtk/gtkimage.h>
32 #include <gtk/gtkmenu.h>
33 #include <gtk/gtkcheckmenuitem.h>
34 #include <gtk/gtklabel.h>
35 #include <gtk/gtkmenuitem.h>
36 #include <gtk/gtkalignment.h>
37 #include <gtk/gtkhbox.h>
38 #include <gtk/gtkvbox.h>
39 #include <gtk/gtkwindow.h>
40 #include <gtk/gtkdrawingarea.h>
41
42 #include "colorlabel.h"
43 #include "utils.h"
44 #include "gtkutils.h"
45 #include "prefs_common.h"
46
47 static gchar *labels[COLORLABELS] = {
48         N_("Orange"),
49         N_("Red") ,
50         N_("Pink"),
51         N_("Sky blue"),
52         N_("Blue"),
53         N_("Green"),
54         N_("Brown")
55 };
56
57 static GdkColor default_colors[COLORLABELS] = {
58         { 0, 0xffff, (0x99 << 8), 0x0 },
59         { 0, 0xffff, 0, 0 },
60         { 0, 0xffff, (0x66 << 8), 0xffff },
61         { 0, 0x0, (0xcc << 8), 0xffff },
62         { 0, 0x0, 0x0, 0xffff },
63         { 0, 0x0, (0x99 << 8), 0x0 },
64         { 0, 0x66 << 8, 0x33 << 8, 0x33 << 8 }
65 };
66         
67 typedef enum LabelColorChangeFlags_ {
68         LCCF_COLOR = 1 << 0,
69         LCCF_LABEL = 1 << 1,
70         LCCF_ALL   = LCCF_COLOR | LCCF_LABEL
71 } LabelColorChangeFlags;
72
73 /* XXX: if you add colors, make sure you also check the procmsg.h.
74  * color indices are stored as 3 bits; that explains the max. of 7 colors */
75 static struct 
76 {
77         LabelColorChangeFlags   changed; 
78         /* color here is initialized from default_colors[] at startup */
79         GdkColor                color;
80
81         /* XXX: note that the label member is supposed to be dynamically 
82          * allocated and fffreed */
83         gchar                   *label;
84         GtkWidget               *widget;
85 } label_colors[NUM_MENUS][COLORLABELS] = {
86     {
87         { LCCF_ALL, { 0 }, NULL, NULL },
88         { LCCF_ALL, { 0 }, NULL, NULL },
89         { LCCF_ALL, { 0 }, NULL, NULL },
90         { LCCF_ALL, { 0 }, NULL, NULL },
91         { LCCF_ALL, { 0 }, NULL, NULL },
92         { LCCF_ALL, { 0 }, NULL, NULL },
93         { LCCF_ALL, { 0 }, NULL, NULL }},
94     {
95         { LCCF_ALL, { 0 }, NULL, NULL },
96         { LCCF_ALL, { 0 }, NULL, NULL },
97         { LCCF_ALL, { 0 }, NULL, NULL },
98         { LCCF_ALL, { 0 }, NULL, NULL },
99         { LCCF_ALL, { 0 }, NULL, NULL },
100         { LCCF_ALL, { 0 }, NULL, NULL },
101         { LCCF_ALL, { 0 }, NULL, NULL }}
102 };
103
104 #define LABEL_COLOR_WIDTH       28
105 #define LABEL_COLOR_HEIGHT      16
106
107 #define LABEL_COLORS_ELEMS (sizeof label_colors[0] / sizeof label_colors[0][0])
108
109 #define G_RETURN_VAL_IF_INVALID_COLOR(color, val) \
110         g_return_val_if_fail((color) >= 0 && (color) < LABEL_COLORS_ELEMS, (val))
111
112 #define INTCOLOR_TO_GDKCOLOR(intcolor, gdkcolor) \
113         gdkcolor.red   = ((intcolor >> 16UL) & 0xFFUL) << 8UL; \
114         gdkcolor.green = ((intcolor >>  8UL) & 0xFFUL) << 8UL; \
115         gdkcolor.blue  = ((intcolor)         & 0xFFUL) << 8UL;
116
117 static void colorlabel_recreate        (gint);
118 static void colorlabel_recreate_label  (gint);
119
120 void colorlabel_update_colortable_from_prefs(void)
121 {
122         gint i, c;
123
124         for (i = 0; i < NUM_MENUS; i++) {
125                 for (c = 0; c < COLORLABELS; c++) {
126                         INTCOLOR_TO_GDKCOLOR(prefs_common.custom_colorlabel[c].color,
127                                         label_colors[i][c].color);
128                         g_free(label_colors[i][c].label);
129                         label_colors[i][c].label =
130                                         g_strdup(prefs_common.custom_colorlabel[c].label);
131                 }
132         }
133 }
134
135
136 gint colorlabel_get_color_count(void)
137 {
138         return LABEL_COLORS_ELEMS;
139 }
140
141 GdkColor colorlabel_get_color(gint color_index)
142 {
143         GdkColor invalid = { 0 };
144
145         G_RETURN_VAL_IF_INVALID_COLOR(color_index, invalid);
146
147         return label_colors[0][color_index].color;
148 }
149
150 GdkColor colorlabel_get_default_color(gint color_index)
151 {
152         GdkColor invalid = { 0 };
153
154         G_RETURN_VAL_IF_INVALID_COLOR(color_index, invalid);
155
156         return default_colors[color_index];
157 }
158                 
159 gchar *colorlabel_get_color_default_text(gint color_index)
160 {
161         G_RETURN_VAL_IF_INVALID_COLOR(color_index, NULL);
162
163         return labels[color_index];
164 }
165
166 static gboolean colorlabel_drawing_area_expose_event_cb
167         (GtkWidget *widget, GdkEventExpose *expose, gpointer data)
168 {
169         GdkDrawable *drawable = widget->window;
170         gulong c = (gulong) GPOINTER_TO_INT(data);
171         GdkColor color;
172         GdkGC *gc;
173
174         INTCOLOR_TO_GDKCOLOR(c, color)
175
176         gdk_colormap_alloc_color(gtk_widget_get_colormap(widget), &color, FALSE, TRUE);
177
178         gc = gdk_gc_new(drawable);
179
180         gdk_gc_set_foreground(gc, &color);
181         gdk_draw_rectangle(drawable, widget->style->black_gc,
182                            FALSE, 0, 0, widget->allocation.width - 1,
183                            widget->allocation.height - 1);
184         gdk_draw_rectangle(drawable, gc,
185                            TRUE, 1, 1, widget->allocation.width - 2,
186                            widget->allocation.height - 2);
187
188         gdk_gc_unref(gc);                          
189         
190         return FALSE;
191 }
192
193 static GtkWidget *colorlabel_create_color_widget(GdkColor color)
194 {
195         GtkWidget *widget;
196
197         widget = gtk_drawing_area_new();
198         gtk_widget_set_size_request(widget, LABEL_COLOR_WIDTH - 2, 
199                                     LABEL_COLOR_HEIGHT - 4);
200
201 #define CL(x)           (((gulong) (x) >> (gulong) 8) & 0xFFUL) 
202 #define CR(r, g, b)     ((CL(r) << (gulong) 16) | \
203                          (CL(g) << (gulong)  8) | \
204                          (CL(b)))
205
206         g_signal_connect(G_OBJECT(widget), "expose_event", 
207                          G_CALLBACK
208                                 (colorlabel_drawing_area_expose_event_cb),
209                          GINT_TO_POINTER
210                                 ((gint)CR(color.red, color.green, color.blue)));
211
212         return widget;
213 }
214
215 /* XXX: colorlabel_recreate_XXX are there to make sure everything
216  * is initialized ok, without having to call a global _xxx_init_
217  * function */
218 static void colorlabel_recreate_color(gint color)
219 {
220         GtkWidget *widget;
221         int i;
222         
223         for (i = 0; i < NUM_MENUS; i++) {
224                 if (!(label_colors[i][color].changed & LCCF_COLOR))
225                         continue;
226
227                 widget = colorlabel_create_color_widget(label_colors[i][color].color);
228                 g_return_if_fail(widget);
229
230                 if (label_colors[i][color].widget) 
231                         gtk_widget_destroy(label_colors[i][color].widget);
232
233                 label_colors[i][color].widget = widget;         
234                 label_colors[i][color].changed &= ~LCCF_COLOR;
235         }
236 }
237
238 static void colorlabel_recreate_label(gint color)
239 {
240         int i;
241         
242         for (i = 0; i < NUM_MENUS; i++) {
243                 if (!label_colors[i][color].changed & LCCF_LABEL)
244                         continue;
245
246                 if (label_colors[i][color].label == NULL) 
247                         label_colors[i][color].label = g_strdup(gettext(labels[color]));
248
249                 label_colors[i][color].changed &= ~LCCF_LABEL;
250         }
251 }
252
253 /* XXX: call this function everytime when you're doing important
254  * stuff with the label_colors[] array */
255 static void colorlabel_recreate(gint color)
256 {
257         colorlabel_recreate_label(color);
258         colorlabel_recreate_color(color);
259 }
260
261 static void colorlabel_recreate_all(void)
262 {
263         gint n;
264
265         for ( n = 0; n < LABEL_COLORS_ELEMS; n++) 
266                 colorlabel_recreate(n);
267 }
268
269 /* colorlabel_create_check_color_menu_item() - creates a color
270  * menu item with a check box */
271 GtkWidget *colorlabel_create_check_color_menu_item(gint color_index, gboolean force, gint menu_index)
272 {
273         GtkWidget *label; 
274         GtkWidget *hbox; 
275         GtkWidget *vbox; 
276         GtkWidget *item;
277         gchar *accel;
278         
279         G_RETURN_VAL_IF_INVALID_COLOR(color_index, NULL);
280
281         item = gtk_check_menu_item_new();
282
283         if (force) {
284                 label_colors[menu_index][color_index].changed |= LCCF_COLOR;
285                 label_colors[menu_index][color_index].changed |= LCCF_LABEL;
286         }
287         colorlabel_recreate(color_index);
288
289         /* XXX: gnome-core::panel::menu.c is a great example of
290          * how to create pixmap menus */
291         label = gtk_label_new(label_colors[menu_index][color_index].label);
292
293         gtk_widget_show(label);
294         hbox = gtk_hbox_new(FALSE, 0);
295         gtk_widget_show(hbox);
296         gtk_container_add(GTK_CONTAINER(item), hbox);
297
298         vbox = gtk_vbox_new(TRUE, 0);
299         gtk_widget_show(vbox);
300         gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
301
302         gtk_container_add(GTK_CONTAINER(vbox),
303                           label_colors[menu_index][color_index].widget);
304         gtk_widget_show(label_colors[menu_index][color_index].widget);
305
306         gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
307         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 4);
308         accel = g_strdup_printf("Ctrl+%c", '1'+color_index);
309         label = gtk_label_new(accel);
310         gtk_widget_show(label);
311         gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
312         g_free(accel);
313         gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 4);
314         return item;
315 }
316
317 /* Work around a gtk bug (?): without that, the selected menu item's 
318  * colored rectangle is drawn at 0,0 in the window...
319  */
320 static void refresh_menu (GtkWidget *menushell, gpointer data)
321 {
322         GtkMenu *menu = (GtkMenu *)data;
323         GtkWidget *widget = gtk_menu_get_attach_widget(menu);
324         gtk_widget_hide_all(widget);
325         gtk_widget_unrealize(widget);
326         gtk_widget_show_all(widget);
327         gtk_widget_queue_draw(widget);
328 }
329
330 /* colorlabel_create_color_menu() - creates a color menu without 
331  * checkitems, probably for use in combo items */
332 GtkWidget *colorlabel_create_color_menu(void)
333 {
334         GtkWidget *label; 
335         GtkWidget *item;
336         GtkWidget *menu;
337         gint i;
338
339         colorlabel_recreate_all();
340
341         /* create the menu items. each item has its color code attached */
342         menu = gtk_menu_new();
343         g_object_set_data(G_OBJECT(menu), "label_color_menu", menu);
344
345         item = gtk_menu_item_new_with_label(_("None"));
346         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
347         g_object_set_data(G_OBJECT(item), "color", GUINT_TO_POINTER(0));
348         gtk_widget_show(item);
349
350         /* and the color items */
351         for (i = 0; i < LABEL_COLORS_ELEMS; i++) {
352                 GtkWidget *hbox; 
353                 GtkWidget *vbox;
354                 GtkWidget *widget;
355
356                 item  = gtk_menu_item_new();
357                 g_object_set_data(G_OBJECT(item), "color",
358                                   GUINT_TO_POINTER(i + 1));
359
360                 label = gtk_label_new(label_colors[0][i].label);
361                 
362                 gtk_widget_show(label);
363                 hbox = gtk_hbox_new(FALSE, 0);
364                 gtk_widget_show(hbox);
365                 gtk_container_add(GTK_CONTAINER(item), hbox);
366
367                 vbox = gtk_vbox_new(TRUE, 0);
368                 gtk_widget_show(vbox);
369                 gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
370
371                 widget = colorlabel_create_color_widget(label_colors[0][i].color);
372                 gtk_widget_show(widget);
373                 gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
374
375                 gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
376                 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 4);
377                 
378                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
379                 gtk_widget_show(item);
380         }
381         
382         g_signal_connect(G_OBJECT(menu), "selection-done", 
383                         G_CALLBACK(refresh_menu), menu);
384         gtk_widget_show(menu);
385
386         return menu;
387 }
388
389 guint colorlabel_get_color_menu_active_item(GtkWidget *menu)
390 {
391         GtkWidget *menuitem;
392         guint color;
393
394         menuitem = gtk_menu_get_active(GTK_MENU(menu));
395         color = GPOINTER_TO_UINT
396                 (g_object_get_data(G_OBJECT(menuitem), "color"));
397         return color;
398 }