Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkwebviewtoolbar.c

pidgin/gtkwebviewtoolbar.c

branch
cpw.qulogic.gtk3-required
changeset 33149
e1b50abc07bb
parent 33132
24afd2b22579
parent 33029
5005e63a35d4
child 33196
e3d6afee499c
equal deleted inserted replaced
33148:34d89dcecc9b 33149:e1b50abc07bb
41 #include "gtkthemes.h" 41 #include "gtkthemes.h"
42 #include "gtkutils.h" 42 #include "gtkutils.h"
43 43
44 #include <gdk/gdkkeysyms.h> 44 #include <gdk/gdkkeysyms.h>
45 45
46 #if !GTK_CHECK_VERSION(2,18,0)
47 #define gtk_widget_get_visible(x) GTK_WIDGET_VISIBLE((x))
48 #define gtk_widget_is_sensitive(x) GTK_WIDGET_IS_SENSITIVE((x))
49 #if !GTK_CHECK_VERSION(2,12,0)
50 #define gtk_widget_set_tooltip_text(w, t) \
51 gtk_tooltips_set_tip(priv->tooltips, (w), (t), NULL)
52 #endif
53 #endif
54
55 #define GTK_WEBVIEWTOOLBAR_GET_PRIVATE(obj) \ 46 #define GTK_WEBVIEWTOOLBAR_GET_PRIVATE(obj) \
56 (G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarPriv)) 47 (G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarPriv))
57 48
58 /****************************************************************************** 49 /******************************************************************************
59 * Structs 50 * Structs
63 PurpleConversation *active_conv; 54 PurpleConversation *active_conv;
64 55
65 GtkWidget *wide_view; 56 GtkWidget *wide_view;
66 GtkWidget *lean_view; 57 GtkWidget *lean_view;
67 58
68 #if !GTK_CHECK_VERSION(2,12,0)
69 GtkTooltips *tooltips;
70 #endif
71
72 GtkWidget *font_label; 59 GtkWidget *font_label;
73 GtkWidget *font_menu; 60 GtkWidget *font_menu;
74 61
75 GtkWidget *bold; 62 GtkAction *bold;
76 GtkWidget *italic; 63 GtkAction *italic;
77 GtkWidget *underline; 64 GtkAction *underline;
78 GtkWidget *strike; 65 GtkAction *strike;
79 66
80 GtkWidget *larger_size; 67 GtkAction *larger_size;
81 GtkWidget *normal_size; 68 #if 0
82 GtkWidget *smaller_size; 69 GtkAction *normal_size;
83 70 #endif
84 GtkWidget *font; 71 GtkAction *smaller_size;
85 GtkWidget *fgcolor; 72
86 GtkWidget *bgcolor; 73 GtkAction *font;
87 74 GtkAction *fgcolor;
88 GtkWidget *clear; 75 GtkAction *bgcolor;
76
77 GtkAction *clear;
89 78
90 GtkWidget *insert_menu; 79 GtkWidget *insert_menu;
91 GtkWidget *image; 80 GtkAction *image;
92 GtkWidget *link; 81 GtkAction *link;
93 GtkWidget *insert_hr; 82 GtkAction *hr;
94 83
95 GtkWidget *smiley; 84 GtkAction *smiley;
96 GtkWidget *attention; 85 GtkAction *attention;
97 GtkWidget *call;
98 86
99 GtkWidget *font_dialog; 87 GtkWidget *font_dialog;
100 GtkWidget *fgcolor_dialog; 88 GtkWidget *fgcolor_dialog;
101 GtkWidget *bgcolor_dialog; 89 GtkWidget *bgcolor_dialog;
102 GtkWidget *link_dialog; 90 GtkWidget *link_dialog;
115 /****************************************************************************** 103 /******************************************************************************
116 * Prototypes 104 * Prototypes
117 *****************************************************************************/ 105 *****************************************************************************/
118 106
119 static void 107 static void
120 toggle_button_set_active_block(GtkToggleButton *button, gboolean is_active, 108 toggle_action_set_active_block(GtkToggleAction *action, gboolean is_active,
121 GtkWebViewToolbar *toolbar); 109 GtkWebViewToolbar *toolbar);
122
123 static gboolean
124 gtk_webviewtoolbar_popup_menu(GtkWidget *widget, GdkEventButton *event,
125 GtkWebViewToolbar *toolbar);
126 110
127 /****************************************************************************** 111 /******************************************************************************
128 * Helpers 112 * Helpers
129 *****************************************************************************/ 113 *****************************************************************************/
130 114
131 static void 115 static void
132 do_bold(GtkWidget *bold, GtkWebViewToolbar *toolbar) 116 do_bold(GtkAction *bold, GtkWebViewToolbar *toolbar)
133 { 117 {
134 g_return_if_fail(toolbar != NULL); 118 g_return_if_fail(toolbar != NULL);
135 gtk_webview_toggle_bold(GTK_WEBVIEW(toolbar->webview)); 119 gtk_webview_toggle_bold(GTK_WEBVIEW(toolbar->webview));
136 gtk_widget_grab_focus(toolbar->webview); 120 gtk_widget_grab_focus(toolbar->webview);
137 } 121 }
138 122
139 static void 123 static void
140 do_italic(GtkWidget *italic, GtkWebViewToolbar *toolbar) 124 do_italic(GtkAction *italic, GtkWebViewToolbar *toolbar)
141 { 125 {
142 g_return_if_fail(toolbar != NULL); 126 g_return_if_fail(toolbar != NULL);
143 gtk_webview_toggle_italic(GTK_WEBVIEW(toolbar->webview)); 127 gtk_webview_toggle_italic(GTK_WEBVIEW(toolbar->webview));
144 gtk_widget_grab_focus(toolbar->webview); 128 gtk_widget_grab_focus(toolbar->webview);
145 } 129 }
146 130
147 static void 131 static void
148 do_underline(GtkWidget *underline, GtkWebViewToolbar *toolbar) 132 do_underline(GtkAction *underline, GtkWebViewToolbar *toolbar)
149 { 133 {
150 g_return_if_fail(toolbar != NULL); 134 g_return_if_fail(toolbar != NULL);
151 gtk_webview_toggle_underline(GTK_WEBVIEW(toolbar->webview)); 135 gtk_webview_toggle_underline(GTK_WEBVIEW(toolbar->webview));
152 gtk_widget_grab_focus(toolbar->webview); 136 gtk_widget_grab_focus(toolbar->webview);
153 } 137 }
154 138
155 static void 139 static void
156 do_strikethrough(GtkWidget *strikethrough, GtkWebViewToolbar *toolbar) 140 do_strikethrough(GtkAction *strikethrough, GtkWebViewToolbar *toolbar)
157 { 141 {
158 g_return_if_fail(toolbar != NULL); 142 g_return_if_fail(toolbar != NULL);
159 gtk_webview_toggle_strike(GTK_WEBVIEW(toolbar->webview)); 143 gtk_webview_toggle_strike(GTK_WEBVIEW(toolbar->webview));
160 gtk_widget_grab_focus(toolbar->webview); 144 gtk_widget_grab_focus(toolbar->webview);
161 } 145 }
162 146
163 static void 147 static void
164 do_small(GtkWidget *smalltb, GtkWebViewToolbar *toolbar) 148 do_small(GtkAction *small, GtkWebViewToolbar *toolbar)
165 { 149 {
166 g_return_if_fail(toolbar != NULL); 150 g_return_if_fail(toolbar != NULL);
167 /* Only shrink the font on activation, not deactivation as well */ 151 gtk_webview_font_shrink(GTK_WEBVIEW(toolbar->webview));
168 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(smalltb)))
169 gtk_webview_font_shrink(GTK_WEBVIEW(toolbar->webview));
170 gtk_widget_grab_focus(toolbar->webview); 152 gtk_widget_grab_focus(toolbar->webview);
171 } 153 }
172 154
173 static void 155 static void
174 do_big(GtkWidget *large, GtkWebViewToolbar *toolbar) 156 do_big(GtkAction *large, GtkWebViewToolbar *toolbar)
175 { 157 {
176 g_return_if_fail(toolbar); 158 g_return_if_fail(toolbar);
177 /* Only grow the font on activation, not deactivation as well */ 159 gtk_webview_font_grow(GTK_WEBVIEW(toolbar->webview));
178 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(large)))
179 gtk_webview_font_grow(GTK_WEBVIEW(toolbar->webview));
180 gtk_widget_grab_focus(toolbar->webview); 160 gtk_widget_grab_focus(toolbar->webview);
181 } 161 }
182 162
183 static gboolean 163 static gboolean
184 destroy_toolbar_font(GtkWidget *widget, GdkEvent *event, 164 destroy_toolbar_font(GtkWidget *widget, GdkEvent *event,
248 228
249 cancel_toolbar_font(NULL, toolbar); 229 cancel_toolbar_font(NULL, toolbar);
250 } 230 }
251 231
252 static void 232 static void
253 toggle_font(GtkWidget *font, GtkWebViewToolbar *toolbar) 233 toggle_font(GtkAction *font, GtkWebViewToolbar *toolbar)
254 { 234 {
255 GtkWebViewToolbarPriv *priv; 235 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
256 g_return_if_fail(toolbar); 236
257 priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 237 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(font))) {
258
259 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(font))) {
260 char *fontname = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview)); 238 char *fontname = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview));
261 239
262 if (!priv->font_dialog) { 240 if (!priv->font_dialog) {
263 priv->font_dialog = gtk_font_selection_dialog_new(_("Select Font")); 241 priv->font_dialog = gtk_font_selection_dialog_new(_("Select Font"));
264 242
286 264
287 gtk_window_present(GTK_WINDOW(priv->font_dialog)); 265 gtk_window_present(GTK_WINDOW(priv->font_dialog));
288 266
289 g_free(fontname); 267 g_free(fontname);
290 } else { 268 } else {
291 cancel_toolbar_font(font, toolbar); 269 cancel_toolbar_font(GTK_WIDGET(toolbar), toolbar);
292 } 270 }
293 271
294 gtk_widget_grab_focus(toolbar->webview); 272 gtk_widget_grab_focus(toolbar->webview);
295 } 273 }
296 274
341 319
342 cancel_toolbar_fgcolor(NULL, toolbar); 320 cancel_toolbar_fgcolor(NULL, toolbar);
343 } 321 }
344 322
345 static void 323 static void
346 toggle_fg_color(GtkWidget *color, GtkWebViewToolbar *toolbar) 324 toggle_fg_color(GtkAction *color, GtkWebViewToolbar *toolbar)
347 { 325 {
348 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 326 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
349 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) { 327
328 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(color))) {
350 GtkWidget *colorsel; 329 GtkWidget *colorsel;
351 GdkColor fgcolor; 330 GdkColor fgcolor;
352 char *color = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview)); 331 char *color = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview));
353 332
354 if (!priv->fgcolor_dialog) { 333 if (!priv->fgcolor_dialog) {
375 354
376 gtk_window_present(GTK_WINDOW(priv->fgcolor_dialog)); 355 gtk_window_present(GTK_WINDOW(priv->fgcolor_dialog));
377 356
378 g_free(color); 357 g_free(color);
379 } else { 358 } else {
380 cancel_toolbar_fgcolor(color, toolbar); 359 cancel_toolbar_fgcolor(GTK_WIDGET(toolbar), toolbar);
381 } 360 }
382 361
383 gtk_widget_grab_focus(toolbar->webview); 362 gtk_widget_grab_focus(toolbar->webview);
384 } 363 }
385 364
430 409
431 cancel_toolbar_bgcolor(NULL, toolbar); 410 cancel_toolbar_bgcolor(NULL, toolbar);
432 } 411 }
433 412
434 static void 413 static void
435 toggle_bg_color(GtkWidget *color, GtkWebViewToolbar *toolbar) 414 toggle_bg_color(GtkAction *color, GtkWebViewToolbar *toolbar)
436 { 415 {
437 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 416 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
438 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) { 417
418 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(color))) {
439 GtkWidget *colorsel; 419 GtkWidget *colorsel;
440 GdkColor bgcolor; 420 GdkColor bgcolor;
441 char *color = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview)); 421 char *color = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview));
442 422
443 if (!priv->bgcolor_dialog) { 423 if (!priv->bgcolor_dialog) {
466 446
467 gtk_window_present(GTK_WINDOW(priv->bgcolor_dialog)); 447 gtk_window_present(GTK_WINDOW(priv->bgcolor_dialog));
468 448
469 g_free(color); 449 g_free(color);
470 } else { 450 } else {
471 cancel_toolbar_bgcolor(color, toolbar); 451 cancel_toolbar_bgcolor(GTK_WIDGET(toolbar), toolbar);
472 } 452 }
473 453
474 gtk_widget_grab_focus(toolbar->webview); 454 gtk_widget_grab_focus(toolbar->webview);
475 } 455 }
476 456
477 static void 457 static void
478 clear_formatting_cb(GtkWidget *clear, GtkWebViewToolbar *toolbar) 458 clear_formatting_cb(GtkAction *clear, GtkWebViewToolbar *toolbar)
479 { 459 {
480 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
481 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->clear), FALSE, toolbar);
482 gtk_webview_clear_formatting(GTK_WEBVIEW(toolbar->webview)); 460 gtk_webview_clear_formatting(GTK_WEBVIEW(toolbar->webview));
461 gtk_widget_grab_focus(toolbar->webview);
483 } 462 }
484 463
485 static void 464 static void
486 cancel_link_cb(GtkWebViewToolbar *toolbar, PurpleRequestFields *fields) 465 cancel_link_cb(GtkWebViewToolbar *toolbar, PurpleRequestFields *fields)
487 { 466 {
488 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 467 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
489 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->link), FALSE); 468 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(priv->link), FALSE);
490 469
491 priv->link_dialog = NULL; 470 priv->link_dialog = NULL;
492 } 471 }
493 472
494 static void 473 static void
512 if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC) 491 if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC)
513 description = purple_request_fields_get_string(fields, "description"); 492 description = purple_request_fields_get_string(fields, "description");
514 else 493 else
515 description = NULL; 494 description = NULL;
516 495
517 if (description == NULL) 496 gtk_webview_insert_link(GTK_WEBVIEW(toolbar->webview), url, description);
518 description = url; 497
519 498 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(priv->link), FALSE);
520 #if 0
521 gtk_webview_insert_link(GTK_WEBVIEW(toolbar->webview),
522 gtk_text_buffer_get_insert(GTK_WEBVIEW(toolbar->webview)->text_buffer),
523 url, description);
524 #endif
525
526 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->link), FALSE);
527 499
528 priv->link_dialog = NULL; 500 priv->link_dialog = NULL;
529 } 501 }
530 502
531 static void 503 static void
532 insert_link_cb(GtkWidget *w, GtkWebViewToolbar *toolbar) 504 insert_link_cb(GtkAction *action, GtkWebViewToolbar *toolbar)
533 { 505 {
534 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 506 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
535 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->link))) { 507
508 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(priv->link))) {
536 PurpleRequestFields *fields; 509 PurpleRequestFields *fields;
537 PurpleRequestFieldGroup *group; 510 PurpleRequestFieldGroup *group;
538 PurpleRequestField *field; 511 PurpleRequestField *field;
539 #if 0
540 GtkTextIter start, end;
541 #endif
542 char *msg; 512 char *msg;
543 char *desc = NULL; 513 char *desc = NULL;
544 514
545 fields = purple_request_fields_new(); 515 fields = purple_request_fields_new();
546 516
550 field = purple_request_field_string_new("url", _("_URL"), NULL, FALSE); 520 field = purple_request_field_string_new("url", _("_URL"), NULL, FALSE);
551 purple_request_field_set_required(field, TRUE); 521 purple_request_field_set_required(field, TRUE);
552 purple_request_field_group_add_field(group, field); 522 purple_request_field_group_add_field(group, field);
553 523
554 if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC) { 524 if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC) {
555 #if 0 525 desc = gtk_webview_get_selected_text(GTK_WEBVIEW(toolbar->webview));
556 if (gtk_text_buffer_get_selection_bounds(GTK_WEBVIEW(toolbar->webview)->text_buffer, &start, &end)) {
557 desc = gtk_webview_get_text(GTK_WEBVIEW(toolbar->webview), &start, &end);
558 }
559 #endif
560 field = purple_request_field_string_new("description", _("_Description"), 526 field = purple_request_field_string_new("description", _("_Description"),
561 desc, FALSE); 527 desc, FALSE);
562 purple_request_field_group_add_field(group, field); 528 purple_request_field_group_add_field(group, field);
563 msg = g_strdup(_("Please enter the URL and description of the " 529 msg = g_strdup(_("Please enter the URL and description of the "
564 "link that you want to insert. The description " 530 "link that you want to insert. The description "
585 551
586 gtk_widget_grab_focus(toolbar->webview); 552 gtk_widget_grab_focus(toolbar->webview);
587 } 553 }
588 554
589 static void 555 static void
590 insert_hr_cb(GtkWidget *widget, GtkWebViewToolbar *toolbar) 556 insert_hr_cb(GtkAction *action, GtkWebViewToolbar *toolbar)
591 { 557 {
592 #if 0 558 gtk_webview_insert_hr(GTK_WEBVIEW(toolbar->webview));
593 GtkTextIter iter;
594 GtkTextMark *ins;
595 GtkIMHtmlScalable *hr;
596
597 ins = gtk_text_buffer_get_insert(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)));
598 gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)), &iter, ins);
599 hr = gtk_webview_hr_new();
600 gtk_webview_hr_add_to(hr, GTK_WEBVIEW(toolbar->webview), &iter);
601 #endif
602 } 559 }
603 560
604 static void 561 static void
605 do_insert_image_cb(GtkWidget *widget, int response, GtkWebViewToolbar *toolbar) 562 do_insert_image_cb(GtkWidget *widget, int response, GtkWebViewToolbar *toolbar)
606 { 563 {
607 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 564 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
608 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE); 565 gchar *filename = NULL, *name, *buf;
609 #if 0
610 gchar *filename, *name, *buf;
611 char *filedata; 566 char *filedata;
612 size_t size; 567 size_t size;
613 GError *error = NULL; 568 GError *error = NULL;
614 int id; 569 int id;
615 GtkTextIter iter; 570
616 GtkTextMark *ins; 571 if (response == GTK_RESPONSE_ACCEPT)
617 572 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));
618 if (response != GTK_RESPONSE_ACCEPT) 573
619 { 574 /* The following triggers a callback that closes the widget */
620 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE); 575 gtk_action_activate(priv->image);
576
577 if (filename == NULL)
621 return; 578 return;
622 }
623
624 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));
625
626 if (filename == NULL) {
627 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
628 return;
629 }
630
631 /* The following triggers a callback that closes the widget */
632 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
633 579
634 if (!g_file_get_contents(filename, &filedata, &size, &error)) { 580 if (!g_file_get_contents(filename, &filedata, &size, &error)) {
635 purple_notify_error(NULL, NULL, error->message, NULL); 581 purple_notify_error(NULL, NULL, error->message, NULL);
636 582
637 g_error_free(error); 583 g_error_free(error);
654 return; 600 return;
655 } 601 }
656 602
657 g_free(filename); 603 g_free(filename);
658 604
659 ins = gtk_text_buffer_get_insert(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview))); 605 gtk_webview_insert_image(GTK_WEBVIEW(toolbar->webview), id);
660 gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)),
661 &iter, ins);
662 gtk_webview_insert_image_at_iter(GTK_WEBVIEW(toolbar->webview), id, &iter);
663 purple_imgstore_unref_by_id(id); 606 purple_imgstore_unref_by_id(id);
664 #endif 607 }
665 } 608
666 609 static void
667 static void 610 insert_image_cb(GtkAction *action, GtkWebViewToolbar *toolbar)
668 insert_image_cb(GtkWidget *save, GtkWebViewToolbar *toolbar)
669 { 611 {
670 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 612 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
671 GtkWidget *window; 613 GtkWidget *window;
672 614
673 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->image))) { 615 if (!priv->image_dialog) {
674 window = gtk_file_chooser_dialog_new(_("Insert Image"), 616 window = gtk_file_chooser_dialog_new(_("Insert Image"), NULL,
675 NULL, 617 GTK_FILE_CHOOSER_ACTION_OPEN,
676 GTK_FILE_CHOOSER_ACTION_OPEN, 618 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
677 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 619 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
678 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 620 NULL);
679 NULL);
680 gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT); 621 gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT);
681 g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(window)), 622 g_signal_connect(G_OBJECT(window), "response",
682 "response", G_CALLBACK(do_insert_image_cb), toolbar); 623 G_CALLBACK(do_insert_image_cb), toolbar);
683 624
684 gtk_widget_show(window); 625 gtk_widget_show(window);
685 priv->image_dialog = window; 626 priv->image_dialog = window;
686 } else { 627 } else {
687 gtk_widget_destroy(priv->image_dialog); 628 gtk_widget_destroy(priv->image_dialog);
892 } 833 }
893 } 834 }
894 #endif 835 #endif
895 836
896 static void 837 static void
897 insert_smiley_cb(GtkWidget *smiley, GtkWebViewToolbar *toolbar) 838 insert_smiley_cb(GtkAction *smiley, GtkWebViewToolbar *toolbar)
898 { 839 {
899 #if 0 840 #if 0
900 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 841 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
901 GtkWidget *dialog, *vbox; 842 GtkWidget *dialog, *vbox;
902 GtkWidget *smiley_table = NULL; 843 GtkWidget *smiley_table = NULL;
904 const GSList *custom_smileys = NULL; 845 const GSList *custom_smileys = NULL;
905 gboolean supports_custom = FALSE; 846 gboolean supports_custom = FALSE;
906 GtkRequisition req; 847 GtkRequisition req;
907 GtkWidget *scrolled, *viewport; 848 GtkWidget *scrolled, *viewport;
908 849
909 if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(smiley))) { 850 if (!gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(smiley))) {
910 destroy_smiley_dialog(toolbar); 851 destroy_smiley_dialog(toolbar);
911 gtk_widget_grab_focus(toolbar->webview); 852 gtk_widget_grab_focus(toolbar->webview);
912 return; 853 return;
913 } 854 }
914 855
1042 gtk_widget_grab_focus(toolbar->webview); 983 gtk_widget_grab_focus(toolbar->webview);
1043 #endif 984 #endif
1044 } 985 }
1045 986
1046 static void 987 static void
1047 send_attention_cb(GtkWidget *attention, GtkWebViewToolbar *toolbar) 988 send_attention_cb(GtkAction *attention, GtkWebViewToolbar *toolbar)
1048 { 989 {
1049 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 990 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1050 PurpleConversation *conv = priv->active_conv; 991 PurpleConversation *conv = priv->active_conv;
1051 const gchar *who = purple_conversation_get_name(conv); 992 const gchar *who = purple_conversation_get_name(conv);
1052 PurpleConnection *gc = purple_conversation_get_connection(conv); 993 PurpleConnection *gc = purple_conversation_get_connection(conv);
1053 994
1054 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(attention), FALSE, toolbar);
1055 purple_prpl_send_attention(gc, who, 0); 995 purple_prpl_send_attention(gc, who, 0);
1056 gtk_widget_grab_focus(toolbar->webview); 996 gtk_widget_grab_focus(toolbar->webview);
1057 } 997 }
1058 998
1059 static void 999 static void
1060 update_buttons_cb(GtkWebView *webview, GtkWebViewButtons buttons, 1000 update_buttons_cb(GtkWebView *webview, GtkWebViewButtons buttons,
1061 GtkWebViewToolbar *toolbar) 1001 GtkWebViewToolbar *toolbar)
1062 { 1002 {
1063 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 1003 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1064 gtk_widget_set_sensitive(GTK_WIDGET(priv->bold), buttons & GTK_WEBVIEW_BOLD); 1004
1065 gtk_widget_set_sensitive(GTK_WIDGET(priv->italic), buttons & GTK_WEBVIEW_ITALIC); 1005 gtk_action_set_sensitive(priv->bold, buttons & GTK_WEBVIEW_BOLD);
1066 gtk_widget_set_sensitive(GTK_WIDGET(priv->underline), buttons & GTK_WEBVIEW_UNDERLINE); 1006 gtk_action_set_sensitive(priv->italic, buttons & GTK_WEBVIEW_ITALIC);
1067 gtk_widget_set_sensitive(GTK_WIDGET(priv->strike), buttons & GTK_WEBVIEW_STRIKE); 1007 gtk_action_set_sensitive(priv->underline, buttons & GTK_WEBVIEW_UNDERLINE);
1068 1008 gtk_action_set_sensitive(priv->strike, buttons & GTK_WEBVIEW_STRIKE);
1069 gtk_widget_set_sensitive(GTK_WIDGET(priv->larger_size), buttons & GTK_WEBVIEW_GROW); 1009
1070 gtk_widget_set_sensitive(GTK_WIDGET(priv->smaller_size), buttons & GTK_WEBVIEW_SHRINK); 1010 gtk_action_set_sensitive(priv->larger_size, buttons & GTK_WEBVIEW_GROW);
1071 1011 gtk_action_set_sensitive(priv->smaller_size, buttons & GTK_WEBVIEW_SHRINK);
1072 gtk_widget_set_sensitive(GTK_WIDGET(priv->font), buttons & GTK_WEBVIEW_FACE); 1012
1073 gtk_widget_set_sensitive(GTK_WIDGET(priv->fgcolor), buttons & GTK_WEBVIEW_FORECOLOR); 1013 gtk_action_set_sensitive(priv->font, buttons & GTK_WEBVIEW_FACE);
1074 gtk_widget_set_sensitive(GTK_WIDGET(priv->bgcolor), buttons & GTK_WEBVIEW_BACKCOLOR); 1014 gtk_action_set_sensitive(priv->fgcolor, buttons & GTK_WEBVIEW_FORECOLOR);
1075 1015 gtk_action_set_sensitive(priv->bgcolor, buttons & GTK_WEBVIEW_BACKCOLOR);
1076 gtk_widget_set_sensitive(GTK_WIDGET(priv->clear), 1016
1077 (buttons & GTK_WEBVIEW_BOLD || 1017 gtk_action_set_sensitive(priv->clear,
1078 buttons & GTK_WEBVIEW_ITALIC || 1018 (buttons & GTK_WEBVIEW_BOLD ||
1079 buttons & GTK_WEBVIEW_UNDERLINE || 1019 buttons & GTK_WEBVIEW_ITALIC ||
1080 buttons & GTK_WEBVIEW_STRIKE || 1020 buttons & GTK_WEBVIEW_UNDERLINE ||
1081 buttons & GTK_WEBVIEW_GROW || 1021 buttons & GTK_WEBVIEW_STRIKE ||
1082 buttons & GTK_WEBVIEW_SHRINK || 1022 buttons & GTK_WEBVIEW_GROW ||
1083 buttons & GTK_WEBVIEW_FACE || 1023 buttons & GTK_WEBVIEW_SHRINK ||
1084 buttons & GTK_WEBVIEW_FORECOLOR || 1024 buttons & GTK_WEBVIEW_FACE ||
1085 buttons & GTK_WEBVIEW_BACKCOLOR)); 1025 buttons & GTK_WEBVIEW_FORECOLOR ||
1086 1026 buttons & GTK_WEBVIEW_BACKCOLOR));
1087 gtk_widget_set_sensitive(GTK_WIDGET(priv->image), buttons & GTK_WEBVIEW_IMAGE); 1027
1088 gtk_widget_set_sensitive(GTK_WIDGET(priv->link), buttons & GTK_WEBVIEW_LINK); 1028 gtk_action_set_sensitive(priv->image, buttons & GTK_WEBVIEW_IMAGE);
1089 gtk_widget_set_sensitive(GTK_WIDGET(priv->smiley), buttons & GTK_WEBVIEW_SMILEY); 1029 gtk_action_set_sensitive(priv->link, buttons & GTK_WEBVIEW_LINK);
1030 gtk_action_set_sensitive(priv->smiley, buttons & GTK_WEBVIEW_SMILEY);
1090 } 1031 }
1091 1032
1092 /* we call this when we want to _set_active the toggle button, it'll 1033 /* we call this when we want to _set_active the toggle button, it'll
1093 * block the callback thats connected to the button so we don't have to 1034 * block the callback that's connected to the button so we don't have to
1094 * do the double toggling hack 1035 * do the double toggling hack
1095 */ 1036 */
1096 static void 1037 static void
1097 toggle_button_set_active_block(GtkToggleButton *button, gboolean is_active, 1038 toggle_action_set_active_block(GtkToggleAction *action, gboolean is_active,
1098 GtkWebViewToolbar *toolbar) 1039 GtkWebViewToolbar *toolbar)
1099 { 1040 {
1100 GObject *object; 1041 GObject *object;
1101 g_return_if_fail(toolbar); 1042 g_return_if_fail(toolbar);
1102 1043
1103 object = g_object_ref(button); 1044 object = g_object_ref(action);
1104 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA, 1045 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA,
1105 0, 0, NULL, NULL, toolbar); 1046 0, 0, NULL, NULL, toolbar);
1106 gtk_toggle_button_set_active(button, is_active); 1047 gtk_toggle_action_set_active(action, is_active);
1107 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, 1048 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA,
1108 0, 0, NULL, NULL, toolbar); 1049 0, 0, NULL, NULL, toolbar);
1109 g_object_unref(object); 1050 g_object_unref(object);
1110 } 1051 }
1111 1052
1112 static void 1053 static void
1113 update_buttons(GtkWebViewToolbar *toolbar) 1054 update_buttons(GtkWebViewToolbar *toolbar)
1114 { 1055 {
1115 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 1056 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1116 gboolean bold, italic, underline, strike; 1057 gboolean bold, italic, underline, strike;
1117 char *tmp; 1058 char *tmp;
1118 GtkLabel *label = GTK_LABEL(priv->font_label); 1059 char *label;
1119 1060
1120 gtk_label_set_label(label, _("_Font")); 1061 label = g_strdup(_("_Font"));
1121 1062
1122 gtk_webview_get_current_format(GTK_WEBVIEW(toolbar->webview), 1063 gtk_webview_get_current_format(GTK_WEBVIEW(toolbar->webview),
1123 &bold, &italic, &underline, &strike); 1064 &bold, &italic, &underline, &strike);
1124 1065
1125 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->bold)) != bold) 1066 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(priv->bold)) != bold)
1126 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->bold), bold, 1067 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->bold), bold,
1127 toolbar); 1068 toolbar);
1128 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->italic)) != italic) 1069 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(priv->italic)) != italic)
1129 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->italic), italic, 1070 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->italic), italic,
1130 toolbar); 1071 toolbar);
1131 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->underline)) != underline) 1072 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(priv->underline)) != underline)
1132 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->underline), 1073 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->underline),
1133 underline, toolbar); 1074 underline, toolbar);
1134 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->strike)) != strike) 1075 if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(priv->strike)) != strike)
1135 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->strike), 1076 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->strike), strike,
1136 strike, toolbar); 1077 toolbar);
1137
1138 /* These buttons aren't ever "active". */
1139 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->smaller_size), FALSE);
1140 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->larger_size), FALSE);
1141 1078
1142 if (bold) { 1079 if (bold) {
1143 gchar *markup = g_strdup_printf("<b>%s</b>", 1080 gchar *markup = g_strdup_printf("<b>%s</b>", label);
1144 gtk_label_get_label(label)); 1081 g_free(label);
1145 gtk_label_set_markup_with_mnemonic(label, markup); 1082 label = markup;
1146 g_free(markup);
1147 } 1083 }
1148 if (italic) { 1084 if (italic) {
1149 gchar *markup = g_strdup_printf("<i>%s</i>", 1085 gchar *markup = g_strdup_printf("<i>%s</i>", label);
1150 gtk_label_get_label(label)); 1086 g_free(label);
1151 gtk_label_set_markup_with_mnemonic(label, markup); 1087 label = markup;
1152 g_free(markup);
1153 } 1088 }
1154 if (underline) { 1089 if (underline) {
1155 gchar *markup = g_strdup_printf("<u>%s</u>", 1090 gchar *markup = g_strdup_printf("<u>%s</u>", label);
1156 gtk_label_get_label(label)); 1091 g_free(label);
1157 gtk_label_set_markup_with_mnemonic(label, markup); 1092 label = markup;
1158 g_free(markup);
1159 } 1093 }
1160 if (strike) { 1094 if (strike) {
1161 gchar *markup = g_strdup_printf("<s>%s</s>", 1095 gchar *markup = g_strdup_printf("<s>%s</s>", label);
1162 gtk_label_get_label(label)); 1096 g_free(label);
1163 gtk_label_set_markup_with_mnemonic(label, markup); 1097 label = markup;
1164 g_free(markup);
1165 } 1098 }
1166 1099
1167 tmp = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview)); 1100 tmp = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview));
1168 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->font), 1101 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->font),
1169 (tmp != NULL), toolbar); 1102 (tmp && *tmp), toolbar);
1170 if (tmp != NULL) { 1103 if (tmp && *tmp) {
1171 gchar *markup = g_strdup_printf("<span font_desc=\"%s\">%s</span>", 1104 gchar *markup = g_strdup_printf("<span font_desc=\"%s\">%s</span>",
1172 tmp, gtk_label_get_label(label)); 1105 tmp, label);
1173 gtk_label_set_markup_with_mnemonic(label, markup); 1106 g_free(label);
1174 g_free(markup); 1107 label = markup;
1175 } 1108 }
1176 g_free(tmp); 1109 g_free(tmp);
1177 1110
1178 tmp = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview)); 1111 tmp = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview));
1179 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->fgcolor), 1112 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->fgcolor),
1180 (tmp != NULL), toolbar); 1113 (tmp && *tmp), toolbar);
1181 if (tmp != NULL) { 1114 if (tmp && *tmp) {
1182 gchar *markup = g_strdup_printf("<span foreground=\"%s\">%s</span>", 1115 gchar *markup = g_strdup_printf("<span foreground=\"%s\">%s</span>",
1183 tmp, gtk_label_get_label(label)); 1116 tmp, label);
1184 gtk_label_set_markup_with_mnemonic(label, markup); 1117 g_free(label);
1185 g_free(markup); 1118 label = markup;
1186 } 1119 }
1187 g_free(tmp); 1120 g_free(tmp);
1188 1121
1189 tmp = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview)); 1122 tmp = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview));
1190 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->bgcolor), 1123 toggle_action_set_active_block(GTK_TOGGLE_ACTION(priv->bgcolor),
1191 (tmp != NULL), toolbar); 1124 (tmp && *tmp), toolbar);
1192 if (tmp != NULL) { 1125 if (tmp && *tmp) {
1193 gchar *markup = g_strdup_printf("<span background=\"%s\">%s</span>", 1126 gchar *markup = g_strdup_printf("<span background=\"%s\">%s</span>",
1194 tmp, gtk_label_get_label(label)); 1127 tmp, label);
1195 gtk_label_set_markup_with_mnemonic(label, markup); 1128 g_free(label);
1196 g_free(markup); 1129 label = markup;
1197 } 1130 }
1198 g_free(tmp); 1131 g_free(tmp);
1132
1133 gtk_label_set_markup_with_mnemonic(GTK_LABEL(priv->font_label), label);
1199 } 1134 }
1200 1135
1201 static void 1136 static void
1202 toggle_button_cb(GtkWebView *webview, GtkWebViewButtons buttons, 1137 toggle_button_cb(GtkWebView *webview, GtkWebViewButtons buttons,
1203 GtkWebViewToolbar *toolbar) 1138 GtkWebViewToolbar *toolbar)
1209 update_format_cb(GtkWebView *webview, GtkWebViewToolbar *toolbar) 1144 update_format_cb(GtkWebView *webview, GtkWebViewToolbar *toolbar)
1210 { 1145 {
1211 update_buttons(toolbar); 1146 update_buttons(toolbar);
1212 } 1147 }
1213 1148
1214 #if 0 1149 static void
1215 static void 1150 mark_set_cb(GtkWebView *webview, GtkWebViewToolbar *toolbar)
1216 mark_set_cb(GtkTextBuffer *buffer, GtkTextIter *location, GtkTextMark *mark, 1151 {
1217 GtkWebViewToolbar *toolbar)
1218 {
1219 if(mark != gtk_text_buffer_get_insert(buffer))
1220 return;
1221
1222 update_buttons(toolbar); 1152 update_buttons(toolbar);
1223 } 1153 }
1224 #endif
1225 1154
1226 /* This comes from gtkmenutoolbutton.c from gtk+ 1155 /* This comes from gtkmenutoolbutton.c from gtk+
1227 * Copyright (C) 2003 Ricardo Fernandez Pascual 1156 * Copyright (C) 2003 Ricardo Fernandez Pascual
1228 * Copyright (C) 2004 Paolo Borelli 1157 * Copyright (C) 2004 Paolo Borelli
1229 */ 1158 */
1230 static void 1159 static void
1231 menu_position_func(GtkMenu *menu, 1160 menu_position_func(GtkMenu *menu,
1232 int *x, 1161 int *x,
1233 int *y, 1162 int *y,
1234 gboolean *push_in, 1163 gboolean *push_in,
1235 gpointer data) 1164 gpointer data)
1236 { 1165 {
1237 GtkWidget *widget = GTK_WIDGET(data); 1166 GtkWidget *widget = GTK_WIDGET(data);
1238 GtkRequisition menu_req; 1167 GtkRequisition menu_req;
1239 GtkAllocation allocation; 1168 GtkAllocation allocation;
1240 gint ythickness = gtk_widget_get_style(widget)->ythickness; 1169 gint ythickness = gtk_widget_get_style(widget)->ythickness;
1241 int savy; 1170 int savy;
1242 1171
1243 gtk_widget_get_allocation(widget, &allocation); 1172 gtk_widget_get_allocation(widget, &allocation);
1244 gtk_widget_size_request(GTK_WIDGET (menu), &menu_req); 1173 gtk_widget_size_request(GTK_WIDGET(menu), &menu_req);
1245 gdk_window_get_origin(gtk_widget_get_window(widget), x, y); 1174 gdk_window_get_origin(gtk_widget_get_window(widget), x, y);
1246 *x += allocation.x; 1175 *x += allocation.x;
1247 *y += allocation.y + allocation.height; 1176 *y += allocation.y + allocation.height;
1248 savy = *y; 1177 savy = *y;
1249 1178
1251 1180
1252 if (savy > *y + ythickness + 1) 1181 if (savy > *y + ythickness + 1)
1253 *y -= allocation.height; 1182 *y -= allocation.height;
1254 } 1183 }
1255 1184
1256 static gboolean
1257 button_activate_on_click(GtkWidget *button, GdkEventButton *event,
1258 GtkWebViewToolbar *toolbar)
1259 {
1260 if (event->button == 1 && GTK_IS_TOGGLE_BUTTON(button))
1261 gtk_widget_activate(button);
1262 else if (event->button == 3)
1263 return gtk_webviewtoolbar_popup_menu(button, event, toolbar);
1264 return FALSE;
1265 }
1266
1267 static void 1185 static void
1268 pidgin_menu_clicked(GtkWidget *button, GtkMenu *menu) 1186 pidgin_menu_clicked(GtkWidget *button, GtkMenu *menu)
1269 { 1187 {
1270 gtk_widget_show_all(GTK_WIDGET(menu)); 1188 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(button))) {
1271 gtk_menu_popup(menu, NULL, NULL, menu_position_func, button, 0, gtk_get_current_event_time()); 1189 gtk_widget_show_all(GTK_WIDGET(menu));
1190 gtk_menu_popup(menu, NULL, NULL, menu_position_func, button, 0, gtk_get_current_event_time());
1191 }
1272 } 1192 }
1273 1193
1274 static void 1194 static void
1275 pidgin_menu_deactivate(GtkWidget *menu, GtkToggleButton *button) 1195 pidgin_menu_deactivate(GtkWidget *menu, GtkToggleButton *button)
1276 { 1196 {
1277 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE); 1197 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(button), FALSE);
1278 } 1198 }
1279 1199
1280 static void 1200 static void
1281 switch_toolbar_view(GtkWidget *item, GtkWebViewToolbar *toolbar) 1201 switch_toolbar_view(GtkWidget *item, GtkWebViewToolbar *toolbar)
1282 { 1202 {
1294 gboolean wide; 1214 gboolean wide;
1295 1215
1296 if (event->button != 3) 1216 if (event->button != 3)
1297 return FALSE; 1217 return FALSE;
1298 1218
1299 wide = gtk_widget_get_visible(priv->bold); 1219 wide = gtk_widget_get_visible(priv->wide_view);
1300 1220
1301 menu = gtk_menu_new(); 1221 menu = gtk_menu_new();
1302 item = gtk_menu_item_new_with_mnemonic(wide ? _("Group Items") : _("Ungroup Items")); 1222 item = gtk_menu_item_new_with_mnemonic(wide ? _("Group Items") : _("Ungroup Items"));
1303 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(switch_toolbar_view), toolbar); 1223 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(switch_toolbar_view), toolbar);
1304 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); 1224 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1305 gtk_widget_show(item); 1225 gtk_widget_show(item);
1306 1226
1307 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, pidgin_menu_position_func_helper, 1227 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, pidgin_menu_position_func_helper,
1308 widget, event->button, event->time); 1228 widget, event->button, event->time);
1229
1309 return TRUE; 1230 return TRUE;
1310 } 1231 }
1311 1232
1312 static void 1233 static void
1313 button_visibility_changed(GtkWidget *button, gpointer dontcare, GtkWidget *item)
1314 {
1315 if (gtk_widget_get_visible(button))
1316 gtk_widget_hide(item);
1317 else
1318 gtk_widget_show(item);
1319 }
1320
1321 static void
1322 button_sensitiveness_changed(GtkWidget *button, gpointer dontcare, GtkWidget *item)
1323 {
1324 gtk_widget_set_sensitive(item, gtk_widget_is_sensitive(button));
1325 }
1326
1327 static void
1328 update_menuitem(GtkToggleButton *button, GtkCheckMenuItem *item)
1329 {
1330 g_signal_handlers_block_by_func(G_OBJECT(item), G_CALLBACK(gtk_button_clicked), button);
1331 gtk_check_menu_item_set_active(item, gtk_toggle_button_get_active(button));
1332 g_signal_handlers_unblock_by_func(G_OBJECT(item), G_CALLBACK(gtk_button_clicked), button);
1333 }
1334
1335 static void
1336 enable_markup(GtkWidget *widget, gpointer null) 1234 enable_markup(GtkWidget *widget, gpointer null)
1337 { 1235 {
1338 if (GTK_IS_LABEL(widget)) 1236 GtkWidget *label;
1339 g_object_set(G_OBJECT(widget), "use-markup", TRUE, NULL); 1237 label = gtk_bin_get_child(GTK_BIN(widget));
1238 if (GTK_IS_LABEL(label))
1239 g_object_set(G_OBJECT(label), "use-markup", TRUE, NULL);
1340 } 1240 }
1341 1241
1342 static void 1242 static void
1343 webviewtoolbar_view_pref_changed(const char *name, PurplePrefType type, 1243 webviewtoolbar_view_pref_changed(const char *name, PurplePrefType type,
1344 gconstpointer value, gpointer toolbar) 1244 gconstpointer value, gpointer toolbar)
1390 #endif 1290 #endif
1391 } 1291 }
1392 1292
1393 g_free(priv->sml); 1293 g_free(priv->sml);
1394 1294
1395 #if !GTK_CHECK_VERSION(2,12,0)
1396 gtk_object_sink(GTK_OBJECT(priv->tooltips));
1397 #endif
1398
1399 if (priv->font_menu) 1295 if (priv->font_menu)
1400 gtk_widget_destroy(priv->font_menu); 1296 gtk_widget_destroy(priv->font_menu);
1401 if (priv->insert_menu) 1297 if (priv->insert_menu)
1402 gtk_widget_destroy(priv->insert_menu); 1298 gtk_widget_destroy(priv->insert_menu);
1403 1299
1404 purple_prefs_disconnect_by_handle(object); 1300 purple_prefs_disconnect_by_handle(object);
1405 1301
1406 G_OBJECT_CLASS(parent_class)->finalize (object); 1302 G_OBJECT_CLASS(parent_class)->finalize(object);
1407 } 1303 }
1408 1304
1409 static void 1305 static void
1410 gtk_webviewtoolbar_class_init(GtkWebViewToolbarClass *class) 1306 gtk_webviewtoolbar_class_init(GtkWebViewToolbarClass *class)
1411 { 1307 {
1419 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/conversations/toolbar"); 1315 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/conversations/toolbar");
1420 purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", FALSE); 1316 purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", FALSE);
1421 } 1317 }
1422 1318
1423 static void 1319 static void
1424 gtk_webviewtoolbar_create_old_buttons(GtkWebViewToolbar *toolbar) 1320 gtk_webviewtoolbar_create_actions(GtkWebViewToolbar *toolbar)
1425 { 1321 {
1426 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 1322 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1427 GtkWidget *hbox; 1323 GtkActionGroup *action_group;
1428 GtkWidget *button; 1324 int i;
1429 struct { 1325 struct {
1326 GtkAction **action;
1327 char *name;
1430 char *stock; 1328 char *stock;
1431 gpointer callback; 1329 char *label;
1432 GtkWidget **button; 1330 char *tooltip;
1433 const char *tooltip; 1331 void (*cb)();
1434 } buttons[] = { 1332 gboolean toggle;
1435 {GTK_STOCK_BOLD, G_CALLBACK(do_bold), &priv->bold, _("Bold")}, 1333 } actions[] = {
1436 {GTK_STOCK_ITALIC, do_italic, &priv->italic, _("Italic")}, 1334 {&priv->bold, "ToggleBold", GTK_STOCK_BOLD, N_("<b>_Bold</b>"), N_("Bold"), do_bold, TRUE},
1437 {GTK_STOCK_UNDERLINE, do_underline, &priv->underline, _("Underline")}, 1335 {&priv->italic, "ToggleItalic", GTK_STOCK_ITALIC, N_("<i>_Italic</i>"), N_("Italic"), do_italic, TRUE},
1438 {GTK_STOCK_STRIKETHROUGH, do_strikethrough, &priv->strike, _("Strikethrough")}, 1336 {&priv->underline, "ToggleUnderline", GTK_STOCK_UNDERLINE, N_("<u>_Underline</u>"), N_("Underline"), do_underline, TRUE},
1439 {"", NULL, NULL, NULL}, 1337 {&priv->strike, "ToggleStrike", GTK_STOCK_STRIKETHROUGH, N_("<span strikethrough='true'>Strikethrough</span>"), N_("Strikethrough"), do_strikethrough, TRUE},
1440 {PIDGIN_STOCK_TOOLBAR_TEXT_LARGER, do_big, &priv->larger_size, _("Increase Font Size")}, 1338 {&priv->larger_size, "ToggleLarger", PIDGIN_STOCK_TOOLBAR_TEXT_LARGER, N_("<span size='larger'>Larger</span>"), N_("Increase Font Size"), do_big, FALSE},
1441 {PIDGIN_STOCK_TOOLBAR_TEXT_SMALLER, do_small, &priv->smaller_size, _("Decrease Font Size")}, 1339 #if 0
1442 {"", NULL, NULL, NULL}, 1340 {&priv->normal_size, "ToggleNormal", NULL, N_("Normal"), N_("Normal Font Size"), NULL, FALSE},
1443 {PIDGIN_STOCK_TOOLBAR_FONT_FACE, toggle_font, &priv->font, _("Font Face")}, 1341 #endif
1444 {PIDGIN_STOCK_TOOLBAR_FGCOLOR, toggle_fg_color, &priv->fgcolor, _("Foreground Color")}, 1342 {&priv->smaller_size, "ToggleSmaller", PIDGIN_STOCK_TOOLBAR_TEXT_SMALLER, N_("<span size='smaller'>Smaller</span>"), N_("Decrease Font Size"), do_small, FALSE},
1445 {PIDGIN_STOCK_TOOLBAR_BGCOLOR, toggle_bg_color, &priv->bgcolor, _("Background Color")}, 1343 {&priv->font, "ToggleFontFace", PIDGIN_STOCK_TOOLBAR_FONT_FACE, N_("_Font face"), N_("Font Face"), toggle_font, TRUE},
1446 {"", NULL, NULL, NULL}, 1344 {&priv->fgcolor, "ToggleFG", PIDGIN_STOCK_TOOLBAR_FGCOLOR, N_("Foreground _color"), N_("Foreground Color"), toggle_fg_color, TRUE},
1447 {PIDGIN_STOCK_CLEAR, clear_formatting_cb, &priv->clear, _("Reset Formatting")}, 1345 {&priv->bgcolor, "ToggleBG", PIDGIN_STOCK_TOOLBAR_BGCOLOR, N_("Bac_kground color"), N_("Background Color"), toggle_bg_color, TRUE},
1448 {"", NULL, NULL, NULL}, 1346 {&priv->clear, "ResetFormat", PIDGIN_STOCK_CLEAR, N_("_Reset formatting"), N_("Reset Formatting"), clear_formatting_cb, FALSE},
1449 {PIDGIN_STOCK_TOOLBAR_INSERT_IMAGE, insert_image_cb, &priv->image, _("Insert IM Image")}, 1347 {&priv->image, "InsertImage", PIDGIN_STOCK_TOOLBAR_INSERT_IMAGE, N_("_Image"), N_("Insert IM Image"), insert_image_cb, FALSE},
1450 {PIDGIN_STOCK_TOOLBAR_INSERT_LINK, insert_link_cb, &priv->link, _("Insert Link")}, 1348 {&priv->link, "InsertLink", PIDGIN_STOCK_TOOLBAR_INSERT_LINK, N_("_Link"), N_("Insert Link"), insert_link_cb, TRUE},
1451 {"", NULL, NULL, NULL}, 1349 {&priv->hr, "InsertHR", NULL, N_("_Horizontal rule"), N_("Insert Horizontal rule"), insert_hr_cb, FALSE},
1452 {PIDGIN_STOCK_TOOLBAR_SMILEY, insert_smiley_cb, &priv->smiley, _("Insert Smiley")}, 1350 {&priv->smiley, "InsertSmiley", PIDGIN_STOCK_TOOLBAR_SMILEY, N_("_Smile!"), N_("Insert Smiley"), insert_smiley_cb, FALSE},
1453 {PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION, send_attention_cb, &priv->attention, _("Send Attention")}, 1351 {&priv->attention, "SendAttention", PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION, N_("_Attention!"), N_("Send Attention"), send_attention_cb, FALSE},
1454 {NULL, NULL, NULL, NULL}
1455 }; 1352 };
1456 int iter; 1353
1457 1354 action_group = gtk_action_group_new("GtkWebViewToolbar");
1458 hbox = gtk_hbox_new(FALSE, 0); 1355 #ifdef ENABLE_NLS
1459 1356 gtk_action_group_set_translation_domain(action_group, PACKAGE);
1460 for (iter = 0; buttons[iter].stock; iter++) { 1357 #endif
1461 if (buttons[iter].stock[0]) { 1358
1462 button = pidgin_pixbuf_toolbar_button_from_stock(buttons[iter].stock); 1359 for (i = 0; i < G_N_ELEMENTS(actions); i++) {
1463 g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar); 1360 GtkAction *action;
1464 g_signal_connect(G_OBJECT(button), "clicked", 1361 if (actions[i].toggle)
1465 G_CALLBACK(buttons[iter].callback), toolbar); 1362 action = GTK_ACTION(gtk_toggle_action_new(actions[i].name,
1466 *(buttons[iter].button) = button; 1363 actions[i].label,
1467 gtk_widget_set_tooltip_text(button, buttons[iter].tooltip); 1364 actions[i].tooltip,
1468 } else 1365 actions[i].stock));
1469 button = gtk_vseparator_new(); 1366 else
1470 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); 1367 action = gtk_action_new(actions[i].name, actions[i].label,
1471 } 1368 actions[i].tooltip, actions[i].stock);
1472 1369 gtk_action_set_is_important(action, TRUE);
1473 gtk_box_pack_start(GTK_BOX(toolbar), hbox, FALSE, FALSE, 0); 1370 gtk_action_group_add_action(action_group, action);
1474 priv->wide_view = hbox; 1371 g_signal_connect(G_OBJECT(action), "activate", actions[i].cb, toolbar);
1475 } 1372 *(actions[i].action) = action;
1476 1373 }
1477 static void 1374 }
1478 gtk_webviewtoolbar_init(GtkWebViewToolbar *toolbar) 1375
1479 { 1376 static void
1480 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); 1377 gtk_webviewtoolbar_create_wide_view(GtkWebViewToolbar *toolbar)
1481 GtkWidget *hbox = GTK_WIDGET(toolbar), *event = gtk_event_box_new(); 1378 {
1482 GtkWidget *bbox, *box = gtk_hbox_new(FALSE, 0); 1379 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1483 GtkWidget *image; 1380 GtkAction *layout[] = {
1381 priv->bold,
1382 priv->italic,
1383 priv->underline,
1384 priv->strike,
1385 NULL,
1386 priv->larger_size,
1387 #if 0
1388 priv->normal_size,
1389 #endif
1390 priv->smaller_size,
1391 NULL,
1392 priv->font,
1393 priv->fgcolor,
1394 priv->bgcolor,
1395 NULL,
1396 priv->clear,
1397 NULL,
1398 priv->image,
1399 priv->link,
1400 NULL,
1401 priv->smiley,
1402 priv->attention
1403 };
1404 int i;
1405 GtkToolItem *item;
1406
1407 priv->wide_view = gtk_toolbar_new();
1408 gtk_toolbar_set_icon_size(GTK_TOOLBAR(priv->wide_view),
1409 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
1410 gtk_toolbar_set_style(GTK_TOOLBAR(priv->wide_view), GTK_TOOLBAR_ICONS);
1411
1412 for (i = 0; i < G_N_ELEMENTS(layout); i++) {
1413 if (layout[i])
1414 item = GTK_TOOL_ITEM(gtk_action_create_tool_item(layout[i]));
1415 else
1416 item = gtk_separator_tool_item_new();
1417 gtk_toolbar_insert(GTK_TOOLBAR(priv->wide_view), item, -1);
1418 }
1419 }
1420
1421 static void
1422 gtk_webviewtoolbar_create_lean_view(GtkWebViewToolbar *toolbar)
1423 {
1424 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1484 GtkWidget *label; 1425 GtkWidget *label;
1485 GtkWidget *insert_button; 1426 GtkWidget *menuitem;
1486 GtkWidget *font_button; 1427 GtkToolItem *sep;
1428 GtkToolItem *font_button;
1429 GtkWidget *font_menu;
1430 GtkToolItem *insert_button;
1431 GtkWidget *insert_menu;
1487 GtkWidget *smiley_button; 1432 GtkWidget *smiley_button;
1488 GtkWidget *attention_button; 1433 GtkWidget *attention_button;
1489 GtkWidget *font_menu; 1434
1490 GtkWidget *insert_menu; 1435 priv->lean_view = gtk_toolbar_new();
1491 GtkWidget *menuitem; 1436 gtk_toolbar_set_icon_size(GTK_TOOLBAR(priv->lean_view),
1492 GtkWidget *sep; 1437 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
1493 int i; 1438 gtk_toolbar_set_style(GTK_TOOLBAR(priv->lean_view), GTK_TOOLBAR_BOTH_HORIZ);
1494 struct { 1439
1495 const char *label; 1440 #define ADD_MENU_ITEM(menu, item) \
1496 GtkWidget **button; 1441 menuitem = gtk_action_create_menu_item((item)); \
1497 gboolean check; 1442 gtk_menu_shell_append(GTK_MENU_SHELL((menu)), menuitem);
1498 } buttons[] = {
1499 {_("<b>_Bold</b>"), &priv->bold, TRUE},
1500 {_("<i>_Italic</i>"), &priv->italic, TRUE},
1501 {_("<u>_Underline</u>"), &priv->underline, TRUE},
1502 {_("<span strikethrough='true'>Strikethrough</span>"), &priv->strike, TRUE},
1503 {_("<span size='larger'>_Larger</span>"), &priv->larger_size, TRUE},
1504 #if 0
1505 {_("_Normal"), &priv->normal_size, TRUE},
1506 #endif
1507 {_("<span size='smaller'>_Smaller</span>"), &priv->smaller_size, TRUE},
1508 /* If we want to show the formatting for the following items, we would
1509 * need to update them when formatting changes. The above items don't need
1510 * no updating nor nothin' */
1511 {_("_Font face"), &priv->font, TRUE},
1512 {_("Foreground _color"), &priv->fgcolor, TRUE},
1513 {_("Bac_kground color"), &priv->bgcolor, TRUE},
1514 {_("_Reset formatting"), &priv->clear, FALSE},
1515 {NULL, NULL, FALSE}
1516 };
1517
1518 toolbar->webview = NULL;
1519 priv->font_dialog = NULL;
1520 priv->fgcolor_dialog = NULL;
1521 priv->bgcolor_dialog = NULL;
1522 priv->link_dialog = NULL;
1523 priv->smiley_dialog = NULL;
1524 priv->image_dialog = NULL;
1525
1526 #if !GTK_CHECK_VERSION(2,12,0)
1527 priv->tooltips = gtk_tooltips_new();
1528 #endif
1529
1530 gtk_box_set_spacing(GTK_BOX(toolbar), 3);
1531
1532 gtk_webviewtoolbar_create_old_buttons(toolbar);
1533 1443
1534 /* Fonts */ 1444 /* Fonts */
1535 font_button = gtk_toggle_button_new(); 1445 font_button = gtk_toggle_tool_button_new();
1536 gtk_button_set_relief(GTK_BUTTON(font_button), GTK_RELIEF_NONE); 1446 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view), font_button, -1);
1537 bbox = gtk_hbox_new(FALSE, 3); 1447 gtk_tool_item_set_is_important(font_button, TRUE);
1538 gtk_container_add(GTK_CONTAINER(font_button), bbox); 1448 gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(font_button), GTK_STOCK_BOLD);
1539 image = gtk_image_new_from_stock(GTK_STOCK_BOLD, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
1540 gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
1541 priv->font_label = label = gtk_label_new_with_mnemonic(_("_Font")); 1449 priv->font_label = label = gtk_label_new_with_mnemonic(_("_Font"));
1542 gtk_label_set_use_markup(GTK_LABEL(label), TRUE); 1450 gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
1543 gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0); 1451 gtk_tool_button_set_label_widget(GTK_TOOL_BUTTON(font_button), label);
1544 gtk_box_pack_start(GTK_BOX(box), font_button, FALSE, FALSE, 0);
1545 gtk_widget_show_all(font_button);
1546 1452
1547 priv->font_menu = font_menu = gtk_menu_new(); 1453 priv->font_menu = font_menu = gtk_menu_new();
1548 1454
1549 for (i = 0; buttons[i].label; i++) { 1455 ADD_MENU_ITEM(font_menu, priv->bold);
1550 GtkWidget *old = *buttons[i].button; 1456 ADD_MENU_ITEM(font_menu, priv->italic);
1551 if (buttons[i].check) { 1457 ADD_MENU_ITEM(font_menu, priv->underline);
1552 menuitem = gtk_check_menu_item_new_with_mnemonic(buttons[i].label); 1458 ADD_MENU_ITEM(font_menu, priv->strike);
1553 g_signal_connect_after(G_OBJECT(old), "toggled", 1459 ADD_MENU_ITEM(font_menu, priv->larger_size);
1554 G_CALLBACK(update_menuitem), menuitem); 1460 #if 0
1555 } else { 1461 ADD_MENU_ITEM(font_menu, priv->normal_size);
1556 menuitem = gtk_menu_item_new_with_mnemonic(buttons[i].label); 1462 #endif
1557 } 1463 ADD_MENU_ITEM(font_menu, priv->smaller_size);
1558 g_signal_connect_swapped(G_OBJECT(menuitem), "activate", 1464 ADD_MENU_ITEM(font_menu, priv->font);
1559 G_CALLBACK(gtk_button_clicked), old); 1465 ADD_MENU_ITEM(font_menu, priv->fgcolor);
1560 gtk_menu_shell_append(GTK_MENU_SHELL(font_menu), menuitem); 1466 ADD_MENU_ITEM(font_menu, priv->bgcolor);
1561 g_signal_connect(G_OBJECT(old), "notify::sensitive", 1467 ADD_MENU_ITEM(font_menu, priv->clear);
1562 G_CALLBACK(button_sensitiveness_changed), menuitem); 1468
1563 g_signal_connect(G_OBJECT(old), "notify::visible", 1469 g_signal_connect(G_OBJECT(font_button), "toggled",
1564 G_CALLBACK(button_visibility_changed), menuitem); 1470 G_CALLBACK(pidgin_menu_clicked), font_menu);
1565 gtk_container_foreach(GTK_CONTAINER(menuitem), (GtkCallback)enable_markup, NULL); 1471 g_signal_connect(G_OBJECT(font_menu), "deactivate",
1566 } 1472 G_CALLBACK(pidgin_menu_deactivate), font_button);
1567 1473
1568 g_signal_connect(G_OBJECT(font_button), "button-press-event", G_CALLBACK(button_activate_on_click), toolbar); 1474 gtk_container_foreach(GTK_CONTAINER(font_menu), enable_markup, NULL);
1569 g_signal_connect(G_OBJECT(font_button), "activate", G_CALLBACK(pidgin_menu_clicked), font_menu);
1570 g_signal_connect(G_OBJECT(font_menu), "deactivate", G_CALLBACK(pidgin_menu_deactivate), font_button);
1571 1475
1572 /* Sep */ 1476 /* Sep */
1573 sep = gtk_vseparator_new(); 1477 sep = gtk_separator_tool_item_new();
1574 gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0); 1478 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view), sep, -1);
1575 gtk_widget_show_all(sep);
1576 1479
1577 /* Insert */ 1480 /* Insert */
1578 insert_button = gtk_toggle_button_new(); 1481 insert_button = gtk_toggle_tool_button_new();
1579 gtk_button_set_relief(GTK_BUTTON(insert_button), GTK_RELIEF_NONE); 1482 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view), insert_button, -1);
1580 bbox = gtk_hbox_new(FALSE, 3); 1483 gtk_tool_item_set_is_important(insert_button, TRUE);
1581 gtk_container_add(GTK_CONTAINER(insert_button), bbox); 1484 gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(insert_button),
1582 image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_INSERT, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); 1485 PIDGIN_STOCK_TOOLBAR_INSERT);
1583 gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
1584 label = gtk_label_new_with_mnemonic(_("_Insert")); 1486 label = gtk_label_new_with_mnemonic(_("_Insert"));
1585 gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0); 1487 gtk_tool_button_set_label_widget(GTK_TOOL_BUTTON(insert_button), label);
1586 gtk_box_pack_start(GTK_BOX(box), insert_button, FALSE, FALSE, 0);
1587 gtk_widget_show_all(insert_button);
1588 1488
1589 priv->insert_menu = insert_menu = gtk_menu_new(); 1489 priv->insert_menu = insert_menu = gtk_menu_new();
1590 1490
1591 menuitem = gtk_menu_item_new_with_mnemonic(_("_Image")); 1491 ADD_MENU_ITEM(insert_menu, priv->image);
1592 g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(gtk_button_clicked), priv->image); 1492 ADD_MENU_ITEM(insert_menu, priv->link);
1593 gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem); 1493 ADD_MENU_ITEM(insert_menu, priv->hr);
1594 g_signal_connect(G_OBJECT(priv->image), "notify::sensitive", 1494
1595 G_CALLBACK(button_sensitiveness_changed), menuitem); 1495 g_signal_connect(G_OBJECT(insert_button), "toggled",
1596 g_signal_connect(G_OBJECT(priv->image), "notify::visible", 1496 G_CALLBACK(pidgin_menu_clicked), insert_menu);
1597 G_CALLBACK(button_visibility_changed), menuitem); 1497 g_signal_connect(G_OBJECT(insert_menu), "deactivate",
1598 1498 G_CALLBACK(pidgin_menu_deactivate), insert_button);
1599 menuitem = gtk_menu_item_new_with_mnemonic(_("_Link")); 1499
1600 g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(gtk_button_clicked), priv->link); 1500 /* Sep */
1601 gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem); 1501 sep = gtk_separator_tool_item_new();
1602 g_signal_connect(G_OBJECT(priv->link), "notify::sensitive", 1502 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view), sep, -1);
1603 G_CALLBACK(button_sensitiveness_changed), menuitem); 1503
1604 g_signal_connect(G_OBJECT(priv->link), "notify::visible", 1504 /* Smiley */
1605 G_CALLBACK(button_visibility_changed), menuitem); 1505 smiley_button = gtk_action_create_tool_item(priv->smiley);
1606 1506 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view),
1607 menuitem = gtk_menu_item_new_with_mnemonic(_("_Horizontal rule")); 1507 GTK_TOOL_ITEM(smiley_button), -1);
1608 g_signal_connect(G_OBJECT(menuitem), "activate" , G_CALLBACK(insert_hr_cb), toolbar); 1508
1609 gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem); 1509 /* Sep */
1610 priv->insert_hr = menuitem; 1510 sep = gtk_separator_tool_item_new();
1611 1511 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view), sep, -1);
1612 g_signal_connect(G_OBJECT(insert_button), "button-press-event", G_CALLBACK(button_activate_on_click), toolbar); 1512
1613 g_signal_connect(G_OBJECT(insert_button), "activate", G_CALLBACK(pidgin_menu_clicked), insert_menu); 1513 /* Attention */
1614 g_signal_connect(G_OBJECT(insert_menu), "deactivate", G_CALLBACK(pidgin_menu_deactivate), insert_button); 1514 attention_button = gtk_action_create_tool_item(priv->attention);
1515 gtk_toolbar_insert(GTK_TOOLBAR(priv->lean_view),
1516 GTK_TOOL_ITEM(attention_button), -1);
1517
1518 #undef ADD_MENU_ITEM
1519 }
1520
1521 static void
1522 gtk_webviewtoolbar_init(GtkWebViewToolbar *toolbar)
1523 {
1524 GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
1525 GtkWidget *hbox = GTK_WIDGET(toolbar);
1526
1527 gtk_webviewtoolbar_create_actions(toolbar);
1528 gtk_webviewtoolbar_create_wide_view(toolbar);
1529 gtk_webviewtoolbar_create_lean_view(toolbar);
1530
1531 gtk_box_pack_start(GTK_BOX(hbox), priv->wide_view, TRUE, TRUE, 0);
1532 gtk_box_pack_start(GTK_BOX(hbox), priv->lean_view, TRUE, TRUE, 0);
1533
1615 priv->sml = NULL; 1534 priv->sml = NULL;
1616 1535
1617 /* Sep */
1618 sep = gtk_vseparator_new();
1619 gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
1620 gtk_widget_show_all(sep);
1621
1622 /* Smiley */
1623 smiley_button = gtk_button_new();
1624 gtk_button_set_relief(GTK_BUTTON(smiley_button), GTK_RELIEF_NONE);
1625 bbox = gtk_hbox_new(FALSE, 3);
1626 gtk_container_add(GTK_CONTAINER(smiley_button), bbox);
1627 image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_SMILEY, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
1628 gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
1629 label = gtk_label_new_with_mnemonic(_("_Smile!"));
1630 gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0);
1631 gtk_box_pack_start(GTK_BOX(box), smiley_button, FALSE, FALSE, 0);
1632 g_signal_connect(G_OBJECT(smiley_button), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
1633 g_signal_connect_swapped(G_OBJECT(smiley_button), "clicked", G_CALLBACK(gtk_button_clicked), priv->smiley);
1634 gtk_widget_show_all(smiley_button);
1635
1636 /* Sep */
1637 sep = gtk_vseparator_new();
1638 gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
1639 gtk_widget_show_all(sep);
1640
1641 /* Attention */
1642 attention_button = gtk_button_new();
1643 gtk_button_set_relief(GTK_BUTTON(attention_button), GTK_RELIEF_NONE);
1644 bbox = gtk_hbox_new(FALSE, 3);
1645 gtk_container_add(GTK_CONTAINER(attention_button), bbox);
1646 image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION,
1647 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL));
1648 gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
1649 label = gtk_label_new_with_mnemonic(_("_Attention!"));
1650 gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0);
1651 gtk_box_pack_start(GTK_BOX(box), attention_button, FALSE, FALSE, 0);
1652 g_signal_connect_swapped(G_OBJECT(attention_button), "clicked",
1653 G_CALLBACK(gtk_button_clicked), priv->attention);
1654 gtk_widget_show_all(attention_button);
1655
1656 g_signal_connect(G_OBJECT(priv->attention), "notify::sensitive",
1657 G_CALLBACK(button_sensitiveness_changed), attention_button);
1658 g_signal_connect(G_OBJECT(priv->attention), "notify::visible",
1659 G_CALLBACK(button_visibility_changed), attention_button);
1660
1661 /* set attention button to be greyed out until we get a conversation */ 1536 /* set attention button to be greyed out until we get a conversation */
1662 gtk_widget_set_sensitive(priv->attention, FALSE); 1537 gtk_action_set_sensitive(priv->attention, FALSE);
1663 1538
1664 gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 0); 1539 purple_prefs_connect_callback(toolbar,
1665 priv->lean_view = box; 1540 PIDGIN_PREFS_ROOT "/conversations/toolbar/wide",
1666 gtk_widget_show(box); 1541 webviewtoolbar_view_pref_changed, toolbar);
1667
1668 purple_prefs_connect_callback(toolbar, PIDGIN_PREFS_ROOT "/conversations/toolbar/wide",
1669 webviewtoolbar_view_pref_changed, toolbar);
1670 g_signal_connect_data(G_OBJECT(toolbar), "realize", 1542 g_signal_connect_data(G_OBJECT(toolbar), "realize",
1671 G_CALLBACK(purple_prefs_trigger_callback), PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", 1543 G_CALLBACK(purple_prefs_trigger_callback),
1672 NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED); 1544 PIDGIN_PREFS_ROOT "/conversations/toolbar/wide",
1673 1545 NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED);
1674 gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), FALSE); 1546
1675 1547 g_signal_connect(G_OBJECT(hbox), "button-press-event",
1676 gtk_widget_add_events(event, GDK_BUTTON_PRESS_MASK); 1548 G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
1677 gtk_box_pack_start(GTK_BOX(hbox), event, TRUE, TRUE, 0);
1678 g_signal_connect(G_OBJECT(event), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
1679 gtk_widget_show(event);
1680 } 1549 }
1681 1550
1682 /****************************************************************************** 1551 /******************************************************************************
1683 * Public API 1552 * Public API
1684 *****************************************************************************/ 1553 *****************************************************************************/
1732 G_CALLBACK(toggle_button_cb), toolbar); 1601 G_CALLBACK(toggle_button_cb), toolbar);
1733 g_signal_connect_after(G_OBJECT(webview), "format-cleared", 1602 g_signal_connect_after(G_OBJECT(webview), "format-cleared",
1734 G_CALLBACK(update_format_cb), toolbar); 1603 G_CALLBACK(update_format_cb), toolbar);
1735 g_signal_connect(G_OBJECT(webview), "format-updated", 1604 g_signal_connect(G_OBJECT(webview), "format-updated",
1736 G_CALLBACK(update_format_cb), toolbar); 1605 G_CALLBACK(update_format_cb), toolbar);
1737 #if 0 1606 g_signal_connect_after(G_OBJECT(webview), "selection-changed",
1738 g_signal_connect_after(G_OBJECT(GTK_WEBVIEW(webview)->text_buffer), "mark-set", G_CALLBACK(mark_set_cb), toolbar); 1607 G_CALLBACK(mark_set_cb), toolbar);
1739 #endif
1740 1608
1741 buttons = gtk_webview_get_format_functions(GTK_WEBVIEW(webview)); 1609 buttons = gtk_webview_get_format_functions(GTK_WEBVIEW(webview));
1742 update_buttons_cb(GTK_WEBVIEW(webview), buttons, toolbar); 1610 update_buttons_cb(GTK_WEBVIEW(webview), buttons, toolbar);
1743 update_buttons(toolbar); 1611 update_buttons(toolbar);
1744 } 1612 }
1762 1630
1763 priv->active_conv = conv; 1631 priv->active_conv = conv;
1764 1632
1765 /* gray out attention button on protocols that don't support it 1633 /* gray out attention button on protocols that don't support it
1766 for the time being it is always disabled for chats */ 1634 for the time being it is always disabled for chats */
1767 gtk_widget_set_sensitive(priv->attention, 1635 gtk_action_set_sensitive(priv->attention,
1768 conv && prpl && purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM && 1636 conv && prpl && purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM &&
1769 PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->send_attention != NULL); 1637 PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->send_attention != NULL);
1770 } 1638 }
1771 1639

Mercurial Repository: pidgin3

mercurial