Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkconv.c

pidgin/gtkconv.c

branch
cpw.qulogic.gtk3-required
changeset 33136
3f29d9c8299c
parent 32964
6934c0712cdc
parent 33132
24afd2b22579
child 33138
7e7aeaa31dfe
equal deleted inserted replaced
32969:b7b1abd3cfa3 33136:3f29d9c8299c
77 #include "pidginstock.h" 77 #include "pidginstock.h"
78 #include "pidgintooltip.h" 78 #include "pidgintooltip.h"
79 #include "smileyparser.h" 79 #include "smileyparser.h"
80 80
81 #include "gtknickcolors.h" 81 #include "gtknickcolors.h"
82
83 #if !GTK_CHECK_VERSION(2,20,0)
84 #define gtk_widget_get_realized(x) GTK_WIDGET_REALIZED(x)
85
86 #if !GTK_CHECK_VERSION(2,18,0)
87 #define gtk_widget_get_visible(x) GTK_WIDGET_VISIBLE(x)
88 #define gtk_widget_is_drawable(x) GTK_WIDGET_DRAWABLE(x)
89 #endif
90 #endif
91 82
92 /** 83 /**
93 * A GTK+ Instant Message pane. 84 * A GTK+ Instant Message pane.
94 */ 85 */
95 struct _PidginImPane 86 struct _PidginImPane
849 GtkSelectionData *sd, guint inf, guint t, gpointer data) 840 GtkSelectionData *sd, guint inf, guint t, gpointer data)
850 { 841 {
851 InviteBuddyInfo *info = (InviteBuddyInfo *)data; 842 InviteBuddyInfo *info = (InviteBuddyInfo *)data;
852 const char *convprotocol; 843 const char *convprotocol;
853 gboolean success = TRUE; 844 gboolean success = TRUE;
845 GdkAtom target = gtk_selection_data_get_target(sd);
854 846
855 convprotocol = purple_account_get_protocol_id(purple_conversation_get_account(info->conv)); 847 convprotocol = purple_account_get_protocol_id(purple_conversation_get_account(info->conv));
856 848
857 if (sd->target == gdk_atom_intern("PURPLE_BLIST_NODE", FALSE)) 849 if (target == gdk_atom_intern("PURPLE_BLIST_NODE", FALSE))
858 { 850 {
859 PurpleBlistNode *node = NULL; 851 PurpleBlistNode *node = NULL;
860 PurpleBuddy *buddy; 852 PurpleBuddy *buddy;
861 853 const guchar *data = gtk_selection_data_get_data(sd);
862 memcpy(&node, sd->data, sizeof(node)); 854
855 memcpy(&node, data, sizeof(node));
863 856
864 if (PURPLE_BLIST_NODE_IS_CONTACT(node)) 857 if (PURPLE_BLIST_NODE_IS_CONTACT(node))
865 buddy = purple_contact_get_priority_buddy((PurpleContact *)node); 858 buddy = purple_contact_get_priority_buddy((PurpleContact *)node);
866 else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) 859 else if (PURPLE_BLIST_NODE_IS_BUDDY(node))
867 buddy = (PurpleBuddy *)node; 860 buddy = (PurpleBuddy *)node;
876 success = FALSE; 869 success = FALSE;
877 } 870 }
878 else 871 else
879 gtk_entry_set_text(GTK_ENTRY(info->entry), purple_buddy_get_name(buddy)); 872 gtk_entry_set_text(GTK_ENTRY(info->entry), purple_buddy_get_name(buddy));
880 873
881 gtk_drag_finish(dc, success, (dc->action == GDK_ACTION_MOVE), t); 874 gtk_drag_finish(dc, success,
882 } 875 gdk_drag_context_get_actions(dc) == GDK_ACTION_MOVE, t);
883 else if (sd->target == gdk_atom_intern("application/x-im-contact", FALSE)) 876 }
877 else if (target == gdk_atom_intern("application/x-im-contact", FALSE))
884 { 878 {
885 char *protocol = NULL; 879 char *protocol = NULL;
886 char *username = NULL; 880 char *username = NULL;
887 PurpleAccount *account; 881 PurpleAccount *account;
888 882
889 if (pidgin_parse_x_im_contact((const char *)sd->data, FALSE, &account, 883 if (pidgin_parse_x_im_contact((const char *) data, FALSE, &account,
890 &protocol, &username, NULL)) 884 &protocol, &username, NULL))
891 { 885 {
892 if (account == NULL) 886 if (account == NULL)
893 { 887 {
894 purple_notify_error(PIDGIN_CONVERSATION(info->conv), NULL, 888 purple_notify_error(PIDGIN_CONVERSATION(info->conv), NULL,
909 } 903 }
910 904
911 g_free(username); 905 g_free(username);
912 g_free(protocol); 906 g_free(protocol);
913 907
914 gtk_drag_finish(dc, success, (dc->action == GDK_ACTION_MOVE), t); 908 gtk_drag_finish(dc, success,
909 gdk_drag_context_get_actions(dc) == GDK_ACTION_MOVE, t);
915 } 910 }
916 } 911 }
917 912
918 static const GtkTargetEntry dnd_targets[] = 913 static const GtkTargetEntry dnd_targets[] =
919 { 914 {
951 946
952 gtk_dialog_set_default_response(GTK_DIALOG(invite_dialog), 947 gtk_dialog_set_default_response(GTK_DIALOG(invite_dialog),
953 GTK_RESPONSE_OK); 948 GTK_RESPONSE_OK);
954 gtk_container_set_border_width(GTK_CONTAINER(invite_dialog), PIDGIN_HIG_BOX_SPACE); 949 gtk_container_set_border_width(GTK_CONTAINER(invite_dialog), PIDGIN_HIG_BOX_SPACE);
955 gtk_window_set_resizable(GTK_WINDOW(invite_dialog), FALSE); 950 gtk_window_set_resizable(GTK_WINDOW(invite_dialog), FALSE);
956 #if !GTK_CHECK_VERSION(2,22,0) 951 /* TODO: set no separator using GTK+ 3.0 */
952 #if 0
957 gtk_dialog_set_has_separator(GTK_DIALOG(invite_dialog), FALSE); 953 gtk_dialog_set_has_separator(GTK_DIALOG(invite_dialog), FALSE);
958 #endif 954 #endif
959 955
960 info->window = GTK_WIDGET(invite_dialog); 956 info->window = GTK_WIDGET(invite_dialog);
961 957
962 /* Setup the outside spacing. */ 958 /* Setup the outside spacing. */
963 vbox = GTK_DIALOG(invite_dialog)->vbox; 959 vbox = gtk_dialog_get_content_area(GTK_DIALOG(invite_dialog));
964 960
965 gtk_box_set_spacing(GTK_BOX(vbox), PIDGIN_HIG_BORDER); 961 gtk_box_set_spacing(GTK_BOX(vbox), PIDGIN_HIG_BORDER);
966 gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BOX_SPACE); 962 gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BOX_SPACE);
967 963
968 /* Setup the inner hbox and put the dialog's icon in it. */ 964 /* Setup the inner hbox and put the dialog's icon in it. */
1155 return; 1151 return;
1156 1152
1157 gtkblist = pidgin_blist_get_default_gtk_blist(); 1153 gtkblist = pidgin_blist_get_default_gtk_blist();
1158 1154
1159 cursor = gdk_cursor_new(GDK_WATCH); 1155 cursor = gdk_cursor_new(GDK_WATCH);
1160 gdk_window_set_cursor(gtkblist->window->window, cursor); 1156 gdk_window_set_cursor(gtk_widget_get_window(gtkblist->window), cursor);
1161 gdk_window_set_cursor(win->window->window, cursor); 1157 gdk_window_set_cursor(gtk_widget_get_window(win->window), cursor);
1162 gdk_cursor_unref(cursor); 1158 gdk_cursor_unref(cursor);
1163 1159
1164 name = purple_conversation_get_name(conv); 1160 name = purple_conversation_get_name(conv);
1165 account = purple_conversation_get_account(conv); 1161 account = purple_conversation_get_account(conv);
1166 1162
1170 PurpleBlistNode *node = cur->data; 1166 PurpleBlistNode *node = cur->data;
1171 if ((node != NULL) && ((node->prev != NULL) || (node->next != NULL))) 1167 if ((node != NULL) && ((node->prev != NULL) || (node->next != NULL)))
1172 { 1168 {
1173 pidgin_log_show_contact((PurpleContact *)node->parent); 1169 pidgin_log_show_contact((PurpleContact *)node->parent);
1174 g_slist_free(buddies); 1170 g_slist_free(buddies);
1175 gdk_window_set_cursor(gtkblist->window->window, NULL); 1171 gdk_window_set_cursor(gtk_widget_get_window(gtkblist->window), NULL);
1176 gdk_window_set_cursor(win->window->window, NULL); 1172 gdk_window_set_cursor(gtk_widget_get_window(win->window), NULL);
1177 return; 1173 return;
1178 } 1174 }
1179 } 1175 }
1180 g_slist_free(buddies); 1176 g_slist_free(buddies);
1181 1177
1182 pidgin_log_show(type, name, account); 1178 pidgin_log_show(type, name, account);
1183 1179
1184 gdk_window_set_cursor(gtkblist->window->window, NULL); 1180 gdk_window_set_cursor(gtk_widget_get_window(gtkblist->window), NULL);
1185 gdk_window_set_cursor(win->window->window, NULL); 1181 gdk_window_set_cursor(gtk_widget_get_window(win->window), NULL);
1186 } 1182 }
1187 1183
1188 static void 1184 static void
1189 menu_clear_cb(GtkAction *action, gpointer data) 1185 menu_clear_cb(GtkAction *action, gpointer data)
1190 { 1186 {
1977 pidgin_tooltip_destroy(); 1973 pidgin_tooltip_destroy();
1978 1974
1979 /* If CTRL was held down... */ 1975 /* If CTRL was held down... */
1980 if (event->state & GDK_CONTROL_MASK) { 1976 if (event->state & GDK_CONTROL_MASK) {
1981 switch (event->keyval) { 1977 switch (event->keyval) {
1982 case GDK_Page_Down: 1978 case GDK_KEY_Page_Down:
1983 case GDK_KP_Page_Down: 1979 case GDK_KEY_KP_Page_Down:
1984 case ']': 1980 case ']':
1985 if (!pidgin_conv_window_get_gtkconv_at_index(win, curconv + 1)) 1981 if (!pidgin_conv_window_get_gtkconv_at_index(win, curconv + 1))
1986 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), 0); 1982 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), 0);
1987 else 1983 else
1988 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), curconv + 1); 1984 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), curconv + 1);
1989 return TRUE; 1985 return TRUE;
1990 break; 1986 break;
1991 1987
1992 case GDK_Page_Up: 1988 case GDK_KEY_Page_Up:
1993 case GDK_KP_Page_Up: 1989 case GDK_KEY_KP_Page_Up:
1994 case '[': 1990 case '[':
1995 if (!pidgin_conv_window_get_gtkconv_at_index(win, curconv - 1)) 1991 if (!pidgin_conv_window_get_gtkconv_at_index(win, curconv - 1))
1996 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), -1); 1992 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), -1);
1997 else 1993 else
1998 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), curconv - 1); 1994 gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), curconv - 1);
1999 return TRUE; 1995 return TRUE;
2000 break; 1996 break;
2001 1997
2002 case GDK_Tab: 1998 case GDK_KEY_Tab:
2003 case GDK_KP_Tab: 1999 case GDK_KEY_KP_Tab:
2004 case GDK_ISO_Left_Tab: 2000 case GDK_KEY_ISO_Left_Tab:
2005 if (event->state & GDK_SHIFT_MASK) { 2001 if (event->state & GDK_SHIFT_MASK) {
2006 move_to_next_unread_tab(gtkconv, FALSE); 2002 move_to_next_unread_tab(gtkconv, FALSE);
2007 } else { 2003 } else {
2008 move_to_next_unread_tab(gtkconv, TRUE); 2004 move_to_next_unread_tab(gtkconv, TRUE);
2009 } 2005 }
2010 2006
2011 return TRUE; 2007 return TRUE;
2012 break; 2008 break;
2013 2009
2014 case GDK_comma: 2010 case GDK_KEY_comma:
2015 gtk_notebook_reorder_child(GTK_NOTEBOOK(win->notebook), 2011 gtk_notebook_reorder_child(GTK_NOTEBOOK(win->notebook),
2016 gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), curconv), 2012 gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), curconv),
2017 curconv - 1); 2013 curconv - 1);
2018 return TRUE; 2014 return TRUE;
2019 break; 2015 break;
2020 2016
2021 case GDK_period: 2017 case GDK_KEY_period:
2022 gtk_notebook_reorder_child(GTK_NOTEBOOK(win->notebook), 2018 gtk_notebook_reorder_child(GTK_NOTEBOOK(win->notebook),
2023 gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), curconv), 2019 gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), curconv),
2024 (curconv + 1) % gtk_notebook_get_n_pages(GTK_NOTEBOOK(win->notebook))); 2020 (curconv + 1) % gtk_notebook_get_n_pages(GTK_NOTEBOOK(win->notebook)));
2025 return TRUE; 2021 return TRUE;
2026 break; 2022 break;
2027 case GDK_F6: 2023 case GDK_KEY_F6:
2028 if (gtkconv_cycle_focus(gtkconv, event->state & GDK_SHIFT_MASK ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD)) 2024 if (gtkconv_cycle_focus(gtkconv, event->state & GDK_SHIFT_MASK ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD))
2029 return TRUE; 2025 return TRUE;
2030 break; 2026 break;
2031 } /* End of switch */ 2027 } /* End of switch */
2032 } 2028 }
2046 2042
2047 /* If neither CTRL nor ALT were held down... */ 2043 /* If neither CTRL nor ALT were held down... */
2048 else 2044 else
2049 { 2045 {
2050 switch (event->keyval) { 2046 switch (event->keyval) {
2051 case GDK_F2: 2047 case GDK_KEY_F2:
2052 if (gtk_widget_is_focus(GTK_WIDGET(win->notebook))) { 2048 if (gtk_widget_is_focus(GTK_WIDGET(win->notebook))) {
2053 infopane_entry_activate(gtkconv); 2049 infopane_entry_activate(gtkconv);
2054 return TRUE; 2050 return TRUE;
2055 } 2051 }
2056 break; 2052 break;
2057 case GDK_F6: 2053 case GDK_KEY_F6:
2058 if (gtkconv_cycle_focus(gtkconv, event->state & GDK_SHIFT_MASK ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD)) 2054 if (gtkconv_cycle_focus(gtkconv, event->state & GDK_SHIFT_MASK ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD))
2059 return TRUE; 2055 return TRUE;
2060 break; 2056 break;
2061 } 2057 }
2062 } 2058 }
2076 return TRUE; 2072 return TRUE;
2077 2073
2078 /* If CTRL was held down... */ 2074 /* If CTRL was held down... */
2079 if (event->state & GDK_CONTROL_MASK) { 2075 if (event->state & GDK_CONTROL_MASK) {
2080 switch (event->keyval) { 2076 switch (event->keyval) {
2081 case GDK_Up: 2077 case GDK_KEY_Up:
2082 if (!gtkconv->send_history) 2078 if (!gtkconv->send_history)
2083 break; 2079 break;
2084 2080
2085 if (gtkconv->entry != entry) 2081 if (gtkconv->entry != entry)
2086 break; 2082 break;
2127 } 2123 }
2128 2124
2129 return TRUE; 2125 return TRUE;
2130 break; 2126 break;
2131 2127
2132 case GDK_Down: 2128 case GDK_KEY_Down:
2133 if (!gtkconv->send_history) 2129 if (!gtkconv->send_history)
2134 break; 2130 break;
2135 2131
2136 if (gtkconv->entry != entry) 2132 if (gtkconv->entry != entry)
2137 break; 2133 break;
2180 } 2176 }
2181 2177
2182 /* If neither CTRL nor ALT were held down... */ 2178 /* If neither CTRL nor ALT were held down... */
2183 else { 2179 else {
2184 switch (event->keyval) { 2180 switch (event->keyval) {
2185 case GDK_Tab: 2181 case GDK_KEY_Tab:
2186 case GDK_KP_Tab: 2182 case GDK_KEY_KP_Tab:
2187 case GDK_ISO_Left_Tab: 2183 case GDK_KEY_ISO_Left_Tab:
2188 if (gtkconv->entry != entry) 2184 if (gtkconv->entry != entry)
2189 break; 2185 break;
2190 { 2186 {
2191 gint plugin_return; 2187 gint plugin_return;
2192 plugin_return = GPOINTER_TO_INT(purple_signal_emit_return_1( 2188 plugin_return = GPOINTER_TO_INT(purple_signal_emit_return_1(
2194 conv, event->state & GDK_SHIFT_MASK)); 2190 conv, event->state & GDK_SHIFT_MASK));
2195 return plugin_return ? TRUE : tab_complete(conv); 2191 return plugin_return ? TRUE : tab_complete(conv);
2196 } 2192 }
2197 break; 2193 break;
2198 2194
2199 case GDK_Page_Up: 2195 case GDK_KEY_Page_Up:
2200 case GDK_KP_Page_Up: 2196 case GDK_KEY_KP_Page_Up:
2201 gtk_webview_page_up(GTK_WEBVIEW(gtkconv->webview)); 2197 gtk_webview_page_up(GTK_WEBVIEW(gtkconv->webview));
2202 return TRUE; 2198 return TRUE;
2203 break; 2199 break;
2204 2200
2205 case GDK_Page_Down: 2201 case GDK_KEY_Page_Down:
2206 case GDK_KP_Page_Down: 2202 case GDK_KEY_KP_Page_Down:
2207 gtk_webview_page_down(GTK_WEBVIEW(gtkconv->webview)); 2203 gtk_webview_page_down(GTK_WEBVIEW(gtkconv->webview));
2208 return TRUE; 2204 return TRUE;
2209 break; 2205 break;
2210 2206
2211 } 2207 }
2245 { 2241 {
2246 PidginConversation *gtkconv = data; 2242 PidginConversation *gtkconv = data;
2247 2243
2248 /* If we have a valid key for the conversation display, then exit */ 2244 /* If we have a valid key for the conversation display, then exit */
2249 if ((event->state & GDK_CONTROL_MASK) || 2245 if ((event->state & GDK_CONTROL_MASK) ||
2250 (event->keyval == GDK_F6) || 2246 (event->keyval == GDK_KEY_F6) ||
2251 (event->keyval == GDK_F10) || 2247 (event->keyval == GDK_KEY_F10) ||
2252 (event->keyval == GDK_Shift_L) || 2248 (event->keyval == GDK_KEY_Shift_L) ||
2253 (event->keyval == GDK_Shift_R) || 2249 (event->keyval == GDK_KEY_Shift_R) ||
2254 (event->keyval == GDK_Control_L) || 2250 (event->keyval == GDK_KEY_Control_L) ||
2255 (event->keyval == GDK_Control_R) || 2251 (event->keyval == GDK_KEY_Control_R) ||
2256 (event->keyval == GDK_Escape) || 2252 (event->keyval == GDK_KEY_Escape) ||
2257 (event->keyval == GDK_Up) || 2253 (event->keyval == GDK_KEY_Up) ||
2258 (event->keyval == GDK_Down) || 2254 (event->keyval == GDK_KEY_Down) ||
2259 (event->keyval == GDK_Left) || 2255 (event->keyval == GDK_KEY_Left) ||
2260 (event->keyval == GDK_Right) || 2256 (event->keyval == GDK_KEY_Right) ||
2261 (event->keyval == GDK_Page_Up) || 2257 (event->keyval == GDK_KEY_Page_Up) ||
2262 (event->keyval == GDK_KP_Page_Up) || 2258 (event->keyval == GDK_KEY_KP_Page_Up) ||
2263 (event->keyval == GDK_Page_Down) || 2259 (event->keyval == GDK_KEY_Page_Down) ||
2264 (event->keyval == GDK_KP_Page_Down) || 2260 (event->keyval == GDK_KEY_KP_Page_Down) ||
2265 (event->keyval == GDK_Home) || 2261 (event->keyval == GDK_KEY_Home) ||
2266 (event->keyval == GDK_End) || 2262 (event->keyval == GDK_KEY_End) ||
2267 (event->keyval == GDK_Tab) || 2263 (event->keyval == GDK_KEY_Tab) ||
2268 (event->keyval == GDK_KP_Tab) || 2264 (event->keyval == GDK_KEY_KP_Tab) ||
2269 (event->keyval == GDK_ISO_Left_Tab)) 2265 (event->keyval == GDK_KEY_ISO_Left_Tab))
2270 { 2266 {
2271 if (event->type == GDK_KEY_PRESS) 2267 if (event->type == GDK_KEY_PRESS)
2272 return conv_keypress_common(gtkconv, event); 2268 return conv_keypress_common(gtkconv, event);
2273 return FALSE; 2269 return FALSE;
2274 } 2270 }
2734 2730
2735 return FALSE; 2731 return FALSE;
2736 } 2732 }
2737 2733
2738 static void 2734 static void
2739 start_anim(GtkObject *obj, PidginConversation *gtkconv) 2735 start_anim(GtkWidget *widget, PidginConversation *gtkconv)
2740 { 2736 {
2741 int delay; 2737 int delay;
2742 2738
2743 if (gtkconv->u.im->anim == NULL) 2739 if (gtkconv->u.im->anim == NULL)
2744 return; 2740 return;
2907 2903
2908 g_free(buf); 2904 g_free(buf);
2909 } 2905 }
2910 2906
2911 static void 2907 static void
2912 stop_anim(GtkObject *obj, PidginConversation *gtkconv) 2908 stop_anim(GtkWidget *widget, PidginConversation *gtkconv)
2913 { 2909 {
2914 if (gtkconv->u.im->icon_timer != 0) 2910 if (gtkconv->u.im->icon_timer != 0)
2915 g_source_remove(gtkconv->u.im->icon_timer); 2911 g_source_remove(gtkconv->u.im->icon_timer);
2916 2912
2917 gtkconv->u.im->icon_timer = 0; 2913 gtkconv->u.im->icon_timer = 0;
2929 else 2925 else
2930 stop_anim(NULL, gtkconv); 2926 stop_anim(NULL, gtkconv);
2931 } 2927 }
2932 2928
2933 static gboolean 2929 static gboolean
2934 icon_menu(GtkObject *obj, GdkEventButton *e, PidginConversation *gtkconv) 2930 icon_menu(GtkWidget *widget, GdkEventButton *e, PidginConversation *gtkconv)
2935 { 2931 {
2936 static GtkWidget *menu = NULL; 2932 static GtkWidget *menu = NULL;
2937 PurpleConversation *conv; 2933 PurpleConversation *conv;
2938 PurpleBuddy *buddy; 2934 PurpleBuddy *buddy;
2939 2935
3776 case 4: 3772 case 4:
3777 stock_id = PIDGIN_STOCK_ANIMATION_TYPING4; 3773 stock_id = PIDGIN_STOCK_ANIMATION_TYPING4;
3778 break; 3774 break;
3779 } 3775 }
3780 if (gtkwin->menu.typing_icon == NULL) { 3776 if (gtkwin->menu.typing_icon == NULL) {
3781 gtkwin->menu.typing_icon = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_MENU); 3777 gtkwin->menu.typing_icon = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_MENU);
3782 pidgin_menu_tray_append(PIDGIN_MENU_TRAY(gtkwin->menu.tray), 3778 pidgin_menu_tray_append(PIDGIN_MENU_TRAY(gtkwin->menu.tray),
3783 gtkwin->menu.typing_icon, 3779 gtkwin->menu.typing_icon,
3784 _("User is typing...")); 3780 _("User is typing..."));
3785 } else { 3781 } else {
3786 gtk_image_set_from_stock(GTK_IMAGE(gtkwin->menu.typing_icon), stock_id, GTK_ICON_SIZE_MENU); 3782 gtk_image_set_from_stock(GTK_IMAGE(gtkwin->menu.typing_icon), stock_id, GTK_ICON_SIZE_MENU);
3787 } 3783 }
3788 gtk_widget_show(gtkwin->menu.typing_icon); 3784 gtk_widget_show(gtkwin->menu.typing_icon);
3789 return TRUE; 3785 return TRUE;
3885 return FALSE; 3881 return FALSE;
3886 3882
3887 if (!(b = purple_find_buddy(account, purple_conversation_get_name(conv)))) 3883 if (!(b = purple_find_buddy(account, purple_conversation_get_name(conv))))
3888 return FALSE; 3884 return FALSE;
3889 3885
3886 #if 0 /* TODO */
3890 gtk_widget_show(win->menu.send_to); 3887 gtk_widget_show(win->menu.send_to);
3891 3888
3892 menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(win->menu.send_to)); 3889 menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(win->menu.send_to));
3893 3890
3894 for (child = gtk_container_get_children(GTK_CONTAINER(menu)); 3891 for (child = gtk_container_get_children(GTK_CONTAINER(menu));
3906 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); 3903 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
3907 g_list_free(child); 3904 g_list_free(child);
3908 break; 3905 break;
3909 } 3906 }
3910 } 3907 }
3908 #endif
3911 3909
3912 return FALSE; 3910 return FALSE;
3913 } 3911 }
3914 3912
3915 static gboolean 3913 static gboolean
4015 } 4013 }
4016 4014
4017 static void 4015 static void
4018 generate_send_to_items(PidginWindow *win) 4016 generate_send_to_items(PidginWindow *win)
4019 { 4017 {
4018 #if 0 /* TODO */
4020 GtkWidget *menu; 4019 GtkWidget *menu;
4021 GSList *group = NULL; 4020 GSList *group = NULL;
4022 GtkSizeGroup *sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); 4021 GtkSizeGroup *sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
4023 PidginConversation *gtkconv; 4022 PidginConversation *gtkconv;
4024 GSList *l, *buds; 4023 GSList *l, *buds;
4100 gtk_widget_show(win->menu.send_to); 4099 gtk_widget_show(win->menu.send_to);
4101 /* TODO: This should never be insensitive. Possibly hidden or not. */ 4100 /* TODO: This should never be insensitive. Possibly hidden or not. */
4102 if (!group) 4101 if (!group)
4103 gtk_widget_set_sensitive(win->menu.send_to, FALSE); 4102 gtk_widget_set_sensitive(win->menu.send_to, FALSE);
4104 update_send_to_selection(win); 4103 update_send_to_selection(win);
4104 #endif
4105 } 4105 }
4106 4106
4107 static const char * 4107 static const char *
4108 get_chat_buddy_status_icon(PurpleConvChat *chat, const char *name, PurpleConvChatBuddyFlags flags) 4108 get_chat_buddy_status_icon(PurpleConvChat *chat, const char *name, PurpleConvChatBuddyFlags flags)
4109 { 4109 {
4752 GtkTextIter iter; 4752 GtkTextIter iter;
4753 int lines; 4753 int lines;
4754 GdkRectangle oneline; 4754 GdkRectangle oneline;
4755 int height, diff; 4755 int height, diff;
4756 int pad_top, pad_inside, pad_bottom; 4756 int pad_top, pad_inside, pad_bottom;
4757 int total_height = (gtkconv->webview->allocation.height + gtkconv->entry->allocation.height); 4757 int total_height;
4758 int max_height = total_height / 2; 4758 int max_height;
4759 int min_lines = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/minimum_entry_lines"); 4759 int min_lines = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/minimum_entry_lines");
4760 int min_height; 4760 int min_height;
4761 gboolean interior_focus; 4761 gboolean interior_focus;
4762 int focus_width; 4762 int focus_width;
4763 GtkAllocation webview_allocation;
4764 GtkAllocation entry_allocation;
4765 GtkAllocation lower_hbox_allocation;
4766
4767 gtk_widget_get_allocation(gtkconv->webview, &webview_allocation);
4768 gtk_widget_get_allocation(gtkconv->entry, &entry_allocation);
4769 gtk_widget_get_allocation(gtkconv->lower_hbox, &lower_hbox_allocation);
4770 total_height = webview_allocation.height + entry_allocation.height;
4771 max_height = total_height / 2;
4763 4772
4764 pad_top = gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(gtkconv->entry)); 4773 pad_top = gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(gtkconv->entry));
4765 pad_bottom = gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(gtkconv->entry)); 4774 pad_bottom = gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(gtkconv->entry));
4766 pad_inside = gtk_text_view_get_pixels_inside_wrap(GTK_TEXT_VIEW(gtkconv->entry)); 4775 pad_inside = gtk_text_view_get_pixels_inside_wrap(GTK_TEXT_VIEW(gtkconv->entry));
4767 4776
4791 "focus-line-width", &focus_width, 4800 "focus-line-width", &focus_width,
4792 NULL); 4801 NULL);
4793 if (!interior_focus) 4802 if (!interior_focus)
4794 height += 2 * focus_width; 4803 height += 2 * focus_width;
4795 4804
4796 diff = height - gtkconv->entry->allocation.height; 4805 diff = height - entry_allocation.height;
4797 if (ABS(diff) < oneline.height / 2) 4806 if (ABS(diff) < oneline.height / 2)
4798 return FALSE; 4807 return FALSE;
4799 4808
4809 purple_debug_info("pidgin", "resizing to %d, %d lines, diff %d\n",
4810 diff + lower_hbox_allocation.height, min_lines, diff);
4811
4800 gtk_widget_set_size_request(gtkconv->lower_hbox, -1, 4812 gtk_widget_set_size_request(gtkconv->lower_hbox, -1,
4801 diff + gtkconv->lower_hbox->allocation.height); 4813 diff + lower_hbox_allocation.height);
4802 4814
4803 return FALSE; 4815 return FALSE;
4804 } 4816 }
4805 4817
4806 static void 4818 static void
4843 gtk_widget_set_size_request(gtkchat->topic_text, -1, BUDDYICON_SIZE_MIN); 4855 gtk_widget_set_size_request(gtkchat->topic_text, -1, BUDDYICON_SIZE_MIN);
4844 4856
4845 if(prpl_info->set_chat_topic == NULL) { 4857 if(prpl_info->set_chat_topic == NULL) {
4846 gtk_editable_set_editable(GTK_EDITABLE(gtkchat->topic_text), FALSE); 4858 gtk_editable_set_editable(GTK_EDITABLE(gtkchat->topic_text), FALSE);
4847 } else { 4859 } else {
4848 g_signal_connect(GTK_OBJECT(gtkchat->topic_text), "activate", 4860 g_signal_connect(G_OBJECT(gtkchat->topic_text), "activate",
4849 G_CALLBACK(topic_callback), gtkconv); 4861 G_CALLBACK(topic_callback), gtkconv);
4850 } 4862 }
4851 4863
4852 gtk_box_pack_start(GTK_BOX(hbox), gtkchat->topic_text, TRUE, TRUE, 0); 4864 gtk_box_pack_start(GTK_BOX(hbox), gtkchat->topic_text, TRUE, TRUE, 0);
4853 g_signal_connect(G_OBJECT(gtkchat->topic_text), "key_press_event", 4865 g_signal_connect(G_OBJECT(gtkchat->topic_text), "key_press_event",
5014 pidgin_conv_end_quickfind(PidginConversation *gtkconv) 5026 pidgin_conv_end_quickfind(PidginConversation *gtkconv)
5015 { 5027 {
5016 gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, NULL); 5028 gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, NULL);
5017 5029
5018 webkit_web_view_unmark_text_matches(WEBKIT_WEB_VIEW(gtkconv->webview)); 5030 webkit_web_view_unmark_text_matches(WEBKIT_WEB_VIEW(gtkconv->webview));
5019 gtk_widget_hide_all(gtkconv->quickfind.container); 5031 gtk_widget_hide(gtkconv->quickfind.container);
5020 5032
5021 gtk_widget_grab_focus(gtkconv->entry); 5033 gtk_widget_grab_focus(gtkconv->entry);
5022 return TRUE; 5034 return TRUE;
5023 } 5035 }
5024 5036
5025 static gboolean 5037 static gboolean
5026 quickfind_process_input(GtkWidget *entry, GdkEventKey *event, PidginConversation *gtkconv) 5038 quickfind_process_input(GtkWidget *entry, GdkEventKey *event, PidginConversation *gtkconv)
5027 { 5039 {
5028 switch (event->keyval) { 5040 switch (event->keyval) {
5029 case GDK_Return: 5041 case GDK_KEY_Return:
5030 case GDK_KP_Enter: 5042 case GDK_KEY_KP_Enter:
5031 if (webkit_web_view_search_text(WEBKIT_WEB_VIEW(gtkconv->webview), gtk_entry_get_text(GTK_ENTRY(entry)), FALSE, TRUE, TRUE)) { 5043 if (webkit_web_view_search_text(WEBKIT_WEB_VIEW(gtkconv->webview), gtk_entry_get_text(GTK_ENTRY(entry)), FALSE, TRUE, TRUE)) {
5032 gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, NULL); 5044 gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, NULL);
5033 } else { 5045 } else {
5034 GdkColor col; 5046 GdkColor col;
5035 col.red = 0xffff; 5047 col.red = 0xffff;
5036 col.green = 0xafff; 5048 col.green = 0xafff;
5037 col.blue = 0xafff; 5049 col.blue = 0xafff;
5038 gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, &col); 5050 gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, &col);
5039 } 5051 }
5040 break; 5052 break;
5041 case GDK_Escape: 5053 case GDK_KEY_Escape:
5042 pidgin_conv_end_quickfind(gtkconv); 5054 pidgin_conv_end_quickfind(gtkconv);
5043 break; 5055 break;
5044 default: 5056 default:
5045 return FALSE; 5057 return FALSE;
5046 } 5058 }
5493 PidginWindow *win = gtkconv->win; 5505 PidginWindow *win = gtkconv->win;
5494 PurpleConversation *c; 5506 PurpleConversation *c;
5495 PurpleAccount *convaccount = purple_conversation_get_account(conv); 5507 PurpleAccount *convaccount = purple_conversation_get_account(conv);
5496 PurpleConnection *gc = purple_account_get_connection(convaccount); 5508 PurpleConnection *gc = purple_account_get_connection(convaccount);
5497 PurplePluginProtocolInfo *prpl_info = gc ? PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc)) : NULL; 5509 PurplePluginProtocolInfo *prpl_info = gc ? PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc)) : NULL;
5498 5510 GdkAtom target = gtk_selection_data_get_target(sd);
5499 if (sd->target == gdk_atom_intern("PURPLE_BLIST_NODE", FALSE)) 5511 const guchar *data = gtk_selection_data_get_data(sd);
5512
5513 if (target == gdk_atom_intern("PURPLE_BLIST_NODE", FALSE))
5500 { 5514 {
5501 PurpleBlistNode *n = NULL; 5515 PurpleBlistNode *n = NULL;
5502 PurpleBuddy *b; 5516 PurpleBuddy *b;
5503 PidginConversation *gtkconv = NULL; 5517 PidginConversation *gtkconv = NULL;
5504 PurpleAccount *buddyaccount; 5518 PurpleAccount *buddyaccount;
5505 const char *buddyname; 5519 const char *buddyname;
5506 5520
5507 n = *(PurpleBlistNode **)sd->data; 5521 n = *(PurpleBlistNode **) data;
5508 5522
5509 if (PURPLE_BLIST_NODE_IS_CONTACT(n)) 5523 if (PURPLE_BLIST_NODE_IS_CONTACT(n))
5510 b = purple_contact_get_priority_buddy((PurpleContact*)n); 5524 b = purple_contact_get_priority_buddy((PurpleContact*)n);
5511 else if (PURPLE_BLIST_NODE_IS_BUDDY(n)) 5525 else if (PURPLE_BLIST_NODE_IS_BUDDY(n))
5512 b = (PurpleBuddy*)n; 5526 b = (PurpleBuddy*)n;
5550 5564
5551 /* Make this conversation the active conversation */ 5565 /* Make this conversation the active conversation */
5552 pidgin_conv_window_switch_gtkconv(win, gtkconv); 5566 pidgin_conv_window_switch_gtkconv(win, gtkconv);
5553 } 5567 }
5554 5568
5555 gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); 5569 gtk_drag_finish(dc, TRUE,
5556 } 5570 gdk_drag_context_get_actions(dc) == GDK_ACTION_MOVE, t);
5557 else if (sd->target == gdk_atom_intern("application/x-im-contact", FALSE)) 5571 }
5572 else if (target == gdk_atom_intern("application/x-im-contact", FALSE))
5558 { 5573 {
5559 char *protocol = NULL; 5574 char *protocol = NULL;
5560 char *username = NULL; 5575 char *username = NULL;
5561 PurpleAccount *account; 5576 PurpleAccount *account;
5562 PidginConversation *gtkconv; 5577 PidginConversation *gtkconv;
5563 5578
5564 if (pidgin_parse_x_im_contact((const char *)sd->data, FALSE, &account, 5579 if (pidgin_parse_x_im_contact((const char *) data, FALSE, &account,
5565 &protocol, &username, NULL)) 5580 &protocol, &username, NULL))
5566 { 5581 {
5567 if (account == NULL) 5582 if (account == NULL)
5568 { 5583 {
5569 purple_notify_error(win, NULL, 5584 purple_notify_error(win, NULL,
5590 } 5605 }
5591 5606
5592 g_free(username); 5607 g_free(username);
5593 g_free(protocol); 5608 g_free(protocol);
5594 5609
5595 gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); 5610 gtk_drag_finish(dc, TRUE,
5596 } 5611 gdk_drag_context_get_actions(dc) == GDK_ACTION_MOVE, t);
5597 else if (sd->target == gdk_atom_intern("text/uri-list", FALSE)) { 5612 }
5613 else if (target == gdk_atom_intern("text/uri-list", FALSE)) {
5598 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) 5614 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM)
5599 pidgin_dnd_file_manage(sd, convaccount, purple_conversation_get_name(conv)); 5615 pidgin_dnd_file_manage(sd, convaccount, purple_conversation_get_name(conv));
5600 gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); 5616 gtk_drag_finish(dc, TRUE,
5617 gdk_drag_context_get_actions(dc) == GDK_ACTION_MOVE, t);
5601 } 5618 }
5602 else 5619 else
5603 gtk_drag_finish(dc, FALSE, FALSE, t); 5620 gtk_drag_finish(dc, FALSE, FALSE, t);
5604 } 5621 }
5605 5622
6008 if (event->type == GDK_BUTTON_PRESS 6025 if (event->type == GDK_BUTTON_PRESS
6009 || event->type == GDK_2BUTTON_PRESS) { 6026 || event->type == GDK_2BUTTON_PRESS) {
6010 GdkEventButton *btn_event = (GdkEventButton*) event; 6027 GdkEventButton *btn_event = (GdkEventButton*) event;
6011 PurpleConversation *conv = data; 6028 PurpleConversation *conv = data;
6012 char *buddyname; 6029 char *buddyname;
6030 gchar *name;
6031
6032 g_object_get(G_OBJECT(tag), "name", &name, NULL);
6013 6033
6014 /* strlen("BUDDY " or "HILIT ") == 6 */ 6034 /* strlen("BUDDY " or "HILIT ") == 6 */
6015 g_return_val_if_fail((tag->name != NULL) 6035 g_return_val_if_fail((name != NULL) && (strlen(name) > 6), FALSE);
6016 && (strlen(tag->name) > 6), FALSE); 6036
6017 6037 buddyname = name + 6;
6018 buddyname = (tag->name) + 6;
6019 6038
6020 /* emit chat-nick-clicked signal */ 6039 /* emit chat-nick-clicked signal */
6021 if (event->type == GDK_BUTTON_PRESS) { 6040 if (event->type == GDK_BUTTON_PRESS) {
6022 gint plugin_return = GPOINTER_TO_INT(purple_signal_emit_return_1( 6041 gint plugin_return = GPOINTER_TO_INT(purple_signal_emit_return_1(
6023 pidgin_conversations_get_handle(), "chat-nick-clicked", 6042 pidgin_conversations_get_handle(), "chat-nick-clicked",
6024 data, buddyname, btn_event->button)); 6043 data, buddyname, btn_event->button));
6025 if (plugin_return) 6044 if (plugin_return) {
6045 g_free(name);
6026 return TRUE; 6046 return TRUE;
6027 } 6047 }
6028 6048 }
6029 if (btn_event->button == 1 && 6049
6030 event->type == GDK_2BUTTON_PRESS) { 6050 if (btn_event->button == 1 && event->type == GDK_2BUTTON_PRESS) {
6031 chat_do_im(PIDGIN_CONVERSATION(conv), buddyname); 6051 chat_do_im(PIDGIN_CONVERSATION(conv), buddyname);
6052 g_free(name);
6053
6032 return TRUE; 6054 return TRUE;
6033 } else if (btn_event->button == 2 6055 } else if (btn_event->button == 2 && event->type == GDK_2BUTTON_PRESS) {
6034 && event->type == GDK_2BUTTON_PRESS) {
6035 chat_do_info(PIDGIN_CONVERSATION(conv), buddyname); 6056 chat_do_info(PIDGIN_CONVERSATION(conv), buddyname);
6057 g_free(name);
6036 6058
6037 return TRUE; 6059 return TRUE;
6038 } else if (btn_event->button == 3 6060 } else if (btn_event->button == 3 && event->type == GDK_BUTTON_PRESS) {
6039 && event->type == GDK_BUTTON_PRESS) {
6040 GtkTextIter start, end; 6061 GtkTextIter start, end;
6041 6062
6042 /* we shouldn't display the popup 6063 /* we shouldn't display the popup
6043 * if the user has selected something: */ 6064 * if the user has selected something: */
6044 if (!gtk_text_buffer_get_selection_bounds( 6065 if (!gtk_text_buffer_get_selection_bounds(
6053 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 6074 gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
6054 NULL, GTK_WIDGET(imhtml), 6075 NULL, GTK_WIDGET(imhtml),
6055 btn_event->button, 6076 btn_event->button,
6056 btn_event->time); 6077 btn_event->time);
6057 6078
6079 g_free(name);
6080
6058 /* Don't propagate the event any further */ 6081 /* Don't propagate the event any further */
6059 return TRUE; 6082 return TRUE;
6060 } 6083 }
6061 } 6084 }
6085
6086 g_free(name);
6062 } 6087 }
6063 6088
6064 return FALSE; 6089 return FALSE;
6065 } 6090 }
6066 #endif 6091 #endif
7302 pidgin_themes_smiley_themeize(PIDGIN_CONVERSATION(conv)->webview); 7327 pidgin_themes_smiley_themeize(PIDGIN_CONVERSATION(conv)->webview);
7303 #endif 7328 #endif
7304 7329
7305 if ((fields & PIDGIN_CONV_COLORIZE_TITLE) || 7330 if ((fields & PIDGIN_CONV_COLORIZE_TITLE) ||
7306 (fields & PIDGIN_CONV_SET_TITLE) || 7331 (fields & PIDGIN_CONV_SET_TITLE) ||
7307 (fields & PIDGIN_CONV_TOPIC)) 7332 (fields & PIDGIN_CONV_TOPIC))
7308 { 7333 {
7309 char *title; 7334 char *title;
7310 PurpleConvIm *im = NULL; 7335 PurpleConvIm *im = NULL;
7311 PurpleAccount *account = purple_conversation_get_account(conv); 7336 PurpleAccount *account = purple_conversation_get_account(conv);
7312 PurpleBuddy *buddy = NULL; 7337 PurpleBuddy *buddy = NULL;
7668 7693
7669 event = gtk_event_box_new(); 7694 event = gtk_event_box_new();
7670 gtk_container_add(GTK_CONTAINER(gtkconv->u.im->icon_container), event); 7695 gtk_container_add(GTK_CONTAINER(gtkconv->u.im->icon_container), event);
7671 gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), FALSE); 7696 gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), FALSE);
7672 gtk_widget_add_events(event, 7697 gtk_widget_add_events(event,
7673 GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK); 7698 GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
7674 g_signal_connect(G_OBJECT(event), "button-press-event", 7699 g_signal_connect(G_OBJECT(event), "button-press-event",
7675 G_CALLBACK(icon_menu), gtkconv); 7700 G_CALLBACK(icon_menu), gtkconv);
7676 7701
7677 pidgin_tooltip_setup_for_widget(event, gtkconv, pidgin_conv_create_tooltip, NULL); 7702 pidgin_tooltip_setup_for_widget(event, gtkconv, pidgin_conv_create_tooltip, NULL);
7678 gtk_widget_show(event); 7703 gtk_widget_show(event);
7710 static gboolean 7735 static gboolean
7711 pidgin_conv_xy_to_right_infopane(PidginWindow *win, int x, int y) 7736 pidgin_conv_xy_to_right_infopane(PidginWindow *win, int x, int y)
7712 { 7737 {
7713 gint pane_x, pane_y, x_rel; 7738 gint pane_x, pane_y, x_rel;
7714 PidginConversation *gtkconv; 7739 PidginConversation *gtkconv;
7715 7740 GtkAllocation allocation;
7716 gdk_window_get_origin(win->notebook->window, &pane_x, &pane_y); 7741
7742 gdk_window_get_origin(gtk_widget_get_window(win->notebook),
7743 &pane_x, &pane_y);
7717 x_rel = x - pane_x; 7744 x_rel = x - pane_x;
7718 gtkconv = pidgin_conv_window_get_active_gtkconv(win); 7745 gtkconv = pidgin_conv_window_get_active_gtkconv(win);
7719 return (x_rel > gtkconv->infopane->allocation.x + gtkconv->infopane->allocation.width / 2); 7746 gtk_widget_get_allocation(gtkconv->infopane, &allocation);
7747 return (x_rel > allocation.x + allocation.width / 2);
7720 } 7748 }
7721 7749
7722 int 7750 int
7723 pidgin_conv_get_tab_at_xy(PidginWindow *win, int x, int y, gboolean *to_right) 7751 pidgin_conv_get_tab_at_xy(PidginWindow *win, int x, int y, gboolean *to_right)
7724 { 7752 {
7732 if (to_right) 7760 if (to_right)
7733 *to_right = FALSE; 7761 *to_right = FALSE;
7734 7762
7735 notebook = GTK_NOTEBOOK(win->notebook); 7763 notebook = GTK_NOTEBOOK(win->notebook);
7736 7764
7737 gdk_window_get_origin(win->notebook->window, &nb_x, &nb_y); 7765 gdk_window_get_origin(gtk_widget_get_window(win->notebook), &nb_x, &nb_y);
7738 x_rel = x - nb_x; 7766 x_rel = x - nb_x;
7739 y_rel = y - nb_y; 7767 y_rel = y - nb_y;
7740 7768
7741 horiz = (gtk_notebook_get_tab_pos(notebook) == GTK_POS_TOP || 7769 horiz = (gtk_notebook_get_tab_pos(notebook) == GTK_POS_TOP ||
7742 gtk_notebook_get_tab_pos(notebook) == GTK_POS_BOTTOM); 7770 gtk_notebook_get_tab_pos(notebook) == GTK_POS_BOTTOM);
7743 7771
7744 count = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)); 7772 count = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook));
7745 7773
7746 for (i = 0; i < count; i++) { 7774 for (i = 0; i < count; i++) {
7775 GtkAllocation allocation;
7747 7776
7748 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i); 7777 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i);
7749 tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook), page); 7778 tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook), page);
7779 gtk_widget_get_allocation(tab, &allocation);
7750 7780
7751 /* Make sure the tab is not hidden beyond an arrow */ 7781 /* Make sure the tab is not hidden beyond an arrow */
7752 if (!gtk_widget_is_drawable(tab) && gtk_notebook_get_show_tabs(notebook)) 7782 if (!gtk_widget_is_drawable(tab) && gtk_notebook_get_show_tabs(notebook))
7753 continue; 7783 continue;
7754 7784
7755 if (horiz) { 7785 if (horiz) {
7756 if (x_rel >= tab->allocation.x - PIDGIN_HIG_BOX_SPACE && 7786 if (x_rel >= allocation.x - PIDGIN_HIG_BOX_SPACE &&
7757 x_rel <= tab->allocation.x + tab->allocation.width + PIDGIN_HIG_BOX_SPACE) { 7787 x_rel <= allocation.x + allocation.width + PIDGIN_HIG_BOX_SPACE) {
7758 page_num = i; 7788 page_num = i;
7759 7789
7760 if (to_right && x_rel >= tab->allocation.x + tab->allocation.width/2) 7790 if (to_right && x_rel >= allocation.x + allocation.width/2)
7761 *to_right = TRUE; 7791 *to_right = TRUE;
7762 7792
7763 break; 7793 break;
7764 } 7794 }
7765 } else { 7795 } else {
7766 if (y_rel >= tab->allocation.y - PIDGIN_HIG_BOX_SPACE && 7796 if (y_rel >= allocation.y - PIDGIN_HIG_BOX_SPACE &&
7767 y_rel <= tab->allocation.y + tab->allocation.height + PIDGIN_HIG_BOX_SPACE) { 7797 y_rel <= allocation.y + allocation.height + PIDGIN_HIG_BOX_SPACE) {
7768 page_num = i; 7798 page_num = i;
7769 7799
7770 if (to_right && y_rel >= tab->allocation.y + tab->allocation.height/2) 7800 if (to_right && y_rel >= allocation.y + allocation.height/2)
7771 *to_right = TRUE; 7801 *to_right = TRUE;
7772 7802
7773 break; 7803 break;
7774 } 7804 }
7775 } 7805 }
8530 purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/conversations/im/show_buddy_icons", 8560 purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/conversations/im/show_buddy_icons",
8531 show_buddy_icons_pref_cb, NULL); 8561 show_buddy_icons_pref_cb, NULL);
8532 purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_protocol_icons", 8562 purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_protocol_icons",
8533 show_protocol_icons_pref_cb, NULL); 8563 show_protocol_icons_pref_cb, NULL);
8534 purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/conversations/im/hide_new", 8564 purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/conversations/im/hide_new",
8535 hide_new_pref_cb, NULL); 8565 hide_new_pref_cb, NULL);
8536 8566
8537 8567
8538 8568
8539 /********************************************************************** 8569 /**********************************************************************
8540 * Register signals 8570 * Register signals
8687 8717
8688 hidden_convwin = pidgin_conv_window_new(); 8718 hidden_convwin = pidgin_conv_window_new();
8689 window_list = g_list_remove(window_list, hidden_convwin); 8719 window_list = g_list_remove(window_list, hidden_convwin);
8690 8720
8691 purple_signal_connect(purple_accounts_get_handle(), "account-status-changed", 8721 purple_signal_connect(purple_accounts_get_handle(), "account-status-changed",
8692 handle, PURPLE_CALLBACK(account_status_changed_cb), NULL); 8722 handle, PURPLE_CALLBACK(account_status_changed_cb), NULL);
8693 8723
8694 /* Callbacks to update a conversation */ 8724 /* Callbacks to update a conversation */
8695 purple_signal_connect(blist_handle, "blist-node-added", handle, 8725 purple_signal_connect(blist_handle, "blist-node-added", handle,
8696 G_CALLBACK(buddy_update_cb), NULL); 8726 G_CALLBACK(buddy_update_cb), NULL);
8697 purple_signal_connect(blist_handle, "blist-node-removed", handle, 8727 purple_signal_connect(blist_handle, "blist-node-removed", handle,
8876 GTK_RESPONSE_OK); 8906 GTK_RESPONSE_OK);
8877 8907
8878 gtk_container_set_border_width(GTK_CONTAINER(warn_close_dialog), 8908 gtk_container_set_border_width(GTK_CONTAINER(warn_close_dialog),
8879 6); 8909 6);
8880 gtk_window_set_resizable(GTK_WINDOW(warn_close_dialog), FALSE); 8910 gtk_window_set_resizable(GTK_WINDOW(warn_close_dialog), FALSE);
8881 #if !GTK_CHECK_VERSION(2,22,0) 8911
8882 gtk_dialog_set_has_separator(GTK_DIALOG(warn_close_dialog), FALSE); 8912 /* TODO: figure out how to set no separator in GTK+ 3.0 */
8913 #if 0
8914 gtk_dialog_set_has_separator(GTK_DIALOG(warn_close_dialog),
8915 FALSE);
8883 #endif 8916 #endif
8884 8917
8885 /* Setup the outside spacing. */ 8918 /* Setup the outside spacing. */
8886 vbox = GTK_DIALOG(warn_close_dialog)->vbox; 8919 vbox = gtk_dialog_get_content_area(GTK_DIALOG(warn_close_dialog));
8887 8920
8888 gtk_box_set_spacing(GTK_BOX(vbox), 12); 8921 gtk_box_set_spacing(GTK_BOX(vbox), 12);
8889 gtk_container_set_border_width(GTK_CONTAINER(vbox), 6); 8922 gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
8890 8923
8891 img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_WARNING, 8924 img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_WARNING,
9035 #ifndef _WIN32 9068 #ifndef _WIN32
9036 /* Currently for win32 GTK+ (as of 2.2.1), gdk_pointer_is_grabbed will 9069 /* Currently for win32 GTK+ (as of 2.2.1), gdk_pointer_is_grabbed will
9037 always be true after a button press. */ 9070 always be true after a button press. */
9038 if (!gdk_pointer_is_grabbed()) 9071 if (!gdk_pointer_is_grabbed())
9039 #endif 9072 #endif
9040 gdk_pointer_grab(gtkwin->notebook->window, FALSE, 9073 gdk_pointer_grab(gtk_widget_get_window(gtkwin->notebook), FALSE,
9041 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, 9074 GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
9042 NULL, cursor, GDK_CURRENT_TIME); 9075 NULL, cursor, GDK_CURRENT_TIME);
9043 } 9076 }
9044 9077
9045 static gboolean 9078 static gboolean
9155 if (e->type != GDK_BUTTON_PRESS) 9188 if (e->type != GDK_BUTTON_PRESS)
9156 return FALSE; 9189 return FALSE;
9157 9190
9158 if (e->button == 1) { 9191 if (e->button == 1) {
9159 int nb_x, nb_y; 9192 int nb_x, nb_y;
9193 GtkAllocation allocation;
9194
9195 gtk_widget_get_allocation(gtkconv->infopane_hbox, &allocation);
9160 9196
9161 if (gtkconv->win->in_drag) 9197 if (gtkconv->win->in_drag)
9162 return TRUE; 9198 return TRUE;
9163 9199
9164 gtkconv->win->in_predrag = TRUE; 9200 gtkconv->win->in_predrag = TRUE;
9165 gtkconv->win->drag_tab = gtk_notebook_page_num(GTK_NOTEBOOK(gtkconv->win->notebook), gtkconv->tab_cont); 9201 gtkconv->win->drag_tab = gtk_notebook_page_num(GTK_NOTEBOOK(gtkconv->win->notebook), gtkconv->tab_cont);
9166 9202
9167 gdk_window_get_origin(gtkconv->infopane_hbox->window, &nb_x, &nb_y); 9203 gdk_window_get_origin(gtk_widget_get_window(gtkconv->infopane_hbox), &nb_x, &nb_y);
9168 9204
9169 gtkconv->win->drag_min_x = gtkconv->infopane_hbox->allocation.x + nb_x; 9205 gtkconv->win->drag_min_x = allocation.x + nb_x;
9170 gtkconv->win->drag_min_y = gtkconv->infopane_hbox->allocation.y + nb_y; 9206 gtkconv->win->drag_min_y = allocation.y + nb_y;
9171 gtkconv->win->drag_max_x = gtkconv->infopane_hbox->allocation.width + gtkconv->win->drag_min_x; 9207 gtkconv->win->drag_max_x = allocation.width + gtkconv->win->drag_min_x;
9172 gtkconv->win->drag_max_y = gtkconv->infopane_hbox->allocation.height + gtkconv->win->drag_min_y; 9208 gtkconv->win->drag_max_y = allocation.height + gtkconv->win->drag_min_y;
9173 9209
9174 gtkconv->win->drag_motion_signal = g_signal_connect(G_OBJECT(gtkconv->win->notebook), "motion_notify_event", 9210 gtkconv->win->drag_motion_signal = g_signal_connect(G_OBJECT(gtkconv->win->notebook), "motion_notify_event",
9175 G_CALLBACK(notebook_motion_cb), gtkconv->win); 9211 G_CALLBACK(notebook_motion_cb), gtkconv->win);
9176 gtkconv->win->drag_leave_signal = g_signal_connect(G_OBJECT(gtkconv->win->notebook), "leave_notify_event", 9212 gtkconv->win->drag_leave_signal = g_signal_connect(G_OBJECT(gtkconv->win->notebook), "leave_notify_event",
9177 G_CALLBACK(notebook_leave_cb), gtkconv->win); 9213 G_CALLBACK(notebook_leave_cb), gtkconv->win);
9180 9216
9181 if (e->button == 3) { 9217 if (e->button == 3) {
9182 /* Right click was pressed. Popup the context menu. */ 9218 /* Right click was pressed. Popup the context menu. */
9183 GtkWidget *menu = gtk_menu_new(), *sub; 9219 GtkWidget *menu = gtk_menu_new(), *sub;
9184 gboolean populated = populate_menu_with_options(menu, gtkconv, TRUE); 9220 gboolean populated = populate_menu_with_options(menu, gtkconv, TRUE);
9185 9221 #if 0 /* TODO */
9186 sub = gtk_menu_item_get_submenu(GTK_MENU_ITEM(gtkconv->win->menu.send_to)); 9222 sub = gtk_menu_item_get_submenu(GTK_MENU_ITEM(gtkconv->win->menu.send_to));
9187 if (sub && gtk_widget_is_sensitive(gtkconv->win->menu.send_to)) { 9223 if (sub && gtk_widget_is_sensitive(gtkconv->win->menu.send_to)) {
9188 GtkWidget *item = gtk_menu_item_new_with_mnemonic(_("S_end To")); 9224 GtkWidget *item = gtk_menu_item_new_with_mnemonic(_("S_end To"));
9189 if (populated) 9225 if (populated)
9190 pidgin_separator(menu); 9226 pidgin_separator(menu);
9194 gtk_widget_show_all(sub); 9230 gtk_widget_show_all(sub);
9195 } else if (!populated) { 9231 } else if (!populated) {
9196 gtk_widget_destroy(menu); 9232 gtk_widget_destroy(menu);
9197 return FALSE; 9233 return FALSE;
9198 } 9234 }
9199 9235 #endif
9200 gtk_widget_show_all(menu); 9236 gtk_widget_show_all(menu);
9201 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, e->button, e->time); 9237 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, e->button, e->time);
9202 return TRUE; 9238 return TRUE;
9203 } 9239 }
9204 return FALSE; 9240 return FALSE;
9209 { 9245 {
9210 gint nb_x, nb_y; 9246 gint nb_x, nb_y;
9211 int tab_clicked; 9247 int tab_clicked;
9212 GtkWidget *page; 9248 GtkWidget *page;
9213 GtkWidget *tab; 9249 GtkWidget *tab;
9250 GtkAllocation allocation;
9214 9251
9215 if (e->button == 2 && e->type == GDK_BUTTON_PRESS) { 9252 if (e->button == 2 && e->type == GDK_BUTTON_PRESS) {
9216 PidginConversation *gtkconv; 9253 PidginConversation *gtkconv;
9217 tab_clicked = pidgin_conv_get_tab_at_xy(win, e->x_root, e->y_root, NULL); 9254 tab_clicked = pidgin_conv_get_tab_at_xy(win, e->x_root, e->y_root, NULL);
9218 9255
9246 9283
9247 /* 9284 /*
9248 * Get the relative position of the press event, with regards to 9285 * Get the relative position of the press event, with regards to
9249 * the position of the notebook. 9286 * the position of the notebook.
9250 */ 9287 */
9251 gdk_window_get_origin(win->notebook->window, &nb_x, &nb_y); 9288 gdk_window_get_origin(gtk_widget_get_window(win->notebook), &nb_x, &nb_y);
9252 9289
9253 /* Reset the min/max x/y */ 9290 /* Reset the min/max x/y */
9254 win->drag_min_x = 0; 9291 win->drag_min_x = 0;
9255 win->drag_min_y = 0; 9292 win->drag_min_y = 0;
9256 win->drag_max_x = 0; 9293 win->drag_max_x = 0;
9258 9295
9259 /* Find out which tab was dragged. */ 9296 /* Find out which tab was dragged. */
9260 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), tab_clicked); 9297 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), tab_clicked);
9261 tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(win->notebook), page); 9298 tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(win->notebook), page);
9262 9299
9263 win->drag_min_x = tab->allocation.x + nb_x; 9300 gtk_widget_get_allocation(tab, &allocation);
9264 win->drag_min_y = tab->allocation.y + nb_y; 9301
9265 win->drag_max_x = tab->allocation.width + win->drag_min_x; 9302 win->drag_min_x = allocation.x + nb_x;
9266 win->drag_max_y = tab->allocation.height + win->drag_min_y; 9303 win->drag_min_y = allocation.y + nb_y;
9304 win->drag_max_x = allocation.width + win->drag_min_x;
9305 win->drag_max_y = allocation.height + win->drag_min_y;
9267 9306
9268 /* Make sure the click occurred in the tab. */ 9307 /* Make sure the click occurred in the tab. */
9269 if (e->x_root < win->drag_min_x || 9308 if (e->x_root < win->drag_min_x ||
9270 e->x_root >= win->drag_max_x || 9309 e->x_root >= win->drag_max_x ||
9271 e->y_root < win->drag_min_y || 9310 e->y_root < win->drag_min_y ||
9272 e->y_root >= win->drag_max_y) { 9311 e->y_root >= win->drag_max_y) {
9273 9312
9274 return FALSE; 9313 return FALSE;
9275 } 9314 }
9276 9315
9277 win->in_predrag = TRUE; 9316 win->in_predrag = TRUE;
9278 win->drag_tab = tab_clicked; 9317 win->drag_tab = tab_clicked;
9279 9318
9280 /* Connect the new motion signals. */ 9319 /* Connect the new motion signals. */
9498 9537
9499 if (gtkconv) 9538 if (gtkconv)
9500 close_conv_cb(NULL, gtkconv); 9539 close_conv_cb(NULL, gtkconv);
9501 } 9540 }
9502 9541
9542 /* TODO: I don't know if this doable in GTK+ 3.0 */
9543 #if 0
9503 static gboolean 9544 static gboolean
9504 right_click_menu_cb(GtkNotebook *notebook, GdkEventButton *event, PidginWindow *win) 9545 right_click_menu_cb(GtkNotebook *notebook, GdkEventButton *event, PidginWindow *win)
9505 { 9546 {
9506 GtkWidget *item, *menu; 9547 GtkWidget *item;
9507 PidginConversation *gtkconv; 9548 PidginConversation *gtkconv;
9549 GtkWidget *menu = gtk_notebook_get_menu
9508 9550
9509 if (event->type != GDK_BUTTON_PRESS || event->button != 3) 9551 if (event->type != GDK_BUTTON_PRESS || event->button != 3)
9510 return FALSE; 9552 return FALSE;
9511 9553
9512 gtkconv = pidgin_conv_window_get_gtkconv_at_index(win, 9554 gtkconv = pidgin_conv_window_get_gtkconv_at_index(win,
9549 g_signal_connect(G_OBJECT(item), "activate", 9591 g_signal_connect(G_OBJECT(item), "activate",
9550 G_CALLBACK(close_tab_cb), menu); 9592 G_CALLBACK(close_tab_cb), menu);
9551 9593
9552 return FALSE; 9594 return FALSE;
9553 } 9595 }
9596 #endif
9554 9597
9555 static void 9598 static void
9556 remove_edit_entry(PidginConversation *gtkconv, GtkWidget *entry) 9599 remove_edit_entry(PidginConversation *gtkconv, GtkWidget *entry)
9557 { 9600 {
9558 g_signal_handlers_disconnect_matched(G_OBJECT(entry), G_SIGNAL_MATCH_DATA, 9601 g_signal_handlers_disconnect_matched(G_OBJECT(entry), G_SIGNAL_MATCH_DATA,
9570 } 9613 }
9571 9614
9572 static gboolean 9615 static gboolean
9573 alias_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) 9616 alias_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
9574 { 9617 {
9575 if (event->keyval == GDK_Escape) { 9618 if (event->keyval == GDK_KEY_Escape) {
9576 remove_edit_entry(user_data, widget); 9619 remove_edit_entry(user_data, widget);
9577 return TRUE; 9620 return TRUE;
9578 } 9621 }
9579 return FALSE; 9622 return FALSE;
9580 } 9623 }
9597 9640
9598 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) { 9641 if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
9599 PurpleBuddy *buddy; 9642 PurpleBuddy *buddy;
9600 buddy = purple_find_buddy(account, name); 9643 buddy = purple_find_buddy(account, name);
9601 if (buddy != NULL) { 9644 if (buddy != NULL) {
9602 purple_blist_alias_buddy(buddy, 9645 purple_blist_alias_buddy(buddy, gtk_entry_get_text(entry));
9603 gtk_entry_get_text(entry));
9604 } 9646 }
9605 serv_alias_buddy(buddy); 9647 serv_alias_buddy(buddy);
9606 } else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) { 9648 } else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
9607 gtk_entry_set_text(GTK_ENTRY(gtkconv->u.chat->topic_text), gtk_entry_get_text(entry)); 9649 gtk_entry_set_text(GTK_ENTRY(gtkconv->u.chat->topic_text), gtk_entry_get_text(entry));
9608 topic_callback(NULL, gtkconv); 9650 topic_callback(NULL, gtkconv);
9744 9786
9745 static GList* 9787 static GList*
9746 make_status_icon_list(const char *stock, GtkWidget *w) 9788 make_status_icon_list(const char *stock, GtkWidget *w)
9747 { 9789 {
9748 GList *l = NULL; 9790 GList *l = NULL;
9749 l = g_list_append(l, gtk_widget_render_icon (w, stock, 9791 l = g_list_append(l,
9750 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL), "GtkWindow")); 9792 gtk_widget_render_icon(w, stock,
9751 l = g_list_append(l, gtk_widget_render_icon (w, stock, 9793 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL), "GtkWindow"));
9752 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow")); 9794 l = g_list_append(l,
9753 l = g_list_append(l, gtk_widget_render_icon (w, stock, 9795 gtk_widget_render_icon(w, stock,
9754 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_MEDIUM), "GtkWindow")); 9796 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow"));
9755 l = g_list_append(l, gtk_widget_render_icon (w, stock, 9797 l = g_list_append(l,
9756 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), "GtkWindow")); 9798 gtk_widget_render_icon(w, stock,
9799 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_MEDIUM), "GtkWindow"));
9800 l = g_list_append(l,
9801 gtk_widget_render_icon(w, stock,
9802 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_LARGE), "GtkWindow"));
9757 return l; 9803 return l;
9758 } 9804 }
9759 9805
9760 static void 9806 static void
9761 create_icon_lists(GtkWidget *w) 9807 create_icon_lists(GtkWidget *w)
9782 else 9828 else
9783 return FALSE; /* carry on normally */ 9829 return FALSE; /* carry on normally */
9784 9830
9785 /* Workaround for GTK+ bug # 169811 - "configure_event" is fired 9831 /* Workaround for GTK+ bug # 169811 - "configure_event" is fired
9786 * when the window is being maximized */ 9832 * when the window is being maximized */
9787 if (gdk_window_get_state(w->window) & GDK_WINDOW_STATE_MAXIMIZED) 9833 if (gdk_window_get_state(gtk_widget_get_window(w)) & GDK_WINDOW_STATE_MAXIMIZED)
9788 return FALSE; 9834 return FALSE;
9789 9835
9790 /* don't save off-screen positioning */ 9836 /* don't save off-screen positioning */
9791 if (x + event->width < 0 || 9837 if (x + event->width < 0 ||
9792 y + event->height < 0 || 9838 y + event->height < 0 ||
9807 9853
9808 static void 9854 static void
9809 pidgin_conv_set_position_size(PidginWindow *win, int conv_x, int conv_y, 9855 pidgin_conv_set_position_size(PidginWindow *win, int conv_x, int conv_y,
9810 int conv_width, int conv_height) 9856 int conv_width, int conv_height)
9811 { 9857 {
9812 /* if the window exists, is hidden, we're saving positions, and the 9858 /* if the window exists, is hidden, we're saving positions, and the
9813 * position is sane... */ 9859 * position is sane... */
9814 if (win && win->window && 9860 if (win && win->window &&
9815 !gtk_widget_get_visible(win->window) && conv_width != 0) { 9861 !gtk_widget_get_visible(win->window) && conv_width != 0) {
9816 9862
9817 #ifdef _WIN32 /* only override window manager placement on Windows */ 9863 #ifdef _WIN32 /* only override window manager placement on Windows */
9818 /* ...check position is on screen... */ 9864 /* ...check position is on screen... */
9895 gtk_notebook_set_scrollable(GTK_NOTEBOOK(win->notebook), TRUE); 9941 gtk_notebook_set_scrollable(GTK_NOTEBOOK(win->notebook), TRUE);
9896 gtk_notebook_popup_enable(GTK_NOTEBOOK(win->notebook)); 9942 gtk_notebook_popup_enable(GTK_NOTEBOOK(win->notebook));
9897 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(win->notebook), FALSE); 9943 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(win->notebook), FALSE);
9898 gtk_notebook_set_show_border(GTK_NOTEBOOK(win->notebook), TRUE); 9944 gtk_notebook_set_show_border(GTK_NOTEBOOK(win->notebook), TRUE);
9899 9945
9946 /* TODO: figure out how to add custom stuff to the right-click menu in
9947 GtkNotebook in GTK+ 3.0 */
9948 #if 0
9900 g_signal_connect(G_OBJECT(win->notebook), "button-press-event", 9949 g_signal_connect(G_OBJECT(win->notebook), "button-press-event",
9901 G_CALLBACK(right_click_menu_cb), win); 9950 G_CALLBACK(right_click_menu_cb), win);
9951 #endif
9902 9952
9903 gtk_widget_show(win->notebook); 9953 gtk_widget_show(win->notebook);
9904 9954
9905 g_signal_connect(G_OBJECT(win->notebook), "switch_page", 9955 g_signal_connect(G_OBJECT(win->notebook), "switch_page",
9906 G_CALLBACK(before_switch_conv_cb), win); 9956 G_CALLBACK(before_switch_conv_cb), win);
9988 } 10038 }
9989 10039
9990 void 10040 void
9991 pidgin_conv_window_raise(PidginWindow *win) 10041 pidgin_conv_window_raise(PidginWindow *win)
9992 { 10042 {
9993 gdk_window_raise(GDK_WINDOW(win->window->window)); 10043 gdk_window_raise(GDK_WINDOW(gtk_widget_get_window(win->window)));
9994 } 10044 }
9995 10045
9996 void 10046 void
9997 pidgin_conv_window_switch_gtkconv(PidginWindow *win, PidginConversation *gtkconv) 10047 pidgin_conv_window_switch_gtkconv(PidginWindow *win, PidginConversation *gtkconv)
9998 { 10048 {
10163 gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE); 10213 gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
10164 gtk_container_add(GTK_CONTAINER(ebox), gtkconv->tabby); 10214 gtk_container_add(GTK_CONTAINER(ebox), gtkconv->tabby);
10165 g_signal_connect(G_OBJECT(ebox), "enter-notify-event", 10215 g_signal_connect(G_OBJECT(ebox), "enter-notify-event",
10166 G_CALLBACK(gtkconv_tab_set_tip), gtkconv); 10216 G_CALLBACK(gtkconv_tab_set_tip), gtkconv);
10167 10217
10168 if (gtkconv->tab_label->parent == NULL) { 10218 if (gtk_widget_get_parent(gtkconv->tab_label) == NULL) {
10169 /* Pack if it's a new widget */ 10219 /* Pack if it's a new widget */
10170 gtk_box_pack_start(GTK_BOX(gtkconv->tabby), first, FALSE, FALSE, 0); 10220 gtk_box_pack_start(GTK_BOX(gtkconv->tabby), first, FALSE, FALSE, 0);
10171 gtk_box_pack_start(GTK_BOX(gtkconv->tabby), gtkconv->tab_label, TRUE, TRUE, 0); 10221 gtk_box_pack_start(GTK_BOX(gtkconv->tabby), gtkconv->tab_label, TRUE, TRUE, 0);
10172 gtk_box_pack_start(GTK_BOX(gtkconv->tabby), third, FALSE, FALSE, 0); 10222 gtk_box_pack_start(GTK_BOX(gtkconv->tabby), third, FALSE, FALSE, 0);
10173 10223
10293 gdkwin = gdk_window_get_toplevel(gdkwin); 10343 gdkwin = gdk_window_get_toplevel(gdkwin);
10294 10344
10295 for (l = pidgin_conv_windows_get_list(); l != NULL; l = l->next) { 10345 for (l = pidgin_conv_windows_get_list(); l != NULL; l = l->next) {
10296 win = l->data; 10346 win = l->data;
10297 10347
10298 if (gdkwin == win->window->window) 10348 if (gdkwin == gtk_widget_get_window(win->window))
10299 return win; 10349 return win;
10300 } 10350 }
10301 10351
10302 return NULL; 10352 return NULL;
10303 } 10353 }
10422 else 10472 else
10423 return FALSE; /* carry on normally */ 10473 return FALSE; /* carry on normally */
10424 10474
10425 /* Workaround for GTK+ bug # 169811 - "configure_event" is fired 10475 /* Workaround for GTK+ bug # 169811 - "configure_event" is fired
10426 * when the window is being maximized */ 10476 * when the window is being maximized */
10427 if (gdk_window_get_state(w->window) & GDK_WINDOW_STATE_MAXIMIZED) 10477 if (gdk_window_get_state(gtk_widget_get_window(w)) & GDK_WINDOW_STATE_MAXIMIZED)
10428 return FALSE; 10478 return FALSE;
10429 10479
10430 /* don't save off-screen positioning */ 10480 /* don't save off-screen positioning */
10431 if (x + event->width < 0 || 10481 if (x + event->width < 0 ||
10432 y + event->height < 0 || 10482 y + event->height < 0 ||

Mercurial Repository: pidgin3

mercurial