static void update_buddy_idle(GaimBuddy *buddy, GaimPresence *presence, time_t current_time, gboolean old_idle, gboolean idle) { GaimBlistUiOps *ops = gaim_blist_get_ui_ops(); if (!old_idle && idle) { if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(buddy->account, FALSE); if (log != NULL) { char *tmp = g_strdup_printf(_("%s became idle"), gaim_buddy_get_alias(buddy)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_buddy_get_alias(buddy), current_time, tmp); g_free(tmp); } } } else if (old_idle && !idle) { if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(buddy->account, FALSE); if (log != NULL) { char *tmp = g_strdup_printf(_("%s became unidle"), gaim_buddy_get_alias(buddy)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_buddy_get_alias(buddy), current_time, tmp); g_free(tmp); } } } if (old_idle != idle) gaim_signal_emit(gaim_blist_get_handle(), "buddy-idle-changed", buddy, old_idle, idle); gaim_contact_invalidate_priority_buddy(gaim_buddy_get_contact(buddy)); /* Should this be done here? It'd perhaps make more sense to * connect to buddy-[un]idle signals and update from there */ if (ops != NULL && ops->update != NULL) ops->update(gaim_get_blist(), (GaimBlistNode *)buddy); }
/* we need to do this for Oscar because serv_login only starts the login * process, it doesn't end there. gaim_setup will be called later from * oscar.c, after the buddy list is made and serv_finish_login is called */ void gaim_setup(GaimConnection *gc) { if (gaim_prefs_get_bool("/gaim/gtk/sound/enabled/login")) { if (snd_tmout) g_source_remove(snd_tmout); gaim_gtk_sound_set_login_mute(TRUE); snd_tmout = gaim_timeout_add(10000, sound_timeout, NULL); } }
static void file_recv_request_cb(GaimXfer *xfer, gpointer handle) { GaimAccount *account; GaimBlistNode *node; const char *pref; char *filename; char *dirname; account = xfer->account; node = (GaimBlistNode *)gaim_find_buddy(account, xfer->who); if (!node) { if (gaim_prefs_get_bool(PREF_STRANGER)) xfer->status = GAIM_XFER_STATUS_CANCEL_LOCAL; return; } node = node->parent; g_return_if_fail(GAIM_BLIST_NODE_IS_CONTACT(node)); pref = gaim_prefs_get_string(PREF_PATH); switch (gaim_blist_node_get_int(node, "autoaccept")) { case FT_ASK: break; case FT_ACCEPT: if (ensure_path_exists(pref)) { dirname = g_build_filename(pref, xfer->who, NULL); if (!ensure_path_exists(dirname)) { g_free(dirname); break; } filename = g_build_filename(dirname, xfer->filename, NULL); gaim_xfer_request_accepted(xfer, filename); g_free(dirname); g_free(filename); } gaim_signal_connect(gaim_xfers_get_handle(), "file-recv-complete", handle, GAIM_CALLBACK(auto_accept_complete_cb), xfer); break; case FT_REJECT: xfer->status = GAIM_XFER_STATUS_CANCEL_LOCAL; break; } }
static void dequeue_message(GtkTreeIter *iter) { gchar *name; GSList *templist; GaimConversation *cnv; gboolean orig_while_away; orig_while_away = gaim_prefs_get_bool("/core/sound/while_away"); if (orig_while_away) gaim_prefs_set_bool("/core/sound/while_away", FALSE); gtk_tree_model_get(GTK_TREE_MODEL(awayqueuestore), iter, 0, &name, -1); gaim_debug(GAIM_DEBUG_INFO, "away", "Dequeueing messages from %s.\n", name); templist = message_queue; while (templist) { struct queued_message *qm = templist->data; if (templist->data) { if (!gaim_utf8_strcasecmp(qm->name, name)) { GaimAccount *account = NULL; if (g_list_index(gaim_accounts_get_all(), qm->account) >= 0) account = qm->account; cnv = gaim_find_conversation_with_account(name, account); if (!cnv) cnv = gaim_conversation_new(GAIM_CONV_IM, account, qm->name); else gaim_conversation_set_account(cnv, account); gaim_conv_im_write(GAIM_CONV_IM(cnv), NULL, qm->message, qm->flags, qm->tm); g_free(qm->message); g_free(qm); templist = message_queue = g_slist_remove(message_queue, qm); } else { templist = templist->next; } } } g_free(name); /* In GTK 2.2, _store_remove actually returns whether iter is valid or not * after the remove, but in GTK 2.0 it is a void function. */ gtk_list_store_remove(awayqueuestore, iter); if (orig_while_away) gaim_prefs_set_bool("/core/sound/while_away", orig_while_away); }
static void auto_accept_complete_cb(GaimXfer *xfer, GaimXfer *my) { if (xfer == my && gaim_prefs_get_bool(PREF_NOTIFY) && !gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, xfer->who, xfer->account)) { char *message = g_strdup_printf(_("Autoaccepted file transfer of \"%s\" from \"%s\" completed."), xfer->filename, xfer->who); gaim_notify_info(NULL, _("Autoaccept complete"), message, NULL); g_free(message); } }
void toggle_away_queue() { if (!awayqueue || !awayqueuesw) return; if (gaim_prefs_get_bool("/gaim/gtk/away/queue_messages")) { gtk_widget_show(awayqueue); gtk_widget_show(awayqueuesw); } else { gtk_widget_hide(awayqueue); gtk_widget_hide(awayqueuesw); purge_away_queue(&message_queue); } }
static void notify_buddy_status_update(GaimBuddy *buddy, GaimPresence *presence, GaimStatus *old_status, GaimStatus *new_status) { GaimBlistUiOps *ops = gaim_blist_get_ui_ops(); if (gaim_prefs_get_bool("/core/logging/log_system")) { time_t current_time = time(NULL); const char *buddy_alias = gaim_buddy_get_alias(buddy); char *tmp; GaimLog *log; if (old_status != NULL) { tmp = g_strdup_printf(_("%s changed status from %s to %s"), buddy_alias, gaim_status_get_name(old_status), gaim_status_get_name(new_status)); } else { /* old_status == NULL when an independent status is toggled. */ if (gaim_status_is_active(new_status)) { tmp = g_strdup_printf(_("%s is now %s"), buddy_alias, gaim_status_get_name(new_status)); } else { tmp = g_strdup_printf(_("%s is no longer %s"), buddy_alias, gaim_status_get_name(new_status)); } } log = gaim_account_get_log(buddy->account, FALSE); if (log != NULL) { gaim_log_write(log, GAIM_MESSAGE_SYSTEM, buddy_alias, current_time, tmp); } g_free(tmp); } if (ops != NULL && ops->update != NULL) ops->update(gaim_get_blist(), (GaimBlistNode*)buddy); }
static void gaim_debug_vargs(GaimDebugLevel level, const char *category, const char *format, va_list args) { GaimDebugUiOps *ops; char *arg_s = NULL; g_return_if_fail(level != GAIM_DEBUG_ALL); g_return_if_fail(format != NULL); ops = gaim_debug_get_ui_ops(); if (!debug_enabled && ((ops == NULL) || (ops->print == NULL))) return; arg_s = g_strdup_vprintf(format, args); if (debug_enabled) { gchar *ts_s; if ((category != NULL) && (gaim_prefs_exists("/core/debug/timestamps")) && (gaim_prefs_get_bool("/core/debug/timestamps"))) { const char *mdate; time_t mtime = time(NULL); mdate = gaim_utf8_strftime("%H:%M:%S", localtime(&mtime)); ts_s = g_strdup_printf("(%s) ", mdate); } else { ts_s = g_strdup(""); } if (category == NULL) g_print("%s%s", ts_s, arg_s); else g_print("%s%s: %s", ts_s, category, arg_s); g_free(ts_s); } if (ops != NULL && ops->print != NULL) ops->print(level, category, arg_s); g_free(arg_s); }
void purge_away_queue(GSList **queue) { GSList *q = *queue; struct queued_message *qm; GaimConversation *cnv; GaimAccount *account; gboolean orig_while_away; orig_while_away = gaim_prefs_get_bool("/core/sound/while_away"); if (orig_while_away) gaim_prefs_set_bool("/core/sound/while_away", FALSE); while (q) { qm = q->data; account = NULL; if (g_list_index(gaim_accounts_get_all(), qm->account) >= 0) account = qm->account; cnv = gaim_find_conversation_with_account(qm->name, account); if (!cnv) cnv = gaim_conversation_new(GAIM_CONV_IM, account, qm->name); else gaim_conversation_set_account(cnv, account); gaim_conv_im_write(GAIM_CONV_IM(cnv), NULL, qm->message, qm->flags, qm->tm); g_free(qm->message); g_free(qm); q->data = NULL; q = q->next; } g_slist_free(*queue); *queue = NULL; if (orig_while_away) gaim_prefs_set_bool("/core/sound/while_away", orig_while_away); }
GaimGtkXferDialog * gaim_gtkxfer_dialog_new(void) { GaimGtkXferDialog *dialog; GtkWidget *window; GtkWidget *vbox1, *vbox2; GtkWidget *bbox; GtkWidget *sw; GtkWidget *sep; GtkWidget *button; GtkWidget *disclosure; GtkWidget *table; GtkWidget *checkbox; dialog = g_new0(GaimGtkXferDialog, 1); dialog->keep_open = gaim_prefs_get_bool("/gaim/gtk/filetransfer/keep_open"); dialog->auto_clear = gaim_prefs_get_bool("/gaim/gtk/filetransfer/clear_finished"); dialog->window = window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_role(GTK_WINDOW(window), "file transfer"); gtk_window_set_title(GTK_WINDOW(window), _("File Transfers")); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_container_set_border_width(GTK_CONTAINER(window), BOX_SPACING); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete_win_cb), dialog); /* Create the parent vbox for everything. */ vbox1 = gtk_vbox_new(FALSE, BOX_SPACING); gtk_container_add(GTK_CONTAINER(window), vbox1); gtk_widget_show(vbox1); /* Create the main vbox for top half of the window. */ vbox2 = gtk_vbox_new(FALSE, CONTAINER_BORDER_WIDTH); gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0); gtk_widget_show(vbox2); /* Setup the listbox */ sw = setup_tree(dialog); gtk_box_pack_start(GTK_BOX(vbox2), sw, TRUE, TRUE, 0); gtk_widget_set_size_request(sw,-1, 140); /* "Keep the dialog open" */ checkbox = gtk_check_button_new_with_mnemonic( _("_Keep the dialog open")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), dialog->keep_open); g_signal_connect(G_OBJECT(checkbox), "toggled", G_CALLBACK(toggle_keep_open_cb), dialog); gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0); gtk_widget_show(checkbox); /* "Clear finished transfers" */ checkbox = gtk_check_button_new_with_mnemonic( _("_Clear finished transfers")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), dialog->auto_clear); g_signal_connect(G_OBJECT(checkbox), "toggled", G_CALLBACK(toggle_clear_finished_cb), dialog); gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0); gtk_widget_show(checkbox); /* "Download Details" arrow */ disclosure = gaim_disclosure_new(_("Show transfer details"), _("Hide transfer details")); dialog->disclosure = disclosure; gtk_box_pack_start(GTK_BOX(vbox2), disclosure, FALSE, FALSE, 0); gtk_widget_show(disclosure); gtk_widget_set_sensitive(disclosure, FALSE); #if 0 g_signal_connect(G_OBJECT(disclosure), "toggled", G_CALLBACK(toggle_details_cb), dialog); #endif /* Separator */ sep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox2), sep, FALSE, FALSE, 0); gtk_widget_show(sep); /* The table of information. */ table = make_info_table(dialog); gtk_box_pack_start(GTK_BOX(vbox2), table, TRUE, TRUE, 0); /* Setup the disclosure for the table. */ gaim_disclosure_set_container(GAIM_DISCLOSURE(disclosure), table); /* Now the button box for the buttons */ bbox = gtk_hbutton_box_new(); gtk_box_set_spacing(GTK_BOX(bbox), CONTAINER_BORDER_WIDTH); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_pack_end(GTK_BOX(vbox1), bbox, FALSE, TRUE, 0); gtk_widget_show(bbox); /* Open button */ button = gtk_button_new_from_stock(GTK_STOCK_OPEN); gtk_widget_set_sensitive(button, FALSE); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); dialog->open_button = button; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(open_button_cb), dialog); /* Pause button */ button = gtk_button_new_with_mnemonic(_("_Pause")); #ifndef GAIM_SMALL_SCREEN gtk_widget_set_sensitive(button, FALSE); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); #endif dialog->pause_button = button; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(pause_button_cb), dialog); /* Resume button */ button = gtk_button_new_with_mnemonic(_("_Resume")); #ifndef GAIM_SMALL_SCREEN gtk_widget_set_sensitive(button, FALSE); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); #endif dialog->resume_button = button; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(resume_button_cb), dialog); /* Remove button */ button = gtk_button_new_from_stock(GTK_STOCK_REMOVE); #ifndef GAIM_SMALL_SCREEN gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_hide(button); #endif dialog->remove_button = button; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_button_cb), dialog); /* Stop button */ button = gtk_button_new_from_stock(GTK_STOCK_STOP); #ifndef GAIM_SMALL_SCREEN gtk_widget_set_sensitive(button, FALSE); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); #endif dialog->stop_button = button; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(stop_button_cb), dialog); /* Close button */ button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); dialog->close_button = button; g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(close_button_cb), dialog); return dialog; }
static void gaim_gtk_debug_print(GaimDebugLevel level, const char *category, const char *format, va_list args) { gchar *arg_s, *ts_s; gboolean timestamps; timestamps = gaim_prefs_get_bool("/gaim/gtk/debug/timestamps"); arg_s = g_strdup_vprintf(format, args); if (category == NULL) { ts_s = g_strdup(""); } else { /* * If the category is not NULL, then do timestamps. * This IS right. :) */ if (timestamps) { gchar mdate[64]; time_t mtime = time(NULL); strftime(mdate, sizeof(mdate), "%H:%M:%S", localtime(&mtime)); ts_s = g_strdup_printf("(%s) ", mdate); } else ts_s = g_strdup(""); } if (gaim_prefs_get_bool("/gaim/gtk/debug/enabled") && debug_win != NULL && !debug_win->paused) { gchar *esc_s, *cat_s, *utf8_s, *s; if (category == NULL) cat_s = g_strdup(""); else cat_s = g_strdup_printf("<b>%s:</b> ", category); esc_s = g_markup_escape_text(arg_s, -1); s = g_strdup_printf("<font color=\"%s\">%s%s%s</font>", debug_fg_colors[level], ts_s, cat_s, esc_s); g_free(esc_s); utf8_s = gaim_utf8_try_convert(s); g_free(s); s = utf8_s; if (level == GAIM_DEBUG_FATAL) { gchar *temp = s; s = g_strdup_printf("<b>%s</b>", temp); g_free(temp); } g_free(cat_s); gtk_imhtml_append_text(GTK_IMHTML(debug_win->text), s, 0); g_free(s); } if (opt_debug) { if (category == NULL) g_print("%s%s", ts_s, arg_s); else g_print("%s%s: %s", ts_s, category, arg_s); } g_free(ts_s); g_free(arg_s); }
void gaim_presence_set_idle(GaimPresence *presence, gboolean idle, time_t idle_time) { gboolean old_idle; g_return_if_fail(presence != NULL); if (presence->idle == idle && presence->idle_time == idle_time) return; old_idle = presence->idle; presence->idle = idle; presence->idle_time = (idle ? idle_time : 0); if (gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_BUDDY) { const GList *l; time_t current_time = time(NULL); for (l = gaim_presence_get_buddies(presence); l != NULL; l = l->next) { update_buddy_idle((GaimBuddy *)l->data, presence, current_time, old_idle, idle); } } else if(gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_ACCOUNT) { GaimAccount *account; GaimConnection *gc; GaimPluginProtocolInfo *prpl_info = NULL; account = gaim_presence_get_account(presence); if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(account, FALSE); if (log != NULL) { char *msg; if (idle) msg = g_strdup_printf(_("+++ %s became idle"), gaim_account_get_username(account)); else msg = g_strdup_printf(_("+++ %s became unidle"), gaim_account_get_username(account)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_account_get_username(account), idle_time, msg); g_free(msg); } } gc = gaim_account_get_connection(account); if (gc != NULL && GAIM_CONNECTION_IS_CONNECTED(gc) && gc->prpl != NULL) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->set_idle) prpl_info->set_idle(gc, (idle ? (time(NULL) - idle_time) : 0)); } }
void gaim_connection_set_state(GaimConnection *gc, GaimConnectionState state) { GaimConnectionUiOps *ops; g_return_if_fail(gc != NULL); if (gc->state == state) return; gc->state = state; ops = gaim_connections_get_ui_ops(); if (gc->state == GAIM_CONNECTING) { connections_connecting = g_list_append(connections_connecting, gc); } else { connections_connecting = g_list_remove(connections_connecting, gc); } if (gc->state == GAIM_CONNECTED) { GaimAccount *account; GaimPresence *presence; account = gaim_connection_get_account(gc); presence = gaim_account_get_presence(account); /* Set the time the account came online */ gaim_presence_set_login_time(presence, time(NULL)); if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(account, TRUE); if (log != NULL) { char *msg = g_strdup_printf(_("+++ %s signed on"), gaim_account_get_username(account)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_account_get_username(account), gaim_presence_get_login_time(presence), msg); g_free(msg); } } if (ops != NULL && ops->connected != NULL) ops->connected(gc); gaim_blist_add_account(account); gaim_signal_emit(gaim_connections_get_handle(), "signed-on", gc); serv_set_permit_deny(gc); update_keepalive(gc, TRUE); } else if (gc->state == GAIM_DISCONNECTED) { GaimAccount *account = gaim_connection_get_account(gc); if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(account, FALSE); if (log != NULL) { char *msg = g_strdup_printf(_("+++ %s signed off"), gaim_account_get_username(account)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_account_get_username(account), time(NULL), msg); g_free(msg); } } gaim_account_destroy_log(account); if (ops != NULL && ops->disconnected != NULL) ops->disconnected(gc); } }
void gaym_update_thumbnail(GaimConversation * conv, GdkPixbuf * pixbuf) { GaimGtkConversation *gtkconv; GdkPixbuf *scale; GdkPixmap *pm = NULL; GdkBitmap *bm = NULL; int scale_width = 0, scale_height = 0; GaimAccount *account; GaimPluginProtocolInfo *prpl_info = NULL; g_return_if_fail(conv != NULL); g_return_if_fail(GAIM_IS_GTK_CONVERSATION(conv)); g_return_if_fail(gaim_conversation_get_type(conv) == GAIM_CONV_CHAT); gtkconv = GAIM_GTK_CONVERSATION(conv); GaymChatIcon *icon_data = g_hash_table_lookup(icons, conv); if (!icon_data->show_icon) return; account = gaim_conversation_get_account(conv); if (account && account->gc) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(account->gc->prpl); if (!gaim_prefs_get_bool ("/gaim/gtk/conversations/im/show_buddy_icons")) return; if (gaim_conversation_get_gc(conv) == NULL) return; get_icon_scale_size(pixbuf, prpl_info ? &prpl_info->icon_spec : NULL, &scale_width, &scale_height); // double // aspect=(double)gdk_pixbuf_get_width(pixbuf)/(double)gdk_pixbuf_get_height(pixbuf); // // scale = gdk_pixbuf_scale_simple(pixbuf, scale_width, scale_height, GDK_INTERP_BILINEAR); gdk_pixbuf_render_pixmap_and_mask(scale, &pm, &bm, 100); g_object_unref(G_OBJECT(scale)); icon_data->event = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(icon_data->frame), icon_data->event); gtk_widget_set_size_request(GTK_WIDGET(icon_data->frame), 57, 77); // g_signal_connect(G_OBJECT(icon_data->event), "button-press-event", // G_CALLBACK(icon_menu), conv); gtk_widget_show(icon_data->event); icon_data->icon = gtk_image_new_from_pixmap(pm, bm); gtk_container_add(GTK_CONTAINER(icon_data->event), icon_data->icon); gtk_widget_show(icon_data->icon); if (pm) g_object_unref(G_OBJECT(pm)); if (bm) g_object_unref(G_OBJECT(bm)); }
void do_away_message(GtkWidget *w, struct away_message *a) { GtkWidget *back; GtkWidget *edit; GtkWidget *awaytext; GtkWidget *sw; GtkWidget *vbox; GtkWidget *hbox; GtkTreeViewColumn *column; GtkCellRenderer *renderer; char *buf; if (!a) return; if(imaway) gtk_widget_destroy(imaway); GAIM_DIALOG(imaway); gtk_window_set_role(GTK_WINDOW(imaway), "imaway"); if (strlen(a->name)) gtk_window_set_title(GTK_WINDOW(imaway), a->name); else gtk_window_set_title(GTK_WINDOW(imaway), _("Away!")); g_signal_connect(G_OBJECT(imaway), "destroy", G_CALLBACK(do_im_back), imaway); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(imaway), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); gtk_widget_show(vbox); hbox = gtk_hbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(hbox), 0); gtk_widget_show(hbox); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_widget_set_size_request(sw, 245, 120); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); gtk_widget_show(sw); awaytext = gtk_imhtml_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(sw), awaytext); gaim_setup_imhtml(awaytext); gtk_widget_show(awaytext); buf = stylize(a->message, BUF_LONG); gtk_imhtml_append_text(GTK_IMHTML(awaytext), buf, GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_SCROLL); g_free(buf); gtk_imhtml_append_text(GTK_IMHTML(awaytext), "<BR>", GTK_IMHTML_NO_TITLE | GTK_IMHTML_NO_COMMENTS | GTK_IMHTML_NO_SCROLL); awayqueuesw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(awayqueuesw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(awayqueuesw), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), awayqueuesw, TRUE, TRUE, 0); awayqueuestore = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); awayqueue = gtk_tree_view_new_with_model(GTK_TREE_MODEL(awayqueuestore)); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(awayqueue), FALSE); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(awayqueue), column); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(awayqueue), column); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(awayqueue), column); gtk_container_add(GTK_CONTAINER(awayqueuesw), awayqueue); g_signal_connect(G_OBJECT(awayqueue), "button_press_event", G_CALLBACK(dequeue_cb), NULL); if (gaim_prefs_get_bool("/gaim/gtk/away/queue_messages")) { gtk_widget_show(awayqueuesw); gtk_widget_show(awayqueue); } awaymessage = a; edit = gaim_pixbuf_button_from_stock(_("Edit This Message"), GTK_STOCK_CONVERT, GAIM_BUTTON_HORIZONTAL); gtk_box_pack_start(GTK_BOX(hbox), edit, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(edit), "clicked", G_CALLBACK(create_away_mess), awaymessage); gtk_widget_show(edit); back = gaim_pixbuf_button_from_stock(_("I'm Back!"), GTK_STOCK_JUMP_TO, GAIM_BUTTON_HORIZONTAL); gtk_box_pack_start(GTK_BOX(hbox), back, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(back), "clicked", G_CALLBACK(do_im_back), imaway); gtk_window_set_focus(GTK_WINDOW(imaway), back); gtk_widget_show(back); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(imaway); serv_set_away_all(awaymessage->message); }
static void * gaim_gtk_notify_formatted(const char *title, const char *primary, const char *secondary, const char *text, GCallback cb, void *user_data) { GtkWidget *window; GtkWidget *vbox; GtkWidget *label; GtkWidget *button; GtkWidget *imhtml; GtkWidget *sw; int options = 0; char label_text[2048]; char *linked_text; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), title); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width(GTK_CONTAINER(window), 12); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(formatted_close_cb), NULL); /* Setup the main vbox */ vbox = gtk_vbox_new(FALSE, 12); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); /* Setup the descriptive label */ g_snprintf(label_text, sizeof(label_text), "<span weight=\"bold\" size=\"larger\">%s</span>%s%s", primary, (secondary ? "\n" : ""), (secondary ? secondary : "")); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), label_text); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); /* Setup the scrolled window that we're putting the gtkimhtml in. */ sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_widget_set_size_request(sw, 300, 250); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); gtk_widget_show(sw); /* Now build that gtkimhtml */ imhtml = gtk_imhtml_new(NULL, NULL); gtk_widget_set_name(imhtml, "gaim_gtknotify_imhtml"); gtk_container_add(GTK_CONTAINER(sw), imhtml); gtk_widget_show(imhtml); gaim_setup_imhtml(imhtml); /* Add the Close button. */ button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); gtk_widget_show(button); g_signal_connect_swapped(G_OBJECT(button), "clicked", G_CALLBACK(formatted_close_cb), window); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(formatted_input_cb), NULL); /* Add the text to the gtkimhtml */ if (gaim_prefs_get_bool("/gaim/gtk/conversations/ignore_colors")) options ^= GTK_IMHTML_NO_COLOURS; if (gaim_prefs_get_bool("/gaim/gtk/conversations/ignore_fonts")) options ^= GTK_IMHTML_NO_FONTS; if (gaim_prefs_get_bool("/gaim/gtk/conversations/ignore_font_sizes")) options ^= GTK_IMHTML_NO_SIZES; options ^= GTK_IMHTML_NO_COMMENTS; options ^= GTK_IMHTML_NO_TITLE; options ^= GTK_IMHTML_NO_NEWLINE; options ^= GTK_IMHTML_NO_SCROLL; /* Make sure URLs are clickable */ linked_text = gaim_markup_linkify(text); gtk_imhtml_append_text(GTK_IMHTML(imhtml), linked_text, options); g_free(linked_text); /* Show the window */ gtk_widget_show(window); return window; }
static DebugWindow * debug_window_new(void) { DebugWindow *win; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *sw; GtkWidget *button; GtkWidget *image; int width, height; win = g_new0(DebugWindow, 1); width = gaim_prefs_get_int("/gaim/gtk/debug/width"); height = gaim_prefs_get_int("/gaim/gtk/debug/height"); GAIM_DIALOG(win->window); gaim_debug(GAIM_DEBUG_INFO, "gtkdebug", "Setting dimensions to %d, %d\n", width, height); gtk_window_set_default_size(GTK_WINDOW(win->window), width, height); gtk_window_set_role(GTK_WINDOW(win->window), "debug"); gtk_window_set_title(GTK_WINDOW(win->window), _("Debug Window")); g_signal_connect(G_OBJECT(win->window), "delete_event", G_CALLBACK(debug_window_destroy), NULL); g_signal_connect(G_OBJECT(win->window), "configure_event", G_CALLBACK(configure_cb), win); /* Setup the vbox */ vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(win->window), vbox); if (gaim_prefs_get_bool("/gaim/gtk/debug/toolbar")) { /* Setup our top button bar thingie. */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); /* Find button */ gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar), GTK_STOCK_FIND, NULL, NULL, G_CALLBACK(find_cb), win, -1); /* Save */ gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar), GTK_STOCK_SAVE, NULL, NULL, G_CALLBACK(save_cb), win, -1); /* Clear button */ gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar), GTK_STOCK_CLEAR, NULL, NULL, G_CALLBACK(clear_cb), win, -1); gtk_toolbar_insert_space(GTK_TOOLBAR(toolbar), -1); /* Pause */ image = gtk_image_new_from_stock(GAIM_STOCK_PAUSE, GTK_ICON_SIZE_MENU); button = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL, _("Pause"), NULL, NULL, image, G_CALLBACK(pause_cb), win); /* Timestamps */ button = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL, _("Timestamps"), NULL, NULL, NULL, G_CALLBACK(timestamps_cb), win); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), gaim_prefs_get_bool("/gaim/gtk/debug/timestamps")); win->timestamps_handle = gaim_prefs_connect_callback("/gaim/gtk/debug/timestamps", timestamps_pref_cb, button); } /* Now our scrolled window... */ sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); /* ... which has a gtkimhtml in it. */ win->text = gtk_imhtml_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(sw), win->text); /* Pack it in... Not like that, sicko. */ gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); gtk_widget_show_all(win->window); return win; }
int main(int argc, char *argv[]) #endif { int opt_acct = 0, opt_help = 0, opt_version = 0, opt_login = 0, opt_nologin = 0, dologin_ret = -1; char *opt_user_arg = NULL, *opt_login_arg = NULL; char *opt_session_arg = NULL, *opt_config_dir_arg = NULL; #ifdef ENABLE_HILDON char *plugin_search_paths[4]; #else char *plugin_search_paths[3]; #endif #if HAVE_SIGNAL_H int sig_indx; /* for setting up signal catching */ sigset_t sigset; void (*prev_sig_disp)(); #endif int opt, opt_user = 0; int i; gboolean gui_check; gchar *gaimrc, *accountsxml; struct option long_options[] = { {"acct", no_argument, NULL, 'a'}, /*{"away", optional_argument, NULL, 'w'}, */ {"help", no_argument, NULL, 'h'}, /*{"login", optional_argument, NULL, 'l'}, */ {"loginwin", no_argument, NULL, 'n'}, {"user", required_argument, NULL, 'u'}, {"config", required_argument, NULL, 'c'}, {"debug", no_argument, NULL, 'd'}, {"version", no_argument, NULL, 'v'}, {"session", required_argument, NULL, 's'}, {0, 0, 0, 0} }; #ifdef DEBUG opt_debug = 1; #endif #ifndef _WIN32 br_set_locate_fallback_func(gaim_find_binary_location, argv[0]); #endif #ifdef ENABLE_NLS bindtextdomain(PACKAGE, LOCALEDIR); bind_textdomain_codeset(PACKAGE, "UTF-8"); textdomain(PACKAGE); #endif #if HAVE_SIGNAL_H /* Let's not violate any PLA's!!!! */ /* jseymour: whatever the fsck that means */ /* Robot101: for some reason things like gdm like to block * * useful signals like SIGCHLD, so we unblock all the ones we * * declare a handler for. thanks JSeymour and Vann. */ if (sigemptyset(&sigset)) { char errmsg[BUFSIZ]; snprintf(errmsg, BUFSIZ, "Warning: couldn't initialise empty signal set"); perror(errmsg); } for(sig_indx = 0; catch_sig_list[sig_indx] != -1; ++sig_indx) { if((prev_sig_disp = signal(catch_sig_list[sig_indx], sighandler)) == SIG_ERR) { char errmsg[BUFSIZ]; snprintf(errmsg, BUFSIZ, "Warning: couldn't set signal %d for catching", catch_sig_list[sig_indx]); perror(errmsg); } if(sigaddset(&sigset, catch_sig_list[sig_indx])) { char errmsg[BUFSIZ]; snprintf(errmsg, BUFSIZ, "Warning: couldn't include signal %d for unblocking", catch_sig_list[sig_indx]); perror(errmsg); } } for(sig_indx = 0; ignore_sig_list[sig_indx] != -1; ++sig_indx) { if((prev_sig_disp = signal(ignore_sig_list[sig_indx], SIG_IGN)) == SIG_ERR) { char errmsg[BUFSIZ]; snprintf(errmsg, BUFSIZ, "Warning: couldn't set signal %d to ignore", ignore_sig_list[sig_indx]); perror(errmsg); } } if (sigprocmask(SIG_UNBLOCK, &sigset, NULL)) { char errmsg[BUFSIZ]; snprintf(errmsg, BUFSIZ, "Warning: couldn't unblock signals"); perror(errmsg); } #endif for (i = 0; i < argc; i++) { /* --login option */ if (strstr(argv[i], "--l") == argv[i]) { char *equals; opt_login = 1; if ((equals = strchr(argv[i], '=')) != NULL) { /* --login=NAME */ opt_login_arg = g_strdup(equals + 1); if (strlen(opt_login_arg) == 0) { g_free(opt_login_arg); opt_login_arg = NULL; } } else if (i + 1 < argc && argv[i + 1][0] != '-') { /* --login NAME */ opt_login_arg = g_strdup(argv[i + 1]); strcpy(argv[i + 1], " "); } strcpy(argv[i], " "); } /* -l option */ else if (strstr(argv[i], "-l") == argv[i]) { opt_login = 1; if (strlen(argv[i]) > 2) { /* -lNAME */ opt_login_arg = g_strdup(argv[i] + 2); } else if (i + 1 < argc && argv[i + 1][0] != '-') { /* -l NAME */ opt_login_arg = g_strdup(argv[i + 1]); strcpy(argv[i + 1], " "); } strcpy(argv[i], " "); } /* --away option */ else if (strstr(argv[i], "--aw") == argv[i]) { char *equals; opt_away = 1; if ((equals = strchr(argv[i], '=')) != NULL) { /* --away=MESG */ opt_away_arg = g_strdup(equals + 1); if (strlen(opt_away_arg) == 0) { g_free(opt_away_arg); opt_away_arg = NULL; } } else if (i + 1 < argc && argv[i + 1][0] != '-') { /* --away MESG */ opt_away_arg = g_strdup(argv[i + 1]); strcpy(argv[i + 1], " "); } strcpy(argv[i], " "); } /* -w option */ else if (strstr(argv[i], "-w") == argv[i]) { opt_away = 1; if (strlen(argv[i]) > 2) { /* -wMESG */ opt_away_arg = g_strdup(argv[i] + 2); } else if (i + 1 < argc && argv[i + 1][0] != '-') { /* -w MESG */ opt_away_arg = g_strdup(argv[i + 1]); strcpy(argv[i + 1], " "); } strcpy(argv[i], " "); } } /* if (opt_login) { printf ("--login given with arg %s\n", opt_login_arg ? opt_login_arg : "NULL"); exit(0); } */ gui_check = gtk_init_check(&argc, &argv); /* scan command-line options */ opterr = 1; while ((opt = getopt_long(argc, argv, #ifndef _WIN32 "adhu:c:vns:", #else "adhu:c:vn", #endif long_options, NULL)) != -1) { switch (opt) { case 'u': /* set user */ opt_user = 1; opt_user_arg = g_strdup(optarg); break; case 'a': /* account editor */ opt_acct = 1; break; case 'd': /* debug */ opt_debug = 1; break; case 'c': /* use specified config dir */ set_gaim_user_dir(optarg); opt_config_dir_arg = g_strdup(optarg); break; case 's': /* use existing session ID */ opt_session_arg = g_strdup(optarg); break; case 'v': /* version */ opt_version = 1; break; case 'h': /* help */ opt_help = 1; break; case 'n': /* don't autologin */ opt_nologin = 1; break; case '?': default: show_usage(1, argv[0]); return 0; break; } } /* show help message */ if (opt_help) { show_usage(0, argv[0]); return 0; } /* show version message */ if (opt_version) { printf("Gaim %s\n",VERSION); return 0; } if (!gui_check) { char *display = gdk_get_display(); g_warning("cannot open display: %s", display ? display : "unset"); g_free(display); return 1; } #ifdef _WIN32 wgaim_init(hint); #endif gaim_core_set_ui_ops(gaim_gtk_core_get_ui_ops()); gaim_eventloop_set_ui_ops(gaim_gtk_eventloop_get_ui_ops()); #ifdef ENABLE_HILDON app = hildon_app_new(); hildon_app_set_two_part_title(HILDON_APP(app), TRUE); hildon_app_set_title(HILDON_APP(app), _("Gaim")); hildon_app_set_autoregistration(HILDON_APP(app), TRUE); /* I will catch the key events here to change views */ g_signal_connect(G_OBJECT(app), "key_press_event", G_CALLBACK(app_key_press_cb), app); g_signal_connect(G_OBJECT(app), "key_press_event", G_CALLBACK(app_key_press_cb), app); g_signal_connect(G_OBJECT(app), "delete_event", G_CALLBACK(app_delete_event_proxy), app); gtk_widget_show_all( GTK_WIDGET( app ) ); /* register with osso initialize */ context = osso_initialize("org.maemo." PACKAGE, PACKAGE_VERSION, FALSE, NULL); osso_application_set_top_cb(context, osso_top_callback, (gpointer)app); #endif if (!gaim_core_init(GAIM_GTK_UI)) { fprintf(stderr, "Initialization of the Gaim core failed. Dumping core.\n" "Please report this!\n"); abort(); } plugin_search_paths[0] = g_strdup(LIBDIR); plugin_search_paths[1] = gaim_user_dir(); plugin_search_paths[2] = g_build_filename(gaim_user_dir(), "plugins", NULL); #ifdef ENABLE_HILDON plugin_search_paths[3] = g_strdup("/var/lib/install/etc/gaim/plugins"); #endif gaim_plugins_set_search_paths(sizeof(plugin_search_paths) / sizeof(*plugin_search_paths), plugin_search_paths); g_free(plugin_search_paths[0]); g_free(plugin_search_paths[2]); gaim_plugins_probe(NULL); /* XXX - Remove this check. Maybe in 2005. --KingAnt, 25 Jul 2004 */ gaimrc = g_build_filename(gaim_home_dir(), ".gaimrc", NULL); accountsxml = g_build_filename(gaim_user_dir(), "accounts.xml", NULL); if (g_file_test(gaimrc, G_FILE_TEST_EXISTS) && !g_file_test(accountsxml, G_FILE_TEST_EXISTS)) { gaim_notify_error(NULL, NULL, _("Unable to load preferences"), _("Gaim was not able to load your preferences because they are stored in an old format that is no longer used. Please reconfigure your settings using the Preferences window.")); } g_free(gaimrc); g_free(accountsxml); gaim_accounts_load(); gaim_set_blist(gaim_blist_new()); gaim_blist_load(); gaim_prefs_load(); gaim_prefs_update_old(); gaim_gtk_prefs_update_old(); /* load plugins we had when we quit */ gaim_plugins_load_saved("/gaim/gtk/plugins/loaded"); gaim_pounces_load(); gaim_status_load(); ui_main(); #ifdef USE_SM session_init(argv[0], opt_session_arg, opt_config_dir_arg); #endif if (opt_session_arg != NULL) { g_free(opt_session_arg); opt_session_arg = NULL; } if (opt_config_dir_arg != NULL) { g_free(opt_config_dir_arg); opt_config_dir_arg = NULL; } /* set the default username */ if (opt_user_arg != NULL) { set_first_user(opt_user_arg); g_free(opt_user_arg); opt_user_arg = NULL; } #ifndef GAIM_SMALL_SCREEN if (gaim_prefs_get_bool("/gaim/gtk/debug/enabled")) gaim_gtk_debug_window_show(); #endif /* deal with --login */ if (opt_login) { dologin_ret = dologin_named(opt_login_arg); if (opt_login_arg != NULL) { g_free(opt_login_arg); opt_login_arg = NULL; } } if (!opt_acct && !opt_nologin) gaim_accounts_auto_login(GAIM_GTK_UI); if (opt_acct) { gaim_gtk_accounts_window_show(); } else if ((dologin_ret == -1) && !gaim_connections_get_all()) show_login(); #ifdef HAVE_STARTUP_NOTIFICATION startup_notification_complete(); #endif gtk_main(); gaim_sound_shutdown(); #ifdef _WIN32 wgaim_cleanup(); #endif #ifdef ENABLE_HILDON gtk_widget_destroy(app); #endif return 0; }
void gaym_gtkconv_update_thumbnail(GaimConversation * conv, struct fetch_thumbnail_data *thumbnail_data) { GaimGtkConversation *gtkconv; char filename[256]; FILE *file; GError *err = NULL; size_t len; GdkPixbuf *buf; GdkPixbuf *scale; GdkPixmap *pm; GdkBitmap *bm; int scale_width, scale_height; GaimAccount *account; GaimPluginProtocolInfo *prpl_info = NULL; g_return_if_fail(conv != NULL); g_return_if_fail(GAIM_IS_GTK_CONVERSATION(conv)); g_return_if_fail(gaim_conversation_get_type(conv) == GAIM_CONV_CHAT); gtkconv = GAIM_GTK_CONVERSATION(conv); GaymChatIcon *icon_data = g_hash_table_lookup(icons, conv); if (!thumbnail_data) return; if (!icon_data->show_icon) return; const char *data = thumbnail_data->pic_data; len = thumbnail_data->pic_data_len; account = gaim_conversation_get_account(conv); if (account && account->gc) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(account->gc->prpl); if (icon_data->anim != NULL) g_object_unref(G_OBJECT(icon_data->anim)); icon_data->anim = NULL; if (icon_data->icon_timer != 0) g_source_remove(icon_data->icon_timer); icon_data->icon_timer = 0; if (icon_data->iter != NULL) g_object_unref(G_OBJECT(icon_data->iter)); icon_data->iter = NULL; if (!gaim_prefs_get_bool ("/gaim/gtk/conversations/im/show_buddy_icons")) return; if (gaim_conversation_get_gc(conv) == NULL) return; /* this is such an evil hack, i don't know why i'm even considering it. we'll do it differently when gdk-pixbuf-loader isn't leaky anymore. */ /* gdk-pixbuf-loader was leaky? is it still? */ g_snprintf(filename, sizeof(filename), "%s" G_DIR_SEPARATOR_S "gaimicon-%s.%d", g_get_tmp_dir(), thumbnail_data->who, getpid()); if (!(file = g_fopen(filename, "wb"))) return; fwrite(data, 1, len, file); fclose(file); icon_data->anim = gdk_pixbuf_animation_new_from_file(filename, &err); /* make sure we remove the file as soon as possible */ g_unlink(filename); if (err) { gaim_debug(GAIM_DEBUG_ERROR, "gtkconv", "Buddy icon error: %s\n", err->message); g_error_free(err); } if (!icon_data->anim) return; if (gdk_pixbuf_animation_is_static_image(icon_data->anim)) { icon_data->iter = NULL; buf = gdk_pixbuf_animation_get_static_image(icon_data->anim); } else { icon_data->iter = gdk_pixbuf_animation_get_iter(icon_data->anim, NULL); /* LEAK */ buf = gdk_pixbuf_animation_iter_get_pixbuf(icon_data->iter); } get_icon_scale_size(icon_data->anim, prpl_info ? &prpl_info->icon_spec : NULL, &scale_width, &scale_height); scale = gdk_pixbuf_scale_simple(buf, MAX(gdk_pixbuf_get_width(buf) * scale_width / gdk_pixbuf_animation_get_width (icon_data->anim), 1), MAX(gdk_pixbuf_get_height(buf) * scale_height / gdk_pixbuf_animation_get_height (icon_data->anim), 1), GDK_INTERP_NEAREST); gdk_pixbuf_render_pixmap_and_mask(scale, &pm, &bm, 100); g_object_unref(G_OBJECT(scale)); icon_data->event = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(icon_data->frame), icon_data->event); gtk_widget_set_size_request(GTK_WIDGET(icon_data->frame), scale_width, scale_height); // g_signal_connect(G_OBJECT(icon_data->event), "button-press-event", // G_CALLBACK(icon_menu), conv); gtk_widget_show(icon_data->event); icon_data->icon = gtk_image_new_from_pixmap(pm, bm); gtk_container_add(GTK_CONTAINER(icon_data->event), icon_data->icon); gtk_widget_show(icon_data->icon); g_object_unref(G_OBJECT(pm)); if (bm) g_object_unref(G_OBJECT(bm)); }
/** * This is our callback for the receiving-im-msg signal. * * We return TRUE to block the IM, FALSE to accept the IM */ static gboolean receiving_im_msg_cb(GaimAccount * account, char **sender, char **buffer, int *flags, void *data) { gboolean retval = FALSE; /* assume the sender is allowed */ gboolean found = FALSE; gint pos = -1; char *botmsg = NULL; PendingMessage *pending = NULL; GSList *slist = NULL; GSList *search = NULL; GaimConnection *connection = NULL; /* expire any old entries in pending */ expire_pending_list(); connection = gaim_account_get_connection(account); /* not good, but don't do anything */ if (!connection || !sender) { return retval; } /* if there is already an open conversation, allowed it */ if (gaim_find_conversation_with_account(*sender, account)) { return retval; } /* don't make buddies use the challenge/response system */ if (gaim_find_buddy(account, *sender)) { return retval; } /* don't make permit list members use the challenge/response system */ for (slist = account->permit; slist != NULL; slist = slist->next) { if (!gaim_utf8_strcasecmp (*sender, gaim_normalize(account, (char *) slist->data))) { return retval; } } /* if there is no question or no answer, allow the sender */ const char *question = gaim_prefs_get_string("/plugins/core/bot/challenger/question"); const char *answer = gaim_prefs_get_string("/plugins/core/bot/challenger/answer"); if (!question || !answer) { return retval; } /* blank / null message ... can this even happen? */ if (!*buffer) { return retval; } /* search if this sender is already in pending */ for (search = pending_list; search; search = search->next) { pending = search->data; pos = g_slist_position(pending_list, search); if (protocmp(account, pending) && usercmp(account, pending) && sendercmp(*sender, pending)) { found = TRUE; break; } } if (!found) { /** * its the first time through, save the nick/msg to the * queue and ask the question */ GTimeVal *now = NULL; now = g_new0(GTimeVal, 1); g_get_current_time(now); PendingMessage *newpend = NULL; newpend = g_new0(PendingMessage, 1); newpend->tv_sec = now->tv_sec; newpend->protocol = g_strdup(account->protocol_id); newpend->username = g_strdup(account->username); newpend->sender = g_strdup(*sender); newpend->message = g_strdup(*buffer); pending_list = g_slist_append(pending_list, newpend); botmsg = g_strdup_printf(_ ("Bot Challenger engaged: you are now being ignored! Your message will be delivered if you can correctly answer the following question within %i minutes: %s"), BOT_MAX_MINUTES, question); send_auto_reply(account, *sender, botmsg); g_free(now); g_free(botmsg); retval = TRUE; } else { if (gaim_utf8_strcasecmp(*buffer, answer)) { /** * Sorry, thanks for playing, please try again */ retval = TRUE; } else { botmsg = _ ("Bot Challenger accepted your answer and delivered your original message. You may now speak freely."); send_auto_reply(account, *sender, botmsg); if (gaim_prefs_get_bool ("/plugins/core/bot/challenger/auto_add_permit")) { if (!gaim_privacy_permit_add(account, *sender, FALSE)) { gaim_debug_info("bot-challenger", "Unable to add %s/%s/%s to permit list\n", *sender, pending->username, pending->protocol); } } /** * Free what is currently in the buffer (the correct answer) * and replace it with the user's first message that was * queued, pending the correct answer. I think some other * process is supposed to free the buffer after its sent. */ g_free(*buffer); *buffer = pending->message; /* Clean up everything else except pending->message */ free_pending(search, FALSE); retval = FALSE; /* Don't block this message */ } } debug_pending_list(); return retval; /* returning TRUE will block the IM */ }
/* recv an IM from a group chat */ void qq_process_recv_group_im(guint8 *data, guint8 **cursor, gint data_len, guint32 internal_group_id, GaimConnection *gc, guint16 im_type) { gchar *msg_with_gaim_smiley, *msg_utf8_encoded, *im_src_name, *hex_dump; guint16 unknown; guint32 unknown4; GaimConversation *conv; qq_data *qd; qq_buddy *member; qq_group *group; qq_recv_group_im *im_group; gint skip_len; g_return_if_fail(data != NULL && data_len > 0); qd = (qq_data *) gc->proto_data; hex_dump = hex_dump_to_str(*cursor, data_len - (*cursor - data)); gaim_debug(GAIM_DEBUG_INFO, "QQ", "group im hex dump\n%s\n", hex_dump); if (*cursor >= (data + data_len - 1)) { gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received group im_group is empty\n"); return; } im_group = g_newa(qq_recv_group_im, 1); read_packet_dw(data, cursor, data_len, &(im_group->external_group_id)); read_packet_b(data, cursor, data_len, &(im_group->group_type)); if(QQ_RECV_IM_TEMP_QUN_IM == im_type) { read_packet_dw(data, cursor, data_len, &(internal_group_id)); } read_packet_dw(data, cursor, data_len, &(im_group->member_uid)); read_packet_w(data, cursor, data_len, &unknown); /* 0x0001? */ read_packet_w(data, cursor, data_len, &(im_group->msg_seq)); read_packet_dw(data, cursor, data_len, (guint32 *) & (im_group->send_time)); read_packet_dw(data, cursor, data_len, &unknown4); /* versionID */ /* * length includes font_attr * this msg_len includes msg and font_attr **** the format is **** * length of all * 1. unknown 10 bytes * 2. 0-ended string * 3. font_attr */ read_packet_w(data, cursor, data_len, &(im_group->msg_len)); g_return_if_fail(im_group->msg_len > 0); /* * 10 bytes from lumaqq * contentType = buf.getChar(); * totalFragments = buf.get() & 255; * fragmentSequence = buf.get() & 255; * messageId = buf.getChar(); * buf.getInt(); */ if(im_type != QQ_RECV_IM_UNKNOWN_QUN_IM) skip_len = 10; else skip_len = 0; *cursor += skip_len; im_group->msg = g_strdup((gchar *) *cursor); *cursor += strlen(im_group->msg) + 1; /* there might not be any font_attr, check it */ im_group->font_attr_len = im_group->msg_len - strlen(im_group->msg) - 1 - skip_len; if (im_group->font_attr_len > 0) im_group->font_attr = g_memdup(*cursor, im_group->font_attr_len); else im_group->font_attr = NULL; /* group im_group has no flag to indicate whether it has font_attr or not */ msg_with_gaim_smiley = qq_smiley_to_gaim(im_group->msg); if (im_group->font_attr_len > 0) msg_utf8_encoded = qq_encode_to_gaim(im_group->font_attr, im_group->font_attr_len, msg_with_gaim_smiley); else msg_utf8_encoded = qq_to_utf8(msg_with_gaim_smiley, QQ_CHARSET_DEFAULT); group = qq_group_find_by_id(gc, internal_group_id, QQ_INTERNAL_ID); g_return_if_fail(group != NULL); conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_CHAT, group->group_name_utf8, gaim_connection_get_account(gc)); if (conv == NULL && gaim_prefs_get_bool("/plugins/prpl/qq/prompt_group_msg_on_recv")) { serv_got_joined_chat(gc, qd->channel++, group->group_name_utf8); conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_CHAT, group->group_name_utf8, gaim_connection_get_account(gc)); } if (conv != NULL) { member = qq_group_find_member_by_uid(group, im_group->member_uid); if (member == NULL || member->nickname == NULL) im_src_name = uid_to_gaim_name(im_group->member_uid); else im_src_name = g_strdup(member->nickname); serv_got_chat_in(gc, gaim_conv_chat_get_id(GAIM_CONV_CHAT (conv)), im_src_name, 0, msg_utf8_encoded, im_group->send_time); g_free(im_src_name); } g_free(hex_dump); g_free(msg_with_gaim_smiley); g_free(msg_utf8_encoded); g_free(im_group->msg); g_free(im_group->font_attr); }