Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkwebview.c

pidgin/gtkwebview.c

branch
gtkdoc-conversion
changeset 35500
ae6432ea326f
parent 35454
cf2a24d01503
child 35506
4252b2882889
equal deleted inserted replaced
35499:c4c5e0a670b1 35500:ae6432ea326f
35 #include "gtk3compat.h" 35 #include "gtk3compat.h"
36 36
37 #define MAX_FONT_SIZE 7 37 #define MAX_FONT_SIZE 7
38 #define MAX_SCROLL_TIME 0.4 /* seconds */ 38 #define MAX_SCROLL_TIME 0.4 /* seconds */
39 #define SCROLL_DELAY 33 /* milliseconds */ 39 #define SCROLL_DELAY 33 /* milliseconds */
40 #define GTK_WEBVIEW_MAX_PROCESS_TIME 100000 /* microseconds */ 40 #define PIDGIN_WEBVIEW_MAX_PROCESS_TIME 100000 /* microseconds */
41 41
42 #define GTK_WEBVIEW_GET_PRIVATE(obj) \ 42 #define PIDGIN_WEBVIEW_GET_PRIVATE(obj) \
43 (G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEW, GtkWebViewPriv)) 43 (G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEW, PidginWebViewPriv))
44 44
45 enum { 45 enum {
46 LOAD_HTML, 46 LOAD_HTML,
47 LOAD_JS 47 LOAD_JS
48 }; 48 };
63 *****************************************************************************/ 63 *****************************************************************************/
64 64
65 typedef struct { 65 typedef struct {
66 WebKitWebInspector *inspector; 66 WebKitWebInspector *inspector;
67 WebKitDOMNode *node; 67 WebKitDOMNode *node;
68 } GtkWebViewInspectData; 68 } PidginWebViewInspectData;
69 69
70 typedef struct { 70 typedef struct {
71 WebKitWebView *webview; 71 WebKitWebView *webview;
72 gunichar ch; 72 gunichar ch;
73 } GtkWebViewInsertData; 73 } PidginWebViewInsertData;
74 74
75 typedef struct { 75 typedef struct {
76 const char *label; 76 const char *label;
77 gunichar ch; 77 gunichar ch;
78 } GtkUnicodeMenuEntry; 78 } GtkUnicodeMenuEntry;
79 79
80 typedef struct { 80 typedef struct {
81 char *name; 81 char *name;
82 int length; 82 int length;
83 83
84 gboolean (*activate)(GtkWebView *webview, const char *uri); 84 gboolean (*activate)(PidginWebView *webview, const char *uri);
85 gboolean (*context_menu)(GtkWebView *webview, WebKitDOMHTMLAnchorElement *link, GtkWidget *menu); 85 gboolean (*context_menu)(PidginWebView *webview, WebKitDOMHTMLAnchorElement *link, GtkWidget *menu);
86 } GtkWebViewProtocol; 86 } PidginWebViewProtocol;
87 87
88 struct _GtkWebViewSmiley { 88 struct _PidginWebViewSmiley {
89 gchar *smile; 89 gchar *smile;
90 gchar *file; 90 gchar *file;
91 GdkPixbufAnimation *icon; 91 GdkPixbufAnimation *icon;
92 gboolean hidden; 92 gboolean hidden;
93 GdkPixbufLoader *loader; 93 GdkPixbufLoader *loader;
94 GSList *anchors; 94 GSList *anchors;
95 GtkWebViewSmileyFlags flags; 95 PidginWebViewSmileyFlags flags;
96 GtkWebView *webview; 96 PidginWebView *webview;
97 gpointer data; 97 gpointer data;
98 gsize datasize; 98 gsize datasize;
99 }; 99 };
100 100
101 typedef struct _GtkSmileyTree GtkSmileyTree; 101 typedef struct _GtkSmileyTree GtkSmileyTree;
102 struct _GtkSmileyTree { 102 struct _GtkSmileyTree {
103 GString *values; 103 GString *values;
104 GtkSmileyTree **children; 104 GtkSmileyTree **children;
105 GtkWebViewSmiley *image; 105 PidginWebViewSmiley *image;
106 }; 106 };
107 107
108 typedef struct _GtkWebViewPriv { 108 typedef struct _PidginWebViewPriv {
109 /* Processing queues */ 109 /* Processing queues */
110 gboolean is_loading; 110 gboolean is_loading;
111 GQueue *load_queue; 111 GQueue *load_queue;
112 guint loader; 112 guint loader;
113 113
116 gboolean autoscroll; 116 gboolean autoscroll;
117 guint scroll_src; 117 guint scroll_src;
118 GTimer *scroll_time; 118 GTimer *scroll_time;
119 119
120 /* Format options */ 120 /* Format options */
121 GtkWebViewButtons format_functions; 121 PidginWebViewButtons format_functions;
122 GtkWebViewToolbar *toolbar; 122 PidginWebViewToolbar *toolbar;
123 struct { 123 struct {
124 gboolean wbfo:1; /* Whole buffer formatting only. */ 124 gboolean wbfo:1; /* Whole buffer formatting only. */
125 gboolean block_changed:1; 125 gboolean block_changed:1;
126 } edit; 126 } edit;
127 127
131 GtkSmileyTree *default_smilies; 131 GtkSmileyTree *default_smilies;
132 132
133 /* WebKit inspector */ 133 /* WebKit inspector */
134 WebKitWebView *inspector_view; 134 WebKitWebView *inspector_view;
135 GtkWindow *inspector_win; 135 GtkWindow *inspector_win;
136 } GtkWebViewPriv; 136 } PidginWebViewPriv;
137 137
138 /****************************************************************************** 138 /******************************************************************************
139 * Globals 139 * Globals
140 *****************************************************************************/ 140 *****************************************************************************/
141 141
144 /****************************************************************************** 144 /******************************************************************************
145 * Smileys 145 * Smileys
146 *****************************************************************************/ 146 *****************************************************************************/
147 147
148 const char * 148 const char *
149 gtk_webview_get_protocol_name(GtkWebView *webview) 149 pidgin_webview_get_protocol_name(PidginWebView *webview)
150 { 150 {
151 GtkWebViewPriv *priv; 151 PidginWebViewPriv *priv;
152 152
153 g_return_val_if_fail(webview != NULL, NULL); 153 g_return_val_if_fail(webview != NULL, NULL);
154 154
155 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 155 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
156 return priv->protocol_name; 156 return priv->protocol_name;
157 } 157 }
158 158
159 void 159 void
160 gtk_webview_set_protocol_name(GtkWebView *webview, const char *protocol_name) 160 pidgin_webview_set_protocol_name(PidginWebView *webview, const char *protocol_name)
161 { 161 {
162 GtkWebViewPriv *priv; 162 PidginWebViewPriv *priv;
163 163
164 g_return_if_fail(webview != NULL); 164 g_return_if_fail(webview != NULL);
165 165
166 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 166 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
167 priv->protocol_name = g_strdup(protocol_name); 167 priv->protocol_name = g_strdup(protocol_name);
168 } 168 }
169 169
170 static GtkSmileyTree * 170 static GtkSmileyTree *
171 gtk_smiley_tree_new(void) 171 gtk_smiley_tree_new(void)
172 { 172 {
173 return g_new0(GtkSmileyTree, 1); 173 return g_new0(GtkSmileyTree, 1);
174 } 174 }
175 175
176 static void 176 static void
177 gtk_smiley_tree_insert(GtkSmileyTree *tree, GtkWebViewSmiley *smiley) 177 gtk_smiley_tree_insert(GtkSmileyTree *tree, PidginWebViewSmiley *smiley)
178 { 178 {
179 GtkSmileyTree *t = tree; 179 GtkSmileyTree *t = tree;
180 const char *x = smiley->smile; 180 const char *x = smiley->smile;
181 181
182 if (!(*x)) 182 if (!(*x))
225 g_free(t); 225 g_free(t);
226 } 226 }
227 } 227 }
228 228
229 static void 229 static void
230 gtk_smiley_tree_remove(GtkSmileyTree *tree, GtkWebViewSmiley *smiley) 230 gtk_smiley_tree_remove(GtkSmileyTree *tree, PidginWebViewSmiley *smiley)
231 { 231 {
232 GtkSmileyTree *t = tree; 232 GtkSmileyTree *t = tree;
233 const gchar *x = smiley->smile; 233 const gchar *x = smiley->smile;
234 int len = 0; 234 int len = 0;
235 235
286 pos = strchr(t->values->str, *amp); 286 pos = strchr(t->values->str, *amp);
287 } 287 }
288 else if (*x == '<') /* Because we're all WYSIWYG now, a '<' char should 288 else if (*x == '<') /* Because we're all WYSIWYG now, a '<' char should
289 * only appear as the start of a tag. Perhaps a 289 * only appear as the start of a tag. Perhaps a
290 * safer (but costlier) check would be to call 290 * safer (but costlier) check would be to call
291 * gtk_webview_is_tag on it */ 291 * pidgin_webview_is_tag on it */
292 break; 292 break;
293 else { 293 else {
294 alen = 1; 294 alen = 1;
295 pos = strchr(t->values->str, *x); 295 pos = strchr(t->values->str, *x);
296 } 296 }
310 return 0; 310 return 0;
311 } 311 }
312 #endif 312 #endif
313 313
314 static void 314 static void
315 gtk_webview_disassociate_smiley_foreach(gpointer key, gpointer value, 315 pidgin_webview_disassociate_smiley_foreach(gpointer key, gpointer value,
316 gpointer user_data) 316 gpointer user_data)
317 { 317 {
318 GtkSmileyTree *tree = (GtkSmileyTree *)value; 318 GtkSmileyTree *tree = (GtkSmileyTree *)value;
319 GtkWebViewSmiley *smiley = (GtkWebViewSmiley *)user_data; 319 PidginWebViewSmiley *smiley = (PidginWebViewSmiley *)user_data;
320 gtk_smiley_tree_remove(tree, smiley); 320 gtk_smiley_tree_remove(tree, smiley);
321 } 321 }
322 322
323 static void 323 static void
324 gtk_webview_disconnect_smiley(GtkWebView *webview, GtkWebViewSmiley *smiley) 324 pidgin_webview_disconnect_smiley(PidginWebView *webview, PidginWebViewSmiley *smiley)
325 { 325 {
326 smiley->webview = NULL; 326 smiley->webview = NULL;
327 g_signal_handlers_disconnect_matched(webview, G_SIGNAL_MATCH_DATA, 0, 0, 327 g_signal_handlers_disconnect_matched(webview, G_SIGNAL_MATCH_DATA, 0, 0,
328 NULL, NULL, smiley); 328 NULL, NULL, smiley);
329 } 329 }
330 330
331 static void 331 static void
332 gtk_webview_disassociate_smiley(GtkWebViewSmiley *smiley) 332 pidgin_webview_disassociate_smiley(PidginWebViewSmiley *smiley)
333 { 333 {
334 if (smiley->webview) { 334 if (smiley->webview) {
335 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(smiley->webview); 335 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(smiley->webview);
336 gtk_smiley_tree_remove(priv->default_smilies, smiley); 336 gtk_smiley_tree_remove(priv->default_smilies, smiley);
337 g_hash_table_foreach(priv->smiley_data, 337 g_hash_table_foreach(priv->smiley_data,
338 gtk_webview_disassociate_smiley_foreach, smiley); 338 pidgin_webview_disassociate_smiley_foreach, smiley);
339 g_signal_handlers_disconnect_matched(smiley->webview, 339 g_signal_handlers_disconnect_matched(smiley->webview,
340 G_SIGNAL_MATCH_DATA, 0, 0, NULL, 340 G_SIGNAL_MATCH_DATA, 0, 0, NULL,
341 NULL, smiley); 341 NULL, smiley);
342 smiley->webview = NULL; 342 smiley->webview = NULL;
343 } 343 }
344 } 344 }
345 345
346 void 346 void
347 gtk_webview_associate_smiley(GtkWebView *webview, const char *sml, 347 pidgin_webview_associate_smiley(PidginWebView *webview, const char *sml,
348 GtkWebViewSmiley *smiley) 348 PidginWebViewSmiley *smiley)
349 { 349 {
350 GtkSmileyTree *tree; 350 GtkSmileyTree *tree;
351 GtkWebViewPriv *priv; 351 PidginWebViewPriv *priv;
352 352
353 g_return_if_fail(webview != NULL); 353 g_return_if_fail(webview != NULL);
354 g_return_if_fail(GTK_IS_WEBVIEW(webview)); 354 g_return_if_fail(GTK_IS_WEBVIEW(webview));
355 355
356 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 356 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
357 357
358 if (sml == NULL) 358 if (sml == NULL)
359 tree = priv->default_smilies; 359 tree = priv->default_smilies;
360 else if (!(tree = g_hash_table_lookup(priv->smiley_data, sml))) { 360 else if (!(tree = g_hash_table_lookup(priv->smiley_data, sml))) {
361 tree = gtk_smiley_tree_new(); 361 tree = gtk_smiley_tree_new();
373 373
374 gtk_smiley_tree_insert(tree, smiley); 374 gtk_smiley_tree_insert(tree, smiley);
375 375
376 /* connect destroy signal for the webview */ 376 /* connect destroy signal for the webview */
377 g_signal_connect(webview, "destroy", 377 g_signal_connect(webview, "destroy",
378 G_CALLBACK(gtk_webview_disconnect_smiley), smiley); 378 G_CALLBACK(pidgin_webview_disconnect_smiley), smiley);
379 } 379 }
380 380
381 #if 0 381 #if 0
382 static gboolean 382 static gboolean
383 gtk_webview_is_smiley(GtkWebViewPriv *priv, const char *sml, const char *text, 383 pidgin_webview_is_smiley(PidginWebViewPriv *priv, const char *sml, const char *text,
384 int *len) 384 int *len)
385 { 385 {
386 GtkSmileyTree *tree; 386 GtkSmileyTree *tree;
387 387
388 if (!sml) 388 if (!sml)
397 *len = gtk_smiley_tree_lookup(tree, text); 397 *len = gtk_smiley_tree_lookup(tree, text);
398 return (*len > 0); 398 return (*len > 0);
399 } 399 }
400 #endif 400 #endif
401 401
402 static GtkWebViewSmiley * 402 static PidginWebViewSmiley *
403 gtk_webview_smiley_get_from_tree(GtkSmileyTree *t, const char *text) 403 pidgin_webview_smiley_get_from_tree(GtkSmileyTree *t, const char *text)
404 { 404 {
405 const char *x = text; 405 const char *x = text;
406 char *pos; 406 char *pos;
407 407
408 if (t == NULL) 408 if (t == NULL)
421 } 421 }
422 422
423 return t->image; 423 return t->image;
424 } 424 }
425 425
426 GtkWebViewSmiley * 426 PidginWebViewSmiley *
427 gtk_webview_smiley_find(GtkWebView *webview, const char *sml, const char *text) 427 pidgin_webview_smiley_find(PidginWebView *webview, const char *sml, const char *text)
428 { 428 {
429 GtkWebViewPriv *priv; 429 PidginWebViewPriv *priv;
430 GtkWebViewSmiley *ret; 430 PidginWebViewSmiley *ret;
431 431
432 g_return_val_if_fail(webview != NULL, NULL); 432 g_return_val_if_fail(webview != NULL, NULL);
433 433
434 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 434 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
435 435
436 /* Look for custom smileys first */ 436 /* Look for custom smileys first */
437 if (sml != NULL) { 437 if (sml != NULL) {
438 ret = gtk_webview_smiley_get_from_tree(g_hash_table_lookup(priv->smiley_data, sml), text); 438 ret = pidgin_webview_smiley_get_from_tree(g_hash_table_lookup(priv->smiley_data, sml), text);
439 if (ret != NULL) 439 if (ret != NULL)
440 return ret; 440 return ret;
441 } 441 }
442 442
443 /* Fall back to check for default smileys */ 443 /* Fall back to check for default smileys */
444 return gtk_webview_smiley_get_from_tree(priv->default_smilies, text); 444 return pidgin_webview_smiley_get_from_tree(priv->default_smilies, text);
445 } 445 }
446 446
447 #if 0 447 #if 0
448 static GdkPixbufAnimation * 448 static GdkPixbufAnimation *
449 gtk_smiley_get_image(GtkWebViewSmiley *smiley) 449 gtk_smiley_get_image(PidginWebViewSmiley *smiley)
450 { 450 {
451 if (!smiley->icon) { 451 if (!smiley->icon) {
452 if (smiley->file) { 452 if (smiley->file) {
453 smiley->icon = gdk_pixbuf_animation_new_from_file(smiley->file, NULL); 453 smiley->icon = gdk_pixbuf_animation_new_from_file(smiley->file, NULL);
454 } else if (smiley->loader) { 454 } else if (smiley->loader) {
463 #endif 463 #endif
464 464
465 static void 465 static void
466 gtk_custom_smiley_allocated(GdkPixbufLoader *loader, gpointer user_data) 466 gtk_custom_smiley_allocated(GdkPixbufLoader *loader, gpointer user_data)
467 { 467 {
468 GtkWebViewSmiley *smiley; 468 PidginWebViewSmiley *smiley;
469 469
470 smiley = (GtkWebViewSmiley *)user_data; 470 smiley = (PidginWebViewSmiley *)user_data;
471 smiley->icon = gdk_pixbuf_loader_get_animation(loader); 471 smiley->icon = gdk_pixbuf_loader_get_animation(loader);
472 472
473 if (smiley->icon) 473 if (smiley->icon)
474 g_object_ref(G_OBJECT(smiley->icon)); 474 g_object_ref(G_OBJECT(smiley->icon));
475 } 475 }
476 476
477 static void 477 static void
478 gtk_custom_smiley_closed(GdkPixbufLoader *loader, gpointer user_data) 478 gtk_custom_smiley_closed(GdkPixbufLoader *loader, gpointer user_data)
479 { 479 {
480 GtkWebViewSmiley *smiley; 480 PidginWebViewSmiley *smiley;
481 GtkWidget *icon = NULL; 481 GtkWidget *icon = NULL;
482 GtkTextChildAnchor *anchor = NULL; 482 GtkTextChildAnchor *anchor = NULL;
483 GSList *current = NULL; 483 GSList *current = NULL;
484 484
485 smiley = (GtkWebViewSmiley *)user_data; 485 smiley = (PidginWebViewSmiley *)user_data;
486 if (!smiley->webview) { 486 if (!smiley->webview) {
487 g_object_unref(G_OBJECT(loader)); 487 g_object_unref(G_OBJECT(loader));
488 smiley->loader = NULL; 488 smiley->loader = NULL;
489 return; 489 return;
490 } 490 }
547 } 547 }
548 } 548 }
549 gdk_pixbuf_loader_set_size(loader, width, height); 549 gdk_pixbuf_loader_set_size(loader, width, height);
550 } 550 }
551 551
552 GtkWebViewSmiley * 552 PidginWebViewSmiley *
553 gtk_webview_smiley_create(const char *file, const char *shortcut, gboolean hide, 553 pidgin_webview_smiley_create(const char *file, const char *shortcut, gboolean hide,
554 GtkWebViewSmileyFlags flags) 554 PidginWebViewSmileyFlags flags)
555 { 555 {
556 GtkWebViewSmiley *smiley = g_new0(GtkWebViewSmiley, 1); 556 PidginWebViewSmiley *smiley = g_new0(PidginWebViewSmiley, 1);
557 smiley->file = g_strdup(file); 557 smiley->file = g_strdup(file);
558 smiley->smile = g_strdup(shortcut); 558 smiley->smile = g_strdup(shortcut);
559 smiley->hidden = hide; 559 smiley->hidden = hide;
560 smiley->flags = flags; 560 smiley->flags = flags;
561 smiley->webview = NULL; 561 smiley->webview = NULL;
562 gtk_webview_smiley_reload(smiley); 562 pidgin_webview_smiley_reload(smiley);
563 return smiley; 563 return smiley;
564 } 564 }
565 565
566 void 566 void
567 gtk_webview_smiley_reload(GtkWebViewSmiley *smiley) 567 pidgin_webview_smiley_reload(PidginWebViewSmiley *smiley)
568 { 568 {
569 if (smiley->icon) 569 if (smiley->icon)
570 g_object_unref(smiley->icon); 570 g_object_unref(smiley->icon);
571 if (smiley->loader) 571 if (smiley->loader)
572 g_object_unref(smiley->loader); 572 g_object_unref(smiley->loader);
590 g_signal_connect(smiley->loader, "size_prepared", 590 g_signal_connect(smiley->loader, "size_prepared",
591 G_CALLBACK(gtk_custom_smiley_size_prepared), smiley); 591 G_CALLBACK(gtk_custom_smiley_size_prepared), smiley);
592 } 592 }
593 593
594 const char * 594 const char *
595 gtk_webview_smiley_get_smile(const GtkWebViewSmiley *smiley) 595 pidgin_webview_smiley_get_smile(const PidginWebViewSmiley *smiley)
596 { 596 {
597 return smiley->smile; 597 return smiley->smile;
598 } 598 }
599 599
600 const char * 600 const char *
601 gtk_webview_smiley_get_file(const GtkWebViewSmiley *smiley) 601 pidgin_webview_smiley_get_file(const PidginWebViewSmiley *smiley)
602 { 602 {
603 return smiley->file; 603 return smiley->file;
604 } 604 }
605 605
606 gboolean 606 gboolean
607 gtk_webview_smiley_get_hidden(const GtkWebViewSmiley *smiley) 607 pidgin_webview_smiley_get_hidden(const PidginWebViewSmiley *smiley)
608 { 608 {
609 return smiley->hidden; 609 return smiley->hidden;
610 } 610 }
611 611
612 GtkWebViewSmileyFlags 612 PidginWebViewSmileyFlags
613 gtk_webview_smiley_get_flags(const GtkWebViewSmiley *smiley) 613 pidgin_webview_smiley_get_flags(const PidginWebViewSmiley *smiley)
614 { 614 {
615 return smiley->flags; 615 return smiley->flags;
616 } 616 }
617 617
618 void 618 void
619 gtk_webview_smiley_destroy(GtkWebViewSmiley *smiley) 619 pidgin_webview_smiley_destroy(PidginWebViewSmiley *smiley)
620 { 620 {
621 gtk_webview_disassociate_smiley(smiley); 621 pidgin_webview_disassociate_smiley(smiley);
622 g_free(smiley->smile); 622 g_free(smiley->smile);
623 g_free(smiley->file); 623 g_free(smiley->file);
624 if (smiley->icon) 624 if (smiley->icon)
625 g_object_unref(smiley->icon); 625 g_object_unref(smiley->icon);
626 if (smiley->loader) 626 if (smiley->loader)
628 g_free(smiley->data); 628 g_free(smiley->data);
629 g_free(smiley); 629 g_free(smiley);
630 } 630 }
631 631
632 void 632 void
633 gtk_webview_remove_smileys(GtkWebView *webview) 633 pidgin_webview_remove_smileys(PidginWebView *webview)
634 { 634 {
635 GtkWebViewPriv *priv; 635 PidginWebViewPriv *priv;
636 636
637 g_return_if_fail(webview != NULL); 637 g_return_if_fail(webview != NULL);
638 638
639 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 639 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
640 640
641 g_hash_table_destroy(priv->smiley_data); 641 g_hash_table_destroy(priv->smiley_data);
642 gtk_smiley_tree_destroy(priv->default_smilies); 642 gtk_smiley_tree_destroy(priv->default_smilies);
643 priv->smiley_data = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, 643 priv->smiley_data = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
644 (GDestroyNotify)gtk_smiley_tree_destroy); 644 (GDestroyNotify)gtk_smiley_tree_destroy);
645 priv->default_smilies = gtk_smiley_tree_new(); 645 priv->default_smilies = gtk_smiley_tree_new();
646 } 646 }
647 647
648 void 648 void
649 gtk_webview_insert_smiley(GtkWebView *webview, const char *sml, 649 pidgin_webview_insert_smiley(PidginWebView *webview, const char *sml,
650 const char *smiley) 650 const char *smiley)
651 { 651 {
652 GtkWebViewPriv *priv; 652 PidginWebViewPriv *priv;
653 char *unescaped; 653 char *unescaped;
654 GtkWebViewSmiley *webview_smiley; 654 PidginWebViewSmiley *webview_smiley;
655 655
656 g_return_if_fail(webview != NULL); 656 g_return_if_fail(webview != NULL);
657 657
658 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 658 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
659 659
660 unescaped = purple_unescape_html(smiley); 660 unescaped = purple_unescape_html(smiley);
661 webview_smiley = gtk_webview_smiley_find(webview, sml, unescaped); 661 webview_smiley = pidgin_webview_smiley_find(webview, sml, unescaped);
662 662
663 if (priv->format_functions & GTK_WEBVIEW_SMILEY) { 663 if (priv->format_functions & PIDGIN_WEBVIEW_SMILEY) {
664 char *tmp; 664 char *tmp;
665 /* TODO Better smiley insertion... */ 665 /* TODO Better smiley insertion... */
666 tmp = g_strdup_printf("<img isEmoticon src='purple-smiley:%p' alt='%s'>", 666 tmp = g_strdup_printf("<img isEmoticon src='purple-smiley:%p' alt='%s'>",
667 webview_smiley, smiley); 667 webview_smiley, smiley);
668 gtk_webview_append_html(webview, tmp); 668 pidgin_webview_append_html(webview, tmp);
669 g_free(tmp); 669 g_free(tmp);
670 } else { 670 } else {
671 gtk_webview_append_html(webview, smiley); 671 pidgin_webview_append_html(webview, smiley);
672 } 672 }
673 673
674 g_free(unescaped); 674 g_free(unescaped);
675 } 675 }
676 676
752 } 752 }
753 } 753 }
754 } 754 }
755 755
756 static void 756 static void
757 process_load_queue_element(GtkWebView *webview) 757 process_load_queue_element(PidginWebView *webview)
758 { 758 {
759 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 759 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
760 int type; 760 int type;
761 char *str; 761 char *str;
762 WebKitDOMDocument *doc; 762 WebKitDOMDocument *doc;
763 WebKitDOMHTMLElement *body; 763 WebKitDOMHTMLElement *body;
764 WebKitDOMNode *start, *end; 764 WebKitDOMNode *start, *end;
823 823
824 g_free(str); 824 g_free(str);
825 } 825 }
826 826
827 static gboolean 827 static gboolean
828 process_load_queue(GtkWebView *webview) 828 process_load_queue(PidginWebView *webview)
829 { 829 {
830 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 830 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
831 gint64 start_time; 831 gint64 start_time;
832 832
833 if (priv->is_loading) { 833 if (priv->is_loading) {
834 priv->loader = 0; 834 priv->loader = 0;
835 return FALSE; 835 return FALSE;
841 841
842 start_time = g_get_monotonic_time(); 842 start_time = g_get_monotonic_time();
843 while (!g_queue_is_empty(priv->load_queue)) { 843 while (!g_queue_is_empty(priv->load_queue)) {
844 process_load_queue_element(webview); 844 process_load_queue_element(webview);
845 if (g_get_monotonic_time() - start_time > 845 if (g_get_monotonic_time() - start_time >
846 GTK_WEBVIEW_MAX_PROCESS_TIME) 846 PIDGIN_WEBVIEW_MAX_PROCESS_TIME)
847 break; 847 break;
848 } 848 }
849 849
850 if (g_queue_is_empty(priv->load_queue)) { 850 if (g_queue_is_empty(priv->load_queue)) {
851 priv->loader = 0; 851 priv->loader = 0;
856 856
857 static void 857 static void
858 webview_load_started(WebKitWebView *webview, WebKitWebFrame *frame, 858 webview_load_started(WebKitWebView *webview, WebKitWebFrame *frame,
859 gpointer userdata) 859 gpointer userdata)
860 { 860 {
861 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 861 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
862 862
863 /* is there a better way to test for is_loading? */ 863 /* is there a better way to test for is_loading? */
864 priv->is_loading = TRUE; 864 priv->is_loading = TRUE;
865 } 865 }
866 866
867 static void 867 static void
868 webview_load_finished(WebKitWebView *webview, WebKitWebFrame *frame, 868 webview_load_finished(WebKitWebView *webview, WebKitWebFrame *frame,
869 gpointer userdata) 869 gpointer userdata)
870 { 870 {
871 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 871 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
872 872
873 priv->is_loading = FALSE; 873 priv->is_loading = FALSE;
874 if (priv->loader == 0) 874 if (priv->loader == 0)
875 priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview); 875 priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview);
876 } 876 }
877 877
878 static void 878 static void
879 webview_inspector_inspect_element(GtkWidget *item, GtkWebViewInspectData *data) 879 webview_inspector_inspect_element(GtkWidget *item, PidginWebViewInspectData *data)
880 { 880 {
881 webkit_web_inspector_inspect_node(data->inspector, data->node); 881 webkit_web_inspector_inspect_node(data->inspector, data->node);
882 } 882 }
883 883
884 static void 884 static void
885 webview_inspector_destroy(GtkWindow *window, GtkWebViewPriv *priv) 885 webview_inspector_destroy(GtkWindow *window, PidginWebViewPriv *priv)
886 { 886 {
887 g_return_if_fail(priv->inspector_win == window); 887 g_return_if_fail(priv->inspector_win == window);
888 888
889 priv->inspector_win = NULL; 889 priv->inspector_win = NULL;
890 priv->inspector_view = NULL; 890 priv->inspector_view = NULL;
892 892
893 static WebKitWebView * 893 static WebKitWebView *
894 webview_inspector_create(WebKitWebInspector *inspector, 894 webview_inspector_create(WebKitWebInspector *inspector,
895 WebKitWebView *webview, gpointer _unused) 895 WebKitWebView *webview, gpointer _unused)
896 { 896 {
897 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 897 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
898 898
899 if (priv->inspector_view != NULL) 899 if (priv->inspector_view != NULL)
900 return priv->inspector_view; 900 return priv->inspector_view;
901 901
902 priv->inspector_win = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); 902 priv->inspector_win = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
914 } 914 }
915 915
916 static gboolean 916 static gboolean
917 webview_inspector_show(WebKitWebInspector *inspector, GtkWidget *webview) 917 webview_inspector_show(WebKitWebInspector *inspector, GtkWidget *webview)
918 { 918 {
919 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 919 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
920 920
921 gtk_widget_show_all(GTK_WIDGET(priv->inspector_win)); 921 gtk_widget_show_all(GTK_WIDGET(priv->inspector_win));
922 922
923 return TRUE; 923 return TRUE;
924 } 924 }
925 925
926 static GtkWebViewProtocol * 926 static PidginWebViewProtocol *
927 webview_find_protocol(const char *url, gboolean reverse) 927 webview_find_protocol(const char *url, gboolean reverse)
928 { 928 {
929 GtkWebViewClass *klass; 929 PidginWebViewClass *klass;
930 GList *iter; 930 GList *iter;
931 GtkWebViewProtocol *proto = NULL; 931 PidginWebViewProtocol *proto = NULL;
932 gssize length = reverse ? (gssize)strlen(url) : -1; 932 gssize length = reverse ? (gssize)strlen(url) : -1;
933 933
934 klass = g_type_class_ref(GTK_TYPE_WEBVIEW); 934 klass = g_type_class_ref(GTK_TYPE_WEBVIEW);
935 for (iter = klass->protocols; iter; iter = iter->next) { 935 for (iter = klass->protocols; iter; iter = iter->next) {
936 proto = iter->data; 936 proto = iter->data;
957 957
958 uri = webkit_network_request_get_uri(request); 958 uri = webkit_network_request_get_uri(request);
959 reason = webkit_web_navigation_action_get_reason(navigation_action); 959 reason = webkit_web_navigation_action_get_reason(navigation_action);
960 960
961 if (reason == WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED) { 961 if (reason == WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED) {
962 GtkWebViewProtocol *proto = webview_find_protocol(uri, FALSE); 962 PidginWebViewProtocol *proto = webview_find_protocol(uri, FALSE);
963 if (proto) { 963 if (proto) {
964 /* XXX: Do something with the return value? */ 964 /* XXX: Do something with the return value? */
965 proto->activate(GTK_WEBVIEW(webview), uri); 965 proto->activate(PIDGIN_WEBVIEW(webview), uri);
966 } 966 }
967 webkit_web_policy_decision_ignore(policy_decision); 967 webkit_web_policy_decision_ignore(policy_decision);
968 } else if (reason == WEBKIT_WEB_NAVIGATION_REASON_OTHER) 968 } else if (reason == WEBKIT_WEB_NAVIGATION_REASON_OTHER)
969 webkit_web_policy_decision_use(policy_decision); 969 webkit_web_policy_decision_use(policy_decision);
970 else 970 else
1013 { N_("ZWJ Zero width _joiner"), 0x200D }, 1013 { N_("ZWJ Zero width _joiner"), 0x200D },
1014 { N_("ZWNJ Zero width _non-joiner"), 0x200C } 1014 { N_("ZWNJ Zero width _non-joiner"), 0x200C }
1015 }; 1015 };
1016 1016
1017 static void 1017 static void
1018 insert_control_character_cb(GtkMenuItem *item, GtkWebViewInsertData *data) 1018 insert_control_character_cb(GtkMenuItem *item, PidginWebViewInsertData *data)
1019 { 1019 {
1020 WebKitWebView *webview = data->webview; 1020 WebKitWebView *webview = data->webview;
1021 gunichar ch = data->ch; 1021 gunichar ch = data->ch;
1022 GtkWebViewPriv *priv; 1022 PidginWebViewPriv *priv;
1023 WebKitDOMDocument *dom; 1023 WebKitDOMDocument *dom;
1024 char buf[6]; 1024 char buf[6];
1025 1025
1026 priv = GTK_WEBVIEW_GET_PRIVATE(GTK_WEBVIEW(webview)); 1026 priv = PIDGIN_WEBVIEW_GET_PRIVATE(PIDGIN_WEBVIEW(webview));
1027 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 1027 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
1028 1028
1029 g_unichar_to_utf8(ch, buf); 1029 g_unichar_to_utf8(ch, buf);
1030 priv->edit.block_changed = TRUE; 1030 priv->edit.block_changed = TRUE;
1031 webkit_dom_document_exec_command(dom, "insertHTML", FALSE, buf); 1031 webkit_dom_document_exec_command(dom, "insertHTML", FALSE, buf);
1050 1050
1051 menuitem = gtk_image_menu_item_new_with_mnemonic(_("_Insert Unicode Control Character")); 1051 menuitem = gtk_image_menu_item_new_with_mnemonic(_("_Insert Unicode Control Character"));
1052 1052
1053 menu = gtk_menu_new(); 1053 menu = gtk_menu_new();
1054 for (i = 0; i < G_N_ELEMENTS(bidi_menu_entries); i++) { 1054 for (i = 0; i < G_N_ELEMENTS(bidi_menu_entries); i++) {
1055 GtkWebViewInsertData *data; 1055 PidginWebViewInsertData *data;
1056 GtkWidget *item; 1056 GtkWidget *item;
1057 1057
1058 data = g_new0(GtkWebViewInsertData, 1); 1058 data = g_new0(PidginWebViewInsertData, 1);
1059 data->webview = webview; 1059 data->webview = webview;
1060 data->ch = bidi_menu_entries[i].ch; 1060 data->ch = bidi_menu_entries[i].ch;
1061 1061
1062 item = gtk_menu_item_new_with_mnemonic(_(bidi_menu_entries[i].label)); 1062 item = gtk_menu_item_new_with_mnemonic(_(bidi_menu_entries[i].label));
1063 g_signal_connect_data(item, "activate", 1063 g_signal_connect_data(item, "activate",
1083 g_signal_connect(menu, "selection-done", 1083 g_signal_connect(menu, "selection-done",
1084 G_CALLBACK(gtk_widget_destroy), NULL); 1084 G_CALLBACK(gtk_widget_destroy), NULL);
1085 1085
1086 if ((context & WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK) 1086 if ((context & WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK)
1087 && !(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION)) { 1087 && !(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION)) {
1088 GtkWebViewProtocol *proto = NULL; 1088 PidginWebViewProtocol *proto = NULL;
1089 GList *children; 1089 GList *children;
1090 1090
1091 while (node && !WEBKIT_DOM_IS_HTML_ANCHOR_ELEMENT(node)) { 1091 while (node && !WEBKIT_DOM_IS_HTML_ANCHOR_ELEMENT(node)) {
1092 node = webkit_dom_node_get_parent_node(node); 1092 node = webkit_dom_node_get_parent_node(node);
1093 } 1093 }
1094 1094
1095 if (uri && node) 1095 if (uri && node)
1096 proto = webview_find_protocol(uri, FALSE); 1096 proto = webview_find_protocol(uri, FALSE);
1097 1097
1098 if (proto && proto->context_menu) { 1098 if (proto && proto->context_menu) {
1099 proto->context_menu(GTK_WEBVIEW(webview), 1099 proto->context_menu(PIDGIN_WEBVIEW(webview),
1100 WEBKIT_DOM_HTML_ANCHOR_ELEMENT(node), menu); 1100 WEBKIT_DOM_HTML_ANCHOR_ELEMENT(node), menu);
1101 } 1101 }
1102 1102
1103 children = gtk_container_get_children(GTK_CONTAINER(menu)); 1103 children = gtk_container_get_children(GTK_CONTAINER(menu));
1104 if (!children) { 1104 if (!children) {
1159 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT 1159 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT
1160 "/webview/inspector_enabled")) 1160 "/webview/inspector_enabled"))
1161 { 1161 {
1162 WebKitWebSettings *settings; 1162 WebKitWebSettings *settings;
1163 GtkWidget *inspect; 1163 GtkWidget *inspect;
1164 GtkWebViewInspectData *data; 1164 PidginWebViewInspectData *data;
1165 1165
1166 settings = webkit_web_view_get_settings(webview); 1166 settings = webkit_web_view_get_settings(webview);
1167 g_object_set(G_OBJECT(settings), "enable-developer-extras", TRUE, NULL); 1167 g_object_set(G_OBJECT(settings), "enable-developer-extras", TRUE, NULL);
1168 1168
1169 data = g_new0(GtkWebViewInspectData, 1); 1169 data = g_new0(PidginWebViewInspectData, 1);
1170 data->inspector = webkit_web_view_get_inspector(webview); 1170 data->inspector = webkit_web_view_get_inspector(webview);
1171 data->node = node; 1171 data->node = node;
1172 1172
1173 pidgin_separator(menu); 1173 pidgin_separator(menu);
1174 1174
1268 * @return TRUE if the window needs to be scrolled further, FALSE if we're at the bottom. 1268 * @return TRUE if the window needs to be scrolled further, FALSE if we're at the bottom.
1269 */ 1269 */
1270 static gboolean 1270 static gboolean
1271 smooth_scroll_cb(gpointer data) 1271 smooth_scroll_cb(gpointer data)
1272 { 1272 {
1273 GtkWebViewPriv *priv = data; 1273 PidginWebViewPriv *priv = data;
1274 GtkAdjustment *adj; 1274 GtkAdjustment *adj;
1275 gdouble max_val; 1275 gdouble max_val;
1276 gdouble scroll_val; 1276 gdouble scroll_val;
1277 1277
1278 g_return_val_if_fail(priv->scroll_time != NULL, FALSE); 1278 g_return_val_if_fail(priv->scroll_time != NULL, FALSE);
1298 } 1298 }
1299 1299
1300 static gboolean 1300 static gboolean
1301 scroll_idle_cb(gpointer data) 1301 scroll_idle_cb(gpointer data)
1302 { 1302 {
1303 GtkWebViewPriv *priv = data; 1303 PidginWebViewPriv *priv = data;
1304 GtkAdjustment *adj = priv->vadj; 1304 GtkAdjustment *adj = priv->vadj;
1305 gdouble max_val; 1305 gdouble max_val;
1306 1306
1307 if (adj) { 1307 if (adj) {
1308 max_val = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_page_size(adj); 1308 max_val = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_page_size(adj);
1312 priv->scroll_src = 0; 1312 priv->scroll_src = 0;
1313 return FALSE; 1313 return FALSE;
1314 } 1314 }
1315 1315
1316 static void 1316 static void
1317 emit_format_signal(GtkWebView *webview, GtkWebViewButtons buttons) 1317 emit_format_signal(PidginWebView *webview, PidginWebViewButtons buttons)
1318 { 1318 {
1319 g_object_ref(webview); 1319 g_object_ref(webview);
1320 g_signal_emit(webview, signals[TOGGLE_FORMAT], 0, buttons); 1320 g_signal_emit(webview, signals[TOGGLE_FORMAT], 0, buttons);
1321 g_object_unref(webview); 1321 g_object_unref(webview);
1322 } 1322 }
1323 1323
1324 static void 1324 static void
1325 do_formatting(GtkWebView *webview, const char *name, const char *value) 1325 do_formatting(PidginWebView *webview, const char *name, const char *value)
1326 { 1326 {
1327 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1327 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1328 WebKitDOMDocument *dom; 1328 WebKitDOMDocument *dom;
1329 WebKitDOMDOMWindow *win; 1329 WebKitDOMDOMWindow *win;
1330 WebKitDOMDOMSelection *sel = NULL; 1330 WebKitDOMDOMSelection *sel = NULL;
1331 WebKitDOMRange *range = NULL; 1331 WebKitDOMRange *range = NULL;
1332 1332
1353 } 1353 }
1354 } 1354 }
1355 } 1355 }
1356 1356
1357 static void 1357 static void
1358 webview_font_shrink(GtkWebView *webview) 1358 webview_font_shrink(PidginWebView *webview)
1359 { 1359 {
1360 gint fontsize; 1360 gint fontsize;
1361 char *tmp; 1361 char *tmp;
1362 1362
1363 fontsize = gtk_webview_get_current_fontsize(webview); 1363 fontsize = pidgin_webview_get_current_fontsize(webview);
1364 fontsize = MAX(fontsize - 1, 1); 1364 fontsize = MAX(fontsize - 1, 1);
1365 1365
1366 tmp = g_strdup_printf("%d", fontsize); 1366 tmp = g_strdup_printf("%d", fontsize);
1367 do_formatting(webview, "fontSize", tmp); 1367 do_formatting(webview, "fontSize", tmp);
1368 g_free(tmp); 1368 g_free(tmp);
1369 } 1369 }
1370 1370
1371 static void 1371 static void
1372 webview_font_grow(GtkWebView *webview) 1372 webview_font_grow(PidginWebView *webview)
1373 { 1373 {
1374 gint fontsize; 1374 gint fontsize;
1375 char *tmp; 1375 char *tmp;
1376 1376
1377 fontsize = gtk_webview_get_current_fontsize(webview); 1377 fontsize = pidgin_webview_get_current_fontsize(webview);
1378 fontsize = MIN(fontsize + 1, MAX_FONT_SIZE); 1378 fontsize = MIN(fontsize + 1, MAX_FONT_SIZE);
1379 1379
1380 tmp = g_strdup_printf("%d", fontsize); 1380 tmp = g_strdup_printf("%d", fontsize);
1381 do_formatting(webview, "fontSize", tmp); 1381 do_formatting(webview, "fontSize", tmp);
1382 g_free(tmp); 1382 g_free(tmp);
1383 } 1383 }
1384 1384
1385 static void 1385 static void
1386 webview_clear_formatting(GtkWebView *webview) 1386 webview_clear_formatting(PidginWebView *webview)
1387 { 1387 {
1388 if (!webkit_web_view_get_editable(WEBKIT_WEB_VIEW(webview))) 1388 if (!webkit_web_view_get_editable(WEBKIT_WEB_VIEW(webview)))
1389 return; 1389 return;
1390 1390
1391 do_formatting(webview, "removeFormat", ""); 1391 do_formatting(webview, "removeFormat", "");
1392 do_formatting(webview, "unlink", ""); 1392 do_formatting(webview, "unlink", "");
1393 do_formatting(webview, "backColor", "inherit"); 1393 do_formatting(webview, "backColor", "inherit");
1394 } 1394 }
1395 1395
1396 static void 1396 static void
1397 webview_toggle_format(GtkWebView *webview, GtkWebViewButtons buttons) 1397 webview_toggle_format(PidginWebView *webview, PidginWebViewButtons buttons)
1398 { 1398 {
1399 /* since this function is the handler for the formatting keystrokes, 1399 /* since this function is the handler for the formatting keystrokes,
1400 we need to check here that the formatting attempted is permitted */ 1400 we need to check here that the formatting attempted is permitted */
1401 buttons &= gtk_webview_get_format_functions(webview); 1401 buttons &= pidgin_webview_get_format_functions(webview);
1402 1402
1403 switch (buttons) { 1403 switch (buttons) {
1404 case GTK_WEBVIEW_BOLD: 1404 case PIDGIN_WEBVIEW_BOLD:
1405 do_formatting(webview, "bold", ""); 1405 do_formatting(webview, "bold", "");
1406 break; 1406 break;
1407 case GTK_WEBVIEW_ITALIC: 1407 case PIDGIN_WEBVIEW_ITALIC:
1408 do_formatting(webview, "italic", ""); 1408 do_formatting(webview, "italic", "");
1409 break; 1409 break;
1410 case GTK_WEBVIEW_UNDERLINE: 1410 case PIDGIN_WEBVIEW_UNDERLINE:
1411 do_formatting(webview, "underline", ""); 1411 do_formatting(webview, "underline", "");
1412 break; 1412 break;
1413 case GTK_WEBVIEW_STRIKE: 1413 case PIDGIN_WEBVIEW_STRIKE:
1414 do_formatting(webview, "strikethrough", ""); 1414 do_formatting(webview, "strikethrough", "");
1415 break; 1415 break;
1416 case GTK_WEBVIEW_SHRINK: 1416 case PIDGIN_WEBVIEW_SHRINK:
1417 webview_font_shrink(webview); 1417 webview_font_shrink(webview);
1418 break; 1418 break;
1419 case GTK_WEBVIEW_GROW: 1419 case PIDGIN_WEBVIEW_GROW:
1420 webview_font_grow(webview); 1420 webview_font_grow(webview);
1421 break; 1421 break;
1422 default: 1422 default:
1423 break; 1423 break;
1424 } 1424 }
1425 } 1425 }
1426 1426
1427 static void 1427 static void
1428 editable_input_cb(GtkWebView *webview, gpointer data) 1428 editable_input_cb(PidginWebView *webview, gpointer data)
1429 { 1429 {
1430 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1430 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1431 if (!priv->edit.block_changed && gtk_widget_is_sensitive(GTK_WIDGET(webview))) 1431 if (!priv->edit.block_changed && gtk_widget_is_sensitive(GTK_WIDGET(webview)))
1432 g_signal_emit(webview, signals[CHANGED], 0); 1432 g_signal_emit(webview, signals[CHANGED], 0);
1433 } 1433 }
1434 1434
1435 /****************************************************************************** 1435 /******************************************************************************
1436 * GObject Stuff 1436 * GObject Stuff
1437 *****************************************************************************/ 1437 *****************************************************************************/
1438 1438
1439 GtkWidget * 1439 GtkWidget *
1440 gtk_webview_new(gboolean editable) 1440 pidgin_webview_new(gboolean editable)
1441 { 1441 {
1442 GtkWidget *result; 1442 GtkWidget *result;
1443 WebKitWebView *webview; 1443 WebKitWebView *webview;
1444 WebKitWebSettings *settings; 1444 WebKitWebSettings *settings;
1445 1445
1446 result = g_object_new(gtk_webview_get_type(), NULL); 1446 result = g_object_new(pidgin_webview_get_type(), NULL);
1447 webview = WEBKIT_WEB_VIEW(result); 1447 webview = WEBKIT_WEB_VIEW(result);
1448 settings = webkit_web_view_get_settings(webview); 1448 settings = webkit_web_view_get_settings(webview);
1449 1449
1450 g_object_set(G_OBJECT(settings), "default-encoding", "utf-8", NULL); 1450 g_object_set(G_OBJECT(settings), "default-encoding", "utf-8", NULL);
1451 #ifdef _WIN32 1451 #ifdef _WIN32
1467 1467
1468 return result; 1468 return result;
1469 } 1469 }
1470 1470
1471 static void 1471 static void
1472 gtk_webview_finalize(GObject *webview) 1472 pidgin_webview_finalize(GObject *webview)
1473 { 1473 {
1474 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1474 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1475 gpointer temp; 1475 gpointer temp;
1476 1476
1477 if (priv->inspector_win != NULL) 1477 if (priv->inspector_win != NULL)
1478 gtk_widget_destroy(GTK_WIDGET(priv->inspector_win)); 1478 gtk_widget_destroy(GTK_WIDGET(priv->inspector_win));
1479 1479
1493 1493
1494 G_OBJECT_CLASS(parent_class)->finalize(G_OBJECT(webview)); 1494 G_OBJECT_CLASS(parent_class)->finalize(G_OBJECT(webview));
1495 } 1495 }
1496 1496
1497 static void 1497 static void
1498 gtk_webview_class_init(GtkWebViewClass *klass, gpointer userdata) 1498 pidgin_webview_class_init(PidginWebViewClass *klass, gpointer userdata)
1499 { 1499 {
1500 GObjectClass *gobject_class; 1500 GObjectClass *gobject_class;
1501 GtkBindingSet *binding_set; 1501 GtkBindingSet *binding_set;
1502 1502
1503 parent_class = g_type_class_ref(webkit_web_view_get_type()); 1503 parent_class = g_type_class_ref(webkit_web_view_get_type());
1504 gobject_class = G_OBJECT_CLASS(klass); 1504 gobject_class = G_OBJECT_CLASS(klass);
1505 1505
1506 g_type_class_add_private(klass, sizeof(GtkWebViewPriv)); 1506 g_type_class_add_private(klass, sizeof(PidginWebViewPriv));
1507 1507
1508 /* Signals */ 1508 /* Signals */
1509 1509
1510 signals[BUTTONS_UPDATE] = g_signal_new("allowed-formats-updated", 1510 signals[BUTTONS_UPDATE] = g_signal_new("allowed-formats-updated",
1511 G_TYPE_FROM_CLASS(gobject_class), 1511 G_TYPE_FROM_CLASS(gobject_class),
1512 G_SIGNAL_RUN_FIRST, 1512 G_SIGNAL_RUN_FIRST,
1513 G_STRUCT_OFFSET(GtkWebViewClass, buttons_update), 1513 G_STRUCT_OFFSET(PidginWebViewClass, buttons_update),
1514 NULL, 0, g_cclosure_marshal_VOID__INT, 1514 NULL, 0, g_cclosure_marshal_VOID__INT,
1515 G_TYPE_NONE, 1, G_TYPE_INT); 1515 G_TYPE_NONE, 1, G_TYPE_INT);
1516 signals[TOGGLE_FORMAT] = g_signal_new("format-toggled", 1516 signals[TOGGLE_FORMAT] = g_signal_new("format-toggled",
1517 G_TYPE_FROM_CLASS(gobject_class), 1517 G_TYPE_FROM_CLASS(gobject_class),
1518 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, 1518 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1519 G_STRUCT_OFFSET(GtkWebViewClass, toggle_format), 1519 G_STRUCT_OFFSET(PidginWebViewClass, toggle_format),
1520 NULL, 0, g_cclosure_marshal_VOID__INT, 1520 NULL, 0, g_cclosure_marshal_VOID__INT,
1521 G_TYPE_NONE, 1, G_TYPE_INT); 1521 G_TYPE_NONE, 1, G_TYPE_INT);
1522 signals[CLEAR_FORMAT] = g_signal_new("format-cleared", 1522 signals[CLEAR_FORMAT] = g_signal_new("format-cleared",
1523 G_TYPE_FROM_CLASS(gobject_class), 1523 G_TYPE_FROM_CLASS(gobject_class),
1524 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, 1524 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
1525 G_STRUCT_OFFSET(GtkWebViewClass, clear_format), 1525 G_STRUCT_OFFSET(PidginWebViewClass, clear_format),
1526 NULL, 0, g_cclosure_marshal_VOID__VOID, 1526 NULL, 0, g_cclosure_marshal_VOID__VOID,
1527 G_TYPE_NONE, 0); 1527 G_TYPE_NONE, 0);
1528 signals[UPDATE_FORMAT] = g_signal_new("format-updated", 1528 signals[UPDATE_FORMAT] = g_signal_new("format-updated",
1529 G_TYPE_FROM_CLASS(gobject_class), 1529 G_TYPE_FROM_CLASS(gobject_class),
1530 G_SIGNAL_RUN_FIRST, 1530 G_SIGNAL_RUN_FIRST,
1531 G_STRUCT_OFFSET(GtkWebViewClass, update_format), 1531 G_STRUCT_OFFSET(PidginWebViewClass, update_format),
1532 NULL, 0, g_cclosure_marshal_VOID__VOID, 1532 NULL, 0, g_cclosure_marshal_VOID__VOID,
1533 G_TYPE_NONE, 0); 1533 G_TYPE_NONE, 0);
1534 signals[CHANGED] = g_signal_new("changed", 1534 signals[CHANGED] = g_signal_new("changed",
1535 G_TYPE_FROM_CLASS(gobject_class), 1535 G_TYPE_FROM_CLASS(gobject_class),
1536 G_SIGNAL_RUN_FIRST, 1536 G_SIGNAL_RUN_FIRST,
1537 G_STRUCT_OFFSET(GtkWebViewClass, changed), 1537 G_STRUCT_OFFSET(PidginWebViewClass, changed),
1538 NULL, NULL, g_cclosure_marshal_VOID__VOID, 1538 NULL, NULL, g_cclosure_marshal_VOID__VOID,
1539 G_TYPE_NONE, 0); 1539 G_TYPE_NONE, 0);
1540 signals[HTML_APPENDED] = g_signal_new("html-appended", 1540 signals[HTML_APPENDED] = g_signal_new("html-appended",
1541 G_TYPE_FROM_CLASS(gobject_class), 1541 G_TYPE_FROM_CLASS(gobject_class),
1542 G_SIGNAL_RUN_FIRST, 1542 G_SIGNAL_RUN_FIRST,
1543 G_STRUCT_OFFSET(GtkWebViewClass, html_appended), 1543 G_STRUCT_OFFSET(PidginWebViewClass, html_appended),
1544 NULL, NULL, 1544 NULL, NULL,
1545 g_cclosure_marshal_VOID__OBJECT, 1545 g_cclosure_marshal_VOID__OBJECT,
1546 G_TYPE_NONE, 1, WEBKIT_TYPE_DOM_RANGE, 1546 G_TYPE_NONE, 1, WEBKIT_TYPE_DOM_RANGE,
1547 NULL); 1547 NULL);
1548 1548
1549 /* Class Methods */ 1549 /* Class Methods */
1550 1550
1551 klass->toggle_format = webview_toggle_format; 1551 klass->toggle_format = webview_toggle_format;
1552 klass->clear_format = webview_clear_formatting; 1552 klass->clear_format = webview_clear_formatting;
1553 1553
1554 gobject_class->finalize = gtk_webview_finalize; 1554 gobject_class->finalize = pidgin_webview_finalize;
1555 1555
1556 /* Key Bindings */ 1556 /* Key Bindings */
1557 1557
1558 binding_set = gtk_binding_set_by_class(parent_class); 1558 binding_set = gtk_binding_set_by_class(parent_class);
1559 gtk_binding_entry_add_signal(binding_set, GDK_KEY_b, GDK_CONTROL_MASK, 1559 gtk_binding_entry_add_signal(binding_set, GDK_KEY_b, GDK_CONTROL_MASK,
1560 "format-toggled", 1, G_TYPE_INT, 1560 "format-toggled", 1, G_TYPE_INT,
1561 GTK_WEBVIEW_BOLD); 1561 PIDGIN_WEBVIEW_BOLD);
1562 gtk_binding_entry_add_signal(binding_set, GDK_KEY_i, GDK_CONTROL_MASK, 1562 gtk_binding_entry_add_signal(binding_set, GDK_KEY_i, GDK_CONTROL_MASK,
1563 "format-toggled", 1, G_TYPE_INT, 1563 "format-toggled", 1, G_TYPE_INT,
1564 GTK_WEBVIEW_ITALIC); 1564 PIDGIN_WEBVIEW_ITALIC);
1565 gtk_binding_entry_add_signal(binding_set, GDK_KEY_u, GDK_CONTROL_MASK, 1565 gtk_binding_entry_add_signal(binding_set, GDK_KEY_u, GDK_CONTROL_MASK,
1566 "format-toggled", 1, G_TYPE_INT, 1566 "format-toggled", 1, G_TYPE_INT,
1567 GTK_WEBVIEW_UNDERLINE); 1567 PIDGIN_WEBVIEW_UNDERLINE);
1568 gtk_binding_entry_add_signal(binding_set, GDK_KEY_plus, GDK_CONTROL_MASK, 1568 gtk_binding_entry_add_signal(binding_set, GDK_KEY_plus, GDK_CONTROL_MASK,
1569 "format-toggled", 1, G_TYPE_INT, 1569 "format-toggled", 1, G_TYPE_INT,
1570 GTK_WEBVIEW_GROW); 1570 PIDGIN_WEBVIEW_GROW);
1571 gtk_binding_entry_add_signal(binding_set, GDK_KEY_equal, GDK_CONTROL_MASK, 1571 gtk_binding_entry_add_signal(binding_set, GDK_KEY_equal, GDK_CONTROL_MASK,
1572 "format-toggled", 1, G_TYPE_INT, 1572 "format-toggled", 1, G_TYPE_INT,
1573 GTK_WEBVIEW_GROW); 1573 PIDGIN_WEBVIEW_GROW);
1574 gtk_binding_entry_add_signal(binding_set, GDK_KEY_minus, GDK_CONTROL_MASK, 1574 gtk_binding_entry_add_signal(binding_set, GDK_KEY_minus, GDK_CONTROL_MASK,
1575 "format-toggled", 1, G_TYPE_INT, 1575 "format-toggled", 1, G_TYPE_INT,
1576 GTK_WEBVIEW_SHRINK); 1576 PIDGIN_WEBVIEW_SHRINK);
1577 1577
1578 binding_set = gtk_binding_set_by_class(klass); 1578 binding_set = gtk_binding_set_by_class(klass);
1579 gtk_binding_entry_add_signal(binding_set, GDK_KEY_r, GDK_CONTROL_MASK, 1579 gtk_binding_entry_add_signal(binding_set, GDK_KEY_r, GDK_CONTROL_MASK,
1580 "format-cleared", 0); 1580 "format-cleared", 0);
1581 1581
1582 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/webview"); 1582 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/webview");
1583 purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/webview/inspector_enabled", FALSE); 1583 purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/webview/inspector_enabled", FALSE);
1584 } 1584 }
1585 1585
1586 static void 1586 static void
1587 gtk_webview_init(GtkWebView *webview, gpointer userdata) 1587 pidgin_webview_init(PidginWebView *webview, gpointer userdata)
1588 { 1588 {
1589 GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1589 PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1590 WebKitWebInspector *inspector; 1590 WebKitWebInspector *inspector;
1591 1591
1592 priv->load_queue = g_queue_new(); 1592 priv->load_queue = g_queue_new();
1593 1593
1594 priv->smiley_data = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, 1594 priv->smiley_data = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
1619 g_signal_connect(G_OBJECT(inspector), "show-window", 1619 g_signal_connect(G_OBJECT(inspector), "show-window",
1620 G_CALLBACK(webview_inspector_show), webview); 1620 G_CALLBACK(webview_inspector_show), webview);
1621 } 1621 }
1622 1622
1623 GType 1623 GType
1624 gtk_webview_get_type(void) 1624 pidgin_webview_get_type(void)
1625 { 1625 {
1626 static GType mview_type = 0; 1626 static GType mview_type = 0;
1627 if (G_UNLIKELY(mview_type == 0)) { 1627 if (G_UNLIKELY(mview_type == 0)) {
1628 static const GTypeInfo mview_info = { 1628 static const GTypeInfo mview_info = {
1629 sizeof(GtkWebViewClass), 1629 sizeof(PidginWebViewClass),
1630 NULL, 1630 NULL,
1631 NULL, 1631 NULL,
1632 (GClassInitFunc)gtk_webview_class_init, 1632 (GClassInitFunc)pidgin_webview_class_init,
1633 NULL, 1633 NULL,
1634 NULL, 1634 NULL,
1635 sizeof(GtkWebView), 1635 sizeof(PidginWebView),
1636 0, 1636 0,
1637 (GInstanceInitFunc)gtk_webview_init, 1637 (GInstanceInitFunc)pidgin_webview_init,
1638 NULL 1638 NULL
1639 }; 1639 };
1640 mview_type = g_type_register_static(webkit_web_view_get_type(), 1640 mview_type = g_type_register_static(webkit_web_view_get_type(),
1641 "GtkWebView", &mview_info, 0); 1641 "PidginWebView", &mview_info, 0);
1642 } 1642 }
1643 return mview_type; 1643 return mview_type;
1644 } 1644 }
1645 1645
1646 /***************************************************************************** 1646 /*****************************************************************************
1647 * Public API functions 1647 * Public API functions
1648 *****************************************************************************/ 1648 *****************************************************************************/
1649 1649
1650 char * 1650 char *
1651 gtk_webview_quote_js_string(const char *text) 1651 pidgin_webview_quote_js_string(const char *text)
1652 { 1652 {
1653 GString *str = g_string_new("\""); 1653 GString *str = g_string_new("\"");
1654 const char *cur = text; 1654 const char *cur = text;
1655 1655
1656 while (cur && *cur) { 1656 while (cur && *cur) {
1676 1676
1677 return g_string_free(str, FALSE); 1677 return g_string_free(str, FALSE);
1678 } 1678 }
1679 1679
1680 void 1680 void
1681 gtk_webview_safe_execute_script(GtkWebView *webview, const char *script) 1681 pidgin_webview_safe_execute_script(PidginWebView *webview, const char *script)
1682 { 1682 {
1683 GtkWebViewPriv *priv; 1683 PidginWebViewPriv *priv;
1684 1684
1685 g_return_if_fail(webview != NULL); 1685 g_return_if_fail(webview != NULL);
1686 1686
1687 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1687 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1688 g_queue_push_tail(priv->load_queue, GINT_TO_POINTER(LOAD_JS)); 1688 g_queue_push_tail(priv->load_queue, GINT_TO_POINTER(LOAD_JS));
1689 g_queue_push_tail(priv->load_queue, g_strdup(script)); 1689 g_queue_push_tail(priv->load_queue, g_strdup(script));
1690 if (!priv->is_loading && priv->loader == 0) 1690 if (!priv->is_loading && priv->loader == 0)
1691 priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview); 1691 priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview);
1692 } 1692 }
1693 1693
1694 void 1694 void
1695 gtk_webview_load_html_string(GtkWebView *webview, const char *html) 1695 pidgin_webview_load_html_string(PidginWebView *webview, const char *html)
1696 { 1696 {
1697 g_return_if_fail(webview != NULL); 1697 g_return_if_fail(webview != NULL);
1698 1698
1699 webkit_web_view_load_string(WEBKIT_WEB_VIEW(webview), html, NULL, NULL, 1699 webkit_web_view_load_string(WEBKIT_WEB_VIEW(webview), html, NULL, NULL,
1700 "file:///"); 1700 "file:///");
1701 } 1701 }
1702 1702
1703 void 1703 void
1704 gtk_webview_load_html_string_with_selection(GtkWebView *webview, const char *html) 1704 pidgin_webview_load_html_string_with_selection(PidginWebView *webview, const char *html)
1705 { 1705 {
1706 g_return_if_fail(webview != NULL); 1706 g_return_if_fail(webview != NULL);
1707 1707
1708 gtk_webview_load_html_string(webview, html); 1708 pidgin_webview_load_html_string(webview, html);
1709 gtk_webview_safe_execute_script(webview, 1709 pidgin_webview_safe_execute_script(webview,
1710 "var s = window.getSelection();" 1710 "var s = window.getSelection();"
1711 "var r = document.createRange();" 1711 "var r = document.createRange();"
1712 "var n = document.getElementById('caret');" 1712 "var n = document.getElementById('caret');"
1713 "r.selectNodeContents(n);" 1713 "r.selectNodeContents(n);"
1714 "var f = r.extractContents();" 1714 "var f = r.extractContents();"
1718 "s.removeAllRanges();" 1718 "s.removeAllRanges();"
1719 "s.addRange(r);"); 1719 "s.addRange(r);");
1720 } 1720 }
1721 1721
1722 void 1722 void
1723 gtk_webview_append_html(GtkWebView *webview, const char *html) 1723 pidgin_webview_append_html(PidginWebView *webview, const char *html)
1724 { 1724 {
1725 GtkWebViewPriv *priv; 1725 PidginWebViewPriv *priv;
1726 1726
1727 g_return_if_fail(webview != NULL); 1727 g_return_if_fail(webview != NULL);
1728 1728
1729 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1729 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1730 g_queue_push_tail(priv->load_queue, GINT_TO_POINTER(LOAD_HTML)); 1730 g_queue_push_tail(priv->load_queue, GINT_TO_POINTER(LOAD_HTML));
1731 g_queue_push_tail(priv->load_queue, g_strdup(html)); 1731 g_queue_push_tail(priv->load_queue, g_strdup(html));
1732 if (!priv->is_loading && priv->loader == 0) 1732 if (!priv->is_loading && priv->loader == 0)
1733 priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview); 1733 priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview);
1734 } 1734 }
1735 1735
1736 void 1736 void
1737 gtk_webview_set_vadjustment(GtkWebView *webview, GtkAdjustment *vadj) 1737 pidgin_webview_set_vadjustment(PidginWebView *webview, GtkAdjustment *vadj)
1738 { 1738 {
1739 GtkWebViewPriv *priv; 1739 PidginWebViewPriv *priv;
1740 1740
1741 g_return_if_fail(webview != NULL); 1741 g_return_if_fail(webview != NULL);
1742 1742
1743 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1743 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1744 priv->vadj = vadj; 1744 priv->vadj = vadj;
1745 } 1745 }
1746 1746
1747 void 1747 void
1748 gtk_webview_scroll_to_end(GtkWebView *webview, gboolean smooth) 1748 pidgin_webview_scroll_to_end(PidginWebView *webview, gboolean smooth)
1749 { 1749 {
1750 GtkWebViewPriv *priv; 1750 PidginWebViewPriv *priv;
1751 1751
1752 g_return_if_fail(webview != NULL); 1752 g_return_if_fail(webview != NULL);
1753 1753
1754 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1754 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1755 if (priv->scroll_time) 1755 if (priv->scroll_time)
1756 g_timer_destroy(priv->scroll_time); 1756 g_timer_destroy(priv->scroll_time);
1757 if (priv->scroll_src) 1757 if (priv->scroll_src)
1758 g_source_remove(priv->scroll_src); 1758 g_source_remove(priv->scroll_src);
1759 if (smooth) { 1759 if (smooth) {
1764 priv->scroll_src = g_idle_add_full(G_PRIORITY_LOW, scroll_idle_cb, priv, NULL); 1764 priv->scroll_src = g_idle_add_full(G_PRIORITY_LOW, scroll_idle_cb, priv, NULL);
1765 } 1765 }
1766 } 1766 }
1767 1767
1768 void 1768 void
1769 gtk_webview_set_autoscroll(GtkWebView *webview, gboolean scroll) 1769 pidgin_webview_set_autoscroll(PidginWebView *webview, gboolean scroll)
1770 { 1770 {
1771 GtkWebViewPriv *priv; 1771 PidginWebViewPriv *priv;
1772 1772
1773 g_return_if_fail(webview != NULL); 1773 g_return_if_fail(webview != NULL);
1774 1774
1775 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1775 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1776 priv->autoscroll = scroll; 1776 priv->autoscroll = scroll;
1777 } 1777 }
1778 1778
1779 gboolean 1779 gboolean
1780 gtk_webview_get_autoscroll(GtkWebView *webview) 1780 pidgin_webview_get_autoscroll(PidginWebView *webview)
1781 { 1781 {
1782 GtkWebViewPriv *priv; 1782 PidginWebViewPriv *priv;
1783 1783
1784 g_return_val_if_fail(webview != NULL, FALSE); 1784 g_return_val_if_fail(webview != NULL, FALSE);
1785 1785
1786 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1786 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1787 return priv->autoscroll; 1787 return priv->autoscroll;
1788 } 1788 }
1789 1789
1790 void 1790 void
1791 gtk_webview_page_up(GtkWebView *webview) 1791 pidgin_webview_page_up(PidginWebView *webview)
1792 { 1792 {
1793 GtkWebViewPriv *priv; 1793 PidginWebViewPriv *priv;
1794 GtkAdjustment *vadj; 1794 GtkAdjustment *vadj;
1795 gdouble scroll_val; 1795 gdouble scroll_val;
1796 1796
1797 g_return_if_fail(webview != NULL); 1797 g_return_if_fail(webview != NULL);
1798 1798
1799 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1799 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1800 vadj = priv->vadj; 1800 vadj = priv->vadj;
1801 scroll_val = gtk_adjustment_get_value(vadj) - gtk_adjustment_get_page_size(vadj); 1801 scroll_val = gtk_adjustment_get_value(vadj) - gtk_adjustment_get_page_size(vadj);
1802 scroll_val = MAX(scroll_val, gtk_adjustment_get_lower(vadj)); 1802 scroll_val = MAX(scroll_val, gtk_adjustment_get_lower(vadj));
1803 1803
1804 gtk_adjustment_set_value(vadj, scroll_val); 1804 gtk_adjustment_set_value(vadj, scroll_val);
1805 } 1805 }
1806 1806
1807 void 1807 void
1808 gtk_webview_page_down(GtkWebView *webview) 1808 pidgin_webview_page_down(PidginWebView *webview)
1809 { 1809 {
1810 GtkWebViewPriv *priv; 1810 PidginWebViewPriv *priv;
1811 GtkAdjustment *vadj; 1811 GtkAdjustment *vadj;
1812 gdouble scroll_val; 1812 gdouble scroll_val;
1813 gdouble page_size; 1813 gdouble page_size;
1814 1814
1815 g_return_if_fail(webview != NULL); 1815 g_return_if_fail(webview != NULL);
1816 1816
1817 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1817 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1818 vadj = priv->vadj; 1818 vadj = priv->vadj;
1819 page_size = gtk_adjustment_get_page_size(vadj); 1819 page_size = gtk_adjustment_get_page_size(vadj);
1820 scroll_val = gtk_adjustment_get_value(vadj) + page_size; 1820 scroll_val = gtk_adjustment_get_value(vadj) + page_size;
1821 scroll_val = MIN(scroll_val, gtk_adjustment_get_upper(vadj) - page_size); 1821 scroll_val = MIN(scroll_val, gtk_adjustment_get_upper(vadj) - page_size);
1822 1822
1823 gtk_adjustment_set_value(vadj, scroll_val); 1823 gtk_adjustment_set_value(vadj, scroll_val);
1824 } 1824 }
1825 1825
1826 void 1826 void
1827 gtk_webview_setup_entry(GtkWebView *webview, PurpleConnectionFlags flags) 1827 pidgin_webview_setup_entry(PidginWebView *webview, PurpleConnectionFlags flags)
1828 { 1828 {
1829 GtkWebViewButtons buttons; 1829 PidginWebViewButtons buttons;
1830 1830
1831 g_return_if_fail(webview != NULL); 1831 g_return_if_fail(webview != NULL);
1832 1832
1833 if (flags & PURPLE_CONNECTION_FLAG_HTML) { 1833 if (flags & PURPLE_CONNECTION_FLAG_HTML) {
1834 gboolean bold, italic, underline, strike; 1834 gboolean bold, italic, underline, strike;
1835 1835
1836 buttons = GTK_WEBVIEW_ALL; 1836 buttons = PIDGIN_WEBVIEW_ALL;
1837 1837
1838 if (flags & PURPLE_CONNECTION_FLAG_NO_BGCOLOR) 1838 if (flags & PURPLE_CONNECTION_FLAG_NO_BGCOLOR)
1839 buttons &= ~GTK_WEBVIEW_BACKCOLOR; 1839 buttons &= ~PIDGIN_WEBVIEW_BACKCOLOR;
1840 if (flags & PURPLE_CONNECTION_FLAG_NO_FONTSIZE) 1840 if (flags & PURPLE_CONNECTION_FLAG_NO_FONTSIZE)
1841 { 1841 {
1842 buttons &= ~GTK_WEBVIEW_GROW; 1842 buttons &= ~PIDGIN_WEBVIEW_GROW;
1843 buttons &= ~GTK_WEBVIEW_SHRINK; 1843 buttons &= ~PIDGIN_WEBVIEW_SHRINK;
1844 } 1844 }
1845 if (flags & PURPLE_CONNECTION_FLAG_NO_URLDESC) 1845 if (flags & PURPLE_CONNECTION_FLAG_NO_URLDESC)
1846 buttons &= ~GTK_WEBVIEW_LINKDESC; 1846 buttons &= ~PIDGIN_WEBVIEW_LINKDESC;
1847 1847
1848 gtk_webview_get_current_format(webview, &bold, &italic, &underline, &strike); 1848 pidgin_webview_get_current_format(webview, &bold, &italic, &underline, &strike);
1849 1849
1850 gtk_webview_set_format_functions(webview, GTK_WEBVIEW_ALL); 1850 pidgin_webview_set_format_functions(webview, PIDGIN_WEBVIEW_ALL);
1851 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold") != bold) 1851 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold") != bold)
1852 gtk_webview_toggle_bold(webview); 1852 pidgin_webview_toggle_bold(webview);
1853 1853
1854 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic") != italic) 1854 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic") != italic)
1855 gtk_webview_toggle_italic(webview); 1855 pidgin_webview_toggle_italic(webview);
1856 1856
1857 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline") != underline) 1857 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline") != underline)
1858 gtk_webview_toggle_underline(webview); 1858 pidgin_webview_toggle_underline(webview);
1859 1859
1860 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike") != strike) 1860 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike") != strike)
1861 gtk_webview_toggle_strike(webview); 1861 pidgin_webview_toggle_strike(webview);
1862 1862
1863 gtk_webview_toggle_fontface(webview, 1863 pidgin_webview_toggle_fontface(webview,
1864 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/font_face")); 1864 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/font_face"));
1865 1865
1866 if (!(flags & PURPLE_CONNECTION_FLAG_NO_FONTSIZE)) 1866 if (!(flags & PURPLE_CONNECTION_FLAG_NO_FONTSIZE))
1867 { 1867 {
1868 int size = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/font_size"); 1868 int size = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/font_size");
1869 1869
1870 /* 3 is the default. */ 1870 /* 3 is the default. */
1871 if (size != 3) 1871 if (size != 3)
1872 gtk_webview_font_set_size(webview, size); 1872 pidgin_webview_font_set_size(webview, size);
1873 } 1873 }
1874 1874
1875 gtk_webview_toggle_forecolor(webview, 1875 pidgin_webview_toggle_forecolor(webview,
1876 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor")); 1876 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor"));
1877 1877
1878 if (!(flags & PURPLE_CONNECTION_FLAG_NO_BGCOLOR)) { 1878 if (!(flags & PURPLE_CONNECTION_FLAG_NO_BGCOLOR)) {
1879 gtk_webview_toggle_backcolor(webview, 1879 pidgin_webview_toggle_backcolor(webview,
1880 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor")); 1880 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor"));
1881 } else { 1881 } else {
1882 gtk_webview_toggle_backcolor(webview, ""); 1882 pidgin_webview_toggle_backcolor(webview, "");
1883 } 1883 }
1884 1884
1885 if (flags & PURPLE_CONNECTION_FLAG_FORMATTING_WBFO) 1885 if (flags & PURPLE_CONNECTION_FLAG_FORMATTING_WBFO)
1886 gtk_webview_set_whole_buffer_formatting_only(webview, TRUE); 1886 pidgin_webview_set_whole_buffer_formatting_only(webview, TRUE);
1887 else 1887 else
1888 gtk_webview_set_whole_buffer_formatting_only(webview, FALSE); 1888 pidgin_webview_set_whole_buffer_formatting_only(webview, FALSE);
1889 } else { 1889 } else {
1890 buttons = GTK_WEBVIEW_SMILEY | GTK_WEBVIEW_IMAGE; 1890 buttons = PIDGIN_WEBVIEW_SMILEY | PIDGIN_WEBVIEW_IMAGE;
1891 webview_clear_formatting(webview); 1891 webview_clear_formatting(webview);
1892 } 1892 }
1893 1893
1894 if (flags & PURPLE_CONNECTION_FLAG_NO_IMAGES) 1894 if (flags & PURPLE_CONNECTION_FLAG_NO_IMAGES)
1895 buttons &= ~GTK_WEBVIEW_IMAGE; 1895 buttons &= ~PIDGIN_WEBVIEW_IMAGE;
1896 1896
1897 if (flags & PURPLE_CONNECTION_FLAG_ALLOW_CUSTOM_SMILEY) 1897 if (flags & PURPLE_CONNECTION_FLAG_ALLOW_CUSTOM_SMILEY)
1898 buttons |= GTK_WEBVIEW_CUSTOM_SMILEY; 1898 buttons |= PIDGIN_WEBVIEW_CUSTOM_SMILEY;
1899 else 1899 else
1900 buttons &= ~GTK_WEBVIEW_CUSTOM_SMILEY; 1900 buttons &= ~PIDGIN_WEBVIEW_CUSTOM_SMILEY;
1901 1901
1902 gtk_webview_set_format_functions(webview, buttons); 1902 pidgin_webview_set_format_functions(webview, buttons);
1903 } 1903 }
1904 1904
1905 void 1905 void
1906 pidgin_webview_set_spellcheck(GtkWebView *webview, gboolean enable) 1906 pidgin_webview_set_spellcheck(PidginWebView *webview, gboolean enable)
1907 { 1907 {
1908 WebKitWebSettings *settings; 1908 WebKitWebSettings *settings;
1909 1909
1910 g_return_if_fail(webview != NULL); 1910 g_return_if_fail(webview != NULL);
1911 1911
1913 g_object_set(G_OBJECT(settings), "enable-spell-checking", enable, NULL); 1913 g_object_set(G_OBJECT(settings), "enable-spell-checking", enable, NULL);
1914 webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webview), settings); 1914 webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webview), settings);
1915 } 1915 }
1916 1916
1917 void 1917 void
1918 gtk_webview_set_whole_buffer_formatting_only(GtkWebView *webview, gboolean wbfo) 1918 pidgin_webview_set_whole_buffer_formatting_only(PidginWebView *webview, gboolean wbfo)
1919 { 1919 {
1920 GtkWebViewPriv *priv; 1920 PidginWebViewPriv *priv;
1921 1921
1922 g_return_if_fail(webview != NULL); 1922 g_return_if_fail(webview != NULL);
1923 1923
1924 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1924 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1925 priv->edit.wbfo = wbfo; 1925 priv->edit.wbfo = wbfo;
1926 } 1926 }
1927 1927
1928 void 1928 void
1929 gtk_webview_set_format_functions(GtkWebView *webview, GtkWebViewButtons buttons) 1929 pidgin_webview_set_format_functions(PidginWebView *webview, PidginWebViewButtons buttons)
1930 { 1930 {
1931 GtkWebViewPriv *priv; 1931 PidginWebViewPriv *priv;
1932 GObject *object; 1932 GObject *object;
1933 1933
1934 g_return_if_fail(webview != NULL); 1934 g_return_if_fail(webview != NULL);
1935 1935
1936 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 1936 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
1937 object = g_object_ref(G_OBJECT(webview)); 1937 object = g_object_ref(G_OBJECT(webview));
1938 priv->format_functions = buttons; 1938 priv->format_functions = buttons;
1939 g_signal_emit(object, signals[BUTTONS_UPDATE], 0, buttons); 1939 g_signal_emit(object, signals[BUTTONS_UPDATE], 0, buttons);
1940 g_object_unref(object); 1940 g_object_unref(object);
1941 } 1941 }
1942 1942
1943 void 1943 void
1944 gtk_webview_activate_anchor(WebKitDOMHTMLAnchorElement *link) 1944 pidgin_webview_activate_anchor(WebKitDOMHTMLAnchorElement *link)
1945 { 1945 {
1946 WebKitDOMDocument *doc; 1946 WebKitDOMDocument *doc;
1947 WebKitDOMEvent *event; 1947 WebKitDOMEvent *event;
1948 1948
1949 doc = webkit_dom_node_get_owner_document(WEBKIT_DOM_NODE(link)); 1949 doc = webkit_dom_node_get_owner_document(WEBKIT_DOM_NODE(link));
1951 webkit_dom_event_init_event(event, "click", TRUE, TRUE); 1951 webkit_dom_event_init_event(event, "click", TRUE, TRUE);
1952 webkit_dom_node_dispatch_event(WEBKIT_DOM_NODE(link), event, NULL); 1952 webkit_dom_node_dispatch_event(WEBKIT_DOM_NODE(link), event, NULL);
1953 } 1953 }
1954 1954
1955 gboolean 1955 gboolean
1956 gtk_webview_class_register_protocol(const char *name, 1956 pidgin_webview_class_register_protocol(const char *name,
1957 gboolean (*activate)(GtkWebView *webview, const char *uri), 1957 gboolean (*activate)(PidginWebView *webview, const char *uri),
1958 gboolean (*context_menu)(GtkWebView *webview, WebKitDOMHTMLAnchorElement *link, GtkWidget *menu)) 1958 gboolean (*context_menu)(PidginWebView *webview, WebKitDOMHTMLAnchorElement *link, GtkWidget *menu))
1959 { 1959 {
1960 GtkWebViewClass *klass; 1960 PidginWebViewClass *klass;
1961 GtkWebViewProtocol *proto; 1961 PidginWebViewProtocol *proto;
1962 1962
1963 g_return_val_if_fail(name, FALSE); 1963 g_return_val_if_fail(name, FALSE);
1964 1964
1965 klass = g_type_class_ref(GTK_TYPE_WEBVIEW); 1965 klass = g_type_class_ref(GTK_TYPE_WEBVIEW);
1966 g_return_val_if_fail(klass, FALSE); 1966 g_return_val_if_fail(klass, FALSE);
1975 return TRUE; 1975 return TRUE;
1976 } else if (!activate) { 1976 } else if (!activate) {
1977 return FALSE; 1977 return FALSE;
1978 } 1978 }
1979 1979
1980 proto = g_new0(GtkWebViewProtocol, 1); 1980 proto = g_new0(PidginWebViewProtocol, 1);
1981 proto->name = g_strdup(name); 1981 proto->name = g_strdup(name);
1982 proto->length = strlen(name); 1982 proto->length = strlen(name);
1983 proto->activate = activate; 1983 proto->activate = activate;
1984 proto->context_menu = context_menu; 1984 proto->context_menu = context_menu;
1985 klass->protocols = g_list_prepend(klass->protocols, proto); 1985 klass->protocols = g_list_prepend(klass->protocols, proto);
1986 1986
1987 return TRUE; 1987 return TRUE;
1988 } 1988 }
1989 1989
1990 gchar * 1990 gchar *
1991 gtk_webview_get_head_html(GtkWebView *webview) 1991 pidgin_webview_get_head_html(PidginWebView *webview)
1992 { 1992 {
1993 WebKitDOMDocument *doc; 1993 WebKitDOMDocument *doc;
1994 WebKitDOMHTMLHeadElement *head; 1994 WebKitDOMHTMLHeadElement *head;
1995 gchar *html; 1995 gchar *html;
1996 1996
2002 2002
2003 return html; 2003 return html;
2004 } 2004 }
2005 2005
2006 gchar * 2006 gchar *
2007 gtk_webview_get_body_html(GtkWebView *webview) 2007 pidgin_webview_get_body_html(PidginWebView *webview)
2008 { 2008 {
2009 WebKitDOMDocument *doc; 2009 WebKitDOMDocument *doc;
2010 WebKitDOMHTMLElement *body; 2010 WebKitDOMHTMLElement *body;
2011 gchar *html; 2011 gchar *html;
2012 2012
2018 2018
2019 return html; 2019 return html;
2020 } 2020 }
2021 2021
2022 gchar * 2022 gchar *
2023 gtk_webview_get_body_text(GtkWebView *webview) 2023 pidgin_webview_get_body_text(PidginWebView *webview)
2024 { 2024 {
2025 WebKitDOMDocument *doc; 2025 WebKitDOMDocument *doc;
2026 WebKitDOMHTMLElement *body; 2026 WebKitDOMHTMLElement *body;
2027 gchar *text; 2027 gchar *text;
2028 2028
2034 2034
2035 return text; 2035 return text;
2036 } 2036 }
2037 2037
2038 gchar * 2038 gchar *
2039 gtk_webview_get_selected_text(GtkWebView *webview) 2039 pidgin_webview_get_selected_text(PidginWebView *webview)
2040 { 2040 {
2041 WebKitDOMDocument *dom; 2041 WebKitDOMDocument *dom;
2042 WebKitDOMDOMWindow *win; 2042 WebKitDOMDOMWindow *win;
2043 WebKitDOMDOMSelection *sel; 2043 WebKitDOMDOMSelection *sel;
2044 WebKitDOMRange *range = NULL; 2044 WebKitDOMRange *range = NULL;
2056 else 2056 else
2057 return NULL; 2057 return NULL;
2058 } 2058 }
2059 2059
2060 void 2060 void
2061 gtk_webview_get_caret(GtkWebView *webview, WebKitDOMNode **container_ret, 2061 pidgin_webview_get_caret(PidginWebView *webview, WebKitDOMNode **container_ret,
2062 glong *pos_ret) 2062 glong *pos_ret)
2063 { 2063 {
2064 WebKitDOMDocument *dom; 2064 WebKitDOMDocument *dom;
2065 WebKitDOMDOMWindow *win; 2065 WebKitDOMDOMWindow *win;
2066 WebKitDOMDOMSelection *sel; 2066 WebKitDOMDOMSelection *sel;
2094 *container_ret = NULL; 2094 *container_ret = NULL;
2095 *pos_ret = -1; 2095 *pos_ret = -1;
2096 } 2096 }
2097 2097
2098 void 2098 void
2099 gtk_webview_set_caret(GtkWebView *webview, WebKitDOMNode *container, glong pos) 2099 pidgin_webview_set_caret(PidginWebView *webview, WebKitDOMNode *container, glong pos)
2100 { 2100 {
2101 WebKitDOMDocument *dom; 2101 WebKitDOMDocument *dom;
2102 WebKitDOMDOMWindow *win; 2102 WebKitDOMDOMWindow *win;
2103 WebKitDOMDOMSelection *sel; 2103 WebKitDOMDOMSelection *sel;
2104 2104
2109 sel = webkit_dom_dom_window_get_selection(win); 2109 sel = webkit_dom_dom_window_get_selection(win);
2110 2110
2111 webkit_dom_dom_selection_set_position(sel, container, pos, NULL); 2111 webkit_dom_dom_selection_set_position(sel, container, pos, NULL);
2112 } 2112 }
2113 2113
2114 GtkWebViewButtons 2114 PidginWebViewButtons
2115 gtk_webview_get_format_functions(GtkWebView *webview) 2115 pidgin_webview_get_format_functions(PidginWebView *webview)
2116 { 2116 {
2117 GtkWebViewPriv *priv; 2117 PidginWebViewPriv *priv;
2118 2118
2119 g_return_val_if_fail(webview != NULL, 0); 2119 g_return_val_if_fail(webview != NULL, 0);
2120 2120
2121 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2121 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2122 return priv->format_functions; 2122 return priv->format_functions;
2123 } 2123 }
2124 2124
2125 void 2125 void
2126 gtk_webview_get_current_format(GtkWebView *webview, gboolean *bold, 2126 pidgin_webview_get_current_format(PidginWebView *webview, gboolean *bold,
2127 gboolean *italic, gboolean *underline, 2127 gboolean *italic, gboolean *underline,
2128 gboolean *strike) 2128 gboolean *strike)
2129 { 2129 {
2130 WebKitDOMDocument *dom; 2130 WebKitDOMDocument *dom;
2131 2131
2142 if (strike) 2142 if (strike)
2143 *strike = webkit_dom_document_query_command_state(dom, "strikethrough"); 2143 *strike = webkit_dom_document_query_command_state(dom, "strikethrough");
2144 } 2144 }
2145 2145
2146 char * 2146 char *
2147 gtk_webview_get_current_fontface(GtkWebView *webview) 2147 pidgin_webview_get_current_fontface(PidginWebView *webview)
2148 { 2148 {
2149 WebKitDOMDocument *dom; 2149 WebKitDOMDocument *dom;
2150 2150
2151 g_return_val_if_fail(webview != NULL, NULL); 2151 g_return_val_if_fail(webview != NULL, NULL);
2152 2152
2153 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 2153 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
2154 return webkit_dom_document_query_command_value(dom, "fontName"); 2154 return webkit_dom_document_query_command_value(dom, "fontName");
2155 } 2155 }
2156 2156
2157 char * 2157 char *
2158 gtk_webview_get_current_forecolor(GtkWebView *webview) 2158 pidgin_webview_get_current_forecolor(PidginWebView *webview)
2159 { 2159 {
2160 WebKitDOMDocument *dom; 2160 WebKitDOMDocument *dom;
2161 2161
2162 g_return_val_if_fail(webview != NULL, NULL); 2162 g_return_val_if_fail(webview != NULL, NULL);
2163 2163
2164 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 2164 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
2165 return webkit_dom_document_query_command_value(dom, "foreColor"); 2165 return webkit_dom_document_query_command_value(dom, "foreColor");
2166 } 2166 }
2167 2167
2168 char * 2168 char *
2169 gtk_webview_get_current_backcolor(GtkWebView *webview) 2169 pidgin_webview_get_current_backcolor(PidginWebView *webview)
2170 { 2170 {
2171 WebKitDOMDocument *dom; 2171 WebKitDOMDocument *dom;
2172 2172
2173 g_return_val_if_fail(webview != NULL, NULL); 2173 g_return_val_if_fail(webview != NULL, NULL);
2174 2174
2175 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 2175 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
2176 return webkit_dom_document_query_command_value(dom, "backColor"); 2176 return webkit_dom_document_query_command_value(dom, "backColor");
2177 } 2177 }
2178 2178
2179 gint 2179 gint
2180 gtk_webview_get_current_fontsize(GtkWebView *webview) 2180 pidgin_webview_get_current_fontsize(PidginWebView *webview)
2181 { 2181 {
2182 WebKitDOMDocument *dom; 2182 WebKitDOMDocument *dom;
2183 gchar *text; 2183 gchar *text;
2184 gint size; 2184 gint size;
2185 2185
2192 2192
2193 return size; 2193 return size;
2194 } 2194 }
2195 2195
2196 void 2196 void
2197 gtk_webview_clear_formatting(GtkWebView *webview) 2197 pidgin_webview_clear_formatting(PidginWebView *webview)
2198 { 2198 {
2199 GObject *object; 2199 GObject *object;
2200 2200
2201 g_return_if_fail(webview != NULL); 2201 g_return_if_fail(webview != NULL);
2202 2202
2204 g_signal_emit(object, signals[CLEAR_FORMAT], 0); 2204 g_signal_emit(object, signals[CLEAR_FORMAT], 0);
2205 g_object_unref(object); 2205 g_object_unref(object);
2206 } 2206 }
2207 2207
2208 void 2208 void
2209 gtk_webview_toggle_bold(GtkWebView *webview) 2209 pidgin_webview_toggle_bold(PidginWebView *webview)
2210 { 2210 {
2211 g_return_if_fail(webview != NULL); 2211 g_return_if_fail(webview != NULL);
2212 emit_format_signal(webview, GTK_WEBVIEW_BOLD); 2212 emit_format_signal(webview, PIDGIN_WEBVIEW_BOLD);
2213 } 2213 }
2214 2214
2215 void 2215 void
2216 gtk_webview_toggle_italic(GtkWebView *webview) 2216 pidgin_webview_toggle_italic(PidginWebView *webview)
2217 { 2217 {
2218 g_return_if_fail(webview != NULL); 2218 g_return_if_fail(webview != NULL);
2219 emit_format_signal(webview, GTK_WEBVIEW_ITALIC); 2219 emit_format_signal(webview, PIDGIN_WEBVIEW_ITALIC);
2220 } 2220 }
2221 2221
2222 void 2222 void
2223 gtk_webview_toggle_underline(GtkWebView *webview) 2223 pidgin_webview_toggle_underline(PidginWebView *webview)
2224 { 2224 {
2225 g_return_if_fail(webview != NULL); 2225 g_return_if_fail(webview != NULL);
2226 emit_format_signal(webview, GTK_WEBVIEW_UNDERLINE); 2226 emit_format_signal(webview, PIDGIN_WEBVIEW_UNDERLINE);
2227 } 2227 }
2228 2228
2229 void 2229 void
2230 gtk_webview_toggle_strike(GtkWebView *webview) 2230 pidgin_webview_toggle_strike(PidginWebView *webview)
2231 { 2231 {
2232 g_return_if_fail(webview != NULL); 2232 g_return_if_fail(webview != NULL);
2233 emit_format_signal(webview, GTK_WEBVIEW_STRIKE); 2233 emit_format_signal(webview, PIDGIN_WEBVIEW_STRIKE);
2234 } 2234 }
2235 2235
2236 gboolean 2236 gboolean
2237 gtk_webview_toggle_forecolor(GtkWebView *webview, const char *color) 2237 pidgin_webview_toggle_forecolor(PidginWebView *webview, const char *color)
2238 { 2238 {
2239 g_return_val_if_fail(webview != NULL, FALSE); 2239 g_return_val_if_fail(webview != NULL, FALSE);
2240 2240
2241 do_formatting(webview, "foreColor", color); 2241 do_formatting(webview, "foreColor", color);
2242 emit_format_signal(webview, GTK_WEBVIEW_FORECOLOR); 2242 emit_format_signal(webview, PIDGIN_WEBVIEW_FORECOLOR);
2243 2243
2244 return FALSE; 2244 return FALSE;
2245 } 2245 }
2246 2246
2247 gboolean 2247 gboolean
2248 gtk_webview_toggle_backcolor(GtkWebView *webview, const char *color) 2248 pidgin_webview_toggle_backcolor(PidginWebView *webview, const char *color)
2249 { 2249 {
2250 g_return_val_if_fail(webview != NULL, FALSE); 2250 g_return_val_if_fail(webview != NULL, FALSE);
2251 2251
2252 do_formatting(webview, "backColor", color); 2252 do_formatting(webview, "backColor", color);
2253 emit_format_signal(webview, GTK_WEBVIEW_BACKCOLOR); 2253 emit_format_signal(webview, PIDGIN_WEBVIEW_BACKCOLOR);
2254 2254
2255 return FALSE; 2255 return FALSE;
2256 } 2256 }
2257 2257
2258 gboolean 2258 gboolean
2259 gtk_webview_toggle_fontface(GtkWebView *webview, const char *face) 2259 pidgin_webview_toggle_fontface(PidginWebView *webview, const char *face)
2260 { 2260 {
2261 g_return_val_if_fail(webview != NULL, FALSE); 2261 g_return_val_if_fail(webview != NULL, FALSE);
2262 2262
2263 do_formatting(webview, "fontName", face); 2263 do_formatting(webview, "fontName", face);
2264 emit_format_signal(webview, GTK_WEBVIEW_FACE); 2264 emit_format_signal(webview, PIDGIN_WEBVIEW_FACE);
2265 2265
2266 return FALSE; 2266 return FALSE;
2267 } 2267 }
2268 2268
2269 void 2269 void
2270 gtk_webview_font_set_size(GtkWebView *webview, gint size) 2270 pidgin_webview_font_set_size(PidginWebView *webview, gint size)
2271 { 2271 {
2272 char *tmp; 2272 char *tmp;
2273 2273
2274 g_return_if_fail(webview != NULL); 2274 g_return_if_fail(webview != NULL);
2275 2275
2276 tmp = g_strdup_printf("%d", size); 2276 tmp = g_strdup_printf("%d", size);
2277 do_formatting(webview, "fontSize", tmp); 2277 do_formatting(webview, "fontSize", tmp);
2278 emit_format_signal(webview, GTK_WEBVIEW_SHRINK|GTK_WEBVIEW_GROW); 2278 emit_format_signal(webview, PIDGIN_WEBVIEW_SHRINK|PIDGIN_WEBVIEW_GROW);
2279 g_free(tmp); 2279 g_free(tmp);
2280 } 2280 }
2281 2281
2282 void 2282 void
2283 gtk_webview_font_shrink(GtkWebView *webview) 2283 pidgin_webview_font_shrink(PidginWebView *webview)
2284 { 2284 {
2285 g_return_if_fail(webview != NULL); 2285 g_return_if_fail(webview != NULL);
2286 emit_format_signal(webview, GTK_WEBVIEW_SHRINK); 2286 emit_format_signal(webview, PIDGIN_WEBVIEW_SHRINK);
2287 } 2287 }
2288 2288
2289 void 2289 void
2290 gtk_webview_font_grow(GtkWebView *webview) 2290 pidgin_webview_font_grow(PidginWebView *webview)
2291 { 2291 {
2292 g_return_if_fail(webview != NULL); 2292 g_return_if_fail(webview != NULL);
2293 emit_format_signal(webview, GTK_WEBVIEW_GROW); 2293 emit_format_signal(webview, PIDGIN_WEBVIEW_GROW);
2294 } 2294 }
2295 2295
2296 void 2296 void
2297 gtk_webview_insert_hr(GtkWebView *webview) 2297 pidgin_webview_insert_hr(PidginWebView *webview)
2298 { 2298 {
2299 GtkWebViewPriv *priv; 2299 PidginWebViewPriv *priv;
2300 WebKitDOMDocument *dom; 2300 WebKitDOMDocument *dom;
2301 2301
2302 g_return_if_fail(webview != NULL); 2302 g_return_if_fail(webview != NULL);
2303 2303
2304 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2304 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2305 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 2305 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
2306 2306
2307 priv->edit.block_changed = TRUE; 2307 priv->edit.block_changed = TRUE;
2308 webkit_dom_document_exec_command(dom, "insertHorizontalRule", FALSE, ""); 2308 webkit_dom_document_exec_command(dom, "insertHorizontalRule", FALSE, "");
2309 priv->edit.block_changed = FALSE; 2309 priv->edit.block_changed = FALSE;
2310 } 2310 }
2311 2311
2312 void 2312 void
2313 gtk_webview_insert_link(GtkWebView *webview, const char *url, const char *desc) 2313 pidgin_webview_insert_link(PidginWebView *webview, const char *url, const char *desc)
2314 { 2314 {
2315 GtkWebViewPriv *priv; 2315 PidginWebViewPriv *priv;
2316 WebKitDOMDocument *dom; 2316 WebKitDOMDocument *dom;
2317 char *link; 2317 char *link;
2318 2318
2319 g_return_if_fail(webview != NULL); 2319 g_return_if_fail(webview != NULL);
2320 2320
2321 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2321 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2322 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 2322 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
2323 link = g_strdup_printf("<a href='%s'>%s</a>", url, desc ? desc : url); 2323 link = g_strdup_printf("<a href='%s'>%s</a>", url, desc ? desc : url);
2324 2324
2325 priv->edit.block_changed = TRUE; 2325 priv->edit.block_changed = TRUE;
2326 webkit_dom_document_exec_command(dom, "insertHTML", FALSE, link); 2326 webkit_dom_document_exec_command(dom, "insertHTML", FALSE, link);
2327 priv->edit.block_changed = FALSE; 2327 priv->edit.block_changed = FALSE;
2328 g_free(link); 2328 g_free(link);
2329 } 2329 }
2330 2330
2331 void 2331 void
2332 gtk_webview_insert_image(GtkWebView *webview, int id) 2332 pidgin_webview_insert_image(PidginWebView *webview, int id)
2333 { 2333 {
2334 GtkWebViewPriv *priv; 2334 PidginWebViewPriv *priv;
2335 WebKitDOMDocument *dom; 2335 WebKitDOMDocument *dom;
2336 char *img; 2336 char *img;
2337 2337
2338 g_return_if_fail(webview != NULL); 2338 g_return_if_fail(webview != NULL);
2339 2339
2340 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2340 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2341 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); 2341 dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
2342 img = g_strdup_printf("<img src='" PURPLE_STORED_IMAGE_PROTOCOL "%d'/>", 2342 img = g_strdup_printf("<img src='" PURPLE_STORED_IMAGE_PROTOCOL "%d'/>",
2343 id); 2343 id);
2344 2344
2345 priv->edit.block_changed = TRUE; 2345 priv->edit.block_changed = TRUE;
2347 priv->edit.block_changed = FALSE; 2347 priv->edit.block_changed = FALSE;
2348 g_free(img); 2348 g_free(img);
2349 } 2349 }
2350 2350
2351 void 2351 void
2352 gtk_webview_set_toolbar(GtkWebView *webview, GtkWidget *toolbar) 2352 pidgin_webview_set_toolbar(PidginWebView *webview, GtkWidget *toolbar)
2353 { 2353 {
2354 GtkWebViewPriv *priv; 2354 PidginWebViewPriv *priv;
2355 2355
2356 g_return_if_fail(webview != NULL); 2356 g_return_if_fail(webview != NULL);
2357 2357
2358 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2358 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2359 priv->toolbar = GTK_WEBVIEWTOOLBAR(toolbar); 2359 priv->toolbar = PIDGIN_WEBVIEWTOOLBAR(toolbar);
2360 } 2360 }
2361 2361
2362 void 2362 void
2363 gtk_webview_show_toolbar(GtkWebView *webview) 2363 pidgin_webview_show_toolbar(PidginWebView *webview)
2364 { 2364 {
2365 GtkWebViewPriv *priv; 2365 PidginWebViewPriv *priv;
2366 2366
2367 g_return_if_fail(webview != NULL); 2367 g_return_if_fail(webview != NULL);
2368 2368
2369 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2369 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2370 g_return_if_fail(priv->toolbar != NULL); 2370 g_return_if_fail(priv->toolbar != NULL);
2371 2371
2372 gtk_widget_show(GTK_WIDGET(priv->toolbar)); 2372 gtk_widget_show(GTK_WIDGET(priv->toolbar));
2373 } 2373 }
2374 2374
2375 void 2375 void
2376 gtk_webview_hide_toolbar(GtkWebView *webview) 2376 pidgin_webview_hide_toolbar(PidginWebView *webview)
2377 { 2377 {
2378 GtkWebViewPriv *priv; 2378 PidginWebViewPriv *priv;
2379 2379
2380 g_return_if_fail(webview != NULL); 2380 g_return_if_fail(webview != NULL);
2381 2381
2382 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2382 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2383 g_return_if_fail(priv->toolbar != NULL); 2383 g_return_if_fail(priv->toolbar != NULL);
2384 2384
2385 gtk_widget_hide(GTK_WIDGET(priv->toolbar)); 2385 gtk_widget_hide(GTK_WIDGET(priv->toolbar));
2386 } 2386 }
2387 2387
2388 void 2388 void
2389 gtk_webview_activate_toolbar(GtkWebView *webview, GtkWebViewAction action) 2389 pidgin_webview_activate_toolbar(PidginWebView *webview, PidginWebViewAction action)
2390 { 2390 {
2391 GtkWebViewPriv *priv; 2391 PidginWebViewPriv *priv;
2392 2392
2393 g_return_if_fail(webview != NULL); 2393 g_return_if_fail(webview != NULL);
2394 2394
2395 priv = GTK_WEBVIEW_GET_PRIVATE(webview); 2395 priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
2396 g_return_if_fail(priv->toolbar != NULL); 2396 g_return_if_fail(priv->toolbar != NULL);
2397 2397
2398 gtk_webviewtoolbar_activate(priv->toolbar, action); 2398 pidgin_webviewtoolbar_activate(priv->toolbar, action);
2399 } 2399 }
2400 2400

Mercurial Repository: pidgin3

mercurial