Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkutils.c

pidgin/gtkutils.c

branch
cpw.qulogic.gtk3
changeset 32438
dc8991868906
parent 32436
7e6e6e9bd6af
equal deleted inserted replaced
32437:a1093fbc45d2 32438:dc8991868906
65 #include "gtkimhtml.h" 65 #include "gtkimhtml.h"
66 #include "gtkimhtmltoolbar.h" 66 #include "gtkimhtmltoolbar.h"
67 #include "pidginstock.h" 67 #include "pidginstock.h"
68 #include "gtkthemes.h" 68 #include "gtkthemes.h"
69 #include "gtkutils.h" 69 #include "gtkutils.h"
70 #include "gtkwebview.h"
70 #include "pidgin/minidialog.h" 71 #include "pidgin/minidialog.h"
72
73 #if !GTK_CHECK_VERSION(2,18,0)
74 #define gtk_widget_get_visible(x) GTK_WIDGET_VISIBLE(x)
75 #define gtk_widget_is_sensitive(x) GTK_WIDGET_IS_SENSITIVE(x)
76 #endif
71 77
72 typedef struct { 78 typedef struct {
73 GtkTreeModel *model; 79 GtkTreeModel *model;
74 gint default_item; 80 gint default_item;
75 } AopMenu; 81 } AopMenu;
178 { 184 {
179 GtkWindow *wnd = NULL; 185 GtkWindow *wnd = NULL;
180 186
181 wnd = GTK_WINDOW(gtk_dialog_new()); 187 wnd = GTK_WINDOW(gtk_dialog_new());
182 pidgin_window_init(wnd, title, border_width, role, resizable); 188 pidgin_window_init(wnd, title, border_width, role, resizable);
189 g_object_set(G_OBJECT(wnd), "has-separator", FALSE, NULL);
183 190
184 return GTK_WIDGET(wnd); 191 return GTK_WIDGET(wnd);
185 } 192 }
186 193
187 GtkWidget * 194 GtkWidget *
188 pidgin_dialog_get_vbox_with_properties(GtkDialog *dialog, gboolean homogeneous, gint spacing) 195 pidgin_dialog_get_vbox_with_properties(GtkDialog *dialog, gboolean homogeneous, gint spacing)
189 { 196 {
190 GtkBox *vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); 197 GtkBox *vbox = GTK_BOX(GTK_DIALOG(dialog)->vbox);
191 gtk_box_set_homogeneous(vbox, homogeneous); 198 gtk_box_set_homogeneous(vbox, homogeneous);
192 gtk_box_set_spacing(vbox, spacing); 199 gtk_box_set_spacing(vbox, spacing);
193 return GTK_WIDGET(vbox); 200 return GTK_WIDGET(vbox);
194 } 201 }
195 202
196 GtkWidget *pidgin_dialog_get_vbox(GtkDialog *dialog) 203 GtkWidget *pidgin_dialog_get_vbox(GtkDialog *dialog)
197 { 204 {
198 return gtk_dialog_get_content_area(GTK_DIALOG(dialog)); 205 return GTK_DIALOG(dialog)->vbox;
199 } 206 }
200 207
201 GtkWidget *pidgin_dialog_get_action_area(GtkDialog *dialog) 208 GtkWidget *pidgin_dialog_get_action_area(GtkDialog *dialog)
202 { 209 {
203 return gtk_dialog_get_action_area(GTK_DIALOG(dialog)); 210 return GTK_DIALOG(dialog)->action_area;
204 } 211 }
205 212
206 GtkWidget *pidgin_dialog_add_button(GtkDialog *dialog, const char *label, 213 GtkWidget *pidgin_dialog_add_button(GtkDialog *dialog, const char *label,
207 GCallback callback, gpointer callbackdata) 214 GCallback callback, gpointer callbackdata)
208 { 215 {
273 *sw_ret = sw; 280 *sw_ret = sw;
274 281
275 return frame; 282 return frame;
276 } 283 }
277 284
285 GtkWidget *
286 pidgin_create_webview(gboolean editable, GtkWidget **webview_ret, GtkWidget **toolbar_ret, GtkWidget **sw_ret)
287 {
288 GtkWidget *frame;
289 GtkWidget *webview;
290 GtkWidget *sep;
291 GtkWidget *sw;
292 GtkWidget *toolbar = NULL;
293 GtkWidget *vbox;
294
295 frame = gtk_frame_new(NULL);
296 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
297
298 vbox = gtk_vbox_new(FALSE, 0);
299 gtk_container_add(GTK_CONTAINER(frame), vbox);
300 gtk_widget_show(vbox);
301
302 if (editable) {
303 toolbar = gtk_imhtmltoolbar_new();
304 gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
305 gtk_widget_show(toolbar);
306
307 sep = gtk_hseparator_new();
308 gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
309 g_signal_connect_swapped(G_OBJECT(toolbar), "show", G_CALLBACK(gtk_widget_show), sep);
310 g_signal_connect_swapped(G_OBJECT(toolbar), "hide", G_CALLBACK(gtk_widget_hide), sep);
311 gtk_widget_show(sep);
312 }
313
314 webview = gtk_webview_new();
315 #if 0
316 /* TODO WEBKIT: Don't have editable webview yet. */
317 gtk_webview_set_editable(GTK_WEBVIEW(webview), editable);
318 #endif /* if 0 */
319 #ifdef USE_GTKSPELL
320 if (editable && purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/spellcheck"))
321 pidgin_setup_gtkspell(GTK_TEXT_VIEW(webview));
322 #endif
323 gtk_widget_show(webview);
324
325 if (editable) {
326 gtk_imhtmltoolbar_attach(GTK_IMHTMLTOOLBAR(toolbar), webview);
327 gtk_imhtmltoolbar_associate_smileys(GTK_IMHTMLTOOLBAR(toolbar), "default");
328 }
329
330 sw = pidgin_make_scrollable(webview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_NONE, -1, -1);
331 gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
332
333 gtk_webview_set_vadjustment(GTK_WEBVIEW(webview),
334 gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sw)));
335
336 if (webview_ret != NULL)
337 *webview_ret = webview;
338
339 if (editable && (toolbar_ret != NULL))
340 *toolbar_ret = toolbar;
341
342 if (sw_ret != NULL)
343 *sw_ret = sw;
344
345 return frame;
346 }
347
278 void 348 void
279 pidgin_set_sensitive_if_input(GtkWidget *entry, GtkWidget *dialog) 349 pidgin_set_sensitive_if_input(GtkWidget *entry, GtkWidget *dialog)
280 { 350 {
281 const char *text = gtk_entry_get_text(GTK_ENTRY(entry)); 351 const char *text = gtk_entry_get_text(GTK_ENTRY(entry));
282 gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, 352 gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK,
289 gboolean sensitivity; 359 gboolean sensitivity;
290 360
291 if (to_toggle == NULL) 361 if (to_toggle == NULL)
292 return; 362 return;
293 363
294 sensitivity = gtk_widget_get_sensitive(to_toggle); 364 sensitivity = gtk_widget_is_sensitive(to_toggle);
295 365
296 gtk_widget_set_sensitive(to_toggle, !sensitivity); 366 gtk_widget_set_sensitive(to_toggle, !sensitivity);
297 } 367 }
298 368
299 void 369 void
306 for (i=0; i < data->len; i++) { 376 for (i=0; i < data->len; i++) {
307 element = g_ptr_array_index(data,i); 377 element = g_ptr_array_index(data,i);
308 if (element == NULL) 378 if (element == NULL)
309 continue; 379 continue;
310 380
311 sensitivity = gtk_widget_get_sensitive(element); 381 sensitivity = gtk_widget_is_sensitive(element);
312 382
313 gtk_widget_set_sensitive(element, !sensitivity); 383 gtk_widget_set_sensitive(element, !sensitivity);
314 } 384 }
315 } 385 }
316 386
674 } 744 }
675 745
676 if (facebook_name && strcmp(facebook_name, plugin->info->name) < 0) { 746 if (facebook_name && strcmp(facebook_name, plugin->info->name) < 0) {
677 char *filename = g_build_filename(DATADIR, "pixmaps", "pidgin", "protocols", 747 char *filename = g_build_filename(DATADIR, "pixmaps", "pidgin", "protocols",
678 "16", "facebook.png", NULL); 748 "16", "facebook.png", NULL);
749
679 pixbuf = pidgin_pixbuf_new_from_file(filename); 750 pixbuf = pidgin_pixbuf_new_from_file(filename);
680 g_free(filename); 751 g_free(filename);
681 752
682 gtk_list_store_append(ls, &iter); 753 gtk_list_store_append(ls, &iter);
683 gtk_list_store_set(ls, &iter, 0, pixbuf, 1, facebook_name, 2, "prpl-jabber", -1); 754 gtk_list_store_set(ls, &iter, 0, pixbuf, 1, facebook_name, 2, "prpl-jabber", -1);
950 if (chat < 0) { 1021 if (chat < 0) {
951 pidgin_retrieve_user_info(conn, name); 1022 pidgin_retrieve_user_info(conn, name);
952 return; 1023 return;
953 } 1024 }
954 1025
955 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(conn->prpl); 1026 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(conn));
956 if (prpl_info != NULL && prpl_info->get_cb_real_name) 1027 if (prpl_info != NULL && prpl_info->get_cb_real_name)
957 who = prpl_info->get_cb_real_name(conn, chat, name); 1028 who = prpl_info->get_cb_real_name(conn, chat, name);
958 if (prpl_info == NULL || prpl_info->get_cb_info == NULL) { 1029 if (prpl_info == NULL || prpl_info->get_cb_info == NULL) {
959 pidgin_retrieve_user_info(conn, who ? who : name); 1030 pidgin_retrieve_user_info(conn, who ? who : name);
960 g_free(who); 1031 g_free(who);
1076 else 1147 else
1077 { 1148 {
1078 gc = (PurpleConnection *)l->data; 1149 gc = (PurpleConnection *)l->data;
1079 account = purple_connection_get_account(gc); 1150 account = purple_connection_get_account(gc);
1080 1151
1081 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); 1152 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
1082 } 1153 }
1083 1154
1084 protoname = prpl_info->list_icon(account, NULL); 1155 protoname = prpl_info->list_icon(account, NULL);
1085 1156
1086 if (!strcmp(protoname, protocol)) 1157 if (!strcmp(protoname, protocol))
1118 else 1189 else
1119 { 1190 {
1120 gc = (PurpleConnection *)l->data; 1191 gc = (PurpleConnection *)l->data;
1121 account = purple_connection_get_account(gc); 1192 account = purple_connection_get_account(gc);
1122 1193
1123 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); 1194 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
1124 } 1195 }
1125 1196
1126 protoname = prpl_info->list_icon(account, NULL); 1197 protoname = prpl_info->list_icon(account, NULL);
1127 1198
1128 if (!strcmp(protoname, "aim") || !strcmp(protoname, "icq")) 1199 if (!strcmp(protoname, "aim") || !strcmp(protoname, "icq"))
1221 1292
1222 g_return_if_fail(GTK_IS_MENU(menu)); 1293 g_return_if_fail(GTK_IS_MENU(menu));
1223 1294
1224 widget = GTK_WIDGET(menu); 1295 widget = GTK_WIDGET(menu);
1225 screen = gtk_widget_get_screen(widget); 1296 screen = gtk_widget_get_screen(widget);
1226 xthickness = gtk_widget_get_style(widget)->xthickness; 1297 xthickness = widget->style->xthickness;
1227 ythickness = gtk_widget_get_style(widget)->ythickness; 1298 ythickness = widget->style->ythickness;
1228 rtl = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL); 1299 rtl = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL);
1229 1300
1230 /* 1301 /*
1231 * We need the requisition to figure out the right place to 1302 * We need the requisition to figure out the right place to
1232 * popup the menu. In fact, we always need to ask here, since 1303 * popup the menu. In fact, we always need to ask here, since
1360 GtkWidget *widget = GTK_WIDGET(data); 1431 GtkWidget *widget = GTK_WIDGET(data);
1361 GtkTreeView *tv = GTK_TREE_VIEW(data); 1432 GtkTreeView *tv = GTK_TREE_VIEW(data);
1362 GtkTreePath *path; 1433 GtkTreePath *path;
1363 GtkTreeViewColumn *col; 1434 GtkTreeViewColumn *col;
1364 GdkRectangle rect; 1435 GdkRectangle rect;
1365 gint ythickness = gtk_widget_get_style(GTK_WIDGET(menu))->ythickness; 1436 gint ythickness = GTK_WIDGET(menu)->style->ythickness;
1366 1437
1367 gdk_window_get_origin (gtk_widget_get_window(widget), x, y); 1438 gdk_window_get_origin (widget->window, x, y);
1368 gtk_tree_view_get_cursor (tv, &path, &col); 1439 gtk_tree_view_get_cursor (tv, &path, &col);
1369 gtk_tree_view_get_cell_area (tv, path, col, &rect); 1440 gtk_tree_view_get_cell_area (tv, path, col, &rect);
1370 1441
1371 *x += rect.x+rect.width; 1442 *x += rect.x+rect.width;
1372 *y += rect.y+rect.height+ythickness; 1443 *y += rect.y+rect.height+ythickness;
1479 1550
1480 void 1551 void
1481 pidgin_dnd_file_manage(GtkSelectionData *sd, PurpleAccount *account, const char *who) 1552 pidgin_dnd_file_manage(GtkSelectionData *sd, PurpleAccount *account, const char *who)
1482 { 1553 {
1483 GdkPixbuf *pb; 1554 GdkPixbuf *pb;
1484 GList *files = purple_uri_list_extract_filenames((const gchar *) gtk_selection_data_get_data(sd)); 1555 GList *files = purple_uri_list_extract_filenames((const gchar *)sd->data);
1485 PurpleConnection *gc = purple_account_get_connection(account); 1556 PurpleConnection *gc = purple_account_get_connection(account);
1486 PurplePluginProtocolInfo *prpl_info = NULL; 1557 PurplePluginProtocolInfo *prpl_info = NULL;
1487 #ifndef _WIN32 1558 #ifndef _WIN32
1488 PurpleDesktopItem *item; 1559 PurpleDesktopItem *item;
1489 #endif 1560 #endif
1530 data->who = g_strdup(who); 1601 data->who = g_strdup(who);
1531 data->filename = g_strdup(filename); 1602 data->filename = g_strdup(filename);
1532 data->account = account; 1603 data->account = account;
1533 1604
1534 if (gc) 1605 if (gc)
1535 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); 1606 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc));
1536 1607
1537 if (prpl_info && prpl_info->options & OPT_PROTO_IM_IMAGE) 1608 if (prpl_info && prpl_info->options & OPT_PROTO_IM_IMAGE)
1538 im = TRUE; 1609 im = TRUE;
1539 1610
1540 if (prpl_info && prpl_info->can_receive_file) 1611 if (prpl_info && prpl_info->can_receive_file)
1761 GtkWidget * 1832 GtkWidget *
1762 pidgin_append_menu_action(GtkWidget *menu, PurpleMenuAction *act, 1833 pidgin_append_menu_action(GtkWidget *menu, PurpleMenuAction *act,
1763 gpointer object) 1834 gpointer object)
1764 { 1835 {
1765 GtkWidget *menuitem; 1836 GtkWidget *menuitem;
1837 GList *list;
1766 1838
1767 if (act == NULL) { 1839 if (act == NULL) {
1768 return pidgin_separator(menu); 1840 return pidgin_separator(menu);
1769 } 1841 }
1770 1842
1771 if (act->children == NULL) { 1843 list = purple_menu_action_get_children(act);
1772 menuitem = gtk_menu_item_new_with_mnemonic(act->label); 1844 menuitem = gtk_menu_item_new_with_mnemonic(purple_menu_action_get_label(act));
1773 1845
1774 if (act->callback != NULL) { 1846 if (list == NULL) {
1847 PurpleCallback callback;
1848
1849 callback = purple_menu_action_get_callback(act);
1850
1851 if (callback != NULL) {
1775 g_object_set_data(G_OBJECT(menuitem), 1852 g_object_set_data(G_OBJECT(menuitem),
1776 "purplecallback", 1853 "purplecallback",
1777 act->callback); 1854 callback);
1778 g_object_set_data(G_OBJECT(menuitem), 1855 g_object_set_data(G_OBJECT(menuitem),
1779 "purplecallbackdata", 1856 "purplecallbackdata",
1780 act->data); 1857 purple_menu_action_get_data(act));
1781 g_signal_connect(G_OBJECT(menuitem), "activate", 1858 g_signal_connect(G_OBJECT(menuitem), "activate",
1782 G_CALLBACK(menu_action_cb), 1859 G_CALLBACK(menu_action_cb),
1783 object); 1860 object);
1784 } else { 1861 } else {
1785 gtk_widget_set_sensitive(menuitem, FALSE); 1862 gtk_widget_set_sensitive(menuitem, FALSE);
1789 } else { 1866 } else {
1790 GList *l = NULL; 1867 GList *l = NULL;
1791 GtkWidget *submenu = NULL; 1868 GtkWidget *submenu = NULL;
1792 GtkAccelGroup *group; 1869 GtkAccelGroup *group;
1793 1870
1794 menuitem = gtk_menu_item_new_with_mnemonic(act->label);
1795 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); 1871 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1796 1872
1797 submenu = gtk_menu_new(); 1873 submenu = gtk_menu_new();
1798 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); 1874 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
1799 1875
1800 group = gtk_menu_get_accel_group(GTK_MENU(menu)); 1876 group = gtk_menu_get_accel_group(GTK_MENU(menu));
1801 if (group) { 1877 if (group) {
1802 char *path = g_strdup_printf("%s/%s", 1878 char *path = g_strdup_printf("%s/%s", GTK_MENU_ITEM(menuitem)->accel_path,
1803 gtk_menu_item_get_accel_path(GTK_MENU_ITEM(menuitem)), 1879 purple_menu_action_get_label(act));
1804 act->label);
1805 gtk_menu_set_accel_path(GTK_MENU(submenu), path); 1880 gtk_menu_set_accel_path(GTK_MENU(submenu), path);
1806 g_free(path); 1881 g_free(path);
1807 gtk_menu_set_accel_group(GTK_MENU(submenu), group); 1882 gtk_menu_set_accel_group(GTK_MENU(submenu), group);
1808 } 1883 }
1809 1884
1810 for (l = act->children; l; l = l->next) { 1885 for (l = list; l; l = l->next) {
1811 PurpleMenuAction *act = (PurpleMenuAction *)l->data; 1886 PurpleMenuAction *act = (PurpleMenuAction *)l->data;
1812 1887
1813 pidgin_append_menu_action(submenu, act, object); 1888 pidgin_append_menu_action(submenu, act, object);
1814 } 1889 }
1815 g_list_free(act->children); 1890 g_list_free(list);
1816 act->children = NULL; 1891 purple_menu_action_set_children(act, NULL);
1817 } 1892 }
1818 purple_menu_action_free(act); 1893 purple_menu_action_free(act);
1819 return menuitem; 1894 return menuitem;
1820 } 1895 }
1821 1896
2011 2086
2012 if (filter_func(&entry, user_data)) { 2087 if (filter_func(&entry, user_data)) {
2013 add_buddyname_autocomplete_entry(data->store, 2088 add_buddyname_autocomplete_entry(data->store,
2014 ((PurpleContact *)cnode)->alias, 2089 ((PurpleContact *)cnode)->alias,
2015 purple_buddy_get_contact_alias(entry.entry.buddy), 2090 purple_buddy_get_contact_alias(entry.entry.buddy),
2016 entry.entry.buddy->account, 2091 purple_buddy_get_account(entry.entry.buddy),
2017 entry.entry.buddy->name 2092 purple_buddy_get_name(entry.entry.buddy)
2018 ); 2093 );
2019 } 2094 }
2020 } 2095 }
2021 } 2096 }
2022 } 2097 }
2104 gboolean 2179 gboolean
2105 pidgin_screenname_autocomplete_default_filter(const PidginBuddyCompletionEntry *completion_entry, gpointer all_accounts) { 2180 pidgin_screenname_autocomplete_default_filter(const PidginBuddyCompletionEntry *completion_entry, gpointer all_accounts) {
2106 gboolean all = GPOINTER_TO_INT(all_accounts); 2181 gboolean all = GPOINTER_TO_INT(all_accounts);
2107 2182
2108 if (completion_entry->is_buddy) { 2183 if (completion_entry->is_buddy) {
2109 return all || purple_account_is_connected(completion_entry->entry.buddy->account); 2184 return all || purple_account_is_connected(purple_buddy_get_account(completion_entry->entry.buddy));
2110 } else { 2185 } else {
2111 return all || (completion_entry->entry.logged_buddy->account != NULL && purple_account_is_connected(completion_entry->entry.logged_buddy->account)); 2186 return all || (completion_entry->entry.logged_buddy->account != NULL && purple_account_is_connected(completion_entry->entry.logged_buddy->account));
2112 } 2187 }
2113 } 2188 }
2114 2189
2115 void pidgin_set_cursor(GtkWidget *widget, GdkCursorType cursor_type) 2190 void pidgin_set_cursor(GtkWidget *widget, GdkCursorType cursor_type)
2116 { 2191 {
2117 GdkCursor *cursor; 2192 GdkCursor *cursor;
2118 2193
2119 g_return_if_fail(widget != NULL); 2194 g_return_if_fail(widget != NULL);
2120 if (gtk_widget_get_window(widget) == NULL) 2195 if (widget->window == NULL)
2121 return; 2196 return;
2122 2197
2123 cursor = gdk_cursor_new(cursor_type); 2198 cursor = gdk_cursor_new(cursor_type);
2124 gdk_window_set_cursor(gtk_widget_get_window(widget), cursor); 2199 gdk_window_set_cursor(widget->window, cursor);
2125 gdk_cursor_unref(cursor); 2200 gdk_cursor_unref(cursor);
2126 2201
2127 gdk_display_flush(gdk_window_get_display(gtk_widget_get_window(widget))); 2202 gdk_display_flush(gdk_drawable_get_display(GDK_DRAWABLE(widget->window)));
2128 } 2203 }
2129 2204
2130 void pidgin_clear_cursor(GtkWidget *widget) 2205 void pidgin_clear_cursor(GtkWidget *widget)
2131 { 2206 {
2132 g_return_if_fail(widget != NULL); 2207 g_return_if_fail(widget != NULL);
2133 if (gtk_widget_get_window(widget) == NULL) 2208 if (widget->window == NULL)
2134 return; 2209 return;
2135 2210
2136 gdk_window_set_cursor(gtk_widget_get_window(widget), NULL); 2211 gdk_window_set_cursor(widget->window, NULL);
2137 } 2212 }
2138 2213
2139 struct _icon_chooser { 2214 struct _icon_chooser {
2140 GtkWidget *icon_filesel; 2215 GtkWidget *icon_filesel;
2141 GtkWidget *icon_preview; 2216 GtkWidget *icon_preview;
2172 if (dialog->callback) 2247 if (dialog->callback)
2173 dialog->callback(filename, dialog->data); 2248 dialog->callback(filename, dialog->data);
2174 gtk_widget_destroy(dialog->icon_filesel); 2249 gtk_widget_destroy(dialog->icon_filesel);
2175 g_free(filename); 2250 g_free(filename);
2176 g_free(dialog); 2251 g_free(dialog);
2177 } 2252 }
2178 2253
2179 2254
2180 static void 2255 static void
2181 icon_preview_change_cb(GtkFileChooser *widget, struct _icon_chooser *dialog) 2256 icon_preview_change_cb(GtkFileChooser *widget, struct _icon_chooser *dialog)
2182 { 2257 {
2410 /* We were able to save the image as this image type and 2485 /* We were able to save the image as this image type and
2411 have it be within the size constraints. Great! Return 2486 have it be within the size constraints. Great! Return
2412 the image. */ 2487 the image. */
2413 purple_debug_info("buddyicon", "Converted image from " 2488 purple_debug_info("buddyicon", "Converted image from "
2414 "%dx%d to %dx%d, format=%s, quality=%u, " 2489 "%dx%d to %dx%d, format=%s, quality=%u, "
2415 "filesize=%zu\n", orig_width, orig_height, 2490 "filesize=%" G_GSIZE_FORMAT "\n",
2416 new_width, new_height, prpl_formats[i], quality, 2491 orig_width, orig_height, new_width, new_height,
2417 length); 2492 prpl_formats[i], quality, length);
2418 if (len) 2493 if (len)
2419 *len = length; 2494 *len = length;
2420 g_strfreev(prpl_formats); 2495 g_strfreev(prpl_formats);
2421 g_object_unref(G_OBJECT(pixbuf)); 2496 g_object_unref(G_OBJECT(pixbuf));
2422 g_object_unref(G_OBJECT(original)); 2497 g_object_unref(G_OBJECT(original));
2791 GtkStyle *style; 2866 GtkStyle *style;
2792 2867
2793 if (!widget) 2868 if (!widget)
2794 return "dim grey"; 2869 return "dim grey";
2795 2870
2796 style = gtk_widget_get_style(widget); 2871 style = gtk_widget_get_style(widget);
2797 if (!style) 2872 if (!style)
2798 return "dim grey"; 2873 return "dim grey";
2799 2874
2800 snprintf(dim_grey_string, sizeof(dim_grey_string), "#%02x%02x%02x", 2875 snprintf(dim_grey_string, sizeof(dim_grey_string), "#%02x%02x%02x",
2801 style->text_aa[GTK_STATE_NORMAL].red >> 8, 2876 style->text_aa[GTK_STATE_NORMAL].red >> 8,
2803 style->text_aa[GTK_STATE_NORMAL].blue >> 8); 2878 style->text_aa[GTK_STATE_NORMAL].blue >> 8);
2804 return dim_grey_string; 2879 return dim_grey_string;
2805 } 2880 }
2806 2881
2807 static void 2882 static void
2808 combo_box_changed_cb(GtkComboBoxText *combo_box, GtkEntry *entry) 2883 combo_box_changed_cb(GtkComboBox *combo_box, GtkEntry *entry)
2809 { 2884 {
2810 char *text = gtk_combo_box_text_get_active_text(combo_box); 2885 char *text = gtk_combo_box_get_active_text(combo_box);
2811 gtk_entry_set_text(entry, text ? text : ""); 2886 gtk_entry_set_text(entry, text ? text : "");
2812 g_free(text); 2887 g_free(text);
2813 } 2888 }
2814 2889
2815 static gboolean 2890 static gboolean
2816 entry_key_pressed_cb(GtkWidget *entry, GdkEventKey *key, GtkComboBoxText *combo) 2891 entry_key_pressed_cb(GtkWidget *entry, GdkEventKey *key, GtkComboBox *combo)
2817 { 2892 {
2818 if (key->keyval == GDK_KEY_Down || key->keyval == GDK_KEY_Up) { 2893 if (key->keyval == GDK_Down || key->keyval == GDK_Up) {
2819 gtk_combo_box_popup(GTK_COMBO_BOX(combo)); 2894 gtk_combo_box_popup(combo);
2820 return TRUE; 2895 return TRUE;
2821 } 2896 }
2822 return FALSE; 2897 return FALSE;
2823 } 2898 }
2824 2899
2825 GtkWidget * 2900 GtkWidget *
2826 pidgin_text_combo_box_entry_new(const char *default_item, GList *items) 2901 pidgin_text_combo_box_entry_new(const char *default_item, GList *items)
2827 { 2902 {
2828 GtkComboBoxText *ret = NULL; 2903 GtkComboBox *ret = NULL;
2829 GtkWidget *the_entry = NULL; 2904 GtkWidget *the_entry = NULL;
2830 2905
2831 ret = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry()); 2906 ret = GTK_COMBO_BOX(gtk_combo_box_entry_new_text());
2832 the_entry = gtk_entry_new(); 2907 the_entry = gtk_entry_new();
2833 gtk_container_add(GTK_CONTAINER(ret), the_entry); 2908 gtk_container_add(GTK_CONTAINER(ret), the_entry);
2834 2909
2835 if (default_item) 2910 if (default_item)
2836 gtk_entry_set_text(GTK_ENTRY(the_entry), default_item); 2911 gtk_entry_set_text(GTK_ENTRY(the_entry), default_item);
2837 2912
2838 for (; items != NULL ; items = items->next) { 2913 for (; items != NULL ; items = items->next) {
2839 char *text = items->data; 2914 char *text = items->data;
2840 if (text && *text) 2915 if (text && *text)
2841 gtk_combo_box_text_append_text(ret, text); 2916 gtk_combo_box_append_text(ret, text);
2842 } 2917 }
2843 2918
2844 g_signal_connect(G_OBJECT(ret), "changed", (GCallback)combo_box_changed_cb, the_entry); 2919 g_signal_connect(G_OBJECT(ret), "changed", (GCallback)combo_box_changed_cb, the_entry);
2845 g_signal_connect_after(G_OBJECT(the_entry), "key-press-event", G_CALLBACK(entry_key_pressed_cb), ret); 2920 g_signal_connect_after(G_OBJECT(the_entry), "key-press-event", G_CALLBACK(entry_key_pressed_cb), ret);
2846 2921
2847 return GTK_WIDGET(ret); 2922 return GTK_WIDGET(ret);
2848 } 2923 }
2849 2924
2850 const char *pidgin_text_combo_box_entry_get_text(GtkWidget *widget) 2925 const char *pidgin_text_combo_box_entry_get_text(GtkWidget *widget)
2851 { 2926 {
2852 return gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((widget))))); 2927 return gtk_entry_get_text(GTK_ENTRY(GTK_BIN((widget))->child));
2853 } 2928 }
2854 2929
2855 void pidgin_text_combo_box_entry_set_text(GtkWidget *widget, const char *text) 2930 void pidgin_text_combo_box_entry_set_text(GtkWidget *widget, const char *text)
2856 { 2931 {
2857 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((widget)))), (text)); 2932 gtk_entry_set_text(GTK_ENTRY(GTK_BIN((widget))->child), (text));
2858 } 2933 }
2859 2934
2860 GtkWidget * 2935 GtkWidget *
2861 pidgin_add_widget_to_vbox(GtkBox *vbox, const char *widget_label, GtkSizeGroup *sg, GtkWidget *widget, gboolean expand, GtkWidget **p_label) 2936 pidgin_add_widget_to_vbox(GtkBox *vbox, const char *widget_label, GtkSizeGroup *sg, GtkWidget *widget, gboolean expand, GtkWidget **p_label)
2862 { 2937 {
2919 time_t value; 2994 time_t value;
2920 2995
2921 windows = g_list_delete_link(windows, windows); 2996 windows = g_list_delete_link(windows, windows);
2922 2997
2923 if (window == widget || 2998 if (window == widget ||
2924 !GTK_WIDGET_VISIBLE(window)) 2999 !gtk_widget_get_visible(window))
2925 continue; 3000 continue;
2926 3001
2927 if (!gdk_property_get(window->window, _WindowTime, _Cardinal, 0, sizeof(time_t), FALSE, 3002 if (!gdk_property_get(window->window, _WindowTime, _Cardinal, 0, sizeof(time_t), FALSE,
2928 NULL, NULL, &al, &data)) 3003 NULL, NULL, &al, &data))
2929 continue; 3004 continue;
2978 !gtk_widget_get_visible(window)) { 3053 !gtk_widget_get_visible(window)) {
2979 continue; 3054 continue;
2980 } 3055 }
2981 3056
2982 if (gtk_window_has_toplevel_focus(GTK_WINDOW(window)) || 3057 if (gtk_window_has_toplevel_focus(GTK_WINDOW(window)) ||
2983 (menu && menu == gtk_widget_get_window(window))) { 3058 (menu && menu == window->window)) {
2984 parent = window; 3059 parent = window;
2985 break; 3060 break;
2986 } 3061 }
2987 } 3062 }
2988 if (windows) 3063 if (windows)
3003 3078
3004 loader = gdk_pixbuf_loader_new(); 3079 loader = gdk_pixbuf_loader_new();
3005 3080
3006 if (!gdk_pixbuf_loader_write(loader, buf, count, &error) || error) { 3081 if (!gdk_pixbuf_loader_write(loader, buf, count, &error) || error) {
3007 purple_debug_warning("gtkutils", "gdk_pixbuf_loader_write() " 3082 purple_debug_warning("gtkutils", "gdk_pixbuf_loader_write() "
3008 "failed with size=%zu: %s\n", count, 3083 "failed with size=%" G_GSIZE_FORMAT ": %s\n", count,
3009 error ? error->message : "(no error message)"); 3084 error ? error->message : "(no error message)");
3010 if (error) 3085 if (error)
3011 g_error_free(error); 3086 g_error_free(error);
3012 g_object_unref(G_OBJECT(loader)); 3087 g_object_unref(G_OBJECT(loader));
3013 return NULL; 3088 return NULL;
3014 } 3089 }
3015 3090
3016 if (!gdk_pixbuf_loader_close(loader, &error) || error) { 3091 if (!gdk_pixbuf_loader_close(loader, &error) || error) {
3017 purple_debug_warning("gtkutils", "gdk_pixbuf_loader_close() " 3092 purple_debug_warning("gtkutils", "gdk_pixbuf_loader_close() "
3018 "failed for image of size %zu: %s\n", count, 3093 "failed for image of size %" G_GSIZE_FORMAT ": %s\n", count,
3019 error ? error->message : "(no error message)"); 3094 error ? error->message : "(no error message)");
3020 if (error) 3095 if (error)
3021 g_error_free(error); 3096 g_error_free(error);
3022 g_object_unref(G_OBJECT(loader)); 3097 g_object_unref(G_OBJECT(loader));
3023 return NULL; 3098 return NULL;
3027 pixbuf = G_OBJECT(gdk_pixbuf_loader_get_animation(loader)); 3102 pixbuf = G_OBJECT(gdk_pixbuf_loader_get_animation(loader));
3028 else 3103 else
3029 pixbuf = G_OBJECT(gdk_pixbuf_loader_get_pixbuf(loader)); 3104 pixbuf = G_OBJECT(gdk_pixbuf_loader_get_pixbuf(loader));
3030 if (!pixbuf) { 3105 if (!pixbuf) {
3031 purple_debug_warning("gtkutils", "%s() returned NULL for image " 3106 purple_debug_warning("gtkutils", "%s() returned NULL for image "
3032 "of size %zu\n", 3107 "of size %" G_GSIZE_FORMAT "\n",
3033 animated ? "gdk_pixbuf_loader_get_animation" 3108 animated ? "gdk_pixbuf_loader_get_animation"
3034 : "gdk_pixbuf_loader_get_pixbuf", count); 3109 : "gdk_pixbuf_loader_get_pixbuf", count);
3035 g_object_unref(G_OBJECT(loader)); 3110 g_object_unref(G_OBJECT(loader));
3036 return NULL; 3111 return NULL;
3037 } 3112 }
3193 int code; 3268 int code;
3194 if (purple_str_has_prefix(uri, "file://")) 3269 if (purple_str_has_prefix(uri, "file://"))
3195 { 3270 {
3196 gchar *escaped = g_shell_quote(uri); 3271 gchar *escaped = g_shell_quote(uri);
3197 gchar *param = g_strconcat("/select,\"", uri, "\"", NULL); 3272 gchar *param = g_strconcat("/select,\"", uri, "\"", NULL);
3198 gchar *wc_param = g_utf8_to_utf16(param, -1, NULL, NULL, NULL); 3273 wchar_t *wc_param = g_utf8_to_utf16(param, -1, NULL, NULL, NULL);
3199 3274
3200 code = (int)ShellExecuteW(NULL, "OPEN", L"explorer.exe", wc_param, NULL, SW_NORMAL); 3275 code = (int)ShellExecuteW(NULL, L"OPEN", L"explorer.exe", wc_param, NULL, SW_NORMAL);
3201 3276
3202 g_free(wc_param); 3277 g_free(wc_param);
3203 g_free(param); 3278 g_free(param);
3204 g_free(escaped); 3279 g_free(escaped);
3205 } else { 3280 } else {
3357 PidginConversation *conv = g_object_get_data(G_OBJECT(item), "gtkconv"); 3432 PidginConversation *conv = g_object_get_data(G_OBJECT(item), "gtkconv");
3358 if (!conv) 3433 if (!conv)
3359 return TRUE; 3434 return TRUE;
3360 purple_request_file(conv->active_conv, _("Save File"), NULL, TRUE, 3435 purple_request_file(conv->active_conv, _("Save File"), NULL, TRUE,
3361 G_CALLBACK(savefile_write_cb), NULL, 3436 G_CALLBACK(savefile_write_cb), NULL,
3362 conv->active_conv->account, NULL, conv->active_conv, 3437 purple_conversation_get_account(conv->active_conv), NULL, conv->active_conv,
3363 (void *)url); 3438 (void *)url);
3364 return TRUE; 3439 return TRUE;
3365 } 3440 }
3366 3441
3367 static gboolean 3442 static gboolean
3539 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), hscrollbar_policy, vscrollbar_policy); 3614 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), hscrollbar_policy, vscrollbar_policy);
3540 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), shadow_type); 3615 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), shadow_type);
3541 if (width != -1 || height != -1) 3616 if (width != -1 || height != -1)
3542 gtk_widget_set_size_request(sw, width, height); 3617 gtk_widget_set_size_request(sw, width, height);
3543 if (child) { 3618 if (child) {
3544 if (GTK_IS_SCROLLABLE(child)) 3619 if (GTK_WIDGET_GET_CLASS(child)->set_scroll_adjustments_signal)
3545 gtk_container_add(GTK_CONTAINER(sw), child); 3620 gtk_container_add(GTK_CONTAINER(sw), child);
3546 else 3621 else
3547 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), child); 3622 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), child);
3548 } 3623 }
3549 return sw; 3624 return sw;
3614 gtk_imhtml_class_register_protocol("https://", NULL, NULL); 3689 gtk_imhtml_class_register_protocol("https://", NULL, NULL);
3615 gtk_imhtml_class_register_protocol("ftp://", NULL, NULL); 3690 gtk_imhtml_class_register_protocol("ftp://", NULL, NULL);
3616 gtk_imhtml_class_register_protocol("mailto:", NULL, NULL); 3691 gtk_imhtml_class_register_protocol("mailto:", NULL, NULL);
3617 gtk_imhtml_class_register_protocol("gopher://", NULL, NULL); 3692 gtk_imhtml_class_register_protocol("gopher://", NULL, NULL);
3618 } 3693 }
3619

Mercurial Repository: pidgin3

mercurial