?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve some sieve-related translations
[claws.git] / src / gtk / gtkutils.c
blobcf97cfd31482acf2b76bf2a7956acde9a229cd2b
1 /*
2 * Claws Mail -- a GTK based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2022 the Claws Mail team and Hiroyuki Yamamoto
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 #ifdef HAVE_CONFIG_H
20 # include "config.h"
21 #include "claws-features.h"
22 #endif
23
24 #include <glib.h>
25 #include <glib/gi18n.h>
26 #include <gdk/gdkkeysyms.h>
27 #include <gdk/gdk.h>
28 #include <gtk/gtk.h>
29 #include "gtk/gtksctree.h"
30 #include <stdlib.h>
31 #include <stdarg.h>
32 #include <sys/stat.h>
33
34 #include "combobox.h"
35
36 #if HAVE_LIBCOMPFACE
37 # include <compface.h>
38 #endif
39
40 #if HAVE_LIBCOMPFACE
41 #define XPM_XFACE_HEIGHT (HEIGHT + 3) /* 3 = 1 header + 2 colors */
42 #endif
43
44 #if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
45 # include <wchar.h>
46 # include <wctype.h>
47 #endif
48
49 #include "defs.h"
50 #include "gtkutils.h"
51 #include "utils.h"
52 #include "gtksctree.h"
53 #include "codeconv.h"
54 #include "stock_pixmap.h"
55 #include "menu.h"
56 #include "prefs_account.h"
57 #include "prefs_common.h"
58 #include "manage_window.h"
59 #include "manual.h"
60
61 gboolean gtkut_get_font_size(GtkWidget *widget,
62 gint *width, gint *height)
63 {
64 PangoLayout *layout;
65 const gchar *str = "Abcdef";
66
67 cm_return_val_if_fail(GTK_IS_WIDGET(widget), FALSE);
68
69 layout = gtk_widget_create_pango_layout(widget, str);
70 cm_return_val_if_fail(layout, FALSE);
71 pango_layout_get_pixel_size(layout, width, height);
72 if (width)
73 *width = *width / g_utf8_strlen(str, -1);
74 g_object_unref(layout);
75
76 return TRUE;
77 }
78
79 void gtkut_widget_set_small_font_size(GtkWidget *widget)
80 {
81 PangoFontDescription *font_desc;
82 gint size;
83
84 cm_return_if_fail(widget != NULL);
85 cm_return_if_fail(gtk_widget_get_style(widget) != NULL);
86
87 if (prefs_common.derive_from_normal_font || !SMALL_FONT) {
88 font_desc = pango_font_description_from_string(NORMAL_FONT);
89 size = pango_font_description_get_size(font_desc);
90 pango_font_description_set_size(font_desc, size * PANGO_SCALE_SMALL);
91 gtk_widget_override_font(widget, font_desc);
92 pango_font_description_free(font_desc);
93 } else {
94 font_desc = pango_font_description_from_string(SMALL_FONT);
95 gtk_widget_override_font(widget, font_desc);
96 pango_font_description_free(font_desc);
97 }
98 }
99
100 void gtkut_stock_button_add_help(GtkWidget *bbox, GtkWidget **help_btn)
101 {
102 cm_return_if_fail(bbox != NULL);
103
104 *help_btn = gtkut_stock_button("help-browser", "Help");
105
106 gtk_widget_set_can_default(*help_btn, TRUE);
107 gtk_box_pack_end(GTK_BOX (bbox), *help_btn, TRUE, TRUE, 0);
108 gtk_button_box_set_child_secondary(GTK_BUTTON_BOX (bbox),
109 *help_btn, TRUE);
110 gtk_widget_set_sensitive(*help_btn,
111 manual_available(MANUAL_MANUAL_CLAWS));
112 gtk_widget_show(*help_btn);
113 }
114
115 void gtkut_stock_button_set_create_with_help(GtkWidget **bbox,
116 GtkWidget **help_button,
117 GtkWidget **button1, const gchar *stock_icon1, const gchar *label1,
118 GtkWidget **button2, const gchar *stock_icon2, const gchar *label2,
119 GtkWidget **button3, const gchar *stock_icon3, const gchar *label3)
120 {
121 cm_return_if_fail(bbox != NULL);
122 cm_return_if_fail(button1 != NULL);
123
124 gtkut_stock_button_set_create(bbox, button1, stock_icon1, label1,
125 button2, stock_icon2, label2, button3, stock_icon3, label3);
126
127 gtkut_stock_button_add_help(*bbox, help_button);
128 }
129
130 void gtkut_stock_button_set_create(GtkWidget **bbox,
131 GtkWidget **button1, const gchar *stock_icon1, const gchar *label1,
132 GtkWidget **button2, const gchar *stock_icon2, const gchar *label2,
133 GtkWidget **button3, const gchar *stock_icon3, const gchar *label3)
134 {
135 cm_return_if_fail(bbox != NULL);
136 cm_return_if_fail(button1 != NULL);
137
138 *bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
139 gtk_button_box_set_layout(GTK_BUTTON_BOX(*bbox), GTK_BUTTONBOX_END);
140 gtk_box_set_spacing(GTK_BOX(*bbox), 5);
141
142 *button1 = gtk_button_new_with_mnemonic(label1);
143 gtk_button_set_image(GTK_BUTTON(*button1),
144 gtk_image_new_from_icon_name(stock_icon1, GTK_ICON_SIZE_BUTTON));
145 gtk_widget_set_can_default(*button1, TRUE);
146 gtk_box_pack_start(GTK_BOX(*bbox), *button1, TRUE, TRUE, 0);
147 gtk_widget_show(*button1);
148
149 if (button2) {
150 *button2 = gtk_button_new_with_mnemonic(label2);
151 gtk_button_set_image(GTK_BUTTON(*button2),
152 gtk_image_new_from_icon_name(stock_icon2, GTK_ICON_SIZE_BUTTON));
153 gtk_widget_set_can_default(*button2, TRUE);
154 gtk_box_pack_start(GTK_BOX(*bbox), *button2, TRUE, TRUE, 0);
155 gtk_widget_show(*button2);
156 }
157
158 if (button3) {
159 *button3 = gtk_button_new_with_mnemonic(label3);
160 gtk_button_set_image(GTK_BUTTON(*button3),
161 gtk_image_new_from_icon_name(stock_icon3, GTK_ICON_SIZE_BUTTON));
162 gtk_widget_set_can_default(*button3, TRUE);
163 gtk_box_pack_start(GTK_BOX(*bbox), *button3, TRUE, TRUE, 0);
164 gtk_widget_show(*button3);
165 }
166 }
167
168 void gtkut_stock_with_text_button_set_create(GtkWidget **bbox,
169 GtkWidget **button1, const gchar *label1, const gchar *text1,
170 GtkWidget **button2, const gchar *label2, const gchar *text2,
171 GtkWidget **button3, const gchar *label3, const gchar *text3)
172 {
173 cm_return_if_fail(bbox != NULL);
174 cm_return_if_fail(button1 != NULL);
175
176 *bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
177 gtk_button_box_set_layout(GTK_BUTTON_BOX(*bbox), GTK_BUTTONBOX_END);
178 gtk_box_set_spacing(GTK_BOX(*bbox), 5);
179
180 *button1 = gtk_button_new_with_mnemonic(text1);
181 gtk_button_set_image(GTK_BUTTON(*button1),
182 gtk_image_new_from_icon_name(label1, GTK_ICON_SIZE_BUTTON));
183 gtk_widget_set_can_default(*button1, TRUE);
184 gtk_box_pack_start(GTK_BOX(*bbox), *button1, TRUE, TRUE, 0);
185 gtk_widget_show(*button1);
186
187 if (button2) {
188 *button2 = gtk_button_new_with_mnemonic(text2);
189 gtk_button_set_image(GTK_BUTTON(*button2),
190 gtk_image_new_from_icon_name(label2, GTK_ICON_SIZE_BUTTON));
191 gtk_widget_set_can_default(*button2, TRUE);
192 gtk_box_pack_start(GTK_BOX(*bbox), *button2, TRUE, TRUE, 0);
193 gtk_widget_show(*button2);
194 }
195
196 if (button3) {
197 *button3 = gtk_button_new_with_mnemonic(text3);
198 gtk_button_set_image(GTK_BUTTON(*button3),
199 gtk_image_new_from_icon_name(label3, GTK_ICON_SIZE_BUTTON));
200 gtk_widget_set_can_default(*button3, TRUE);
201 gtk_box_pack_start(GTK_BOX(*bbox), *button3, TRUE, TRUE, 0);
202 gtk_widget_show(*button3);
203 }
204 }
205
206 #define CELL_SPACING 1
207 #define ROW_TOP_YPIXEL(clist, row) (((clist)->row_height * (row)) + \
208 (((row) + 1) * CELL_SPACING) + \
209 (clist)->voffset)
210 #define ROW_FROM_YPIXEL(clist, y) (((y) - (clist)->voffset) / \
211 ((clist)->row_height + CELL_SPACING))
212
213 void gtkut_ctree_node_move_if_on_the_edge(GtkCMCTree *ctree, GtkCMCTreeNode *node, gint _row)
214 {
215 GtkCMCList *clist = GTK_CMCLIST(ctree);
216 gint row;
217 GtkVisibility row_visibility, prev_row_visibility, next_row_visibility;
218 gfloat row_align;
219
220 cm_return_if_fail(ctree != NULL);
221 cm_return_if_fail(node != NULL);
222
223 row = (_row != -1 ? _row : g_list_position(clist->row_list, (GList *)node));
224
225 if (row < 0 || row >= clist->rows || clist->row_height == 0) return;
226 row_visibility = gtk_cmclist_row_is_visible(clist, row);
227 prev_row_visibility = gtk_cmclist_row_is_visible(clist, row - 1);
228 next_row_visibility = gtk_cmclist_row_is_visible(clist, row + 1);
229
230 if (row_visibility == GTK_VISIBILITY_NONE) {
231 row_align = 0.5;
232 if (gtk_cmclist_row_is_above_viewport(clist, row))
233 row_align = 0.2;
234 else if (gtk_cmclist_row_is_below_viewport(clist, row))
235 row_align = 0.8;
236 gtk_cmclist_moveto(clist, row, -1, row_align, 0);
237 return;
238 }
239 if (row_visibility == GTK_VISIBILITY_FULL &&
240 prev_row_visibility == GTK_VISIBILITY_FULL &&
241 next_row_visibility == GTK_VISIBILITY_FULL)
242 return;
243 if (prev_row_visibility != GTK_VISIBILITY_FULL &&
244 next_row_visibility != GTK_VISIBILITY_FULL)
245 return;
246
247 if (prev_row_visibility != GTK_VISIBILITY_FULL) {
248 gtk_cmclist_moveto(clist, row, -1, 0.2, 0);
249 return;
250 }
251 if (next_row_visibility != GTK_VISIBILITY_FULL) {
252 gtk_cmclist_moveto(clist, row, -1, 0.8, 0);
253 return;
254 }
255 }
256
257 #undef CELL_SPACING
258 #undef ROW_TOP_YPIXEL
259 #undef ROW_FROM_YPIXEL
260
261 gint gtkut_ctree_get_nth_from_node(GtkCMCTree *ctree, GtkCMCTreeNode *node)
262 {
263 cm_return_val_if_fail(ctree != NULL, -1);
264 cm_return_val_if_fail(node != NULL, -1);
265
266 return g_list_position(GTK_CMCLIST(ctree)->row_list, (GList *)node);
267 }
268
269 /* get the next node, including the invisible one */
270 GtkCMCTreeNode *gtkut_ctree_node_next(GtkCMCTree *ctree, GtkCMCTreeNode *node)
271 {
272 GtkCMCTreeNode *parent;
273
274 if (!node) return NULL;
275
276 if (GTK_CMCTREE_ROW(node)->children)
277 return GTK_CMCTREE_ROW(node)->children;
278
279 if (GTK_CMCTREE_ROW(node)->sibling)
280 return GTK_CMCTREE_ROW(node)->sibling;
281
282 for (parent = GTK_CMCTREE_ROW(node)->parent; parent != NULL;
283 parent = GTK_CMCTREE_ROW(parent)->parent) {
284 if (GTK_CMCTREE_ROW(parent)->sibling)
285 return GTK_CMCTREE_ROW(parent)->sibling;
286 }
287
288 return NULL;
289 }
290
291 /* get the previous node, including the invisible one */
292 GtkCMCTreeNode *gtkut_ctree_node_prev(GtkCMCTree *ctree, GtkCMCTreeNode *node)
293 {
294 GtkCMCTreeNode *prev;
295 GtkCMCTreeNode *child;
296
297 if (!node) return NULL;
298
299 prev = GTK_CMCTREE_NODE_PREV(node);
300 if (prev == GTK_CMCTREE_ROW(node)->parent)
301 return prev;
302
303 child = prev;
304 while (GTK_CMCTREE_ROW(child)->children != NULL) {
305 child = GTK_CMCTREE_ROW(child)->children;
306 while (GTK_CMCTREE_ROW(child)->sibling != NULL)
307 child = GTK_CMCTREE_ROW(child)->sibling;
308 }
309
310 return child;
311 }
312
313 gboolean gtkut_ctree_node_is_selected(GtkCMCTree *ctree, GtkCMCTreeNode *node)
314 {
315 GtkCMCList *clist = GTK_CMCLIST(ctree);
316 GList *cur;
317
318 for (cur = clist->selection; cur != NULL; cur = cur->next) {
319 if (node == GTK_CMCTREE_NODE(cur->data))
320 return TRUE;
321 }
322
323 return FALSE;
324 }
325
326 GtkCMCTreeNode *gtkut_ctree_find_collapsed_parent(GtkCMCTree *ctree,
327 GtkCMCTreeNode *node)
328 {
329 if (!node) return NULL;
330
331 while ((node = GTK_CMCTREE_ROW(node)->parent) != NULL) {
332 if (!GTK_CMCTREE_ROW(node)->expanded)
333 return node;
334 }
335
336 return NULL;
337 }
338
339 void gtkut_ctree_expand_parent_all(GtkCMCTree *ctree, GtkCMCTreeNode *node)
340 {
341 gtk_cmclist_freeze(GTK_CMCLIST(ctree));
342
343 while ((node = gtkut_ctree_find_collapsed_parent(ctree, node)) != NULL)
344 gtk_cmctree_expand(ctree, node);
345
346 gtk_cmclist_thaw(GTK_CMCLIST(ctree));
347 }
348
349 gboolean gtkut_ctree_node_is_parent(GtkCMCTreeNode *parent, GtkCMCTreeNode *node)
350 {
351 GtkCMCTreeNode *tmp;
352 cm_return_val_if_fail(node != NULL, FALSE);
353 cm_return_val_if_fail(parent != NULL, FALSE);
354 tmp = node;
355
356 while (tmp) {
357 if(GTK_CMCTREE_ROW(tmp)->parent && GTK_CMCTREE_ROW(tmp)->parent == parent)
358 return TRUE;
359 tmp = GTK_CMCTREE_ROW(tmp)->parent;
360 }
361
362 return FALSE;
363 }
364
365 void gtkut_ctree_set_focus_row(GtkCMCTree *ctree, GtkCMCTreeNode *node)
366 {
367 if (node == NULL)
368 return;
369 gtkut_clist_set_focus_row(GTK_CMCLIST(ctree),
370 gtkut_ctree_get_nth_from_node(ctree, node));
371 }
372
373 void gtkut_clist_set_focus_row(GtkCMCList *clist, gint row)
374 {
375 clist->focus_row = row;
376 GTKUT_CTREE_REFRESH(clist);
377 }
378
379 static gboolean gtkut_text_buffer_match_string(GtkTextBuffer *textbuf,
380 const GtkTextIter *iter,
381 gunichar *wcs, gint len,
382 gboolean case_sens)
383 {
384 GtkTextIter start_iter, end_iter;
385 gchar *utf8str, *p;
386 gint match_count;
387
388 start_iter = end_iter = *iter;
389 gtk_text_iter_forward_chars(&end_iter, len);
390
391 utf8str = gtk_text_buffer_get_text(textbuf, &start_iter, &end_iter,
392 FALSE);
393 if (!utf8str) return FALSE;
394
395 if ((gint)g_utf8_strlen(utf8str, -1) != len) {
396 g_free(utf8str);
397 return FALSE;
398 }
399
400 for (p = utf8str, match_count = 0;
401 *p != '\0' && match_count < len;
402 p = g_utf8_next_char(p), match_count++) {
403 gunichar wc;
404
405 wc = g_utf8_get_char(p);
406
407 if (case_sens) {
408 if (wc != wcs[match_count])
409 break;
410 } else {
411 if (g_unichar_tolower(wc) !=
412 g_unichar_tolower(wcs[match_count]))
413 break;
414 }
415 }
416
417 g_free(utf8str);
418
419 if (match_count == len)
420 return TRUE;
421 else
422 return FALSE;
423 }
424
425 static gboolean gtkut_text_buffer_find(GtkTextBuffer *buffer, const GtkTextIter *iter,
426 const gchar *str, gboolean case_sens,
427 GtkTextIter *match_pos)
428 {
429 gunichar *wcs;
430 gint len;
431 glong items_read = 0, items_written = 0;
432 GError *error = NULL;
433 GtkTextIter iter_;
434 gboolean found = FALSE;
435
436 wcs = g_utf8_to_ucs4(str, -1, &items_read, &items_written, &error);
437 if (error != NULL) {
438 g_warning("an error occurred while converting a string from UTF-8 to UCS-4: %s",
439 error->message);
440 g_error_free(error);
441 }
442 if (!wcs || items_written <= 0) return FALSE;
443 len = (gint)items_written;
444
445 iter_ = *iter;
446 do {
447 found = gtkut_text_buffer_match_string
448 (buffer, &iter_, wcs, len, case_sens);
449 if (found) {
450 *match_pos = iter_;
451 break;
452 }
453 } while (gtk_text_iter_forward_char(&iter_));
454
455 g_free(wcs);
456
457 return found;
458 }
459
460 static gboolean gtkut_text_buffer_find_backward(GtkTextBuffer *buffer,
461 const GtkTextIter *iter,
462 const gchar *str, gboolean case_sens,
463 GtkTextIter *match_pos)
464 {
465 gunichar *wcs;
466 gint len;
467 glong items_read = 0, items_written = 0;
468 GError *error = NULL;
469 GtkTextIter iter_;
470 gboolean found = FALSE;
471
472 wcs = g_utf8_to_ucs4(str, -1, &items_read, &items_written, &error);
473 if (error != NULL) {
474 g_warning("an error occurred while converting a string from UTF-8 to UCS-4: %s",
475 error->message);
476 g_error_free(error);
477 }
478 if (!wcs || items_written <= 0) return FALSE;
479 len = (gint)items_written;
480
481 iter_ = *iter;
482 while (gtk_text_iter_backward_char(&iter_)) {
483 found = gtkut_text_buffer_match_string
484 (buffer, &iter_, wcs, len, case_sens);
485 if (found) {
486 *match_pos = iter_;
487 break;
488 }
489 }
490
491 g_free(wcs);
492
493 return found;
494 }
495
496 gchar *gtkut_text_view_get_selection(GtkTextView *textview)
497 {
498 GtkTextBuffer *buffer;
499 GtkTextIter start_iter, end_iter;
500 gboolean found;
501
502 cm_return_val_if_fail(GTK_IS_TEXT_VIEW(textview), NULL);
503
504 buffer = gtk_text_view_get_buffer(textview);
505 found = gtk_text_buffer_get_selection_bounds(buffer,
506 &start_iter,
507 &end_iter);
508 if (found)
509 return gtk_text_buffer_get_text(buffer, &start_iter, &end_iter,
510 FALSE);
511 else
512 return NULL;
513 }
514
515
516 void gtkut_text_view_set_position(GtkTextView *text, gint pos)
517 {
518 GtkTextBuffer *buffer;
519 GtkTextIter iter;
520 GtkTextMark *mark;
521
522 cm_return_if_fail(text != NULL);
523
524 buffer = gtk_text_view_get_buffer(text);
525
526 gtk_text_buffer_get_iter_at_offset(buffer, &iter, pos);
527 gtk_text_buffer_place_cursor(buffer, &iter);
528 mark = gtk_text_buffer_create_mark(buffer, NULL, &iter, TRUE);
529 gtk_text_view_scroll_to_mark(text, mark, 0.0, FALSE, 0.0, 0.0);
530 }
531
532 gboolean gtkut_text_view_search_string(GtkTextView *text, const gchar *str,
533 gboolean case_sens)
534 {
535 GtkTextBuffer *buffer;
536 GtkTextIter iter, match_pos;
537 GtkTextMark *mark;
538 gint len;
539
540 cm_return_val_if_fail(text != NULL, FALSE);
541 cm_return_val_if_fail(str != NULL, FALSE);
542
543 buffer = gtk_text_view_get_buffer(text);
544
545 len = g_utf8_strlen(str, -1);
546 cm_return_val_if_fail(len >= 0, FALSE);
547
548 mark = gtk_text_buffer_get_insert(buffer);
549 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
550
551 if (gtkut_text_buffer_find(buffer, &iter, str, case_sens,
552 &match_pos)) {
553 GtkTextIter end = match_pos;
554
555 gtk_text_iter_forward_chars(&end, len);
556 /* place "insert" at the last character */
557 gtk_text_buffer_select_range(buffer, &end, &match_pos);
558 gtk_text_view_scroll_to_mark(text, mark, 0.0, TRUE, 0.0, 0.5);
559 return TRUE;
560 }
561
562 return FALSE;
563 }
564
565 gboolean gtkut_text_view_search_string_backward(GtkTextView *text, const gchar *str,
566 gboolean case_sens)
567 {
568 GtkTextBuffer *buffer;
569 GtkTextIter iter, match_pos;
570 GtkTextMark *mark;
571 gint len;
572
573 cm_return_val_if_fail(text != NULL, FALSE);
574 cm_return_val_if_fail(str != NULL, FALSE);
575
576 buffer = gtk_text_view_get_buffer(text);
577
578 len = g_utf8_strlen(str, -1);
579 cm_return_val_if_fail(len >= 0, FALSE);
580
581 mark = gtk_text_buffer_get_insert(buffer);
582 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
583
584 if (gtkut_text_buffer_find_backward(buffer, &iter, str, case_sens,
585 &match_pos)) {
586 GtkTextIter end = match_pos;
587
588 gtk_text_iter_forward_chars(&end, len);
589 gtk_text_buffer_select_range(buffer, &match_pos, &end);
590 gtk_text_view_scroll_to_mark(text, mark, 0.0, TRUE, 0.0, 0.5);
591 return TRUE;
592 }
593
594 return FALSE;
595 }
596
597 void gtkut_window_popup(GtkWidget *window)
598 {
599 GdkWindow *gdkwin;
600 gint x, y, sx, sy, new_x, new_y;
601 GdkRectangle workarea = {0};
602
603 gdkwin = gtk_widget_get_window(window);
604
605 cm_return_if_fail(window != NULL);
606 cm_return_if_fail(gdkwin != NULL);
607
608 gdk_monitor_get_workarea(gdk_display_get_primary_monitor(gdk_display_get_default()),
609 &workarea);
610
611 sx = MAX(1, workarea.width);
612 sy = MAX(1, workarea.height);
613
614 gdk_window_get_origin(gdkwin, &x, &y);
615 new_x = x % sx; if (new_x < 0) new_x = 0;
616 new_y = y % sy; if (new_y < 0) new_y = 0;
617 if (new_x != x || new_y != y)
618 gdk_window_move(gdkwin, new_x, new_y);
619
620 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), FALSE);
621 gtk_window_present_with_time(GTK_WINDOW(window), time(NULL));
622 }
623
624 void gtkut_widget_get_uposition(GtkWidget *widget, gint *px, gint *py)
625 {
626 GdkWindow *gdkwin;
627 gint x, y;
628 gint sx, sy;
629 GdkRectangle workarea = {0};
630
631 gdkwin = gtk_widget_get_window(widget);
632
633 cm_return_if_fail(widget != NULL);
634 cm_return_if_fail(gdkwin != NULL);
635
636 gdk_monitor_get_workarea(gdk_display_get_primary_monitor(gdk_display_get_default()),
637 &workarea);
638
639 sx = MAX(1, workarea.width);
640 sy = MAX(1, workarea.height);
641
642 /* gdk_window_get_root_origin ever return *rootwindow*'s position */
643 gdk_window_get_root_origin(gdkwin, &x, &y);
644
645 x %= sx; if (x < 0) x = 0;
646 y %= sy; if (y < 0) y = 0;
647 *px = x;
648 *py = y;
649 }
650
651 static void gtkut_clist_bindings_add(GtkWidget *clist)
652 {
653 GtkBindingSet *binding_set;
654
655 binding_set = gtk_binding_set_by_class
656 (GTK_CMCLIST_GET_CLASS(clist));
657
658 gtk_binding_entry_add_signal(binding_set, GDK_KEY_n, GDK_CONTROL_MASK,
659 "scroll_vertical", 2,
660 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
661 G_TYPE_FLOAT, 0.0);
662 gtk_binding_entry_add_signal(binding_set, GDK_KEY_p, GDK_CONTROL_MASK,
663 "scroll_vertical", 2,
664 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
665 G_TYPE_FLOAT, 0.0);
666 }
667
668 void gtkut_widget_init(void)
669 {
670 GtkWidget *clist;
671
672 clist = gtk_cmclist_new(1);
673 g_object_ref(G_OBJECT(clist));
674 g_object_ref_sink (G_OBJECT(clist));
675 gtkut_clist_bindings_add(clist);
676 g_object_unref(G_OBJECT(clist));
677
678 clist = gtk_cmctree_new(1, 0);
679 g_object_ref(G_OBJECT(clist));
680 g_object_ref_sink (G_OBJECT(clist));
681 gtkut_clist_bindings_add(clist);
682 g_object_unref(G_OBJECT(clist));
683
684 clist = gtk_sctree_new_with_titles(1, 0, NULL);
685 g_object_ref(G_OBJECT(clist));
686 g_object_ref_sink (G_OBJECT(clist));
687 gtkut_clist_bindings_add(clist);
688 g_object_unref(G_OBJECT(clist));
689 }
690
691 void gtkut_widget_set_app_icon(GtkWidget *widget)
692 {
693 static GList *icon_list = NULL;
694
695 cm_return_if_fail(widget != NULL);
696 cm_return_if_fail(gtk_widget_get_window(widget) != NULL);
697 if (!icon_list) {
698 GdkPixbuf *icon = NULL, *big_icon = NULL;
699 priv_pixbuf_gdk(PRIV_PIXMAP_CLAWS_MAIL_ICON, &icon);
700 priv_pixbuf_gdk(PRIV_PIXMAP_CLAWS_MAIL_LOGO, &big_icon);
701 if (icon)
702 icon_list = g_list_append(icon_list, icon);
703 if (big_icon)
704 icon_list = g_list_append(icon_list, big_icon);
705 }
706 if (icon_list)
707 gtk_window_set_icon_list(GTK_WINDOW(widget), icon_list);
708 }
709
710 void gtkut_widget_set_composer_icon(GtkWidget *widget)
711 {
712 static GList *icon_list = NULL;
713
714 cm_return_if_fail(widget != NULL);
715 cm_return_if_fail(gtk_widget_get_window(widget) != NULL);
716 if (!icon_list) {
717 GdkPixbuf *icon = NULL, *big_icon = NULL;
718 stock_pixbuf_gdk(STOCK_PIXMAP_MAIL_COMPOSE, &icon);
719 stock_pixbuf_gdk(STOCK_PIXMAP_MAIL_COMPOSE_LOGO, &big_icon);
720 if (icon)
721 icon_list = g_list_append(icon_list, icon);
722 if (big_icon)
723 icon_list = g_list_append(icon_list, big_icon);
724 }
725 if (icon_list)
726 gtk_window_set_icon_list(GTK_WINDOW(widget), icon_list);
727 }
728
729 static gboolean move_bar = FALSE;
730 static gint move_bar_id = -1;
731
732 static gboolean move_bar_cb(gpointer data)
733 {
734 GtkWidget *w = (GtkWidget *)data;
735 if (!move_bar)
736 return FALSE;
737
738 if (!GTK_IS_PROGRESS_BAR(w)) {
739 return FALSE;
740 }
741 gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(w), 0.1);
742 gtk_progress_bar_pulse(GTK_PROGRESS_BAR(w));
743 GTK_EVENTS_FLUSH();
744 return TRUE;
745 }
746
747 GtkWidget *label_window_create(const gchar *str)
748 {
749 GtkWidget *window;
750 GtkWidget *label, *vbox, *hbox;
751 GtkWidget *wait_progress = gtk_progress_bar_new();
752
753 window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "gtkutils");
754 gtk_widget_set_size_request(window, 380, 70);
755 gtk_container_set_border_width(GTK_CONTAINER(window), 8);
756 gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
757 gtk_window_set_title(GTK_WINDOW(window), str);
758 gtk_window_set_modal(GTK_WINDOW(window), TRUE);
759 gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
760 manage_window_set_transient(GTK_WINDOW(window));
761
762 label = gtk_label_new(str);
763
764 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
765 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
766 gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, FALSE, 0);
767 gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 0);
768 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
769 gtk_box_pack_start(GTK_BOX(hbox), wait_progress, TRUE, FALSE, 0);
770 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
771
772 gtk_container_add(GTK_CONTAINER(window), vbox);
773 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
774 gtk_widget_show_all(vbox);
775
776 gtk_widget_show_now(window);
777
778 if (move_bar_id == -1) {
779 move_bar_id = g_timeout_add(200, move_bar_cb, wait_progress);
780 move_bar = TRUE;
781 }
782
783 GTK_EVENTS_FLUSH();
784
785 return window;
786 }
787
788 void label_window_destroy(GtkWidget *window)
789 {
790 move_bar = FALSE;
791 g_source_remove(move_bar_id);
792 move_bar_id = -1;
793 GTK_EVENTS_FLUSH();
794 gtk_widget_destroy(window);
795 }
796
797 GtkWidget *gtkut_account_menu_new(GList *ac_list,
798 GCallback callback,
799 gpointer data)
800 {
801 GList *cur_ac;
802 GtkWidget *optmenu;
803 GtkListStore *menu;
804 GtkTreeIter iter;
805 PrefsAccount *account;
806 gchar *name;
807
808 cm_return_val_if_fail(ac_list != NULL, NULL);
809
810 optmenu = gtkut_sc_combobox_create(NULL, FALSE);
811 menu = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(optmenu)));
812
813 for (cur_ac = ac_list; cur_ac != NULL; cur_ac = cur_ac->next) {
814 account = (PrefsAccount *) cur_ac->data;
815 if (account->name)
816 name = g_strdup_printf("%s: %s <%s>",
817 account->account_name,
818 account->name,
819 account->address);
820 else
821 name = g_strdup_printf("%s: %s",
822 account->account_name,
823 account->address);
824 COMBOBOX_ADD_ESCAPED(menu, name, account->account_id);
825 g_free(name);
826 }
827 gtk_combo_box_set_active(GTK_COMBO_BOX(optmenu), 0);
828
829 if( callback != NULL )
830 g_signal_connect(G_OBJECT(optmenu), "changed", callback, data);
831
832 return optmenu;
833 }
834
835 /*!
836 *\brief Tries to find a focused child using a lame strategy
837 */
838 GtkWidget *gtkut_get_focused_child(GtkContainer *parent)
839 {
840 GtkWidget *result = NULL;
841 GList *child_list = NULL;
842 GList *c;
843
844 cm_return_val_if_fail(parent, NULL);
845
846 /* Get children list and see which has the focus. */
847 child_list = gtk_container_get_children(parent);
848 if (!child_list)
849 return NULL;
850
851 for (c = child_list; c != NULL; c = g_list_next(c)) {
852 if (c->data && GTK_IS_WIDGET(c->data)) {
853 if (gtk_widget_has_focus(GTK_WIDGET(c->data))) {
854 result = GTK_WIDGET(c->data);
855 break;
856 }
857 }
858 }
859
860 /* See if the returned widget is a container itself; if it is,
861 * see if one of its children is focused. If the focused
862 * container has no focused child, it is itself a focusable
863 * child, and has focus. */
864 if (result && GTK_IS_CONTAINER(result)) {
865 GtkWidget *tmp = gtkut_get_focused_child(GTK_CONTAINER(result));
866
867 if (tmp)
868 result = tmp;
869 } else {
870 /* Try the same for each container in the chain */
871 for (c = child_list; c != NULL && !result; c = g_list_next(c)) {
872 if (c->data && GTK_IS_WIDGET(c->data)
873 && GTK_IS_CONTAINER(c->data)) {
874 result = gtkut_get_focused_child
875 (GTK_CONTAINER(c->data));
876 }
877 }
878
879 }
880
881 g_list_free(child_list);
882
883 return result;
884 }
885
886 /*!
887 *\brief Create a Browse (file) button based on GTK stock
888 */
889 GtkWidget *gtkut_get_browse_file_btn(const gchar *button_label)
890 {
891 GtkWidget *button;
892
893 button = gtk_button_new_with_mnemonic(button_label);
894 gtk_button_set_image(GTK_BUTTON(button),
895 gtk_image_new_from_icon_name("folder", GTK_ICON_SIZE_BUTTON));
896
897 return button;
898 }
899
900 /*!
901 *\brief Create a Browse (directory) button based on GTK stock
902 */
903 GtkWidget *gtkut_get_browse_directory_btn(const gchar *button_label)
904 {
905 GtkWidget *button;
906
907 button = gtk_button_new_with_mnemonic(button_label);
908 gtk_button_set_image(GTK_BUTTON(button),
909 gtk_image_new_from_icon_name("folder", GTK_ICON_SIZE_BUTTON));
910
911 return button;
912 }
913
914 GtkWidget *gtkut_get_replace_btn(const gchar *button_label)
915 {
916 GtkWidget *button;
917
918 button = gtk_button_new_with_mnemonic(button_label);
919 gtk_button_set_image(GTK_BUTTON(button),
920 gtk_image_new_from_icon_name("view-refresh", GTK_ICON_SIZE_BUTTON));
921
922 return button;
923 }
924
925 GtkWidget *gtkut_stock_button(const gchar *stock_image, const gchar *label)
926 {
927 GtkWidget *button;
928
929 cm_return_val_if_fail(stock_image != NULL, NULL);
930
931 button = gtk_button_new_from_icon_name(stock_image, GTK_ICON_SIZE_BUTTON);
932 if (label != NULL)
933 gtk_button_set_label(GTK_BUTTON(button), _(label));
934 gtk_button_set_use_underline(GTK_BUTTON(button), TRUE);
935 gtk_button_set_always_show_image(GTK_BUTTON(button), TRUE);
936
937 return button;
938 };
939
940 /**
941 * merge some part of code into one function : it creates a frame and add
942 * these into gtk box widget passed in param.
943 * \param box gtk box where adding new created frame.
944 * \param pframe pointer with which to assign the frame. If NULL, no pointer
945 * is assigned but the frame is anyway created and added to @box.
946 * \param frame_label frame label of new created frame.
947 */
948 GtkWidget *gtkut_get_options_frame(GtkWidget *box, GtkWidget **pframe,
949 const gchar *frame_label)
950 {
951 GtkWidget *vbox;
952 GtkWidget *frame;
953
954 frame = gtk_frame_new(frame_label);
955 gtk_widget_show(frame);
956 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 0);
957 gtk_frame_set_label_align(GTK_FRAME(frame), 0.01, 0.5);
958
959 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
960 gtk_widget_show(vbox);
961 gtk_container_add(GTK_CONTAINER (frame), vbox);
962 gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
963
964 if (pframe != NULL)
965 *pframe = frame;
966
967 return vbox;
968 }
969
970 #if HAVE_LIBCOMPFACE
971 static gint create_xpm_from_xface(gchar *xpm[], const gchar *xface)
972 {
973 static gchar *bit_pattern[] = {
974 "....",
975 "...#",
976 "..#.",
977 "..##",
978 ".#..",
979 ".#.#",
980 ".##.",
981 ".###",
982 "#...",
983 "#..#",
984 "#.#.",
985 "#.##",
986 "##..",
987 "##.#",
988 "###.",
989 "####"
990 };
991
992 static gchar *xface_header = "48 48 2 1";
993 static gchar *xface_black = "# c #000000";
994 static gchar *xface_white = ". c #ffffff";
995
996 gint i, line = 0;
997 const guchar *p;
998 gchar buf[WIDTH * 4 + 1]; /* 4 = strlen("0x0000") */
999
1000 p = xface;
1001
1002 strcpy(xpm[line++], xface_header);
1003 strcpy(xpm[line++], xface_black);
1004 strcpy(xpm[line++], xface_white);
1005
1006 for (i = 0; i < HEIGHT; i++) {
1007 gint col;
1008
1009 buf[0] = '\0';
1010
1011 for (col = 0; col < 3; col++) {
1012 gint figure;
1013
1014 p += 2; /* skip '0x' */
1015
1016 for (figure = 0; figure < 4; figure++) {
1017 gint n = 0;
1018
1019 if ('0' <= *p && *p <= '9') {
1020 n = *p - '0';
1021 } else if ('a' <= *p && *p <= 'f') {
1022 n = *p - 'a' + 10;
1023 } else if ('A' <= *p && *p <= 'F') {
1024 n = *p - 'A' + 10;
1025 }
1026
1027 strcat(buf, bit_pattern[n]);
1028 p++; /* skip ',' */
1029 }
1030
1031 p++; /* skip '\n' */
1032 }
1033
1034 strcpy(xpm[line++], buf);
1035 p++;
1036 }
1037
1038 return 0;
1039 }
1040 #endif
1041
1042 gboolean get_tag_range(GtkTextIter *iter,
1043 GtkTextTag *tag,
1044 GtkTextIter *start_iter,
1045 GtkTextIter *end_iter)
1046 {
1047 GtkTextIter _start_iter, _end_iter;
1048
1049 _end_iter = *iter;
1050 if (!gtk_text_iter_forward_to_tag_toggle(&_end_iter, tag)) {
1051 debug_print("Can't find end.\n");
1052 return FALSE;
1053 }
1054
1055 _start_iter = _end_iter;
1056 if (!gtk_text_iter_backward_to_tag_toggle(&_start_iter, tag)) {
1057 debug_print("Can't find start.\n");
1058 return FALSE;
1059 }
1060
1061 *start_iter = _start_iter;
1062 *end_iter = _end_iter;
1063
1064 return TRUE;
1065 }
1066
1067 #if HAVE_LIBCOMPFACE
1068 GtkWidget *xface_get_from_header(const gchar *o_xface)
1069 {
1070 static gchar *xpm_xface[XPM_XFACE_HEIGHT];
1071 static gboolean xpm_xface_init = TRUE;
1072 GdkPixbuf *pixbuf;
1073 GtkWidget *ret;
1074 gchar xface[2048];
1075
1076 if (o_xface == NULL)
1077 return NULL;
1078
1079 strncpy(xface, o_xface, sizeof(xface) - 1);
1080 xface[sizeof(xface) - 1] = '\0';
1081
1082 if (uncompface(xface) < 0) {
1083 g_warning("uncompface failed");
1084 return NULL;
1085 }
1086
1087 if (xpm_xface_init) {
1088 gint i;
1089
1090 for (i = 0; i < XPM_XFACE_HEIGHT; i++) {
1091 xpm_xface[i] = g_malloc(WIDTH + 1);
1092 *xpm_xface[i] = '\0';
1093 }
1094 xpm_xface_init = FALSE;
1095 }
1096
1097 create_xpm_from_xface(xpm_xface, xface);
1098
1099 pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)xpm_xface);
1100 ret = gtk_image_new_from_pixbuf(pixbuf);
1101 g_object_unref(pixbuf);
1102
1103 return ret;
1104 }
1105 #endif
1106
1107 GtkWidget *face_get_from_header(const gchar *o_face)
1108 {
1109 gchar face[2048];
1110 gchar *face_png;
1111 gsize pngsize;
1112 GdkPixbuf *pixbuf;
1113 GError *error = NULL;
1114 GdkPixbufLoader *loader = gdk_pixbuf_loader_new ();
1115 GtkWidget *image;
1116
1117 if (o_face == NULL || strlen(o_face) == 0)
1118 return NULL;
1119
1120 strncpy2(face, o_face, sizeof(face));
1121
1122 unfold_line(face); /* strip all whitespace and linebreaks */
1123 remove_space(face);
1124
1125 face_png = g_base64_decode(face, &pngsize);
1126 debug_print("---------------------- loaded face png\n");
1127
1128 if (!gdk_pixbuf_loader_write (loader, face_png, pngsize, &error) ||
1129 !gdk_pixbuf_loader_close (loader, &error)) {
1130 g_warning("loading face failed");
1131 g_object_unref(loader);
1132 g_free(face_png);
1133 return NULL;
1134 }
1135 g_free(face_png);
1136
1137 pixbuf = g_object_ref(gdk_pixbuf_loader_get_pixbuf(loader));
1138
1139 g_object_unref(loader);
1140
1141 if ((gdk_pixbuf_get_width(pixbuf) != 48) || (gdk_pixbuf_get_height(pixbuf) != 48)) {
1142 g_object_unref(pixbuf);
1143 g_warning("wrong_size");
1144 return NULL;
1145 }
1146
1147 image = gtk_image_new_from_pixbuf(pixbuf);
1148 g_object_unref(pixbuf);
1149 return image;
1150 }
1151
1152 static gboolean _combobox_separator_func(GtkTreeModel *model,
1153 GtkTreeIter *iter, gpointer data)
1154 {
1155 gchar *txt = NULL;
1156
1157 cm_return_val_if_fail(model != NULL, FALSE);
1158
1159 gtk_tree_model_get(model, iter, COMBOBOX_TEXT, &txt, -1);
1160
1161 if( txt == NULL )
1162 return TRUE;
1163
1164 g_free(txt);
1165 return FALSE;
1166 }
1167
1168 GtkWidget *gtkut_sc_combobox_create(GtkWidget *eventbox, gboolean focus_on_click)
1169 {
1170 GtkWidget *combobox;
1171 GtkListStore *menu;
1172 GtkCellRenderer *rend;
1173
1174 menu = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN);
1175
1176 combobox = gtk_combo_box_new_with_model(GTK_TREE_MODEL(menu));
1177
1178 rend = gtk_cell_renderer_text_new();
1179 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), rend, TRUE);
1180 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox), rend,
1181 "markup", COMBOBOX_TEXT,
1182 "sensitive", COMBOBOX_SENS,
1183 NULL);
1184
1185 if( eventbox != NULL )
1186 gtk_container_add(GTK_CONTAINER(eventbox), combobox);
1187 gtk_widget_set_focus_on_click(GTK_WIDGET(combobox), focus_on_click);
1188
1189 gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combobox),
1190 (GtkTreeViewRowSeparatorFunc)_combobox_separator_func, NULL, NULL);
1191
1192 return combobox;
1193 }
1194
1195 static void gtkutils_smooth_scroll_do(GtkWidget *widget, GtkAdjustment *vadj,
1196 gfloat old_value, gfloat last_value,
1197 gint step)
1198 {
1199 gint change_value;
1200 gboolean up;
1201 gint i;
1202
1203 if (old_value < last_value) {
1204 change_value = last_value - old_value;
1205 up = FALSE;
1206 } else {
1207 change_value = old_value - last_value;
1208 up = TRUE;
1209 }
1210
1211 for (i = step; i <= change_value; i += step) {
1212 gtk_adjustment_set_value(vadj, old_value + (up ? -i : i));
1213 g_signal_emit_by_name(G_OBJECT(vadj),
1214 "value_changed", 0);
1215 }
1216
1217 gtk_adjustment_set_value(vadj, last_value);
1218 g_signal_emit_by_name(G_OBJECT(vadj), "value_changed", 0);
1219
1220 gtk_widget_queue_draw(widget);
1221 }
1222
1223 static gboolean gtkutils_smooth_scroll_page(GtkWidget *widget, GtkAdjustment *vadj, gboolean up)
1224 {
1225 gfloat upper;
1226 gfloat page_incr;
1227 gfloat old_value;
1228 gfloat last_value;
1229
1230 page_incr = gtk_adjustment_get_page_increment(vadj);
1231 if (prefs_common.scroll_halfpage)
1232 page_incr /= 2;
1233
1234 old_value = gtk_adjustment_get_value(vadj);
1235 if (!up) {
1236 upper = gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj);
1237 if (old_value < upper) {
1238 last_value = old_value + page_incr;
1239 last_value = MIN(last_value, upper);
1240
1241 gtkutils_smooth_scroll_do(widget, vadj, old_value,
1242 last_value,
1243 prefs_common.scroll_step);
1244 } else
1245 return FALSE;
1246 } else {
1247 if (old_value > 0.0) {
1248 last_value = old_value - page_incr;
1249 last_value = MAX(last_value, 0.0);
1250
1251 gtkutils_smooth_scroll_do(widget, vadj, old_value,
1252 last_value,
1253 prefs_common.scroll_step);
1254 } else
1255 return FALSE;
1256 }
1257
1258 return TRUE;
1259 }
1260
1261 gboolean gtkutils_scroll_page(GtkWidget *widget, GtkAdjustment *vadj, gboolean up)
1262 {
1263 gfloat upper;
1264 gfloat page_incr;
1265 gfloat old_value;
1266
1267 if (prefs_common.enable_smooth_scroll)
1268 return gtkutils_smooth_scroll_page(widget, vadj, up);
1269
1270 page_incr = gtk_adjustment_get_page_increment(vadj);
1271 if (prefs_common.scroll_halfpage)
1272 page_incr /= 2;
1273
1274 old_value = gtk_adjustment_get_value(vadj);
1275 if (!up) {
1276 upper = gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj);
1277 if (old_value < upper) {
1278 old_value += page_incr;
1279 old_value = MIN(old_value, upper);
1280 gtk_adjustment_set_value(vadj, old_value);
1281 g_signal_emit_by_name(G_OBJECT(vadj),
1282 "value_changed", 0);
1283 } else
1284 return FALSE;
1285 } else {
1286 if (old_value > 0.0) {
1287 old_value -= page_incr;
1288 old_value = MAX(old_value, 0.0);
1289 gtk_adjustment_set_value(vadj, old_value);
1290 g_signal_emit_by_name(G_OBJECT(vadj),
1291 "value_changed", 0);
1292 } else
1293 return FALSE;
1294 }
1295 return TRUE;
1296 }
1297
1298 static void gtkutils_smooth_scroll_one_line(GtkWidget *widget, GtkAdjustment *vadj, gboolean up)
1299 {
1300 gfloat upper;
1301 gfloat old_value;
1302 gfloat last_value;
1303
1304 old_value = gtk_adjustment_get_value(vadj);
1305 if (!up) {
1306 upper = gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj);
1307 if (old_value < upper) {
1308 last_value = old_value + gtk_adjustment_get_step_increment(vadj);
1309 last_value = MIN(last_value, upper);
1310
1311 gtkutils_smooth_scroll_do(widget, vadj, old_value,
1312 last_value,
1313 prefs_common.scroll_step);
1314 }
1315 } else {
1316 if (old_value > 0.0) {
1317 last_value = old_value - gtk_adjustment_get_step_increment(vadj);
1318 last_value = MAX(last_value, 0.0);
1319
1320 gtkutils_smooth_scroll_do(widget, vadj, old_value,
1321 last_value,
1322 prefs_common.scroll_step);
1323 }
1324 }
1325 }
1326
1327 void gtkutils_scroll_one_line(GtkWidget *widget, GtkAdjustment *vadj, gboolean up)
1328 {
1329 gfloat upper;
1330 gfloat old_value;
1331
1332 if (prefs_common.enable_smooth_scroll) {
1333 gtkutils_smooth_scroll_one_line(widget, vadj, up);
1334 return;
1335 }
1336
1337 old_value = gtk_adjustment_get_value(vadj);
1338 if (!up) {
1339 upper = gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj);
1340 if (old_value < upper) {
1341 old_value += gtk_adjustment_get_step_increment(vadj);
1342 old_value = MIN(old_value, upper);
1343 gtk_adjustment_set_value(vadj, old_value);
1344 g_signal_emit_by_name(G_OBJECT(vadj),
1345 "value_changed", 0);
1346 }
1347 } else {
1348 if (old_value > 0.0) {
1349 old_value -= gtk_adjustment_get_step_increment(vadj);
1350 old_value = MAX(old_value, 0.0);
1351 gtk_adjustment_set_value(vadj, old_value);
1352 g_signal_emit_by_name(G_OBJECT(vadj),
1353 "value_changed", 0);
1354 }
1355 }
1356 }
1357
1358 gboolean gtkut_tree_model_text_iter_prev(GtkTreeModel *model,
1359 GtkTreeIter *iter,
1360 const gchar* text)
1361 /* do the same as gtk_tree_model_iter_next, but _prev instead.
1362 to use with widgets with one text column (gtk_combo_box_text_new()
1363 and with GtkComboBoxEntry's for instance),
1364 */
1365 {
1366 GtkTreeIter cur_iter;
1367 gchar *cur_value;
1368 gboolean valid;
1369 gint count;
1370
1371 cm_return_val_if_fail(model != NULL, FALSE);
1372 cm_return_val_if_fail(iter != NULL, FALSE);
1373
1374 if (text == NULL || *text == '\0')
1375 return FALSE;
1376
1377 valid = gtk_tree_model_get_iter_first(model, &cur_iter);
1378 count = 0;
1379 while (valid) {
1380 gtk_tree_model_get(model, &cur_iter, 0, &cur_value, -1);
1381
1382 if (strcmp(text, cur_value) == 0) {
1383 g_free(cur_value);
1384 if (count <= 0)
1385 return FALSE;
1386
1387 return gtk_tree_model_iter_nth_child(model, iter, NULL, count - 1);
1388 }
1389
1390 g_free(cur_value);
1391 valid = gtk_tree_model_iter_next(model, &cur_iter);
1392 count++;
1393 }
1394 return FALSE;
1395 }
1396
1397 gboolean gtkut_tree_model_get_iter_last(GtkTreeModel *model,
1398 GtkTreeIter *iter)
1399 /* do the same as gtk_tree_model_get_iter_first, but _last instead.
1400 */
1401 {
1402 gint count;
1403
1404 cm_return_val_if_fail(model != NULL, FALSE);
1405 cm_return_val_if_fail(iter != NULL, FALSE);
1406
1407 count = gtk_tree_model_iter_n_children(model, NULL);
1408
1409 if (count <= 0)
1410 return FALSE;
1411
1412 return gtk_tree_model_iter_nth_child(model, iter, NULL, count - 1);
1413 }
1414
1415 GtkWidget *gtkut_window_new (GtkWindowType type,
1416 const gchar *class)
1417 {
1418 GtkWidget *window = gtk_window_new(type);
1419 gtk_window_set_role(GTK_WINDOW(window), class);
1420 gtk_widget_set_name(GTK_WIDGET(window), class);
1421 return window;
1422 }
1423
1424 static gboolean gtkut_tree_iter_comp(GtkTreeModel *model,
1425 GtkTreeIter *iter1,
1426 GtkTreeIter *iter2)
1427 {
1428 GtkTreePath *path1 = gtk_tree_model_get_path(model, iter1);
1429 GtkTreePath *path2 = gtk_tree_model_get_path(model, iter2);
1430 gboolean result;
1431
1432 result = gtk_tree_path_compare(path1, path2) == 0;
1433
1434 gtk_tree_path_free(path1);
1435 gtk_tree_path_free(path2);
1436
1437 return result;
1438 }
1439
1440 /*!
1441 *\brief Get selected row number.
1442 */
1443 gint gtkut_list_view_get_selected_row(GtkWidget *list_view)
1444 {
1445 GtkTreeView *view = GTK_TREE_VIEW(list_view);
1446 GtkTreeModel *model = gtk_tree_view_get_model(view);
1447 int n_rows = gtk_tree_model_iter_n_children(model, NULL);
1448 GtkTreeSelection *selection;
1449 GtkTreeIter iter;
1450 int row;
1451
1452 if (n_rows == 0)
1453 return -1;
1454
1455 selection = gtk_tree_view_get_selection(view);
1456 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1457 return -1;
1458
1459 /* get all iterators and compare them... */
1460 for (row = 0; row < n_rows; row++) {
1461 GtkTreeIter itern;
1462
1463 if (gtk_tree_model_iter_nth_child(model, &itern, NULL, row)
1464 && gtkut_tree_iter_comp(model, &iter, &itern))
1465 return row;
1466 }
1467
1468 return -1;
1469 }
1470
1471 /*!
1472 *\brief Select a row by its number.
1473 */
1474 gboolean gtkut_list_view_select_row(GtkWidget *list, gint row)
1475 {
1476 GtkTreeView *list_view = GTK_TREE_VIEW(list);
1477 GtkTreeSelection *selection = gtk_tree_view_get_selection(list_view);
1478 GtkTreeModel *model = gtk_tree_view_get_model(list_view);
1479 GtkTreeIter iter;
1480 GtkTreePath *path;
1481
1482 if (!gtk_tree_model_iter_nth_child(model, &iter, NULL, row))
1483 return FALSE;
1484
1485 gtk_tree_selection_select_iter(selection, &iter);
1486
1487 path = gtk_tree_model_get_path(model, &iter);
1488 gtk_tree_view_set_cursor(list_view, path, NULL, FALSE);
1489 gtk_tree_path_free(path);
1490
1491 return TRUE;
1492 }
1493
1494 static GtkUIManager *gui_manager = NULL;
1495
1496 GtkUIManager *gtkut_create_ui_manager(void)
1497 {
1498 cm_return_val_if_fail(gui_manager == NULL, gui_manager);
1499 return (gui_manager = gtk_ui_manager_new());
1500 }
1501
1502 GtkUIManager *gtkut_ui_manager(void)
1503 {
1504 return gui_manager;
1505 }
1506
1507 typedef struct _ClawsIOClosure ClawsIOClosure;
1508
1509 struct _ClawsIOClosure
1510 {
1511 ClawsIOFunc function;
1512 GIOCondition condition;
1513 GDestroyNotify notify;
1514 gpointer data;
1515 };
1516
1517 static gboolean
1518 claws_io_invoke (GIOChannel *source,
1519 GIOCondition condition,
1520 gpointer data)
1521 {
1522 ClawsIOClosure *closure = data;
1523 int fd;
1524 #ifndef G_OS_WIN32
1525 fd = g_io_channel_unix_get_fd (source);
1526 #else
1527 fd = g_io_channel_win32_get_fd (source);
1528 #endif
1529 if (closure->condition & condition)
1530 closure->function (closure->data, fd, condition);
1531
1532 return TRUE;
1533 }
1534
1535 static void
1536 claws_io_destroy (gpointer data)
1537 {
1538 ClawsIOClosure *closure = data;
1539
1540 if (closure->notify)
1541 closure->notify (closure->data);
1542
1543 g_free (closure);
1544 }
1545
1546 gint
1547 claws_input_add (gint source,
1548 GIOCondition condition,
1549 ClawsIOFunc function,
1550 gpointer data,
1551 gboolean is_sock)
1552 {
1553 guint result;
1554 ClawsIOClosure *closure = g_new (ClawsIOClosure, 1);
1555 GIOChannel *channel;
1556
1557 closure->function = function;
1558 closure->condition = condition;
1559 closure->notify = NULL;
1560 closure->data = data;
1561
1562 #ifndef G_OS_WIN32
1563 channel = g_io_channel_unix_new (source);
1564 #else
1565 if (is_sock)
1566 channel = g_io_channel_win32_new_socket(source);
1567 else
1568 channel = g_io_channel_win32_new_fd(source);
1569 #endif
1570 result = g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, condition,
1571 claws_io_invoke,
1572 closure, claws_io_destroy);
1573 g_io_channel_unref (channel);
1574
1575 return result;
1576 }
1577
1578 /**
1579 * Load a pixbuf fitting inside the specified size. EXIF orientation is
1580 * respected if available.
1581 *
1582 * @param[in] filename the file to load
1583 * @param[in] box_width the max width (-1 for no resize)
1584 * @param[in] box_height the max height (-1 for no resize)
1585 * @param[out] error the possible load error
1586 *
1587 * @return a GdkPixbuf
1588 */
1589 GdkPixbuf *claws_load_pixbuf_fitting(GdkPixbuf *src_pixbuf, gboolean inline_img,
1590 gboolean fit_img_height, int box_width, int box_height)
1591 {
1592 gint w, h, orientation, angle;
1593 gint avail_width, avail_height;
1594 gboolean flip_horiz, flip_vert;
1595 const gchar *orient_str;
1596 GdkPixbuf *pixbuf, *t_pixbuf;
1597
1598 pixbuf = src_pixbuf;
1599
1600 if (pixbuf == NULL)
1601 return NULL;
1602
1603 angle = 0;
1604 flip_horiz = flip_vert = FALSE;
1605
1606 /* EXIF orientation */
1607 orient_str = gdk_pixbuf_get_option(pixbuf, "orientation");
1608 if (orient_str != NULL && *orient_str != '\0') {
1609 orientation = atoi(orient_str);
1610 switch(orientation) {
1611 /* See EXIF standard for different values */
1612 case 1: break;
1613 case 2: flip_horiz = 1;
1614 break;
1615 case 3: angle = 180;
1616 break;
1617 case 4: flip_vert = 1;
1618 break;
1619 case 5: angle = 90;
1620 flip_horiz = 1;
1621 break;
1622 case 6: angle = 270;
1623 break;
1624 case 7: angle = 90;
1625 flip_vert = 1;
1626 break;
1627 case 8: angle = 90;
1628 break;
1629 }
1630 }
1631
1632
1633 /* Rotate if needed */
1634 if (angle != 0) {
1635 t_pixbuf = gdk_pixbuf_rotate_simple(pixbuf, angle);
1636 g_object_unref(pixbuf);
1637 pixbuf = t_pixbuf;
1638 }
1639
1640 /* Flip horizontally if needed */
1641 if (flip_horiz) {
1642 t_pixbuf = gdk_pixbuf_flip(pixbuf, TRUE);
1643 g_object_unref(pixbuf);
1644 pixbuf = t_pixbuf;
1645 }
1646
1647 /* Flip vertically if needed */
1648 if (flip_vert) {
1649 t_pixbuf = gdk_pixbuf_flip(pixbuf, FALSE);
1650 g_object_unref(pixbuf);
1651 pixbuf = t_pixbuf;
1652 }
1653
1654 w = gdk_pixbuf_get_width(pixbuf);
1655 h = gdk_pixbuf_get_height(pixbuf);
1656
1657 avail_width = box_width-32;
1658 avail_height = box_height;
1659
1660 if (box_width != -1 && box_height != -1 && avail_width - 100 > 0) {
1661 if (inline_img || fit_img_height) {
1662 if (w > avail_width) {
1663 h = (avail_width * h) / w;
1664 w = avail_width;
1665 }
1666 if (h > avail_height) {
1667 w = (avail_height * w) / h;
1668 h = avail_height;
1669 }
1670 } else {
1671 if (w > avail_width || h > avail_height) {
1672 h = (avail_width * h) / w;
1673 w = avail_width;
1674 }
1675 }
1676 t_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
1677 w, h, GDK_INTERP_BILINEAR);
1678 g_object_unref(pixbuf);
1679 pixbuf = t_pixbuf;
1680 }
1681
1682 return pixbuf;
1683 }
1684
1685 #if defined USE_GNUTLS
1686 static void auto_configure_done(const gchar *hostname, gint port, gboolean ssl, AutoConfigureData *data)
1687 {
1688 gboolean smtp = strcmp(data->tls_service, "submission") == 0 ? TRUE : FALSE;
1689
1690 if (hostname != NULL) {
1691 if (data->hostname_entry)
1692 gtk_entry_set_text(data->hostname_entry, hostname);
1693 if (data->set_port)
1694 gtk_toggle_button_set_active(data->set_port,
1695 (ssl && port != data->default_ssl_port) || (!ssl && port != data->default_port));
1696 if (data->port)
1697 gtk_spin_button_set_value(data->port, port);
1698 else if (data->hostname_entry) {
1699 if ((ssl && port != data->default_ssl_port) || (!ssl && port != data->default_port)) {
1700 gchar *tmp = g_strdup_printf("%s:%d", hostname, port);
1701 gtk_entry_set_text(data->hostname_entry, tmp);
1702 g_free(tmp);
1703 } else
1704 gtk_entry_set_text(data->hostname_entry, hostname);
1705 }
1706
1707 if (ssl && data->ssl_checkbtn) {
1708 gtk_toggle_button_set_active(data->ssl_checkbtn, TRUE);
1709 gtk_toggle_button_set_active(data->tls_checkbtn, FALSE);
1710 } else if (data->tls_checkbtn) {
1711 if (!GTK_IS_RADIO_BUTTON(data->ssl_checkbtn)) {
1712 /* Wizard where TLS is [x]SSL + [x]TLS */
1713 gtk_toggle_button_set_active(data->ssl_checkbtn, TRUE);
1714 }
1715
1716 /* Even though technically this is against the RFCs,
1717 * if a "_submission._tcp" SRV record uses port 465,
1718 * it is safe to assume TLS-only service, instead of
1719 * plaintext + STARTTLS one. */
1720 if (smtp && port == 465)
1721 gtk_toggle_button_set_active(data->ssl_checkbtn, TRUE);
1722 else
1723 gtk_toggle_button_set_active(data->tls_checkbtn, TRUE);
1724 }
1725
1726 /* Check authentication by default. This is probably required if
1727 * auto-configuration worked.
1728 */
1729 if (data->auth_checkbtn)
1730 gtk_toggle_button_set_active(data->auth_checkbtn, TRUE);
1731
1732 /* Set user ID to full email address, which is used by the
1733 * majority of providers where auto-configuration works.
1734 */
1735 if (data->uid_entry)
1736 gtk_entry_set_text(data->uid_entry, data->address);
1737
1738 gtk_label_set_text(data->info_label, _("Done."));
1739 } else {
1740 gchar *msg;
1741 switch (data->resolver_error) {
1742 case G_RESOLVER_ERROR_NOT_FOUND:
1743 msg = g_strdup(_("Failed: no service record found."));
1744 break;
1745 case G_RESOLVER_ERROR_TEMPORARY_FAILURE:
1746 msg = g_strdup(_("Failed: network error."));
1747 break;
1748 default:
1749 msg = g_strdup_printf(_("Failed: unknown error (%d)."), data->resolver_error);
1750 }
1751 gtk_label_set_text(data->info_label, msg);
1752 g_free(msg);
1753 }
1754 gtk_widget_show(GTK_WIDGET(data->configure_button));
1755 gtk_widget_hide(GTK_WIDGET(data->cancel_button));
1756 g_free(data->address);
1757 g_free(data);
1758 }
1759
1760 static void resolve_done(GObject *source, GAsyncResult *result, gpointer user_data)
1761 {
1762 AutoConfigureData *data = (AutoConfigureData *)user_data;
1763 GResolver *resolver = (GResolver *)source;
1764 GError *error = NULL;
1765 gchar *hostname = NULL;
1766 guint16 port;
1767 GList *answers, *cur;
1768 gboolean found = FALSE;
1769 gboolean abort = FALSE;
1770
1771 answers = g_resolver_lookup_service_finish(resolver, result, &error);
1772
1773 if (answers) {
1774 for (cur = g_srv_target_list_sort(answers); cur; cur = cur->next) {
1775 GSrvTarget *target = (GSrvTarget *)cur->data;
1776 const gchar *h = g_srv_target_get_hostname(target);
1777 port = g_srv_target_get_port(target);
1778 if (h && strcmp(h,"") && port > 0) {
1779 hostname = g_strdup(h);
1780 found = TRUE;
1781 break;
1782 }
1783 }
1784 g_resolver_free_targets(answers);
1785 } else if (error) {
1786 if (error->code == G_IO_ERROR_CANCELLED)
1787 abort = TRUE;
1788 else
1789 data->resolver_error = error->code;
1790 debug_print("error %s\n", error->message);
1791 g_error_free(error);
1792 }
1793
1794 if (found) {
1795 auto_configure_done(hostname, port, data->ssl_service != NULL, data);
1796 } else if (data->ssl_service && !abort) {
1797 /* Fallback to TLS */
1798 data->ssl_service = NULL;
1799 auto_configure_service(data);
1800 } else {
1801 auto_configure_done(NULL, 0, FALSE, data);
1802 }
1803 g_free(hostname);
1804 g_object_unref(resolver);
1805 }
1806
1807 void auto_configure_service(AutoConfigureData *data)
1808 {
1809 GResolver *resolver;
1810 const gchar *cur_service = data->ssl_service != NULL ? data->ssl_service : data->tls_service;
1811
1812 cm_return_if_fail(cur_service != NULL);
1813 cm_return_if_fail(data->address != NULL);
1814
1815 resolver = g_resolver_get_default();
1816 if (resolver != NULL) {
1817 const gchar *domain = strchr(data->address, '@') + 1;
1818
1819 gtk_label_set_text(data->info_label, _("Configuring..."));
1820 gtk_widget_hide(GTK_WIDGET(data->configure_button));
1821 gtk_widget_show(GTK_WIDGET(data->cancel_button));
1822 g_resolver_lookup_service_async(resolver, cur_service, "tcp", domain,
1823 data->cancel, resolve_done, data);
1824 }
1825 }
1826
1827 gboolean auto_configure_service_sync(const gchar *service, const gchar *domain, gchar **srvhost, guint16 *srvport)
1828 {
1829 GResolver *resolver;
1830 GList *answers, *cur;
1831 GError *error = NULL;
1832 gboolean result = FALSE;
1833
1834 cm_return_val_if_fail(service != NULL, FALSE);
1835 cm_return_val_if_fail(domain != NULL, FALSE);
1836
1837 resolver = g_resolver_get_default();
1838 if (resolver == NULL)
1839 return FALSE;
1840
1841 answers = g_resolver_lookup_service(resolver, service, "tcp", domain, NULL, &error);
1842
1843 *srvhost = NULL;
1844 *srvport = 0;
1845
1846 if (answers) {
1847 for (cur = g_srv_target_list_sort(answers); cur; cur = cur->next) {
1848 GSrvTarget *target = (GSrvTarget *)cur->data;
1849 const gchar *hostname = g_srv_target_get_hostname(target);
1850 guint16 port = g_srv_target_get_port(target);
1851 if (hostname && strcmp(hostname,"") && port > 0) {
1852 result = TRUE;
1853 *srvhost = g_strdup(hostname);
1854 *srvport = port;
1855 break;
1856 }
1857 }
1858 g_resolver_free_targets(answers);
1859 } else if (error) {
1860 g_error_free(error);
1861 }
1862
1863 g_object_unref(resolver);
1864 return result;
1865 }
1866 #endif
1867
1868 gboolean gtkut_pointer_is_grabbed(GtkWidget *widget)
1869 {
1870 GdkDisplay *display;
1871 GdkDevice *pointerdev;
1872
1873 cm_return_val_if_fail(widget != NULL, FALSE);
1874
1875 display = gtk_widget_get_display(widget);
1876 pointerdev = gdk_seat_get_pointer(gdk_display_get_default_seat(display));
1877
1878 return gdk_display_device_is_grabbed(display, pointerdev);
1879 }
1880
1881 gpointer gtkut_tree_view_get_selected_pointer(GtkTreeView *view,
1882 gint column, GtkTreeModel **_model, GtkTreeSelection **_selection,
1883 GtkTreeIter *_iter)
1884 {
1885 GtkTreeIter iter;
1886 GtkTreeModel *model;
1887 GtkTreeSelection *sel;
1888 gpointer ptr;
1889 GType type;
1890
1891 cm_return_val_if_fail(view != NULL, NULL);
1892 cm_return_val_if_fail(column >= 0, NULL);
1893
1894 model = gtk_tree_view_get_model(view);
1895 if (_model != NULL)
1896 *_model = model;
1897
1898 sel = gtk_tree_view_get_selection(view);
1899 if (_selection != NULL)
1900 *_selection = sel;
1901
1902 if (!gtk_tree_selection_get_selected(sel, NULL, &iter))
1903 return NULL; /* No row selected */
1904
1905 if (_iter != NULL)
1906 *_iter = iter;
1907
1908 if (gtk_tree_selection_count_selected_rows(sel) > 1)
1909 return NULL; /* Can't work with multiselect */
1910
1911 cm_return_val_if_fail(
1912 gtk_tree_model_get_n_columns(model) > column,
1913 NULL);
1914
1915 type = gtk_tree_model_get_column_type(model, column);
1916 cm_return_val_if_fail(
1917 type == G_TYPE_POINTER || type == G_TYPE_STRING,
1918 NULL);
1919
1920 gtk_tree_model_get(model, &iter, column, &ptr, -1);
1921
1922 return ptr;
1923 }
1924
1925 static GList *get_predefined_times(void)
1926 {
1927 int h,m;
1928 GList *times = NULL;
1929 for (h = 0; h < 24; h++) {
1930 for (m = 0; m < 60; m += 15) {
1931 gchar *tmp = g_strdup_printf("%02d:%02d", h, m);
1932 times = g_list_append(times, tmp);
1933 }
1934 }
1935 return times;
1936 }
1937
1938 static int get_list_item_num(int h, int m)
1939 {
1940 if (m % 15 != 0)
1941 return -1;
1942
1943 return (h*4 + m/15);
1944 }
1945
1946 GtkWidget *gtkut_time_select_combo_new()
1947 {
1948 GtkWidget *combo = gtk_combo_box_text_new_with_entry();
1949 GList *times = get_predefined_times();
1950
1951 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), -1);
1952 combobox_set_popdown_strings(GTK_COMBO_BOX_TEXT(combo), times);
1953
1954 list_free_strings_full(times);
1955
1956 return combo;
1957 }
1958
1959
1960 void gtkut_time_select_select_by_time(GtkComboBox *combo, int hour, int minute)
1961 {
1962 gchar *time_text = g_strdup_printf("%02d:%02d", hour, minute);
1963 gint num = get_list_item_num(hour, minute);
1964
1965 if (num > -1)
1966 combobox_select_by_text(combo, time_text);
1967 else
1968 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo))), time_text);
1969
1970 g_free(time_text);
1971 }
1972
1973 static void get_time_from_combo(GtkComboBox *combo, int *h, int *m)
1974 {
1975 gchar *tmp;
1976 gchar **parts;
1977
1978 if (!h || !m)
1979 return;
1980
1981 tmp = gtk_editable_get_chars(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(combo))), 0, -1);
1982 parts = g_strsplit(tmp, ":", 2);
1983 if (parts[0] && parts[1] && *parts[0] && *parts[1]) {
1984 *h = atoi(parts[0]);
1985 *m = atoi(parts[1]);
1986 }
1987 g_strfreev(parts);
1988 g_free(tmp);
1989 }
1990
1991 gboolean gtkut_time_select_get_time(GtkComboBox *combo, int *hour, int *minute)
1992 {
1993 const gchar *value = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo))));
1994
1995 if (value == NULL || strlen(value) != 5)
1996 return FALSE;
1997
1998 if (hour == NULL || minute == NULL)
1999 return FALSE;
2000
2001 get_time_from_combo(combo, hour, minute);
2002
2003 if (*hour < 0 || *hour > 23)
2004 return FALSE;
2005 if (*minute < 0 || *minute > 59)
2006 return FALSE;
2007
2008 return TRUE;
2009 }
2010
2011 void gtk_calendar_select_today(GtkCalendar *calendar)
2012 {
2013 time_t t = time (NULL);
2014 struct tm buft;
2015 struct tm *lt = localtime_r (&t, &buft);
2016
2017 mktime(lt);
2018 gtk_calendar_select_day(calendar, lt->tm_mday);
2019 gtk_calendar_select_month(calendar, lt->tm_mon, lt->tm_year + 1900);
2020 }
2021
2022
2023 #define RGBA_ELEMENT_TO_BYTE(x) (int)((gdouble)x * 255)
2024 gchar *gtkut_gdk_rgba_to_string(GdkRGBA *rgba)
2025 {
2026 gchar *str = g_strdup_printf("#%02x%02x%02x",
2027 RGBA_ELEMENT_TO_BYTE(rgba->red),
2028 RGBA_ELEMENT_TO_BYTE(rgba->green),
2029 RGBA_ELEMENT_TO_BYTE(rgba->blue));
2030
2031 return str;
2032 }
2033 #undef RGBA_ELEMENT_TO_BYTE