account_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y,

GtkSelectionData *sd, guint info, guint t, AccountPrefsDialog *dialog)

{

/* Well, it looks like the drag event was cool.

* Let's do something with it */

if (!g_ascii_strncasecmp(name, "file://", 7)) {

dialog->new_proxy_type == PURPLE_PROXY_NONE ||

dialog->new_proxy_type == PURPLE_PROXY_USE_ENVVAR) {

}

else

gtk_widget_show_all(dialog->proxy_vbox);

if (type == PURPLE_PROXY_USE_GLOBAL || type == PURPLE_PROXY_NONE ||

type == PURPLE_PROXY_USE_ENVVAR)

if ((value = purple_proxy_info_get_host(proxy_info)) != NULL)

dialog->new_proxy_type = PURPLE_PROXY_USE_GLOBAL;

gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->proxy_dropdown),

dialog->new_proxy_type + 1);

}

/* Connect signals. */

GtkSelectionData *data, guint info, guint time,

AccountsWindow *dialog)

{

GtkTreeRowReference *ref;

GtkTreePath *source_row;

GtkTreeIter iter;

guint x, guint y, GtkSelectionData *sd,

guint info, guint t, AccountsWindow *dialog)

{

gint dest_index;

PurpleAccount *a = NULL;

GtkTreePath *path = NULL;

GtkTreeViewDropPosition position;

if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y,

&path, &position)) {

GdkColor color;

if (temp && gdk_color_parse(temp, &color)) {

return gdk_color_copy(&color);

} else {

return NULL;

/* check for visibility because when we aren't visible, this will *

* give us bogus (0,0) coordinates. - xOr */

gtk_window_get_position(GTK_WINDOW(w), &x, &y);

else

return FALSE; /* carry on normally */

gtkblist = PIDGIN_BLIST(purple_get_blist());

blist_window = gtkblist ? GTK_WINDOW(gtkblist->window) : NULL;

data->window = gtk_dialog_new_with_buttons(title,

gtk_window_set_transient_for(GTK_WINDOW(data->window), blist_window);

gtk_dialog_set_default_response(GTK_DIALOG(data->window), GTK_RESPONSE_OK);

gtk_container_set_border_width(GTK_CONTAINER(data->window), PIDGIN_HIG_BOX_SPACE);

gtk_window_set_resizable(GTK_WINDOW(data->window), FALSE);

gtk_window_set_role(GTK_WINDOW(data->window), window_role);

hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);

gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);

gtk_misc_set_alignment(GTK_MISC(img), 0, 0);

if (pce->is_int)

{

adjust = gtk_adjustment_new(pce->min, pce->min, pce->max,

1, 10, 10);

input = gtk_spin_button_new(GTK_ADJUSTMENT(adjust), 1, 0);

pidgin_retrieve_user_info(buddy->account->gc, buddy->name);

} else {

switch (event->keyval) {

gtk_blist_menu_alias_cb(tv, node);

break;

path = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &iter);

if (gtk_tree_view_row_expanded(GTK_TREE_VIEW(tv), path)) {

/* Collapse the Group */

gtk_tree_path_free(path);

break;

path = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &iter);

if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(tv), path)) {

/* Expand the Group */

guint time,

gpointer null)

{

GtkTreeRowReference *ref = g_object_get_data(G_OBJECT(dc), "gtk-tree-view-source-row");

GtkTreePath *sourcerow = gtk_tree_row_reference_get_path(ref);

GtkTreeIter iter;

sizeof (node));

gtk_tree_path_free(sourcerow);

GtkTreeRowReference *ref;

GtkTreePath *sourcerow;

GtkTreeIter iter;

static void pidgin_blist_drag_data_rcv_cb(GtkWidget *widget, GdkDragContext *dc, guint x, guint y,

GtkSelectionData *sd, guint info, guint t)

{

if (gtkblist->drag_timeout) {

g_source_remove(gtkblist->drag_timeout);

gtkblist->drag_timeout = 0;

}

PurpleBlistNode *n = NULL;

GtkTreePath *path = NULL;

GtkTreeViewDropPosition position;

if(gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) {

/* if we're here, I think it means the drop is ok */

GtkTreeIter iter;

}

gtk_tree_path_free(path);

PurpleGroup *group = NULL;

GtkTreePath *path = NULL;

GtkTreeViewDropPosition position;

}

}

&protocol, &username, &alias))

{

if (account == NULL)

if (path != NULL)

gtk_tree_path_free(path);

{

gboolean result;

PurpleGroup *group = NULL;

}

}

GtkTreePath *path = NULL;

GtkTreeViewDropPosition position;

if (PURPLE_BLIST_NODE_IS_BUDDY(node) || PURPLE_BLIST_NODE_IS_CONTACT(node)) {

PurpleBuddy *b = PURPLE_BLIST_NODE_IS_BUDDY(node) ? PURPLE_BUDDY(node) : purple_contact_get_priority_buddy(PURPLE_CONTACT(node));

pidgin_dnd_file_manage(sd, b->account, b->name);

} else {

gtk_drag_finish(dc, FALSE, FALSE, t);

}

if(gtkblist->tooltipdata == NULL)

return FALSE;

max_text_width = 0;

max_avatar_width = 0;

for(l = gtkblist->tooltipdata; l; l = l->next)

{

struct tooltip_data *td = l->data;

if (td->avatar && pidgin_gdk_pixbuf_is_opaque(td->avatar))

{

if (dir == GTK_TEXT_DIR_RTL)

else

max_width - (td->avatar_width+ TOOLTIP_BORDER)-1,

current_height-1,td->avatar_width+2, td->avatar_height+2);

}

if (td->status_icon) {

gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->status_icon,

0, 0, max_width - TOOLTIP_BORDER - status_size, current_height, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);

gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->status_icon,

0, 0, TOOLTIP_BORDER, current_height, -1 , -1, GDK_RGB_DITHER_NONE, 0, 0);

if(td->avatar) {

gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL,

td->avatar, 0, 0, TOOLTIP_BORDER, current_height, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);

gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL,

td->avatar, 0, 0, max_width - (td->avatar_width + TOOLTIP_BORDER),

current_height, -1 , -1, GDK_RGB_DITHER_NONE, 0, 0);

gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->prpl_icon,

0, 0,

prpl_col,

current_height + ((td->name_height / 2) - (PRPL_SIZE / 2)),

-1 , -1, GDK_RGB_DITHER_NONE, 0, 0);

if (td->name_layout) {

if (dir == GTK_TEXT_DIR_RTL) {

max_width -(TOOLTIP_BORDER + status_size + SMALL_SPACE) - PANGO_PIXELS(300000),

current_height, td->name_layout);

} else {

TOOLTIP_BORDER + status_size + SMALL_SPACE, current_height, td->name_layout);

}

}

if (td->layout) {

if (dir != GTK_TEXT_DIR_RTL) {

TOOLTIP_BORDER + status_size + SMALL_SPACE, current_height + td->name_height, td->layout);

} else {

max_width - (TOOLTIP_BORDER + status_size + SMALL_SPACE) - PANGO_PIXELS(300000),

current_height + td->name_height,

td->layout);

}

}

current_height += MAX(td->name_height + td->height, td->avatar_height) + td->padding;

}

return FALSE;

pidgin_blist_expand_contact_cb(NULL, node);

gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, NULL, &gtkblist->contact_rect);

gtkblist->mouseover_contact = node;

gtk_tree_path_down (path);

while (gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &i, path)) {

/* if the window exists, is hidden, we're saving positions, and the

* position is sane... */

if (gtkblist && gtkblist->window &&

blist_x = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/x");

blist_y = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/y");

PurpleBlistNode *gnode, *cnode;

if (gtk_blist_visibility == GDK_VISIBILITY_FULLY_OBSCURED

return TRUE;

for(gnode = list->root; gnode; gnode = gnode->next) {

widget = gtk_window_get_focus(GTK_WINDOW(gtkblist->window));

if (GTK_IS_IMHTML(widget) || GTK_IS_ENTRY(widget)) {

return TRUE;

}

return FALSE;

static gboolean

headline_box_enter_cb(GtkWidget *widget, GdkEventCrossing *event, PidginBuddyList *gtkblist)

{

return FALSE;

}

static gboolean

headline_box_leave_cb(GtkWidget *widget, GdkEventCrossing *event, PidginBuddyList *gtkblist)

{

return FALSE;

}

}

static void

PurpleAccount *account)

{

g_hash_table_remove(gtkblist->connection_errors, account);

GdkEventExpose *event,

gpointer user_data)

{

GTK_STATE_NORMAL,

GTK_SHADOW_OUT,

widget,

"tooltip",

return FALSE;

}

G_CALLBACK(blist_focus_cb), gtkblist);

g_signal_connect(G_OBJECT(gtkblist->window), "focus-out-event",

G_CALLBACK(blist_focus_cb), gtkblist);

gtkblist->main_vbox = gtk_vbox_new(FALSE, 0);

gtk_widget_show(gtkblist->main_vbox);

return;

if (show) {

purple_signal_emit(pidgin_blist_get_handle(), "gtkblist-unhiding", gtkblist);

pidgin_blist_restore_position();

gtk_window_present(GTK_WINDOW(gtkblist->window));

purple_signal_emit(pidgin_blist_get_handle(), "gtkblist-hiding", gtkblist);

gtk_widget_hide(gtkblist->window);

} else {

gtk_widget_show(gtkblist->window);

gtk_window_iconify(GTK_WINDOW(gtkblist->window));

}

pidgin_blist_toggle_visibility()

{

if (gtkblist && gtkblist->window) {

/* make the buddy list visible if it is iconified or if it is

* obscured and not currently focused (the focus part ensures

* that we do something reasonable if the buddy list is obscured

static void

set_urgent(void)

{

pidgin_set_urgent(GTK_WINDOW(gtkblist->window), TRUE);

}

}

static void

{

if (pam && pam->callback)

pam->callback(pam);

static void pidgin_cell_renderer_expander_class_init (PidginCellRendererExpanderClass *class);

static void pidgin_cell_renderer_expander_get_size (GtkCellRenderer *cell,

GtkWidget *widget,

gint *x_offset,

gint *y_offset,

gint *width,

gint *height);

static void pidgin_cell_renderer_expander_render (GtkCellRenderer *cell,

GtkWidget *widget,

static gboolean pidgin_cell_renderer_expander_activate (GtkCellRenderer *r,

GdkEvent *event,

GtkWidget *widget,

const gchar *p,

GtkCellRendererState flags);

static void pidgin_cell_renderer_expander_finalize (GObject *gobject);

static void pidgin_cell_renderer_expander_init (PidginCellRendererExpander *cellexpander)

{

}

static void pidgin_cell_renderer_expander_class_init (PidginCellRendererExpanderClass *class)

static void pidgin_cell_renderer_expander_get_size (GtkCellRenderer *cell,

GtkWidget *widget,

gint *x_offset,

gint *y_offset,

gint *width,

gint calc_width;

gint calc_height;

gint expander_size;

gtk_widget_style_get(widget, "expander-size", &expander_size, NULL);

if (width)

*width = calc_width;

{

if (x_offset)

{

*x_offset = MAX (*x_offset, 0);

}

if (y_offset)

{

*y_offset = MAX (*y_offset, 0);

}

}

static void pidgin_cell_renderer_expander_render(GtkCellRenderer *cell,

GtkWidget *widget,

{

PidginCellRendererExpander *cellexpander = (PidginCellRendererExpander *) cell;

gboolean set;

gint width, height;

GtkStateType state;

if (!cellexpander->is_expander)

return;

width = cell_area->width;

height = cell_area->height;

state = GTK_STATE_INSENSITIVE;

else if (flags & GTK_CELL_RENDERER_PRELIT)

state = GTK_STATE_PRELIGHT;

state = GTK_STATE_ACTIVE;

else

state = GTK_STATE_NORMAL;

/* only draw the line if the color isn't set - this prevents a bug where the hline appears only under the expander */

g_object_get(cellexpander, "cell-background-set", &set, NULL);

}

static gboolean pidgin_cell_renderer_expander_activate(GtkCellRenderer *r,

GdkEvent *event,

GtkWidget *widget,

const gchar *p,

GtkCellRendererState flags)

{

GtkTreePath *path = gtk_tree_path_new_from_string(p);

InviteBuddyInfo *info = (InviteBuddyInfo *)data;

const char *convprotocol;

gboolean success = TRUE;

convprotocol = purple_account_get_protocol_id(purple_conversation_get_account(info->conv));

{

PurpleBlistNode *node = NULL;

PurpleBuddy *buddy;

if (PURPLE_BLIST_NODE_IS_CONTACT(node))

buddy = purple_contact_get_priority_buddy((PurpleContact *)node);

else

gtk_entry_set_text(GTK_ENTRY(info->entry), purple_buddy_get_name(buddy));

{

char *protocol = NULL;

char *username = NULL;

PurpleAccount *account;

&protocol, &username, NULL))

{

if (account == NULL)

g_free(username);

g_free(protocol);

}

}

GTK_RESPONSE_OK);

gtk_container_set_border_width(GTK_CONTAINER(invite_dialog), PIDGIN_HIG_BOX_SPACE);

gtk_window_set_resizable(GTK_WINDOW(invite_dialog), FALSE);

gtk_dialog_set_has_separator(GTK_DIALOG(invite_dialog), FALSE);

info->window = GTK_WIDGET(invite_dialog);

/* Setup the outside spacing. */

gtk_box_set_spacing(GTK_BOX(vbox), PIDGIN_HIG_BORDER);

gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BOX_SPACE);

gtkblist = pidgin_blist_get_default_gtk_blist();

cursor = gdk_cursor_new(GDK_WATCH);

gdk_cursor_unref(cursor);

#if GTK_CHECK_VERSION(2,4,0) && !GTK_CHECK_VERSION(2,6,0) //FIXME: What?

gdk_display_flush(gdk_drawable_get_display(GDK_DRAWABLE(widget->window)));

{

pidgin_log_show_contact((PurpleContact *)node->parent);

g_slist_free(buddies);

return;

}

}

pidgin_log_show(type, name, account);

}

static void

/* If CTRL was held down... */

if (event->state & GDK_CONTROL_MASK) {

switch (event->keyval) {

case ']':

if (!pidgin_conv_window_get_gtkconv_at_index(win, curconv + 1))

gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), 0);

return TRUE;

break;

case '[':

if (!pidgin_conv_window_get_gtkconv_at_index(win, curconv - 1))

gtk_notebook_set_current_page(GTK_NOTEBOOK(win->notebook), -1);

return TRUE;

break;

if (event->state & GDK_SHIFT_MASK) {

move_to_next_unread_tab(gtkconv, FALSE);

} else {

return TRUE;

break;

gtk_notebook_reorder_child(GTK_NOTEBOOK(win->notebook),

gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), curconv),

curconv - 1);

return TRUE;

break;

gtk_notebook_reorder_child(GTK_NOTEBOOK(win->notebook),

gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), curconv),

(curconv + 1) % gtk_notebook_get_n_pages(GTK_NOTEBOOK(win->notebook)));

return TRUE;

break;

if (gtkconv_cycle_focus(gtkconv, event->state & GDK_SHIFT_MASK ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD))

return TRUE;

break;

else

{

switch (event->keyval) {

if (gtk_widget_is_focus(GTK_WIDGET(win->notebook))) {

infopane_entry_activate(gtkconv);

return TRUE;

}

break;

if (gtkconv_cycle_focus(gtkconv, event->state & GDK_SHIFT_MASK ? GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD))

return TRUE;

break;

/* If CTRL was held down... */

if (event->state & GDK_CONTROL_MASK) {

switch (event->keyval) {

if (!gtkconv->send_history)

break;

return TRUE;

break;

if (!gtkconv->send_history)

break;

/* If neither CTRL nor ALT were held down... */

else {

switch (event->keyval) {

if (gtkconv->entry != entry)

break;

return tab_complete(conv);

break;

gtk_imhtml_page_up(GTK_IMHTML(gtkconv->imhtml));

return TRUE;

break;

gtk_imhtml_page_down(GTK_IMHTML(gtkconv->imhtml));

return TRUE;

break;

/* If we have a valid key for the conversation display, then exit */

if ((event->state & GDK_CONTROL_MASK) ||

{

if (event->type == GDK_KEY_PRESS)

return conv_keypress_common(gtkconv, event);

}

static void

{

int delay;

}

static void

{

if (gtkconv->u.im->icon_timer != 0)

g_source_remove(gtkconv->u.im->icon_timer);

}

static gboolean

{

static GtkWidget *menu = NULL;

PurpleConversation *conv;

GdkRectangle oneline;

int height, diff;

int pad_top, pad_inside, pad_bottom;

int min_lines = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/minimum_entry_lines");

int min_height;

gboolean interior_focus;

int focus_width;

pad_top = gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(gtkconv->entry));

pad_bottom = gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(gtkconv->entry));

pad_inside = gtk_text_view_get_pixels_inside_wrap(GTK_TEXT_VIEW(gtkconv->entry));

if (!interior_focus)

height += 2 * focus_width;

if (ABS(diff) < oneline.height / 2)

return FALSE;

gtk_widget_set_size_request(gtkconv->lower_hbox, -1,

return FALSE;

}

if(prpl_info->set_chat_topic == NULL) {

gtk_editable_set_editable(GTK_EDITABLE(gtkchat->topic_text), FALSE);

} else {

G_CALLBACK(topic_callback), gtkconv);

}

gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, NULL);

gtk_imhtml_search_clear(GTK_IMHTML(gtkconv->imhtml));

gtk_widget_grab_focus(gtkconv->entry);

return TRUE;

quickfind_process_input(GtkWidget *entry, GdkEventKey *event, PidginConversation *gtkconv)

{

switch (event->keyval) {

if (gtk_imhtml_search_find(GTK_IMHTML(gtkconv->imhtml), gtk_entry_get_text(GTK_ENTRY(entry)))) {

gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, NULL);

} else {

gtk_widget_modify_base(gtkconv->quickfind.entry, GTK_STATE_NORMAL, &col);

}

break;

pidgin_conv_end_quickfind(gtkconv);

break;

default:

PurpleAccount *convaccount = purple_conversation_get_account(conv);

PurpleConnection *gc = purple_account_get_connection(convaccount);

PurplePluginProtocolInfo *prpl_info = gc ? PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl) : NULL;

{

PurpleBlistNode *n = NULL;

PurpleBuddy *b;

PurpleAccount *buddyaccount;

const char *buddyname;

if (PURPLE_BLIST_NODE_IS_CONTACT(n))

b = purple_contact_get_priority_buddy((PurpleContact*)n);

pidgin_conv_window_switch_gtkconv(win, gtkconv);

}

{

char *protocol = NULL;

char *username = NULL;

PurpleAccount *account;

PidginConversation *gtkconv;

&protocol, &username, NULL))

{

if (account == NULL)

g_free(username);

g_free(protocol);

if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM)

pidgin_dnd_file_manage(sd, convaccount, purple_conversation_get_name(conv));

}

else

gtk_drag_finish(dc, FALSE, FALSE, t);

GdkEventButton *btn_event = (GdkEventButton*) event;

PurpleConversation *conv = data;

char *buddyname;

/* strlen("BUDDY " or "HILIT ") == 6 */

if (btn_event->button == 1 &&

event->type == GDK_2BUTTON_PRESS) {

chat_do_im(PIDGIN_CONVERSATION(conv), buddyname);

return TRUE;

} else if (btn_event->button == 2

&& event->type == GDK_2BUTTON_PRESS) {

chat_do_info(PIDGIN_CONVERSATION(conv), buddyname);

return TRUE;

} else if (btn_event->button == 3

&& event->type == GDK_BUTTON_PRESS) {

btn_event->button,

btn_event->time);

/* Don't propagate the event any further */

return TRUE;

}

}

}

return FALSE;

if (title != markup)

g_free(markup);

gtk_widget_realize(gtkconv->tab_label);

accessibility_obj = gtk_widget_get_accessible(gtkconv->tab_cont);

{

gint pane_x, pane_y, x_rel;

PidginConversation *gtkconv;

x_rel = x - pane_x;

gtkconv = pidgin_conv_window_get_active_gtkconv(win);

}

int

notebook = GTK_NOTEBOOK(win->notebook);

x_rel = x - nb_x;

y_rel = y - nb_y;

count = gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook));

for (i = 0; i < count; i++) {

page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), i);

tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook), page);

/* Make sure the tab is not hidden beyond an arrow */

continue;

if (horiz) {

page_num = i;

*to_right = TRUE;

break;

}

} else {

page_num = i;

*to_right = TRUE;

break;

gtk_container_set_border_width(GTK_CONTAINER(warn_close_dialog),

6);

gtk_window_set_resizable(GTK_WINDOW(warn_close_dialog), FALSE);

FALSE);

/* Setup the outside spacing. */

gtk_box_set_spacing(GTK_BOX(vbox), 12);

gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

always be true after a button press. */

if (!gdk_pointer_is_grabbed())

#endif

GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,

NULL, cursor, GDK_CURRENT_TIME);

}

if (e->button == 1) {

int nb_x, nb_y;

if (gtkconv->win->in_drag)

return TRUE;

gtkconv->win->in_predrag = TRUE;

gtkconv->win->drag_tab = gtk_notebook_page_num(GTK_NOTEBOOK(gtkconv->win->notebook), gtkconv->tab_cont);

gtkconv->win->drag_motion_signal = g_signal_connect(G_OBJECT(gtkconv->win->notebook), "motion_notify_event",

G_CALLBACK(notebook_motion_cb), gtkconv->win);

int tab_clicked;

GtkWidget *page;

GtkWidget *tab;

if (e->button == 2 && e->type == GDK_BUTTON_PRESS) {

PidginConversation *gtkconv;

* Get the relative position of the press event, with regards to

* the position of the notebook.

*/

/* Reset the min/max x/y */

win->drag_min_x = 0;

page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(win->notebook), tab_clicked);

tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(win->notebook), page);

/* Make sure the click occurred in the tab. */

if (e->x_root < win->drag_min_x ||

close_conv_cb(NULL, gtkconv);

}

static gboolean

right_click_menu_cb(GtkNotebook *notebook, GdkEventButton *event, PidginWindow *win)

{

PidginConversation *gtkconv;

if (event->type != GDK_BUTTON_PRESS || event->button != 3)

return FALSE;

return FALSE;

}

static void

remove_edit_entry(PidginConversation *gtkconv, GtkWidget *entry)

static gboolean

alias_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data)

{

remove_edit_entry(user_data, widget);

return TRUE;

}

PurpleConversation *conv = gtkconv->active_conv;

const char *text = NULL;

/* There's already an entry for alias. Let's not create another one. */

return FALSE;

}

static gboolean gtk_conv_configure_cb(GtkWidget *w, GdkEventConfigure *event, gpointer data) {

int x, y;

gtk_window_get_position(GTK_WINDOW(w), &x, &y);

else

return FALSE; /* carry on normally */

/* Workaround for GTK+ bug # 169811 - "configure_event" is fired

* when the window is being maximized */

return FALSE;

/* don't save off-screen positioning */

/* if the window exists, is hidden, we're saving positions, and the

* position is sane... */

if (win && win->window &&

#ifdef _WIN32 /* only override window manager placement on Windows */

/* ...check position is on screen... */

gtk_notebook_set_show_tabs(GTK_NOTEBOOK(win->notebook), FALSE);

gtk_notebook_set_show_border(GTK_NOTEBOOK(win->notebook), TRUE);

g_signal_connect(G_OBJECT(win->notebook), "button-press-event",

G_CALLBACK(right_click_menu_cb), win);

gtk_widget_show(win->notebook);

g_signal_connect(G_OBJECT(win->notebook), "switch_page",

void

pidgin_conv_window_raise(PidginWindow *win)

{

}

void

g_signal_connect(G_OBJECT(ebox), "enter-notify-event",

G_CALLBACK(gtkconv_tab_set_tip), gtkconv);

/* Pack if it's a new widget */

gtk_box_pack_start(GTK_BOX(gtkconv->tabby), first, FALSE, FALSE, 0);

gtk_box_pack_start(GTK_BOX(gtkconv->tabby), gtkconv->tab_label, TRUE, TRUE, 0);

gtk_notebook_set_tab_label(GTK_NOTEBOOK(win->notebook), gtkconv->tab_cont, ebox);

}

if (pidgin_conv_window_get_gtkconv_count(win) == 1)

gtk_notebook_set_show_tabs(GTK_NOTEBOOK(win->notebook),

for (l = pidgin_conv_windows_get_list(); l != NULL; l = l->next) {

win = l->data;

return win;

}

PurpleConversationType type = purple_conversation_get_type(conv->active_conv);

GList *all;

gtk_window_get_position(GTK_WINDOW(w), &x, &y);

else

return FALSE; /* carry on normally */

/* Workaround for GTK+ bug # 169811 - "configure_event" is fired

* when the window is being maximized */

return FALSE;

/* don't save off-screen positioning */

static gboolean

configure_cb(GtkWidget *w, GdkEventConfigure *event, DebugWindow *win)

{

purple_prefs_set_int(PIDGIN_PREFS_ROOT "/debug/width", event->width);

purple_prefs_set_int(PIDGIN_PREFS_ROOT "/debug/height", event->height);

}

static void

regex_key_release_cb(GtkWidget *w, GdkEventKey *e, DebugWindow *win) {

!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(win->filter)))

{

gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(win->filter), TRUE);

gtk_container_add(GTK_CONTAINER(item), gtk_label_new(_("Level ")));

gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(item));

item = gtk_tool_item_new();

#if GTK_CHECK_VERSION(2,12,0)

gtk_widget_set_tooltip_text(win->filterlevel, _("Select the debug filter level."));

gtk_container_add(GTK_CONTAINER(item), win->filterlevel);

gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(item));

gtk_combo_box_set_active(GTK_COMBO_BOX(win->filterlevel),

purple_prefs_get_int(PIDGIN_PREFS_ROOT "/debug/filterlevel"));

#ifdef USE_REGEX

button = pidgin_dialog_add_button(GTK_DIALOG(win), GTK_STOCK_CLOSE,

G_CALLBACK(destroy_win), win);

gtk_widget_grab_default(button);

gtk_widget_show_all(win);

gtk_container_set_border_width (GTK_CONTAINER(window), PIDGIN_HIG_BOX_SPACE);

gtk_window_set_resizable(GTK_WINDOW(window), FALSE);

hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);

img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_COOL, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE));

gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);

gtk_window_set_type_hint(GTK_WINDOW(x), GDK_WINDOW_TYPE_HINT_DIALOG)

#endif

#endif /* _PIDGINDIALOGS_H_ */

static GtkWidget *

dnd_hints_init_window(const gchar *fname)

{

GdkPixbuf *pixbuf;

GtkWidget *pix;

GtkWidget *win;

pixbuf = gdk_pixbuf_new_from_file(fname, NULL);

g_return_val_if_fail(pixbuf, NULL);

gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, &bitmap, 128);

g_object_unref(G_OBJECT(pixbuf));

win = gtk_window_new(GTK_WINDOW_POPUP);

gtk_container_add(GTK_CONTAINER(win), pix);

g_object_unref(G_OBJECT(pixmap));

g_object_unref(G_OBJECT(bitmap));

gtk_widget_show_all(pix);

return win;

get_widget_coords(GtkWidget *w, gint *x1, gint *y1, gint *x2, gint *y2)

{

gint ox, oy, width, height;

{

}

else

{

}

if (x1) *x1 = ox;

{

gint x1, x2, y1, y2;

gint x = 0, y = 0;

get_widget_coords(widget, &x1, &y1, &x2, &y2);

switch (horiz)

{

docklet_gtk_status_update_icon(PurpleStatusPrimitive status, gboolean connecting, gboolean pending)

{

const gchar *icon_name = NULL;

switch (status) {

case PURPLE_STATUS_OFFLINE:

icon_name = PIDGIN_STOCK_TRAY_OFFLINE;

}

if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/docklet/blink")) {

}

}

docklet_gtk_status_set_tooltip(gchar *tooltip)

{

if (tooltip) {

} else {

}

}

static void

docklet_toggle_mute(GtkWidget *toggle, void *data)

{

}

static void

docklet_toggle_blink(GtkWidget *toggle, void *data)

{

}

static void

docklet_toggle_blist(GtkWidget *toggle, void *data)

{

}

#ifdef _WIN32

static void

{

if (pam && pam->callback)

pam->callback(pam);

int event_base, error_base;

if (has_extension == -1)

if (has_extension)

{

if (mit_info == NULL)

mit_info = XScreenSaverAllocInfo();

return (mit_info->idle) / 1000;

}

else

/* Don't scroll here if we're in the middle of a smooth scroll */

if (scroll && imhtml->scroll_time == NULL &&

gtk_imhtml_scroll_to_end(imhtml, FALSE);

}

gtk_imhtml_tip_paint (GtkIMHtml *imhtml)

{

PangoLayout *layout;

g_return_val_if_fail(GTK_IS_IMHTML(imhtml), FALSE);

layout = gtk_widget_create_pango_layout(imhtml->tip_window, imhtml->tip);

"tooltip", 0, 0, -1, -1);

g_object_unref(layout);

return FALSE;

}

PangoFontMetrics *font_metrics;

PangoLayout *layout;

PangoFont *font;

gint gap, x, y, h, w, scr_w, baseline_skip;

g_return_val_if_fail(GTK_IS_IMHTML(imhtml), FALSE);

imhtml->tip_timer = 0;

return FALSE;

}

gtk_widget_ensure_style (imhtml->tip_window);

layout = gtk_widget_create_pango_layout(imhtml->tip_window, imhtml->tip);

font = pango_context_load_font(pango_layout_get_context(layout),

if (font == NULL) {

purple_debug(PURPLE_DEBUG_ERROR, "gtk_imhtml_tip",

"pango_context_load_font() couldn't load font: '%s'\n",

h = 8 + baseline_skip;

gdk_window_get_pointer (NULL, &x, &y, NULL);

scr_w = gdk_screen_width();

oldprelit_tag = GTK_IMHTML(imhtml)->prelit_tag;

gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(imhtml), GTK_TEXT_WINDOW_WIDGET,

event->x, event->y, &x, &y);

gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(imhtml), &iter, x, y);

return FALSE;

}

static gint

gtk_imhtml_expose_event (GtkWidget *widget,

GdkEventExpose *event)

gdk_color_parse(GTK_IMHTML(widget)->edit.background, &gcolor);

gdk_cairo_set_source_color(cr, &gcolor);

} else {

}

cairo_rectangle(cr,

return FALSE;

}

static void paste_unformatted_cb(GtkMenuItem *menu, GtkIMHtml *imhtml)

{

char *text;

GtkIMHtml *imhtml = data;

if (!gtk_text_view_get_editable(GTK_TEXT_VIEW(imhtml)))

return;

gtk_clipboard_request_text(clipboard, paste_plaintext_received_cb, imhtml);

return;

} else {

}

#endif

/* Make sure the paste data is null-terminated. Given that

* we're passed length (but assume later that it is

* null-terminated), this seems sensible to me.

*/

}

#ifdef _WIN32

}

#endif

(*(guint16 *)text == 0xfeff || *(guint16 *)text == 0xfffe)) {

/* This is UTF-16 */

g_free(text);

text = utf8;

if (!text) {

gobject_class->finalize = gtk_imhtml_finalize;

widget_class->drag_motion = gtk_text_view_drag_motion;

parent_size_allocate = widget_class->size_allocate;

widget_class->size_allocate = gtk_imhtml_size_allocate;

parent_style_set = widget_class->style_set;

TRUE, G_PARAM_READABLE));

binding_set = gtk_binding_set_by_class (parent_class);

binding_set = gtk_binding_set_by_class(klass);

}

static void gtk_imhtml_init (GtkIMHtml *imhtml)

/* can't accept any of the offered targets */

} else {

GtkWidget *source_widget;

source_widget = gtk_drag_get_source_widget (context);

if (source_widget == widget) {

/* Default to MOVE, unless the user has

* pressed ctrl or alt to affect available actions

*/

suggested_action = GDK_ACTION_MOVE;

}

}

{

gchar **links;

gchar *link;

GtkTextMark *mark = gtk_text_buffer_get_insert(imhtml->text_buffer);

GtkTextIter iter;

gint i = 0;

gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, mark);

switch (info) {

case GTK_IMHTML_DRAG_URL:

/* TODO: Is it really ok to change sd->data...? */

while((link = links[i]) != NULL){

if (gtk_imhtml_is_protocol(link)) {

gchar *label;

* See also the comment on text/html here:

* http://mail.gnome.org/archives/gtk-devel-list/2001-September/msg00114.html

*/

if (!utf8) {

purple_debug_warning("gtkimhtml", "g_convert from UTF-16 failed in drag_rcv_cb\n");

gtk_drag_finish(dc, FALSE, FALSE, t);

return;

}

} else {

gtk_drag_finish(dc, FALSE, FALSE, t);

}

static gboolean smooth_scroll_cb(gpointer data)

{

GtkIMHtml *imhtml = data;

gdouble scroll_val = gtk_adjustment_get_value(adj) + ((max_val - gtk_adjustment_get_value(adj)) / 3);

g_return_val_if_fail(imhtml->scroll_time != NULL, FALSE);

static gboolean scroll_idle_cb(gpointer data)

{

GtkIMHtml *imhtml = data;

if(adj) {

}

imhtml->scroll_src = 0;

return FALSE;

for (l = tags; l; l = l->next) {

GtkTextTag *tag = l->data;

gtk_text_buffer_remove_tag(imhtml->text_buffer, tag, i, e);

}

g_slist_free(tags);

for (l = tags; l; l = l->next) {

GtkTextTag *tag = l->data;

gtk_text_buffer_remove_tag(imhtml->text_buffer, tag, &iter, e);

g_slist_free(tags);

}

gtk_text_iter_begins_tag(start, tag) && /* the tag starts with the selection */

(!gtk_text_iter_has_tag(end, tag) || /* the tag ends within the selection */

gtk_text_iter_ends_tag(end, tag))) {

gtk_text_buffer_remove_tag(imhtml->text_buffer, tag, start, end);

gtk_imhtml_toggle_link(imhtml, NULL);

}

}

}

g_slist_free(tags);

for (l = tags; l != NULL; l = l->next) {

GtkTextTag *tag = GTK_TEXT_TAG(l->data);

imhtml->edit.bold = TRUE;

imhtml->edit.italic = TRUE;

imhtml->edit.underline = TRUE;

imhtml->edit.strike = TRUE;

imhtml->edit.link = tag;

}

}

g_slist_free(tags);

gtk_text_buffer_end_user_action(imhtml->text_buffer);

}

static gboolean

image_expose(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)

{

return TRUE;

}

/* In case the smiley gets removed from the imhtml before it gets removed from the queue */

{

GList *l = imhtml->animations->head;

while (l) {

* images, and ensures that they are handled by the image

* itself, without propagating to the textview and causing

* a complete refresh */

g_signal_connect(G_OBJECT(icon), "expose-event", G_CALLBACK(image_expose), NULL);

gtk_widget_show(icon);

if (ebox)