Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkimhtmltoolbar.c

pidgin/gtkimhtmltoolbar.c

changeset 15435
4b933b06d75e
parent 14695
3c807db89544
child 15562
8c8249fe5e3c
equal deleted inserted replaced
15434:94dcf9e39d66 15435:4b933b06d75e
1 /*
2 * @file gtkimhtmltoolbar.c GTK+ IMHtml Toolbar
3 * @ingroup gtkui
4 *
5 * gaim
6 *
7 * Gaim is the legal property of its developers, whose names are too numerous
8 * to list here. Please refer to the COPYRIGHT file distributed with this
9 * source distribution.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26 #include "internal.h"
27 #include "gtkgaim.h"
28
29 #include "imgstore.h"
30 #include "notify.h"
31 #include "request.h"
32 #include "gaimstock.h"
33 #include "util.h"
34
35 #include "gtkdialogs.h"
36 #include "gtkimhtmltoolbar.h"
37 #include "gtkthemes.h"
38 #include "gtkutils.h"
39
40 static GtkHBoxClass *parent_class = NULL;
41
42 static void toggle_button_set_active_block(GtkToggleButton *button,
43 gboolean is_active,
44 GtkIMHtmlToolbar *toolbar);
45
46
47 static void do_bold(GtkWidget *bold, GtkIMHtmlToolbar *toolbar)
48 {
49 g_return_if_fail(toolbar != NULL);
50 gtk_imhtml_toggle_bold(GTK_IMHTML(toolbar->imhtml));
51 gtk_widget_grab_focus(toolbar->imhtml);
52 }
53
54 static void
55 do_italic(GtkWidget *italic, GtkIMHtmlToolbar *toolbar)
56 {
57 g_return_if_fail(toolbar != NULL);
58 gtk_imhtml_toggle_italic(GTK_IMHTML(toolbar->imhtml));
59 gtk_widget_grab_focus(toolbar->imhtml);
60 }
61
62 static void
63 do_underline(GtkWidget *underline, GtkIMHtmlToolbar *toolbar)
64 {
65 g_return_if_fail(toolbar != NULL);
66 gtk_imhtml_toggle_underline(GTK_IMHTML(toolbar->imhtml));
67 gtk_widget_grab_focus(toolbar->imhtml);
68 }
69
70 static void
71 do_small(GtkWidget *smalltb, GtkIMHtmlToolbar *toolbar)
72 {
73 g_return_if_fail(toolbar != NULL);
74 gtk_imhtml_font_shrink(GTK_IMHTML(toolbar->imhtml));
75 gtk_widget_grab_focus(toolbar->imhtml);
76 }
77
78 static void
79 do_big(GtkWidget *large, GtkIMHtmlToolbar *toolbar)
80 {
81 g_return_if_fail(toolbar);
82 gtk_imhtml_font_grow(GTK_IMHTML(toolbar->imhtml));
83 gtk_widget_grab_focus(toolbar->imhtml);
84 }
85
86 static void
87 destroy_toolbar_font(GtkWidget *widget, GdkEvent *event,
88 GtkIMHtmlToolbar *toolbar)
89 {
90 if (widget != NULL)
91 gtk_imhtml_toggle_fontface(GTK_IMHTML(toolbar->imhtml), "");
92
93 if (toolbar->font_dialog != NULL)
94 {
95 gtk_widget_destroy(toolbar->font_dialog);
96 toolbar->font_dialog = NULL;
97 }
98 }
99
100 static void
101 realize_toolbar_font(GtkWidget *widget, GtkIMHtmlToolbar *toolbar)
102 {
103 GtkFontSelection *sel;
104
105 sel = GTK_FONT_SELECTION(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog)->fontsel);
106 gtk_widget_hide_all(gtk_widget_get_parent(sel->size_entry));
107 gtk_widget_show_all(sel->family_list);
108 gtk_widget_show(gtk_widget_get_parent(sel->family_list));
109 gtk_widget_show(gtk_widget_get_parent(gtk_widget_get_parent(sel->family_list)));
110 }
111
112 static void
113 cancel_toolbar_font(GtkWidget *widget, GtkIMHtmlToolbar *toolbar)
114 {
115 destroy_toolbar_font(widget, NULL, toolbar);
116 }
117
118 static void apply_font(GtkWidget *widget, GtkFontSelection *fontsel)
119 {
120 /* this could be expanded to include font size, weight, etc.
121 but for now only works with font face */
122 char *fontname;
123 char *space;
124 GtkIMHtmlToolbar *toolbar = g_object_get_data(G_OBJECT(fontsel), "gaim_toolbar");
125
126 fontname = gtk_font_selection_dialog_get_font_name(GTK_FONT_SELECTION_DIALOG(fontsel));
127
128 space = strrchr(fontname, ' ');
129 if(space && isdigit(*(space+1)))
130 *space = '\0';
131
132 gtk_imhtml_toggle_fontface(GTK_IMHTML(toolbar->imhtml), fontname);
133 g_free(fontname);
134
135 cancel_toolbar_font(NULL, toolbar);
136 }
137
138 static void
139 toggle_font(GtkWidget *font, GtkIMHtmlToolbar *toolbar)
140 {
141 g_return_if_fail(toolbar);
142
143 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(font))) {
144 char *fontname = gtk_imhtml_get_current_fontface(GTK_IMHTML(toolbar->imhtml));
145
146 if (!toolbar->font_dialog) {
147 toolbar->font_dialog = gtk_font_selection_dialog_new(_("Select Font"));
148
149 g_object_set_data(G_OBJECT(toolbar->font_dialog), "gaim_toolbar", toolbar);
150
151 if(fontname) {
152 char *fonttif = g_strdup_printf("%s 12", fontname);
153 g_free(fontname);
154 gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog),
155 fonttif);
156 g_free(fonttif);
157 } else {
158 gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog),
159 DEFAULT_FONT_FACE);
160 }
161
162 g_signal_connect(G_OBJECT(toolbar->font_dialog), "delete_event",
163 G_CALLBACK(destroy_toolbar_font), toolbar);
164 g_signal_connect(G_OBJECT(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog)->ok_button), "clicked",
165 G_CALLBACK(apply_font), toolbar->font_dialog);
166 g_signal_connect(G_OBJECT(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog)->cancel_button), "clicked",
167 G_CALLBACK(cancel_toolbar_font), toolbar);
168 g_signal_connect_after(G_OBJECT(toolbar->font_dialog), "realize",
169 G_CALLBACK(realize_toolbar_font), toolbar);
170 }
171 gtk_window_present(GTK_WINDOW(toolbar->font_dialog));
172 } else {
173 cancel_toolbar_font(font, toolbar);
174 }
175 gtk_widget_grab_focus(toolbar->imhtml);
176 }
177
178 static void
179 destroy_toolbar_fgcolor(GtkWidget *widget, GdkEvent *event,
180 GtkIMHtmlToolbar *toolbar)
181 {
182 if (widget != NULL)
183 gtk_imhtml_toggle_forecolor(GTK_IMHTML(toolbar->imhtml), "");
184
185 if (toolbar->fgcolor_dialog != NULL)
186 {
187 gtk_widget_destroy(toolbar->fgcolor_dialog);
188 toolbar->fgcolor_dialog = NULL;
189 }
190 }
191
192 static void cancel_toolbar_fgcolor(GtkWidget *widget,
193 GtkIMHtmlToolbar *toolbar)
194 {
195 destroy_toolbar_fgcolor(widget, NULL, toolbar);
196 }
197
198 static void do_fgcolor(GtkWidget *widget, GtkColorSelection *colorsel)
199 {
200 GdkColor text_color;
201 GtkIMHtmlToolbar *toolbar = g_object_get_data(G_OBJECT(colorsel), "gaim_toolbar");
202 char *open_tag;
203
204 open_tag = g_malloc(30);
205 gtk_color_selection_get_current_color(colorsel, &text_color);
206 g_snprintf(open_tag, 23, "#%02X%02X%02X",
207 text_color.red / 256,
208 text_color.green / 256,
209 text_color.blue / 256);
210 gtk_imhtml_toggle_forecolor(GTK_IMHTML(toolbar->imhtml), open_tag);
211 g_free(open_tag);
212
213 cancel_toolbar_fgcolor(NULL, toolbar);
214 }
215
216 static void
217 toggle_fg_color(GtkWidget *color, GtkIMHtmlToolbar *toolbar)
218 {
219 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) {
220 GtkWidget *colorsel;
221 GdkColor fgcolor;
222 char *color = gtk_imhtml_get_current_forecolor(GTK_IMHTML(toolbar->imhtml));
223
224 if (!toolbar->fgcolor_dialog) {
225
226 toolbar->fgcolor_dialog = gtk_color_selection_dialog_new(_("Select Text Color"));
227 colorsel = GTK_COLOR_SELECTION_DIALOG(toolbar->fgcolor_dialog)->colorsel;
228 if (color) {
229 gdk_color_parse(color, &fgcolor);
230 gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &fgcolor);
231 g_free(color);
232 }
233
234 g_object_set_data(G_OBJECT(colorsel), "gaim_toolbar", toolbar);
235
236 g_signal_connect(G_OBJECT(toolbar->fgcolor_dialog), "delete_event",
237 G_CALLBACK(destroy_toolbar_fgcolor), toolbar);
238 g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(toolbar->fgcolor_dialog)->ok_button), "clicked",
239 G_CALLBACK(do_fgcolor), colorsel);
240 g_signal_connect(G_OBJECT (GTK_COLOR_SELECTION_DIALOG(toolbar->fgcolor_dialog)->cancel_button), "clicked",
241 G_CALLBACK(cancel_toolbar_fgcolor), toolbar);
242 }
243 gtk_window_present(GTK_WINDOW(toolbar->fgcolor_dialog));
244 } else {
245 cancel_toolbar_fgcolor(color, toolbar);
246 }
247 gtk_widget_grab_focus(toolbar->imhtml);
248 }
249
250 static void
251 destroy_toolbar_bgcolor(GtkWidget *widget, GdkEvent *event,
252 GtkIMHtmlToolbar *toolbar)
253 {
254 if (widget != NULL) {
255 if (gtk_text_buffer_get_selection_bounds(GTK_IMHTML(toolbar->imhtml)->text_buffer, NULL, NULL))
256 gtk_imhtml_toggle_backcolor(GTK_IMHTML(toolbar->imhtml), "");
257 else
258 gtk_imhtml_toggle_background(GTK_IMHTML(toolbar->imhtml), "");
259 }
260
261 if (toolbar->bgcolor_dialog != NULL)
262 {
263 gtk_widget_destroy(toolbar->bgcolor_dialog);
264 toolbar->bgcolor_dialog = NULL;
265 }
266 }
267
268 static void
269 cancel_toolbar_bgcolor(GtkWidget *widget, GtkIMHtmlToolbar *toolbar)
270 {
271 destroy_toolbar_bgcolor(widget, NULL, toolbar);
272 }
273
274 static void do_bgcolor(GtkWidget *widget, GtkColorSelection *colorsel)
275 {
276 GdkColor text_color;
277 GtkIMHtmlToolbar *toolbar = g_object_get_data(G_OBJECT(colorsel), "gaim_toolbar");
278 char *open_tag;
279
280 open_tag = g_malloc(30);
281 gtk_color_selection_get_current_color(colorsel, &text_color);
282 g_snprintf(open_tag, 23, "#%02X%02X%02X",
283 text_color.red / 256,
284 text_color.green / 256,
285 text_color.blue / 256);
286 if (gtk_text_buffer_get_selection_bounds(GTK_IMHTML(toolbar->imhtml)->text_buffer, NULL, NULL))
287 gtk_imhtml_toggle_backcolor(GTK_IMHTML(toolbar->imhtml), open_tag);
288 else
289 gtk_imhtml_toggle_background(GTK_IMHTML(toolbar->imhtml), open_tag);
290 g_free(open_tag);
291
292 cancel_toolbar_bgcolor(NULL, toolbar);
293 }
294
295 static void
296 toggle_bg_color(GtkWidget *color, GtkIMHtmlToolbar *toolbar)
297 {
298 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) {
299 GtkWidget *colorsel;
300 GdkColor bgcolor;
301 char *color = gtk_imhtml_get_current_backcolor(GTK_IMHTML(toolbar->imhtml));
302
303 if (!toolbar->bgcolor_dialog) {
304
305 toolbar->bgcolor_dialog = gtk_color_selection_dialog_new(_("Select Background Color"));
306 colorsel = GTK_COLOR_SELECTION_DIALOG(toolbar->bgcolor_dialog)->colorsel;
307 if (color) {
308 gdk_color_parse(color, &bgcolor);
309 gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &bgcolor);
310 g_free(color);
311 }
312
313 g_object_set_data(G_OBJECT(colorsel), "gaim_toolbar", toolbar);
314
315 g_signal_connect(G_OBJECT(toolbar->bgcolor_dialog), "delete_event",
316 G_CALLBACK(destroy_toolbar_bgcolor), toolbar);
317 g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(toolbar->bgcolor_dialog)->ok_button), "clicked",
318 G_CALLBACK(do_bgcolor), colorsel);
319 g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(toolbar->bgcolor_dialog)->cancel_button), "clicked",
320 G_CALLBACK(cancel_toolbar_bgcolor), toolbar);
321
322 }
323 gtk_window_present(GTK_WINDOW(toolbar->bgcolor_dialog));
324 } else {
325 cancel_toolbar_bgcolor(color, toolbar);
326 }
327 gtk_widget_grab_focus(toolbar->imhtml);
328 }
329
330 static void
331 clear_formatting_cb(GtkWidget *clear, GtkIMHtmlToolbar *toolbar)
332 {
333 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->clear), FALSE, toolbar);
334 gtk_imhtml_clear_formatting(GTK_IMHTML(toolbar->imhtml));
335 }
336
337 static void
338 cancel_link_cb(GtkIMHtmlToolbar *toolbar, GaimRequestFields *fields)
339 {
340 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->link), FALSE);
341
342 toolbar->link_dialog = NULL;
343 }
344
345 static void
346 close_link_dialog(GtkIMHtmlToolbar *toolbar)
347 {
348 if (toolbar->link_dialog != NULL)
349 {
350 gaim_request_close(GAIM_REQUEST_FIELDS, toolbar->link_dialog);
351 toolbar->link_dialog = NULL;
352 }
353 }
354
355 static void
356 do_insert_link_cb(GtkIMHtmlToolbar *toolbar, GaimRequestFields *fields)
357 {
358 const char *url, *description;
359
360 url = gaim_request_fields_get_string(fields, "url");
361 if (GTK_IMHTML(toolbar->imhtml)->format_functions & GTK_IMHTML_LINKDESC)
362 description = gaim_request_fields_get_string(fields, "description");
363 else
364 description = NULL;
365
366 if (description == NULL)
367 description = url;
368
369 gtk_imhtml_insert_link(GTK_IMHTML(toolbar->imhtml),
370 gtk_text_buffer_get_insert(GTK_IMHTML(toolbar->imhtml)->text_buffer),
371 url, description);
372
373 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->link), FALSE);
374
375 toolbar->link_dialog = NULL;
376 }
377
378 static void
379 insert_link_cb(GtkWidget *w, GtkIMHtmlToolbar *toolbar)
380 {
381 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->link))) {
382 GaimRequestFields *fields;
383 GaimRequestFieldGroup *group;
384 GaimRequestField *field;
385 GtkTextIter start, end;
386 char *msg;
387 char *desc = NULL;
388
389 fields = gaim_request_fields_new();
390
391 group = gaim_request_field_group_new(NULL);
392 gaim_request_fields_add_group(fields, group);
393
394 field = gaim_request_field_string_new("url", _("_URL"), NULL, FALSE);
395 gaim_request_field_set_required(field, TRUE);
396 gaim_request_field_group_add_field(group, field);
397
398 if(GTK_IMHTML(toolbar->imhtml)->format_functions & GTK_IMHTML_LINKDESC) {
399 if (gtk_text_buffer_get_selection_bounds(GTK_IMHTML(toolbar->imhtml)->text_buffer, &start, &end)) {
400 desc = gtk_imhtml_get_text(GTK_IMHTML(toolbar->imhtml), &start, &end);
401 }
402 field = gaim_request_field_string_new("description", _("_Description"),
403 desc, FALSE);
404 gaim_request_field_group_add_field(group, field);
405 msg = g_strdup(_("Please enter the URL and description of the "
406 "link that you want to insert. The description "
407 "is optional."));
408 } else {
409 msg = g_strdup(_("Please enter the URL of the "
410 "link that you want to insert."));
411 }
412
413 toolbar->link_dialog =
414 gaim_request_fields(toolbar, _("Insert Link"),
415 NULL,
416 msg,
417 fields,
418 _("_Insert"), G_CALLBACK(do_insert_link_cb),
419 _("Cancel"), G_CALLBACK(cancel_link_cb),
420 toolbar);
421 g_free(msg);
422 g_free(desc);
423 } else {
424 close_link_dialog(toolbar);
425 }
426 gtk_widget_grab_focus(toolbar->imhtml);
427 }
428
429
430 static void
431 do_insert_image_cb(GtkWidget *widget, int response, GtkIMHtmlToolbar *toolbar)
432 {
433 gchar *filename, *name, *buf;
434 char *filedata;
435 size_t size;
436 GError *error = NULL;
437 int id;
438 GtkTextIter iter;
439 GtkTextMark *ins;
440
441 #if GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
442 if (response != GTK_RESPONSE_ACCEPT) {
443 #else /* FILECHOOSER */
444 if (response != GTK_RESPONSE_OK) {
445 #endif /* FILECHOOSER */
446 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
447 return;
448 }
449
450 #if GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
451 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));
452 #else /* FILECHOOSER */
453 filename = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION(widget)));
454 #endif /* FILECHOOSER */
455
456 if (filename == NULL) {
457 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
458 return;
459 }
460
461 #if !GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
462 if (gaim_gtk_check_if_dir(filename, GTK_FILE_SELECTION(widget))) {
463 g_free(filename);
464 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
465 return;
466 }
467 #endif /* FILECHOOSER */
468
469 /* The following triggers a callback that closes the widget */
470 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
471
472 if (!g_file_get_contents(filename, &filedata, &size, &error)) {
473 gaim_notify_error(NULL, NULL, error->message, NULL);
474
475 g_error_free(error);
476 g_free(filename);
477
478 return;
479 }
480
481 name = strrchr(filename, G_DIR_SEPARATOR) + 1;
482
483 id = gaim_imgstore_add(filedata, size, name);
484 g_free(filedata);
485
486 if (id == 0) {
487 buf = g_strdup_printf(_("Failed to store image: %s\n"), filename);
488 gaim_notify_error(NULL, NULL, buf, NULL);
489
490 g_free(buf);
491 g_free(filename);
492
493 return;
494 }
495
496 g_free(filename);
497
498 ins = gtk_text_buffer_get_insert(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->imhtml)));
499 gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->imhtml)),
500 &iter, ins);
501 gtk_imhtml_insert_image_at_iter(GTK_IMHTML(toolbar->imhtml), id, &iter);
502 gaim_imgstore_unref(id);
503 }
504
505
506 static void
507 insert_image_cb(GtkWidget *save, GtkIMHtmlToolbar *toolbar)
508 {
509 GtkWidget *window;
510
511 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->image))) {
512 #if GTK_CHECK_VERSION(2,4,0) /* FILECHOOSER */
513 window = gtk_file_chooser_dialog_new(_("Insert Image"),
514 NULL,
515 GTK_FILE_CHOOSER_ACTION_OPEN,
516 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
517 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
518 NULL);
519 gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT);
520 g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(window)),
521 "response", G_CALLBACK(do_insert_image_cb), toolbar);
522 #else /* FILECHOOSER */
523 window = gtk_file_selection_new(_("Insert Image"));
524 gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_OK);
525 g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(window)),
526 "response", G_CALLBACK(do_insert_image_cb), toolbar);
527 #endif /* FILECHOOSER */
528
529 gtk_widget_show(window);
530 toolbar->image_dialog = window;
531 } else {
532 gtk_widget_destroy(toolbar->image_dialog);
533 toolbar->image_dialog = NULL;
534 }
535
536 gtk_widget_grab_focus(toolbar->imhtml);
537 }
538
539
540 static void
541 destroy_smiley_dialog(GtkIMHtmlToolbar *toolbar)
542 {
543 if (toolbar->smiley_dialog != NULL)
544 {
545 gtk_widget_destroy(toolbar->smiley_dialog);
546 toolbar->smiley_dialog = NULL;
547 }
548 }
549
550 static void
551 close_smiley_dialog(GtkWidget *widget, GdkEvent *event,
552 GtkIMHtmlToolbar *toolbar)
553 {
554 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->smiley), FALSE);
555 }
556
557
558 static void
559 insert_smiley_text(GtkWidget *widget, GtkIMHtmlToolbar *toolbar)
560 {
561 char *smiley_text, *escaped_smiley;
562
563 smiley_text = g_object_get_data(G_OBJECT(widget), "smiley_text");
564 escaped_smiley = g_markup_escape_text(smiley_text, -1);
565
566 gtk_imhtml_insert_smiley(GTK_IMHTML(toolbar->imhtml),
567 GTK_IMHTML(toolbar->imhtml)->protocol_name,
568 escaped_smiley);
569
570 g_free(escaped_smiley);
571
572 close_smiley_dialog(NULL, NULL, toolbar);
573 }
574
575 /* smiley buttons list */
576 struct smiley_button_list {
577 int width, height;
578 GtkWidget *button;
579 struct smiley_button_list *next;
580 };
581
582 static struct smiley_button_list *
583 sort_smileys(struct smiley_button_list *ls, GtkIMHtmlToolbar *toolbar, int *width, char *filename, char *face)
584 {
585 GtkWidget *image;
586 GtkWidget *button;
587 GtkRequisition size;
588 struct smiley_button_list *cur;
589 struct smiley_button_list *it, *it_last;
590
591 cur = malloc(sizeof(struct smiley_button_list));
592 it = ls;
593 it_last = ls; /* list iterators*/
594 image = gtk_image_new_from_file(filename);
595
596 gtk_widget_size_request(image, &size);
597 (*width) += size.width;
598
599 button = gtk_button_new();
600 gtk_container_add(GTK_CONTAINER(button), image);
601
602 g_object_set_data(G_OBJECT(button), "smiley_text", face);
603 g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(insert_smiley_text), toolbar);
604
605 gtk_tooltips_set_tip(toolbar->tooltips, button, face, NULL);
606
607 /* these look really weird with borders */
608 gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
609
610 /* set current element to add */
611 cur->height = size.height;
612 cur->width = size.width;
613 cur->button = button;
614 cur->next = ls;
615
616 /* check where to insert by height */
617 if (ls == NULL)
618 return cur;
619 while (it != NULL) {
620 it_last = it;
621 it = it->next;
622 }
623 cur->next = it;
624 it_last->next = cur;
625 return ls;
626 }
627
628
629 static gboolean
630 smiley_is_unique(GSList *list, GtkIMHtmlSmiley *smiley)
631 {
632 while (list) {
633 GtkIMHtmlSmiley *cur = list->data;
634 if (!strcmp(cur->file, smiley->file))
635 return FALSE;
636 list = list->next;
637 }
638 return TRUE;
639 }
640
641
642 static void
643 insert_smiley_cb(GtkWidget *smiley, GtkIMHtmlToolbar *toolbar)
644 {
645 GtkWidget *dialog;
646 GtkWidget *smiley_table = NULL;
647 GSList *smileys, *unique_smileys = NULL;
648
649 if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(smiley))) {
650 destroy_smiley_dialog(toolbar);
651 gtk_widget_grab_focus(toolbar->imhtml);
652 return;
653 }
654
655 if (toolbar->sml)
656 smileys = gaim_gtkthemes_get_proto_smileys(toolbar->sml);
657 else
658 smileys = gaim_gtkthemes_get_proto_smileys(NULL);
659
660 while(smileys) {
661 GtkIMHtmlSmiley *smiley = smileys->data;
662 if(!smiley->hidden) {
663 if(smiley_is_unique(unique_smileys, smiley))
664 unique_smileys = g_slist_append(unique_smileys, smiley);
665 }
666 smileys = smileys->next;
667 }
668
669 GAIM_DIALOG(dialog);
670
671 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
672 gtk_window_set_role(GTK_WINDOW(dialog), "smiley_dialog");
673 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
674
675 if (g_slist_length(unique_smileys)) {
676 struct smiley_button_list *ls, *it, *it_tmp;
677 GtkWidget *line;
678 int line_width = 0;
679 int max_line_width, num_lines;
680 int col=0;
681
682 /* We use hboxes packed in a vbox */
683 ls = NULL;
684 line = gtk_hbox_new(FALSE, 0);
685 line_width = 0;
686 max_line_width = 0;
687 num_lines = floor(sqrt(g_slist_length(unique_smileys)));
688 smiley_table = gtk_vbox_new(FALSE, 0);
689
690 /* create list of smileys sorted by height */
691 while (unique_smileys) {
692 GtkIMHtmlSmiley *smiley = unique_smileys->data;
693 if (!smiley->hidden) {
694 fflush(stdout);
695 ls = sort_smileys(ls, toolbar, &max_line_width, smiley->file, smiley->smile);
696 }
697 unique_smileys = unique_smileys->next;
698 }
699 /* pack buttons of the list */
700 max_line_width = max_line_width / num_lines;
701 it = ls;
702 while (it != NULL)
703 {
704 it_tmp = it;
705 gtk_box_pack_start(GTK_BOX(line), it->button, TRUE, TRUE, 0);
706 gtk_widget_show(it->button);
707 line_width += it->width;
708 if (line_width >= max_line_width) {
709 gtk_box_pack_start(GTK_BOX(smiley_table), line, FALSE, TRUE, 0);
710 line = gtk_hbox_new(FALSE, 0);
711 line_width = 0;
712 col = 0;
713 }
714 col++;
715 it = it->next;
716 free(it_tmp);
717 }
718 gtk_box_pack_start(GTK_BOX(smiley_table), line, FALSE, TRUE, 0);
719 }
720 else {
721 smiley_table = gtk_label_new(_("This theme has no available smileys."));
722 }
723
724 gtk_container_add(GTK_CONTAINER(dialog), smiley_table);
725
726 gtk_widget_show(smiley_table);
727
728 gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
729
730 /* connect signals */
731 g_signal_connect(G_OBJECT(dialog), "delete_event",
732 G_CALLBACK(close_smiley_dialog), toolbar);
733
734 /* show everything */
735 gtk_window_set_title(GTK_WINDOW(dialog), _("Smile!"));
736 gtk_widget_show_all(dialog);
737
738 toolbar->smiley_dialog = dialog;
739
740 gtk_widget_grab_focus(toolbar->imhtml);
741 }
742
743 static void update_buttons_cb(GtkIMHtml *imhtml, GtkIMHtmlButtons buttons, GtkIMHtmlToolbar *toolbar)
744 {
745 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->bold), buttons & GTK_IMHTML_BOLD);
746 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->italic), buttons & GTK_IMHTML_ITALIC);
747 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->underline), buttons & GTK_IMHTML_UNDERLINE);
748
749 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->larger_size), buttons & GTK_IMHTML_GROW);
750 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->smaller_size), buttons & GTK_IMHTML_SHRINK);
751
752 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->font), buttons & GTK_IMHTML_FACE);
753 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->fgcolor), buttons & GTK_IMHTML_FORECOLOR);
754 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->bgcolor), buttons & GTK_IMHTML_BACKCOLOR);
755
756 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->clear),
757 (buttons & GTK_IMHTML_BOLD ||
758 buttons & GTK_IMHTML_ITALIC ||
759 buttons & GTK_IMHTML_UNDERLINE ||
760 buttons & GTK_IMHTML_GROW ||
761 buttons & GTK_IMHTML_SHRINK ||
762 buttons & GTK_IMHTML_FACE ||
763 buttons & GTK_IMHTML_FORECOLOR ||
764 buttons & GTK_IMHTML_BACKCOLOR));
765
766 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->image), buttons & GTK_IMHTML_IMAGE);
767 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->link), buttons & GTK_IMHTML_LINK);
768 gtk_widget_set_sensitive(GTK_WIDGET(toolbar->smiley), buttons & GTK_IMHTML_SMILEY);
769 }
770
771 /* we call this when we want to _set_active the toggle button, it'll
772 * block the callback thats connected to the button so we don't have to
773 * do the double toggling hack
774 */
775 static void toggle_button_set_active_block(GtkToggleButton *button,
776 gboolean is_active,
777 GtkIMHtmlToolbar *toolbar)
778 {
779 GObject *object;
780 g_return_if_fail(toolbar);
781
782 object = g_object_ref(button);
783 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA,
784 0, 0, NULL, NULL, toolbar);
785 gtk_toggle_button_set_active(button, is_active);
786 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA,
787 0, 0, NULL, NULL, toolbar);
788 g_object_unref(object);
789 }
790
791 static void update_buttons(GtkIMHtmlToolbar *toolbar) {
792 gboolean bold, italic, underline;
793 char *tmp;
794 char *tmp2;
795
796 gtk_imhtml_get_current_format(GTK_IMHTML(toolbar->imhtml),
797 &bold, &italic, &underline);
798
799 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->bold)) != bold)
800 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->bold), bold,
801 toolbar);
802
803 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->italic)) != italic)
804 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->italic), italic,
805 toolbar);
806
807 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->underline)) != underline)
808 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->underline),
809 underline, toolbar);
810
811 /* These buttons aren't ever "active". */
812 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->smaller_size), FALSE);
813 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->larger_size), FALSE);
814
815 tmp = gtk_imhtml_get_current_fontface(GTK_IMHTML(toolbar->imhtml));
816 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->font),
817 (tmp != NULL), toolbar);
818 g_free(tmp);
819
820 tmp = gtk_imhtml_get_current_forecolor(GTK_IMHTML(toolbar->imhtml));
821 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->fgcolor),
822 (tmp != NULL), toolbar);
823 g_free(tmp);
824
825 tmp = gtk_imhtml_get_current_backcolor(GTK_IMHTML(toolbar->imhtml));
826 tmp2 = gtk_imhtml_get_current_background(GTK_IMHTML(toolbar->imhtml));
827 toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->bgcolor),
828 (tmp != NULL || tmp2 != NULL), toolbar);
829 g_free(tmp);
830 g_free(tmp2);
831 }
832
833 static void toggle_button_cb(GtkIMHtml *imhtml, GtkIMHtmlButtons buttons, GtkIMHtmlToolbar *toolbar)
834 {
835 update_buttons(toolbar);
836 }
837
838 static void update_format_cb(GtkIMHtml *imhtml, GtkIMHtmlToolbar *toolbar) {
839 update_buttons(toolbar);
840 }
841
842 static void mark_set_cb(GtkTextBuffer *buffer, GtkTextIter *location,
843 GtkTextMark *mark, GtkIMHtmlToolbar *toolbar)
844 {
845 if(mark != gtk_text_buffer_get_insert(buffer))
846 return;
847
848 update_buttons(toolbar);
849 }
850
851 enum {
852 LAST_SIGNAL
853 };
854 /* static guint signals [LAST_SIGNAL] = { 0 }; */
855
856 static void
857 gtk_imhtmltoolbar_finalize (GObject *object)
858 {
859 GtkIMHtmlToolbar *toolbar = GTK_IMHTMLTOOLBAR(object);
860
861 if (toolbar->image_dialog != NULL)
862 {
863 gtk_widget_destroy(toolbar->image_dialog);
864 toolbar->image_dialog = NULL;
865 }
866
867 destroy_toolbar_font(NULL, NULL, toolbar);
868 destroy_smiley_dialog(toolbar);
869 destroy_toolbar_bgcolor(NULL, NULL, toolbar);
870 destroy_toolbar_fgcolor(NULL, NULL, toolbar);
871 close_link_dialog(toolbar);
872 if (toolbar->imhtml) {
873 g_signal_handlers_disconnect_matched(toolbar->imhtml,
874 G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
875 toolbar);
876 g_signal_handlers_disconnect_matched(GTK_IMHTML(toolbar->imhtml)->text_buffer,
877 G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
878 toolbar);
879 }
880
881 free(toolbar->sml);
882 gtk_object_sink(GTK_OBJECT(toolbar->tooltips));
883
884 G_OBJECT_CLASS(parent_class)->finalize (object);
885 }
886
887 /* Boring GTK+ stuff */
888 static void gtk_imhtmltoolbar_class_init (GtkIMHtmlToolbarClass *class)
889 {
890 GtkObjectClass *object_class;
891 GObjectClass *gobject_class;
892 object_class = (GtkObjectClass*) class;
893 gobject_class = (GObjectClass*) class;
894 parent_class = gtk_type_class(GTK_TYPE_HBOX);
895 gobject_class->finalize = gtk_imhtmltoolbar_finalize;
896 }
897
898 static void gtk_imhtmltoolbar_init (GtkIMHtmlToolbar *toolbar)
899 {
900 GtkWidget *hbox = GTK_WIDGET(toolbar);
901 GtkWidget *button;
902 GtkWidget *sep;
903 GtkSizeGroup *sg;
904
905 toolbar->imhtml = NULL;
906 toolbar->font_dialog = NULL;
907 toolbar->fgcolor_dialog = NULL;
908 toolbar->bgcolor_dialog = NULL;
909 toolbar->link_dialog = NULL;
910 toolbar->smiley_dialog = NULL;
911 toolbar->image_dialog = NULL;
912
913 toolbar->tooltips = gtk_tooltips_new();
914
915 gtk_box_set_spacing(GTK_BOX(toolbar), GAIM_HIG_BOX_SPACE);
916 sg = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
917
918 /* Bold */
919 button = gaim_pixbuf_toolbar_button_from_stock(GTK_STOCK_BOLD);
920 gtk_size_group_add_widget(sg, button);
921 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
922 gtk_tooltips_set_tip(toolbar->tooltips, button, _("Bold"), NULL);
923
924 g_signal_connect(G_OBJECT(button), "clicked",
925 G_CALLBACK(do_bold), toolbar);
926
927 toolbar->bold = button;
928
929 /* Italic */
930 button = gaim_pixbuf_toolbar_button_from_stock(GTK_STOCK_ITALIC);
931 gtk_size_group_add_widget(sg, button);
932 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
933 gtk_tooltips_set_tip(toolbar->tooltips, button, _("Italic"), NULL);
934
935 g_signal_connect(G_OBJECT(button), "clicked",
936 G_CALLBACK(do_italic), toolbar);
937
938 toolbar->italic = button;
939
940 /* Underline */
941 button = gaim_pixbuf_toolbar_button_from_stock(GTK_STOCK_UNDERLINE);
942 gtk_size_group_add_widget(sg, button);
943 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
944 gtk_tooltips_set_tip(toolbar->tooltips, button, _("Underline"), NULL);
945
946 g_signal_connect(G_OBJECT(button), "clicked",
947 G_CALLBACK(do_underline), toolbar);
948
949 toolbar->underline = button;
950
951 /* Sep */
952 sep = gtk_vseparator_new();
953 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
954
955 /* Increase font size */
956 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_TEXT_BIGGER);
957 gtk_size_group_add_widget(sg, button);
958 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
959 gtk_tooltips_set_tip(toolbar->tooltips, button,
960 _("Larger font size"), NULL);
961
962 g_signal_connect(G_OBJECT(button), "clicked",
963 G_CALLBACK(do_big), toolbar);
964
965 toolbar->larger_size = button;
966
967 /* Decrease font size */
968 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_TEXT_SMALLER);
969 gtk_size_group_add_widget(sg, button);
970 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
971 gtk_tooltips_set_tip(toolbar->tooltips, button,
972 _("Smaller font size"), NULL);
973
974 g_signal_connect(G_OBJECT(button), "clicked",
975 G_CALLBACK(do_small), toolbar);
976
977 toolbar->smaller_size = button;
978
979 /* Sep */
980 sep = gtk_vseparator_new();
981 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
982
983 /* Font Face */
984
985 button = gaim_pixbuf_toolbar_button_from_stock(GTK_STOCK_SELECT_FONT);
986 gtk_size_group_add_widget(sg, button);
987 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
988 gtk_tooltips_set_tip(toolbar->tooltips, button,
989 _("Font face"), NULL);
990
991 g_signal_connect(G_OBJECT(button), "clicked",
992 G_CALLBACK(toggle_font), toolbar);
993
994 toolbar->font = button;
995
996 /* Foreground Color */
997 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_FGCOLOR);
998 gtk_size_group_add_widget(sg, button);
999 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
1000 gtk_tooltips_set_tip(toolbar->tooltips, button,
1001 _("Foreground font color"), NULL);
1002
1003 g_signal_connect(G_OBJECT(button), "clicked",
1004 G_CALLBACK(toggle_fg_color), toolbar);
1005
1006 toolbar->fgcolor = button;
1007
1008 /* Background Color */
1009 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_BGCOLOR);
1010 gtk_size_group_add_widget(sg, button);
1011 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
1012 gtk_tooltips_set_tip(toolbar->tooltips, button,
1013 _("Background color"), NULL);
1014
1015 g_signal_connect(G_OBJECT(button), "clicked",
1016 G_CALLBACK(toggle_bg_color), toolbar);
1017
1018 toolbar->bgcolor = button;
1019
1020 /* Sep */
1021 sep = gtk_vseparator_new();
1022 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
1023
1024 /* Reset Formatting */
1025 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_CLEAR);
1026 gtk_size_group_add_widget(sg, button);
1027 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
1028 gtk_tooltips_set_tip(toolbar->tooltips, button,
1029 _("Reset formatting"), NULL);
1030
1031 g_signal_connect(G_OBJECT(button), "clicked",
1032 G_CALLBACK(clear_formatting_cb), toolbar);
1033
1034 toolbar->clear = button;
1035
1036 /* Sep */
1037 sep = gtk_vseparator_new();
1038 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
1039
1040 /* Insert Link */
1041 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_LINK);
1042 gtk_size_group_add_widget(sg, button);
1043 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
1044 gtk_tooltips_set_tip(toolbar->tooltips, button, _("Insert link"), NULL);
1045 g_signal_connect(G_OBJECT(button), "clicked",
1046 G_CALLBACK(insert_link_cb), toolbar);
1047
1048 toolbar->link = button;
1049
1050 /* Insert IM Image */
1051 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_IMAGE);
1052 gtk_size_group_add_widget(sg, button);
1053 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
1054 gtk_tooltips_set_tip(toolbar->tooltips, button, _("Insert image"), NULL);
1055
1056 g_signal_connect(G_OBJECT(button), "clicked",
1057 G_CALLBACK(insert_image_cb), toolbar);
1058
1059 toolbar->image = button;
1060
1061 /* Insert Smiley */
1062 button = gaim_pixbuf_toolbar_button_from_stock(GAIM_STOCK_SMILEY);
1063 gtk_size_group_add_widget(sg, button);
1064 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
1065 gtk_tooltips_set_tip(toolbar->tooltips, button, _("Insert smiley"), NULL);
1066
1067 g_signal_connect(G_OBJECT(button), "clicked",
1068 G_CALLBACK(insert_smiley_cb), toolbar);
1069
1070 toolbar->smiley = button;
1071
1072 toolbar->sml = NULL;
1073 gtk_widget_show_all(hbox);
1074 }
1075
1076 GtkWidget *gtk_imhtmltoolbar_new()
1077 {
1078 return GTK_WIDGET(g_object_new(gtk_imhtmltoolbar_get_type(), NULL));
1079 }
1080
1081 GType gtk_imhtmltoolbar_get_type()
1082 {
1083 static GType imhtmltoolbar_type = 0;
1084
1085 if (!imhtmltoolbar_type) {
1086 static const GTypeInfo imhtmltoolbar_info = {
1087 sizeof(GtkIMHtmlToolbarClass),
1088 NULL,
1089 NULL,
1090 (GClassInitFunc) gtk_imhtmltoolbar_class_init,
1091 NULL,
1092 NULL,
1093 sizeof (GtkIMHtmlToolbar),
1094 0,
1095 (GInstanceInitFunc) gtk_imhtmltoolbar_init,
1096 NULL
1097 };
1098
1099 imhtmltoolbar_type = g_type_register_static(GTK_TYPE_HBOX,
1100 "GtkIMHtmlToolbar", &imhtmltoolbar_info, 0);
1101 }
1102
1103 return imhtmltoolbar_type;
1104 }
1105
1106
1107 void gtk_imhtmltoolbar_attach(GtkIMHtmlToolbar *toolbar, GtkWidget *imhtml)
1108 {
1109 GtkIMHtmlButtons buttons;
1110 gboolean bold, italic, underline;
1111
1112 g_return_if_fail(toolbar != NULL);
1113 g_return_if_fail(GTK_IS_IMHTMLTOOLBAR(toolbar));
1114 g_return_if_fail(imhtml != NULL);
1115 g_return_if_fail(GTK_IS_IMHTML(imhtml));
1116
1117 toolbar->imhtml = imhtml;
1118 g_signal_connect(G_OBJECT(imhtml), "format_buttons_update", G_CALLBACK(update_buttons_cb), toolbar);
1119 g_signal_connect_after(G_OBJECT(imhtml), "format_function_toggle", G_CALLBACK(toggle_button_cb), toolbar);
1120 g_signal_connect_after(G_OBJECT(imhtml), "format_function_clear", G_CALLBACK(update_format_cb), toolbar);
1121 g_signal_connect(G_OBJECT(imhtml), "format_function_update", G_CALLBACK(update_format_cb), toolbar);
1122 g_signal_connect_after(G_OBJECT(GTK_IMHTML(imhtml)->text_buffer), "mark-set", G_CALLBACK(mark_set_cb), toolbar);
1123
1124 buttons = gtk_imhtml_get_format_functions(GTK_IMHTML(imhtml));
1125 update_buttons_cb(GTK_IMHTML(imhtml), buttons, toolbar);
1126
1127 gtk_imhtml_get_current_format(GTK_IMHTML(imhtml), &bold, &italic, &underline);
1128
1129 update_buttons(toolbar);
1130 }
1131
1132 void gtk_imhtmltoolbar_associate_smileys(GtkIMHtmlToolbar *toolbar, const char *proto_id)
1133 {
1134 g_free(toolbar->sml);
1135 toolbar->sml = g_strdup(proto_id);
1136 }

Mercurial Repository: pidgin3

mercurial