Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkconv.c

pidgin/gtkconv.c

changeset 33259
51d25c394fca
parent 33251
887606eec74b
child 33261
1e26b193b3a5
equal deleted inserted replaced
33258:7f35c2552b63 33259:51d25c394fca
62 #include "gtkconv.h" 62 #include "gtkconv.h"
63 #include "gtkconvwin.h" 63 #include "gtkconvwin.h"
64 #include "gtkconv-theme.h" 64 #include "gtkconv-theme.h"
65 #include "gtkconv-theme-loader.h" 65 #include "gtkconv-theme-loader.h"
66 #include "gtkdialogs.h" 66 #include "gtkdialogs.h"
67 #include "gtkimhtml.h"
68 #include "gtkimhtmltoolbar.h"
69 #include "gtklog.h" 67 #include "gtklog.h"
70 #include "gtkmenutray.h" 68 #include "gtkmenutray.h"
71 #include "gtkpounce.h" 69 #include "gtkpounce.h"
72 #include "gtkprefs.h" 70 #include "gtkprefs.h"
73 #include "gtkprivacy.h" 71 #include "gtkprivacy.h"
74 #include "gtkthemes.h" 72 #include "gtkthemes.h"
75 #include "gtkutils.h" 73 #include "gtkutils.h"
76 #include "gtkwebview.h" 74 #include "gtkwebview.h"
75 #include "gtkwebviewtoolbar.h"
77 #include "pidginstock.h" 76 #include "pidginstock.h"
78 #include "pidgintooltip.h" 77 #include "pidgintooltip.h"
79 #include "smileyparser.h" 78 #include "smileyparser.h"
80 79
81 #include "gtknickcolors.h" 80 #include "gtknickcolors.h"
329 328
330 static void 329 static void
331 default_formatize(PidginConversation *c) 330 default_formatize(PidginConversation *c)
332 { 331 {
333 PurpleConversation *conv = c->active_conv; 332 PurpleConversation *conv = c->active_conv;
334 gtk_imhtml_setup_entry(GTK_IMHTML(c->entry), purple_conversation_get_features(conv)); 333 gtk_webview_setup_entry(GTK_WEBVIEW(c->entry), purple_conversation_get_features(conv));
335 } 334 }
336 335
337 static void 336 static void
338 conversation_entry_clear(PidginConversation *gtkconv) 337 conversation_entry_clear(PidginConversation *gtkconv)
339 { 338 {
340 GtkIMHtml *imhtml = GTK_IMHTML(gtkconv->entry); 339 GtkWebView *webview = GTK_WEBVIEW(gtkconv->entry);
341 gtk_source_undo_manager_begin_not_undoable_action(imhtml->undo_manager); 340 gtk_webview_load_html_string(webview, "");
342 gtk_imhtml_clear(imhtml); 341 #if 0
343 gtk_source_undo_manager_end_not_undoable_action(imhtml->undo_manager); 342 /* TODO WebKit */
344 } 343 gtk_source_undo_manager_begin_not_undoable_action(webview->undo_manager);
345 344 gtk_webview_clear(webview);
346 static void 345 gtk_source_undo_manager_end_not_undoable_action(webview->undo_manager);
347 clear_formatting_cb(GtkIMHtml *imhtml, PidginConversation *gtkconv) 346 #endif
347 }
348
349 static void
350 clear_formatting_cb(GtkWebView *webview, PidginConversation *gtkconv)
348 { 351 {
349 default_formatize(gtkconv); 352 default_formatize(gtkconv);
350 } 353 }
351 354
352 static const char * 355 static const char *
539 gboolean retval = FALSE; 542 gboolean retval = FALSE;
540 543
541 gtkconv = PIDGIN_CONVERSATION(conv); 544 gtkconv = PIDGIN_CONVERSATION(conv);
542 prefix = pidgin_get_cmd_prefix(); 545 prefix = pidgin_get_cmd_prefix();
543 546
544 cmd = gtk_imhtml_get_text(GTK_IMHTML(gtkconv->entry), NULL, NULL); 547 cmd = gtk_webview_get_body_text(GTK_WEBVIEW(gtkconv->entry));
545 gtk_text_buffer_get_start_iter(GTK_IMHTML(gtkconv->entry)->text_buffer, &start); 548
546 549 if (cmd && purple_str_has_prefix(cmd, prefix)) {
547 if (cmd && (strncmp(cmd, prefix, strlen(prefix)) == 0)
548 && !gtk_text_iter_get_child_anchor(&start)) {
549 PurpleCmdStatus status; 550 PurpleCmdStatus status;
550 char *error, *cmdline, *markup, *send_history; 551 char *error, *cmdline, *markup, *send_history;
551 GtkTextIter end; 552
552 553 send_history = gtk_webview_get_body_html(GTK_WEBVIEW(gtkconv->entry));
553 send_history = gtk_imhtml_get_markup(GTK_IMHTML(gtkconv->entry));
554 send_history_add(gtkconv, send_history); 554 send_history_add(gtkconv, send_history);
555 g_free(send_history); 555 g_free(send_history);
556 556
557 cmdline = cmd + strlen(prefix); 557 cmdline = cmd + strlen(prefix);
558 558
561 PURPLE_MESSAGE_NO_LOG, time(NULL)); 561 PURPLE_MESSAGE_NO_LOG, time(NULL));
562 g_free(cmd); 562 g_free(cmd);
563 return TRUE; 563 return TRUE;
564 } 564 }
565 565
566 gtk_text_iter_forward_chars(&start, g_utf8_strlen(prefix, -1)); 566 /* TODO WebKit: Cut out prefix for markup... */
567 gtk_text_buffer_get_end_iter(GTK_IMHTML(gtkconv->entry)->text_buffer, &end); 567 markup = gtk_webview_get_body_html(GTK_WEBVIEW(gtkconv->entry));
568 markup = gtk_imhtml_get_markup_range(GTK_IMHTML(gtkconv->entry), &start, &end);
569 status = purple_cmd_do_command(conv, cmdline, markup, &error); 568 status = purple_cmd_do_command(conv, cmdline, markup, &error);
570 g_free(markup); 569 g_free(markup);
571 570
572 switch (status) { 571 switch (status) {
573 case PURPLE_CMD_STATUS_OK: 572 case PURPLE_CMD_STATUS_OK:
625 break; 624 break;
626 } 625 }
627 } 626 }
628 627
629 g_free(cmd); 628 g_free(cmd);
629
630 return retval; 630 return retval;
631 } 631 }
632 632
633 static void 633 static void
634 send_cb(GtkWidget *widget, PidginConversation *gtkconv) 634 send_cb(GtkWidget *widget, PidginConversation *gtkconv)
651 return; 651 return;
652 652
653 if (!purple_account_is_connected(account)) 653 if (!purple_account_is_connected(account))
654 return; 654 return;
655 655
656 buf = gtk_imhtml_get_markup(GTK_IMHTML(gtkconv->entry)); 656 buf = gtk_webview_get_body_html(GTK_WEBVIEW(gtkconv->entry));
657 clean = gtk_imhtml_get_text(GTK_IMHTML(gtkconv->entry), NULL, NULL); 657 clean = gtk_webview_get_body_text(GTK_WEBVIEW(gtkconv->entry));
658 658
659 gtk_widget_grab_focus(gtkconv->entry); 659 gtk_widget_grab_focus(gtkconv->entry);
660 660
661 if (!*clean) { 661 if (!*clean) {
662 g_free(buf); 662 g_free(buf);
664 return; 664 return;
665 } 665 }
666 666
667 purple_idle_touch(); 667 purple_idle_touch();
668 668
669 #if 0
670 /* TODO WebKit: Image stuff... */
669 /* XXX: is there a better way to tell if the message has images? */ 671 /* XXX: is there a better way to tell if the message has images? */
670 if (GTK_IMHTML(gtkconv->entry)->im_images != NULL) 672 if (GTK_WEBVIEW(gtkconv->entry)->im_images != NULL)
671 flags |= PURPLE_MESSAGE_IMAGES; 673 flags |= PURPLE_MESSAGE_IMAGES;
672 674 #endif
673 gc = purple_account_get_connection(account); 675
676 gc = NULL/*purple_account_get_connection(account)*/;
674 if (gc && (purple_conversation_get_features(conv) & PURPLE_CONNECTION_NO_NEWLINES)) { 677 if (gc && (purple_conversation_get_features(conv) & PURPLE_CONNECTION_NO_NEWLINES)) {
678 #if 0
679 /* TODO WebKit */
675 char **bufs; 680 char **bufs;
676 int i; 681 int i;
677 682
678 bufs = gtk_imhtml_get_markup_lines(GTK_IMHTML(gtkconv->entry)); 683 bufs = gtk_webview_get_markup_lines(GTK_WEBVIEW(gtkconv->entry));
679 for (i = 0; bufs[i]; i++) { 684 for (i = 0; bufs[i]; i++) {
680 send_history_add(gtkconv, bufs[i]); 685 send_history_add(gtkconv, bufs[i]);
681 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) 686 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM)
682 purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), bufs[i], flags); 687 purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), bufs[i], flags);
683 else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) 688 else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT)
684 purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(conv), bufs[i], flags); 689 purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(conv), bufs[i], flags);
685 } 690 }
686 691
687 g_strfreev(bufs); 692 g_strfreev(bufs);
693 #endif
688 694
689 } else { 695 } else {
690 send_history_add(gtkconv, buf); 696 send_history_add(gtkconv, buf);
691 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) 697 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM)
692 purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), buf, flags); 698 purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), buf, flags);
1263 static void 1269 static void
1264 menu_insert_link_cb(GtkAction *action, gpointer data) 1270 menu_insert_link_cb(GtkAction *action, gpointer data)
1265 { 1271 {
1266 PidginWindow *win = data; 1272 PidginWindow *win = data;
1267 PidginConversation *gtkconv; 1273 PidginConversation *gtkconv;
1268 GtkIMHtmlToolbar *toolbar; 1274 GtkWebViewToolbar *toolbar;
1269 1275
1270 gtkconv = pidgin_conv_window_get_active_gtkconv(win); 1276 gtkconv = pidgin_conv_window_get_active_gtkconv(win);
1271 toolbar = GTK_IMHTMLTOOLBAR(gtkconv->toolbar); 1277 toolbar = GTK_WEBVIEWTOOLBAR(gtkconv->toolbar);
1272 1278
1273 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->link), 1279 gtk_webviewtoolbar_activate(toolbar, GTK_WEBVIEWTOOLBAR_ACTION_LINK);
1274 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->link)));
1275 } 1280 }
1276 1281
1277 static void 1282 static void
1278 menu_insert_image_cb(GtkAction *action, gpointer data) 1283 menu_insert_image_cb(GtkAction *action, gpointer data)
1279 { 1284 {
1280 PidginWindow *win = data; 1285 PidginWindow *win = data;
1281 PidginConversation *gtkconv; 1286 PidginConversation *gtkconv;
1282 GtkIMHtmlToolbar *toolbar; 1287 GtkWebViewToolbar *toolbar;
1283 1288
1284 gtkconv = pidgin_conv_window_get_active_gtkconv(win); 1289 gtkconv = pidgin_conv_window_get_active_gtkconv(win);
1285 toolbar = GTK_IMHTMLTOOLBAR(gtkconv->toolbar); 1290 toolbar = GTK_WEBVIEWTOOLBAR(gtkconv->toolbar);
1286 1291
1287 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), 1292 gtk_webviewtoolbar_activate(toolbar, GTK_WEBVIEWTOOLBAR_ACTION_IMAGE);
1288 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->image))); 1293 }
1289 }
1290
1291 1294
1292 static void 1295 static void
1293 menu_alias_cb(GtkAction *action, gpointer data) 1296 menu_alias_cb(GtkAction *action, gpointer data)
1294 { 1297 {
1295 PidginWindow *win = data; 1298 PidginWindow *win = data;
1959 conv_keypress_common(PidginConversation *gtkconv, GdkEventKey *event) 1962 conv_keypress_common(PidginConversation *gtkconv, GdkEventKey *event)
1960 { 1963 {
1961 PidginWindow *win; 1964 PidginWindow *win;
1962 int curconv; 1965 int curconv;
1963 1966
1964 win = gtkconv->win; 1967 win = gtkconv->win;
1965 curconv = gtk_notebook_get_current_page(GTK_NOTEBOOK(win->notebook)); 1968 curconv = gtk_notebook_get_current_page(GTK_NOTEBOOK(win->notebook));
1966 1969
1967 /* clear any tooltips */ 1970 /* clear any tooltips */
1968 pidgin_tooltip_destroy(); 1971 pidgin_tooltip_destroy();
1969 1972
2075 2078
2076 if (gtkconv->entry != entry) 2079 if (gtkconv->entry != entry)
2077 break; 2080 break;
2078 2081
2079 if (!gtkconv->send_history->prev) { 2082 if (!gtkconv->send_history->prev) {
2080 GtkTextIter start, end;
2081
2082 g_free(gtkconv->send_history->data); 2083 g_free(gtkconv->send_history->data);
2083 2084
2084 gtk_text_buffer_get_start_iter(gtkconv->entry_buffer,
2085 &start);
2086 gtk_text_buffer_get_end_iter(gtkconv->entry_buffer, &end);
2087
2088 gtkconv->send_history->data = 2085 gtkconv->send_history->data =
2089 gtk_imhtml_get_markup(GTK_IMHTML(gtkconv->entry)); 2086 gtk_webview_get_body_html(GTK_WEBVIEW(gtkconv->entry));
2090 } 2087 }
2091 2088
2092 if (gtkconv->send_history->next && gtkconv->send_history->next->data) { 2089 if (gtkconv->send_history->next && gtkconv->send_history->next->data) {
2093 GObject *object; 2090 GObject *object;
2091 #if 0
2092 /* TODO WebKit: maybe not necessary? */
2094 GtkTextIter iter; 2093 GtkTextIter iter;
2095 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->entry)); 2094 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->entry));
2095 #endif
2096 2096
2097 gtkconv->send_history = gtkconv->send_history->next; 2097 gtkconv->send_history = gtkconv->send_history->next;
2098 2098
2099 /* Block the signal to prevent application of default formatting. */ 2099 /* Block the signal to prevent application of default formatting. */
2100 object = g_object_ref(G_OBJECT(gtkconv->entry)); 2100 object = g_object_ref(G_OBJECT(gtkconv->entry));
2101 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, 2101 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA,
2102 NULL, gtkconv); 2102 0, 0, NULL, NULL, gtkconv);
2103 /* Clear the formatting. */ 2103 /* Clear the formatting. */
2104 gtk_imhtml_clear_formatting(GTK_IMHTML(gtkconv->entry)); 2104 gtk_webview_clear_formatting(GTK_WEBVIEW(gtkconv->entry));
2105 /* Unblock the signal. */ 2105 /* Unblock the signal. */
2106 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, 2106 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA,
2107 NULL, gtkconv); 2107 0, 0, NULL, NULL, gtkconv);
2108 g_object_unref(object); 2108 g_object_unref(object);
2109 2109
2110 gtk_imhtml_clear(GTK_IMHTML(gtkconv->entry)); 2110 gtk_webview_load_html_string(GTK_WEBVIEW(gtkconv->entry),
2111 gtk_imhtml_append_text_with_images( 2111 gtkconv->send_history->data);
2112 GTK_IMHTML(gtkconv->entry), gtkconv->send_history->data,
2113 0, NULL);
2114 /* this is mainly just a hack so the formatting at the 2112 /* this is mainly just a hack so the formatting at the
2115 * cursor gets picked up. */ 2113 * cursor gets picked up. */
2114 #if 0
2115 /* TODO WebKit: maybe not necessary? */
2116 gtk_text_buffer_get_end_iter(buffer, &iter); 2116 gtk_text_buffer_get_end_iter(buffer, &iter);
2117 gtk_text_buffer_move_mark_by_name(buffer, "insert", &iter); 2117 gtk_text_buffer_move_mark_by_name(buffer, "insert", &iter);
2118 #endif
2118 } 2119 }
2119 2120
2120 return TRUE; 2121 return TRUE;
2121 break; 2122 break;
2122 2123
2127 if (gtkconv->entry != entry) 2128 if (gtkconv->entry != entry)
2128 break; 2129 break;
2129 2130
2130 if (gtkconv->send_history->prev && gtkconv->send_history->prev->data) { 2131 if (gtkconv->send_history->prev && gtkconv->send_history->prev->data) {
2131 GObject *object; 2132 GObject *object;
2133 #if 0
2134 /* TODO WebKit: maybe not necessary? */
2132 GtkTextIter iter; 2135 GtkTextIter iter;
2133 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->entry)); 2136 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->entry));
2137 #endif
2134 2138
2135 gtkconv->send_history = gtkconv->send_history->prev; 2139 gtkconv->send_history = gtkconv->send_history->prev;
2136 2140
2137 /* Block the signal to prevent application of default formatting. */ 2141 /* Block the signal to prevent application of default formatting. */
2138 object = g_object_ref(G_OBJECT(gtkconv->entry)); 2142 object = g_object_ref(G_OBJECT(gtkconv->entry));
2139 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, 2143 g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA,
2140 NULL, gtkconv); 2144 0, 0, NULL, NULL, gtkconv);
2141 /* Clear the formatting. */ 2145 /* Clear the formatting. */
2142 gtk_imhtml_clear_formatting(GTK_IMHTML(gtkconv->entry)); 2146 gtk_webview_clear_formatting(GTK_WEBVIEW(gtkconv->entry));
2143 /* Unblock the signal. */ 2147 /* Unblock the signal. */
2144 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, 2148 g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA,
2145 NULL, gtkconv); 2149 0, 0, NULL, NULL, gtkconv);
2146 g_object_unref(object); 2150 g_object_unref(object);
2147 2151
2148 gtk_imhtml_clear(GTK_IMHTML(gtkconv->entry)); 2152 gtk_webview_load_html_string(GTK_WEBVIEW(gtkconv->entry),
2149 gtk_imhtml_append_text_with_images( 2153 gtkconv->send_history->data);
2150 GTK_IMHTML(gtkconv->entry), gtkconv->send_history->data,
2151 0, NULL);
2152 /* this is mainly just a hack so the formatting at the 2154 /* this is mainly just a hack so the formatting at the
2153 * cursor gets picked up. */ 2155 * cursor gets picked up. */
2154 if (*(char *)gtkconv->send_history->data) { 2156 if (*(char *)gtkconv->send_history->data) {
2157 #if 0
2158 /* TODO WebKit: maybe not necessary? */
2155 gtk_text_buffer_get_end_iter(buffer, &iter); 2159 gtk_text_buffer_get_end_iter(buffer, &iter);
2156 gtk_text_buffer_move_mark_by_name(buffer, "insert", &iter); 2160 gtk_text_buffer_move_mark_by_name(buffer, "insert", &iter);
2161 #endif
2157 } else { 2162 } else {
2158 /* Restore the default formatting */ 2163 /* Restore the default formatting */
2159 default_formatize(gtkconv); 2164 default_formatize(gtkconv);
2160 } 2165 }
2161 } 2166 }
2194 break; 2199 break;
2195 2200
2196 case GDK_KEY_Page_Down: 2201 case GDK_KEY_Page_Down:
2197 case GDK_KEY_KP_Page_Down: 2202 case GDK_KEY_KP_Page_Down:
2198 gtk_webview_page_down(GTK_WEBVIEW(gtkconv->webview)); 2203 gtk_webview_page_down(GTK_WEBVIEW(gtkconv->webview));
2204 return TRUE;
2205 break;
2206
2207 case GDK_KEY_KP_Enter:
2208 case GDK_KEY_Return:
2209 send_cb(entry, gtkconv);
2199 return TRUE; 2210 return TRUE;
2200 break; 2211 break;
2201 2212
2202 } 2213 }
2203 } 2214 }
2277 void 2288 void
2278 pidgin_conv_switch_active_conversation(PurpleConversation *conv) 2289 pidgin_conv_switch_active_conversation(PurpleConversation *conv)
2279 { 2290 {
2280 PidginConversation *gtkconv; 2291 PidginConversation *gtkconv;
2281 PurpleConversation *old_conv; 2292 PurpleConversation *old_conv;
2282 GtkIMHtml *entry; 2293 GtkWebView *entry;
2283 const char *protocol_name; 2294 const char *protocol_name;
2284 PurpleConnectionFlags features; 2295 PurpleConnectionFlags features;
2285 2296
2286 g_return_if_fail(conv != NULL); 2297 g_return_if_fail(conv != NULL);
2287 2298
2288 gtkconv = PIDGIN_CONVERSATION(conv); 2299 gtkconv = PIDGIN_CONVERSATION(conv);
2289 old_conv = gtkconv->active_conv; 2300 old_conv = gtkconv->active_conv;
2290 2301
2291 purple_debug_info("gtkconv", "setting active conversation on toolbar %p\n", 2302 purple_debug_info("gtkconv", "setting active conversation on toolbar %p\n",
2292 conv); 2303 conv);
2293 gtk_imhtmltoolbar_switch_active_conversation(GTK_IMHTMLTOOLBAR(gtkconv->toolbar), 2304 gtk_webviewtoolbar_switch_active_conversation(GTK_WEBVIEWTOOLBAR(gtkconv->toolbar),
2294 conv); 2305 conv);
2295 2306
2296 if (old_conv == conv) 2307 if (old_conv == conv)
2297 return; 2308 return;
2298 2309
2300 gtkconv->active_conv = conv; 2311 gtkconv->active_conv = conv;
2301 2312
2302 purple_conversation_set_logging(conv, 2313 purple_conversation_set_logging(conv,
2303 gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(gtkconv->win->menu.logging))); 2314 gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(gtkconv->win->menu.logging)));
2304 2315
2305 entry = GTK_IMHTML(gtkconv->entry); 2316 entry = GTK_WEBVIEW(gtkconv->entry);
2306 protocol_name = purple_account_get_protocol_name(purple_conversation_get_account(conv)); 2317 protocol_name = purple_account_get_protocol_name(purple_conversation_get_account(conv));
2307 gtk_imhtml_set_protocol_name(entry, protocol_name); 2318 gtk_webview_set_protocol_name(entry, protocol_name);
2308 /* TODO WEBKIT: gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol_name); */ 2319 gtk_webview_set_protocol_name(GTK_WEBVIEW(gtkconv->webview), protocol_name);
2309 2320
2310 features = purple_conversation_get_features(conv); 2321 features = purple_conversation_get_features(conv);
2311 if (!(features & PURPLE_CONNECTION_HTML)) 2322 if (!(features & PURPLE_CONNECTION_HTML))
2312 gtk_imhtml_clear_formatting(GTK_IMHTML(gtkconv->entry)); 2323 gtk_webview_clear_formatting(GTK_WEBVIEW(gtkconv->entry));
2313 else if (features & PURPLE_CONNECTION_FORMATTING_WBFO && 2324 else if (features & PURPLE_CONNECTION_FORMATTING_WBFO &&
2314 !(purple_conversation_get_features(old_conv) & PURPLE_CONNECTION_FORMATTING_WBFO)) 2325 !(purple_conversation_get_features(old_conv) & PURPLE_CONNECTION_FORMATTING_WBFO))
2315 { 2326 {
2316 /* The old conversation allowed formatting on parts of the 2327 /* The old conversation allowed formatting on parts of the
2317 * buffer, but the new one only allows it on the whole 2328 * buffer, but the new one only allows it on the whole
2320 * applies the saved formatting to the entire buffer. */ 2331 * applies the saved formatting to the entire buffer. */
2321 2332
2322 gboolean bold; 2333 gboolean bold;
2323 gboolean italic; 2334 gboolean italic;
2324 gboolean underline; 2335 gboolean underline;
2325 char *fontface = gtk_imhtml_get_current_fontface(entry); 2336 gboolean strike;
2326 char *forecolor = gtk_imhtml_get_current_forecolor(entry); 2337 char *fontface = gtk_webview_get_current_fontface(entry);
2327 char *backcolor = gtk_imhtml_get_current_backcolor(entry); 2338 char *forecolor = gtk_webview_get_current_forecolor(entry);
2328 char *background = gtk_imhtml_get_current_background(entry); 2339 char *backcolor = gtk_webview_get_current_backcolor(entry);
2329 gint fontsize = gtk_imhtml_get_current_fontsize(entry); 2340 #if 0
2341 /* TODO WebKit: Do we need this again? */
2342 char *background = gtk_webview_get_current_background(entry);
2343 #endif
2344 gint fontsize = gtk_webview_get_current_fontsize(entry);
2330 gboolean bold2; 2345 gboolean bold2;
2331 gboolean italic2; 2346 gboolean italic2;
2332 gboolean underline2; 2347 gboolean underline2;
2333 2348 gboolean strike2;
2334 gtk_imhtml_get_current_format(entry, &bold, &italic, &underline); 2349
2350 gtk_webview_get_current_format(entry, &bold, &italic, &underline, &strike);
2335 2351
2336 /* Clear existing formatting */ 2352 /* Clear existing formatting */
2337 gtk_imhtml_clear_formatting(entry); 2353 gtk_webview_clear_formatting(entry);
2338 2354
2339 /* Apply saved formatting to the whole buffer. */ 2355 /* Apply saved formatting to the whole buffer. */
2340 2356
2341 gtk_imhtml_get_current_format(entry, &bold2, &italic2, &underline2); 2357 gtk_webview_get_current_format(entry, &bold2, &italic2, &underline2, &strike2);
2342 2358
2343 if (bold != bold2) 2359 if (bold != bold2)
2344 gtk_imhtml_toggle_bold(entry); 2360 gtk_webview_toggle_bold(entry);
2345 2361
2346 if (italic != italic2) 2362 if (italic != italic2)
2347 gtk_imhtml_toggle_italic(entry); 2363 gtk_webview_toggle_italic(entry);
2348 2364
2349 if (underline != underline2) 2365 if (underline != underline2)
2350 gtk_imhtml_toggle_underline(entry); 2366 gtk_webview_toggle_underline(entry);
2351 2367
2352 gtk_imhtml_toggle_fontface(entry, fontface); 2368 if (strike != strike2)
2369 gtk_webview_toggle_strike(entry);
2370
2371 gtk_webview_toggle_fontface(entry, fontface);
2353 2372
2354 if (!(features & PURPLE_CONNECTION_NO_FONTSIZE)) 2373 if (!(features & PURPLE_CONNECTION_NO_FONTSIZE))
2355 gtk_imhtml_font_set_size(entry, fontsize); 2374 gtk_webview_font_set_size(entry, fontsize);
2356 2375
2357 gtk_imhtml_toggle_forecolor(entry, forecolor); 2376 gtk_webview_toggle_forecolor(entry, forecolor);
2358 2377
2359 if (!(features & PURPLE_CONNECTION_NO_BGCOLOR)) 2378 if (!(features & PURPLE_CONNECTION_NO_BGCOLOR))
2360 { 2379 {
2361 gtk_imhtml_toggle_backcolor(entry, backcolor); 2380 gtk_webview_toggle_backcolor(entry, backcolor);
2362 gtk_imhtml_toggle_background(entry, background); 2381 #if 0
2382 gtk_webview_toggle_background(entry, background);
2383 #endif
2363 } 2384 }
2364 2385
2365 g_free(fontface); 2386 g_free(fontface);
2366 g_free(forecolor); 2387 g_free(forecolor);
2367 g_free(backcolor); 2388 g_free(backcolor);
2389 #if 0
2368 g_free(background); 2390 g_free(background);
2391 #endif
2369 } 2392 }
2370 else 2393 else
2371 { 2394 {
2372 /* This is done in default_formatize, which is called from clear_formatting_cb, 2395 /* This is done in default_formatize, which is called from clear_formatting_cb,
2373 * which is (obviously) a clear_formatting signal handler. However, if we're 2396 * which is (obviously) a clear_formatting signal handler. However, if we're
2374 * here, we didn't call gtk_imhtml_clear_formatting() (because we want to 2397 * here, we didn't call gtk_imhtml_clear_formatting() (because we want to
2375 * preserve the formatting exactly as it is), so we have to do this now. */ 2398 * preserve the formatting exactly as it is), so we have to do this now. */
2376 gtk_imhtml_set_whole_buffer_formatting_only(entry, 2399 gtk_webview_set_whole_buffer_formatting_only(entry,
2377 (features & PURPLE_CONNECTION_FORMATTING_WBFO)); 2400 (features & PURPLE_CONNECTION_FORMATTING_WBFO));
2378 } 2401 }
2379 2402
2380 purple_signal_emit(pidgin_conversations_get_handle(), "conversation-switched", conv); 2403 purple_signal_emit(pidgin_conversations_get_handle(), "conversation-switched", conv);
2381 2404
4273 } 4296 }
4274 4297
4275 static gboolean 4298 static gboolean
4276 tab_complete(PurpleConversation *conv) 4299 tab_complete(PurpleConversation *conv)
4277 { 4300 {
4301 #if 0
4302 /* TODO WebKit */
4278 PidginConversation *gtkconv; 4303 PidginConversation *gtkconv;
4279 GtkTextIter cursor, word_start, start_buffer; 4304 GtkTextIter cursor, word_start, start_buffer;
4280 int start; 4305 int start;
4281 int most_matched = -1; 4306 int most_matched = -1;
4282 char *entered, *partial = NULL; 4307 char *entered, *partial = NULL;
4443 g_free(addthis); 4468 g_free(addthis);
4444 } 4469 }
4445 4470
4446 g_free(entered); 4471 g_free(entered);
4447 g_free(partial); 4472 g_free(partial);
4448 4473 #endif
4449 return TRUE; 4474 return TRUE;
4450 } 4475 }
4451 4476
4452 static void topic_callback(GtkWidget *w, PidginConversation *gtkconv) 4477 static void topic_callback(GtkWidget *w, PidginConversation *gtkconv)
4453 { 4478 {
4703 return; 4728 return;
4704 4729
4705 buddy_cb_common(PURPLE_BUDDY(node), conv, FALSE); 4730 buddy_cb_common(PURPLE_BUDDY(node), conv, FALSE);
4706 } 4731 }
4707 4732
4708 static void send_menu_cb(GtkWidget *widget, PidginConversation *gtkconv) 4733 static void
4709 { 4734 entry_popup_menu_cb(GtkWebView *webview, GtkMenu *menu, gpointer data)
4710 g_signal_emit_by_name(gtkconv->entry, "message_send");
4711 }
4712
4713 static void
4714 entry_popup_menu_cb(GtkIMHtml *imhtml, GtkMenu *menu, gpointer data)
4715 { 4735 {
4716 GtkWidget *menuitem; 4736 GtkWidget *menuitem;
4717 PidginConversation *gtkconv = data; 4737 PidginConversation *gtkconv = data;
4738 char *tmp;
4718 4739
4719 g_return_if_fail(menu != NULL); 4740 g_return_if_fail(menu != NULL);
4720 g_return_if_fail(gtkconv != NULL); 4741 g_return_if_fail(gtkconv != NULL);
4721 4742
4722 menuitem = pidgin_new_item_from_stock(NULL, _("_Send"), NULL, 4743 menuitem = pidgin_new_item_from_stock(NULL, _("_Send"), NULL,
4723 G_CALLBACK(send_menu_cb), gtkconv, 4744 G_CALLBACK(send_cb), gtkconv,
4724 0, 0, NULL); 4745 0, 0, NULL);
4725 if (gtk_text_buffer_get_char_count(imhtml->text_buffer) == 0) 4746 tmp = gtk_webview_get_body_text(webview);
4747 if (!tmp || !*tmp)
4726 gtk_widget_set_sensitive(menuitem, FALSE); 4748 gtk_widget_set_sensitive(menuitem, FALSE);
4749 g_free(tmp);
4727 gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 0); 4750 gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 0);
4728 4751
4729 menuitem = gtk_separator_menu_item_new(); 4752 menuitem = gtk_separator_menu_item_new();
4730 gtk_widget_show(menuitem); 4753 gtk_widget_show(menuitem);
4731 gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 1); 4754 gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 1);
4732 } 4755 }
4733 4756
4734 static gboolean resize_imhtml_cb(PidginConversation *gtkconv) 4757 static gboolean
4758 resize_webview_cb(PidginConversation *gtkconv)
4735 { 4759 {
4736 GtkTextBuffer *buffer; 4760 GtkTextBuffer *buffer;
4737 GtkTextIter iter; 4761 GtkTextIter iter;
4738 int lines; 4762 int lines;
4739 GdkRectangle oneline; 4763 GdkRectangle oneline;
4811 while (l != NULL) 4835 while (l != NULL)
4812 { 4836 {
4813 conv = (PurpleConversation *)l->data; 4837 conv = (PurpleConversation *)l->data;
4814 4838
4815 if (PIDGIN_IS_PIDGIN_CONVERSATION(conv)) 4839 if (PIDGIN_IS_PIDGIN_CONVERSATION(conv))
4816 resize_imhtml_cb(PIDGIN_CONVERSATION(conv)); 4840 resize_webview_cb(PIDGIN_CONVERSATION(conv));
4817 4841
4818 l = l->next; 4842 l = l->next;
4819 } 4843 }
4820 } 4844 }
4821 4845
5406 GtkWidget *hpaned; 5430 GtkWidget *hpaned;
5407 5431
5408 /* Add the topic */ 5432 /* Add the topic */
5409 setup_chat_topic(gtkconv, vbox); 5433 setup_chat_topic(gtkconv, vbox);
5410 5434
5411 /* Add the gtkimhtml frame */ 5435 /* Add the gtkwebview frame */
5412 hpaned = gtk_hpaned_new(); 5436 hpaned = gtk_hpaned_new();
5413 gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); 5437 gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
5414 gtk_widget_show(hpaned); 5438 gtk_widget_show(hpaned);
5415 gtk_paned_pack1(GTK_PANED(hpaned), frame, TRUE, TRUE); 5439 gtk_paned_pack1(GTK_PANED(hpaned), frame, TRUE, TRUE);
5416 5440
5436 gtkconv->lower_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); 5460 gtkconv->lower_hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
5437 gtk_box_pack_start(GTK_BOX(vbox), gtkconv->lower_hbox, FALSE, FALSE, 0); 5461 gtk_box_pack_start(GTK_BOX(vbox), gtkconv->lower_hbox, FALSE, FALSE, 0);
5438 gtk_widget_show(gtkconv->lower_hbox); 5462 gtk_widget_show(gtkconv->lower_hbox);
5439 5463
5440 /* Setup the toolbar, entry widget and all signals */ 5464 /* Setup the toolbar, entry widget and all signals */
5441 frame = pidgin_create_imhtml(TRUE, &gtkconv->entry, &gtkconv->toolbar, NULL); 5465 frame = pidgin_create_webview(TRUE, &gtkconv->entry, &gtkconv->toolbar, NULL);
5442 gtk_box_pack_start(GTK_BOX(gtkconv->lower_hbox), frame, TRUE, TRUE, 0); 5466 gtk_box_pack_start(GTK_BOX(gtkconv->lower_hbox), frame, TRUE, TRUE, 0);
5443 gtk_widget_show(frame); 5467 gtk_widget_show(frame);
5444 5468
5445 gtk_widget_set_name(gtkconv->entry, "pidgin_conv_entry"); 5469 gtk_widget_set_name(gtkconv->entry, "pidgin_conv_entry");
5446 gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->entry), 5470 gtk_webview_set_protocol_name(GTK_WEBVIEW(gtkconv->entry),
5447 purple_account_get_protocol_name(purple_conversation_get_account(conv))); 5471 purple_account_get_protocol_name(purple_conversation_get_account(conv)));
5448 5472
5449 g_signal_connect(G_OBJECT(gtkconv->entry), "populate-popup", 5473 g_signal_connect(G_OBJECT(gtkconv->entry), "populate-popup",
5450 G_CALLBACK(entry_popup_menu_cb), gtkconv); 5474 G_CALLBACK(entry_popup_menu_cb), gtkconv);
5451 g_signal_connect(G_OBJECT(gtkconv->entry), "key_press_event", 5475 g_signal_connect(G_OBJECT(gtkconv->entry), "key-press-event",
5452 G_CALLBACK(entry_key_press_cb), gtkconv); 5476 G_CALLBACK(entry_key_press_cb), gtkconv);
5453 g_signal_connect_after(G_OBJECT(gtkconv->entry), "message_send", 5477 #if 0
5454 G_CALLBACK(send_cb), gtkconv); 5478 /* TODO WebKit: Why? */
5455 g_signal_connect_after(G_OBJECT(gtkconv->entry), "button_press_event", 5479 g_signal_connect_after(G_OBJECT(gtkconv->entry), "button-press-event",
5456 G_CALLBACK(entry_stop_rclick_cb), NULL); 5480 G_CALLBACK(entry_stop_rclick_cb), NULL);
5457 5481 #endif
5458 gtkconv->entry_buffer =
5459 gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->entry));
5460 g_object_set_data(G_OBJECT(gtkconv->entry_buffer), "user_data", gtkconv);
5461 5482
5462 if (!chat) { 5483 if (!chat) {
5463 /* For sending typing notifications for IMs */ 5484 /* For sending typing notifications for IMs */
5485 #if 0
5486 /* TODO WebKit */
5464 g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "insert_text", 5487 g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "insert_text",
5465 G_CALLBACK(insert_text_cb), gtkconv); 5488 G_CALLBACK(insert_text_cb), gtkconv);
5466 g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "delete_range", 5489 g_signal_connect(G_OBJECT(gtkconv->entry_buffer), "delete_range",
5467 G_CALLBACK(delete_text_cb), gtkconv); 5490 G_CALLBACK(delete_text_cb), gtkconv);
5491 #endif
5468 gtkconv->u.im->typing_timer = 0; 5492 gtkconv->u.im->typing_timer = 0;
5469 gtkconv->u.im->animate = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/im/animate_buddy_icons"); 5493 gtkconv->u.im->animate = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/im/animate_buddy_icons");
5470 gtkconv->u.im->show_icon = TRUE; 5494 gtkconv->u.im->show_icon = TRUE;
5471 } 5495 }
5472 5496
5497 #if 0
5498 /* TODO WebKit: sizing stuff? */
5473 g_signal_connect_swapped(G_OBJECT(gtkconv->entry_buffer), "changed", 5499 g_signal_connect_swapped(G_OBJECT(gtkconv->entry_buffer), "changed",
5474 G_CALLBACK(resize_imhtml_cb), gtkconv); 5500 G_CALLBACK(resize_webview_cb), gtkconv);
5475 g_signal_connect_swapped(G_OBJECT(gtkconv->entry), "size-allocate", 5501 g_signal_connect_swapped(G_OBJECT(gtkconv->entry), "size-allocate",
5476 G_CALLBACK(resize_imhtml_cb), gtkconv); 5502 G_CALLBACK(resize_webview_cb), gtkconv);
5503 #endif
5477 5504
5478 default_formatize(gtkconv); 5505 default_formatize(gtkconv);
5479 g_signal_connect_after(G_OBJECT(gtkconv->entry), "format_function_clear", 5506 g_signal_connect_after(G_OBJECT(gtkconv->entry), "format-cleared",
5480 G_CALLBACK(clear_formatting_cb), gtkconv); 5507 G_CALLBACK(clear_formatting_cb), gtkconv);
5481 return vbox; 5508 return vbox;
5482 } 5509 }
5483 5510
5484 static void 5511 static void
5606 } 5633 }
5607 5634
5608 5635
5609 static const GtkTargetEntry te[] = 5636 static const GtkTargetEntry te[] =
5610 { 5637 {
5611 GTK_IMHTML_DND_TARGETS,
5612 {"PURPLE_BLIST_NODE", GTK_TARGET_SAME_APP, PIDGIN_DRAG_BLIST_NODE}, 5638 {"PURPLE_BLIST_NODE", GTK_TARGET_SAME_APP, PIDGIN_DRAG_BLIST_NODE},
5613 {"application/x-im-contact", 0, PIDGIN_DRAG_IM_CONTACT} 5639 {"application/x-im-contact", 0, PIDGIN_DRAG_IM_CONTACT}
5614 }; 5640 };
5615 5641
5616 static PidginConversation * 5642 static PidginConversation *
6881 6907
6882 return FALSE; 6908 return FALSE;
6883 } 6909 }
6884 6910
6885 static gboolean 6911 static gboolean
6886 add_custom_smiley_for_imhtml(GtkIMHtml *imhtml, const char *sml, const char *smile) 6912 add_custom_smiley_for_webview(GtkWebView *webview, const char *sml, const char *smile)
6887 { 6913 {
6888 GtkIMHtmlSmiley *smiley; 6914 GtkWebViewSmiley *smiley;
6889 6915
6890 smiley = gtk_imhtml_smiley_get(imhtml, sml, smile); 6916 smiley = gtk_webview_smiley_find(webview, sml, smile);
6891 6917
6892 if (smiley) { 6918 if (smiley) {
6893 if (!(smiley->flags & GTK_IMHTML_SMILEY_CUSTOM)) { 6919 if (!(gtk_webview_smiley_get_flags(smiley) & GTK_WEBVIEW_SMILEY_CUSTOM))
6894 return FALSE; 6920 return FALSE;
6895 } 6921
6896 gtk_imhtml_smiley_reload(smiley); 6922 gtk_webview_smiley_reload(smiley);
6897 return TRUE; 6923 return TRUE;
6898 } 6924 }
6899 6925
6900 smiley = gtk_imhtml_smiley_create(NULL, smile, FALSE, GTK_IMHTML_SMILEY_CUSTOM); 6926 smiley = gtk_webview_smiley_create(NULL, smile, FALSE,
6901 gtk_imhtml_associate_smiley(imhtml, sml, smiley); 6927 GTK_WEBVIEW_SMILEY_CUSTOM);
6902 g_signal_connect_swapped(imhtml, "destroy", G_CALLBACK(gtk_imhtml_smiley_destroy), smiley); 6928 gtk_webview_associate_smiley(webview, sml, smiley);
6903 6929 g_signal_connect_swapped(webview, "destroy",
6904 return TRUE; 6930 G_CALLBACK(gtk_webview_smiley_destroy), smiley);
6905 } 6931
6906
6907 static gboolean
6908 add_custom_smiley_for_webview(GtkWebView *webview, const char *sml, const char *smile)
6909 {
6910 /* TODO WEBKIT: Smileys need to be added to webkit stuff */
6911 return TRUE; 6932 return TRUE;
6912 } 6933 }
6913 6934
6914 static gboolean 6935 static gboolean
6915 pidgin_conv_custom_smiley_add(PurpleConversation *conv, const char *smile, gboolean remote) 6936 pidgin_conv_custom_smiley_add(PurpleConversation *conv, const char *smile, gboolean remote)
6940 6961
6941 if (!add_custom_smiley_for_webview(GTK_WEBVIEW(gtkconv->webview), sml, smile)) 6962 if (!add_custom_smiley_for_webview(GTK_WEBVIEW(gtkconv->webview), sml, smile))
6942 return FALSE; 6963 return FALSE;
6943 6964
6944 if (!remote) /* If it's a local custom smiley, then add it for the entry */ 6965 if (!remote) /* If it's a local custom smiley, then add it for the entry */
6945 if (!add_custom_smiley_for_imhtml(GTK_IMHTML(gtkconv->entry), sml, smile)) 6966 if (!add_custom_smiley_for_webview(GTK_WEBVIEW(gtkconv->entry), sml, smile))
6946 return FALSE; 6967 return FALSE;
6947 6968
6948 return TRUE; 6969 return TRUE;
6949 } 6970 }
6950 6971
7038 static void 7059 static void
7039 pidgin_conv_send_confirm(PurpleConversation *conv, const char *message) 7060 pidgin_conv_send_confirm(PurpleConversation *conv, const char *message)
7040 { 7061 {
7041 PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv); 7062 PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
7042 7063
7043 gtk_imhtml_append_text(GTK_IMHTML(gtkconv->entry), message, 0); 7064 gtk_webview_append_html(GTK_WEBVIEW(gtkconv->webview), message);
7044 } 7065 }
7045 7066
7046 /* 7067 /*
7047 * Makes sure all the menu items and all the buttons are hidden/shown and 7068 * Makes sure all the menu items and all the buttons are hidden/shown and
7048 * sensitive/insensitive. This is called after changing tabs and when an 7069 * sensitive/insensitive. This is called after changing tabs and when an
7054 PidginWindow *win; 7075 PidginWindow *win;
7055 PurpleConversation *conv = gtkconv->active_conv; 7076 PurpleConversation *conv = gtkconv->active_conv;
7056 PurpleConnection *gc; 7077 PurpleConnection *gc;
7057 PurplePluginProtocolInfo *prpl_info = NULL; 7078 PurplePluginProtocolInfo *prpl_info = NULL;
7058 GdkPixbuf *window_icon = NULL; 7079 GdkPixbuf *window_icon = NULL;
7059 GtkIMHtmlButtons buttons; 7080 GtkWebViewButtons buttons;
7060 PurpleAccount *account; 7081 PurpleAccount *account;
7061 7082
7062 win = pidgin_conv_get_window(gtkconv); 7083 win = pidgin_conv_get_window(gtkconv);
7063 gc = purple_conversation_get_connection(conv); 7084 gc = purple_conversation_get_connection(conv);
7064 account = purple_conversation_get_account(conv); 7085 account = purple_conversation_get_account(conv);
7145 PurpleConnectionFlags features = purple_conversation_get_features(conv); 7166 PurpleConnectionFlags features = purple_conversation_get_features(conv);
7146 /* Account is online */ 7167 /* Account is online */
7147 /* Deal with the toolbar */ 7168 /* Deal with the toolbar */
7148 if (features & PURPLE_CONNECTION_HTML) 7169 if (features & PURPLE_CONNECTION_HTML)
7149 { 7170 {
7150 buttons = GTK_IMHTML_ALL; /* Everything on */ 7171 buttons = GTK_WEBVIEW_ALL; /* Everything on */
7151 if (features & PURPLE_CONNECTION_NO_BGCOLOR) 7172 if (features & PURPLE_CONNECTION_NO_BGCOLOR)
7152 buttons &= ~GTK_IMHTML_BACKCOLOR; 7173 buttons &= ~GTK_WEBVIEW_BACKCOLOR;
7153 if (features & PURPLE_CONNECTION_NO_FONTSIZE) 7174 if (features & PURPLE_CONNECTION_NO_FONTSIZE)
7154 { 7175 {
7155 buttons &= ~GTK_IMHTML_GROW; 7176 buttons &= ~GTK_WEBVIEW_GROW;
7156 buttons &= ~GTK_IMHTML_SHRINK; 7177 buttons &= ~GTK_WEBVIEW_SHRINK;
7157 } 7178 }
7158 if (features & PURPLE_CONNECTION_NO_URLDESC) 7179 if (features & PURPLE_CONNECTION_NO_URLDESC)
7159 buttons &= ~GTK_IMHTML_LINKDESC; 7180 buttons &= ~GTK_WEBVIEW_LINKDESC;
7160 } else { 7181 } else {
7161 buttons = GTK_IMHTML_SMILEY | GTK_IMHTML_IMAGE; 7182 buttons = GTK_WEBVIEW_SMILEY | GTK_WEBVIEW_IMAGE;
7162 } 7183 }
7163 7184
7164 if (!(prpl_info->options & OPT_PROTO_IM_IMAGE) 7185 if (!(prpl_info->options & OPT_PROTO_IM_IMAGE)
7165 && !(features & PURPLE_CONNECTION_NO_IMAGES)) { 7186 && !(features & PURPLE_CONNECTION_NO_IMAGES)) {
7166 features |= PURPLE_CONNECTION_NO_IMAGES; 7187 features |= PURPLE_CONNECTION_NO_IMAGES;
7167 purple_conversation_set_features(conv, features); 7188 purple_conversation_set_features(conv, features);
7168 } 7189 }
7169 7190
7170 if (features & PURPLE_CONNECTION_NO_IMAGES) 7191 if (features & PURPLE_CONNECTION_NO_IMAGES)
7171 buttons &= ~GTK_IMHTML_IMAGE; 7192 buttons &= ~GTK_WEBVIEW_IMAGE;
7172 7193
7173 if (features & PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY) 7194 if (features & PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY)
7174 buttons |= GTK_IMHTML_CUSTOM_SMILEY; 7195 buttons |= GTK_WEBVIEW_CUSTOM_SMILEY;
7175 else 7196 else
7176 buttons &= ~GTK_IMHTML_CUSTOM_SMILEY; 7197 buttons &= ~GTK_WEBVIEW_CUSTOM_SMILEY;
7177 7198
7178 gtk_imhtml_set_format_functions(GTK_IMHTML(gtkconv->entry), buttons); 7199 gtk_webview_set_format_functions(GTK_WEBVIEW(gtkconv->entry), buttons);
7179 if (account != NULL) 7200 if (account != NULL)
7180 gtk_imhtmltoolbar_associate_smileys(GTK_IMHTMLTOOLBAR(gtkconv->toolbar), purple_account_get_protocol_id(account)); 7201 gtk_webviewtoolbar_associate_smileys(GTK_WEBVIEWTOOLBAR(gtkconv->toolbar), purple_account_get_protocol_id(account));
7181 7202
7182 /* Deal with menu items */ 7203 /* Deal with menu items */
7183 gtk_action_set_sensitive(win->menu.view_log, TRUE); 7204 gtk_action_set_sensitive(win->menu.view_log, TRUE);
7184 gtk_action_set_sensitive(win->menu.add_pounce, TRUE); 7205 gtk_action_set_sensitive(win->menu.add_pounce, TRUE);
7185 gtk_action_set_sensitive(win->menu.get_info, (prpl_info->get_info != NULL)); 7206 gtk_action_set_sensitive(win->menu.get_info, (prpl_info->get_info != NULL));
7829 { 7850 {
7830 #ifdef USE_GTKSPELL 7851 #ifdef USE_GTKSPELL
7831 GList *cl; 7852 GList *cl;
7832 PurpleConversation *conv; 7853 PurpleConversation *conv;
7833 PidginConversation *gtkconv; 7854 PidginConversation *gtkconv;
7834 GtkSpell *spell;
7835 7855
7836 for (cl = purple_get_conversations(); cl != NULL; cl = cl->next) { 7856 for (cl = purple_get_conversations(); cl != NULL; cl = cl->next) {
7837 7857
7838 conv = (PurpleConversation *)cl->data; 7858 conv = (PurpleConversation *)cl->data;
7839 7859
7840 if (!PIDGIN_IS_PIDGIN_CONVERSATION(conv)) 7860 if (!PIDGIN_IS_PIDGIN_CONVERSATION(conv))
7841 continue; 7861 continue;
7842 7862
7843 gtkconv = PIDGIN_CONVERSATION(conv); 7863 gtkconv = PIDGIN_CONVERSATION(conv);
7844 7864
7845 if (value) 7865 pidgin_webview_set_spellcheck(GTK_WEBVIEW(gtkconv->entry), value);
7846 pidgin_setup_gtkspell(GTK_TEXT_VIEW(gtkconv->entry));
7847 else {
7848 spell = gtkspell_get_from_text_view(GTK_TEXT_VIEW(gtkconv->entry));
7849 if (spell)
7850 gtkspell_detach(spell);
7851 }
7852 } 7866 }
7853 #endif 7867 #endif
7854 } 7868 }
7855 7869
7856 static void 7870 static void
7898 if ((gboolean)GPOINTER_TO_INT(value)) 7912 if ((gboolean)GPOINTER_TO_INT(value))
7899 gtk_widget_show(gtkconv->toolbar); 7913 gtk_widget_show(gtkconv->toolbar);
7900 else 7914 else
7901 gtk_widget_hide(gtkconv->toolbar); 7915 gtk_widget_hide(gtkconv->toolbar);
7902 7916
7903 g_idle_add((GSourceFunc)resize_imhtml_cb,gtkconv); 7917 g_idle_add((GSourceFunc)resize_webview_cb, gtkconv);
7904 } 7918 }
7905 } 7919 }
7906 7920
7907 static void 7921 static void
7908 animate_buddy_icons_pref_cb(const char *name, PurplePrefType type, 7922 animate_buddy_icons_pref_cb(const char *name, PurplePrefType type,
8834 #include "gtkpounce.h" 8848 #include "gtkpounce.h"
8835 #include "gtkprefs.h" 8849 #include "gtkprefs.h"
8836 #include "gtkprivacy.h" 8850 #include "gtkprivacy.h"
8837 #include "gtkutils.h" 8851 #include "gtkutils.h"
8838 #include "pidginstock.h" 8852 #include "pidginstock.h"
8839 #include "gtkimhtml.h"
8840 #include "gtkimhtmltoolbar.h"
8841 8853
8842 static void 8854 static void
8843 do_close(GtkWidget *w, int resp, PidginWindow *win) 8855 do_close(GtkWidget *w, int resp, PidginWindow *win)
8844 { 8856 {
8845 gtk_widget_destroy(warn_close_dialog); 8857 gtk_widget_destroy(warn_close_dialog);

Mercurial Repository: pidgin3

mercurial