static gboolean plugin_load(PurplePlugin *plugin) { purple_signal_connect(purple_conversations_get_handle(), "conversation-created", plugin, PURPLE_CALLBACK(historize), NULL); purple_prefs_connect_callback(plugin, "/purple/logging/log_ims", history_prefs_cb, plugin); purple_prefs_connect_callback(plugin, "/purple/logging/log_chats", history_prefs_cb, plugin); history_prefs_check(plugin); return TRUE; }
guint purple_perl_prefs_connect_callback(PurplePlugin *plugin, const char *name, SV *callback, SV *data) { PurplePerlPrefsHandler *handler; if (plugin == NULL) { croak("Invalid handle in adding perl prefs handler.\n"); return 0; } handler = g_new0(PurplePerlPrefsHandler, 1); handler->plugin = plugin; handler->callback = (callback != NULL && callback != &PL_sv_undef ? newSVsv(callback) : NULL); handler->data = (data != NULL && data != &PL_sv_undef ? newSVsv(data) : NULL); pref_handlers = g_slist_prepend(pref_handlers, handler); handler->iotag = purple_prefs_connect_callback(plugin, name, perl_pref_cb, handler); return handler->iotag; }
void purple_prefs_init(void) { void *handle = purple_prefs_get_handle(); prefs_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); purple_prefs_connect_callback(handle, "/", prefs_save_cb, NULL); purple_prefs_add_none("/purple"); purple_prefs_add_none("/plugins"); purple_prefs_add_none("/plugins/core"); purple_prefs_add_none("/plugins/lopl"); purple_prefs_add_none("/plugins/prpl"); /* Away */ purple_prefs_add_none("/purple/away"); purple_prefs_add_string("/purple/away/idle_reporting", "system"); purple_prefs_add_bool("/purple/away/away_when_idle", TRUE); purple_prefs_add_int("/purple/away/mins_before_away", 5); /* Away -> Auto-Reply */ if (!purple_prefs_exists("/purple/away/auto_response/enabled") || !purple_prefs_exists("/purple/away/auto_response/idle_only")) { purple_prefs_add_string("/purple/away/auto_reply", "awayidle"); } else { if (!purple_prefs_get_bool("/purple/away/auto_response/enabled")) { purple_prefs_add_string("/purple/away/auto_reply", "never"); } else { if (purple_prefs_get_bool("/purple/away/auto_response/idle_only")) { purple_prefs_add_string("/purple/away/auto_reply", "awayidle"); } else { purple_prefs_add_string("/purple/away/auto_reply", "away"); } } } /* Buddies */ purple_prefs_add_none("/purple/buddies"); /* Contact Priority Settings */ purple_prefs_add_none("/purple/contact"); purple_prefs_add_bool("/purple/contact/last_match", FALSE); purple_prefs_remove("/purple/contact/offline_score"); purple_prefs_remove("/purple/contact/away_score"); purple_prefs_remove("/purple/contact/idle_score"); purple_prefs_load(); purple_prefs_update_old(); }
static gboolean plugin_load(PurplePlugin *plugin, GError **error) { purple_prefs_add_none("/plugins/gtk"); purple_prefs_add_none("/plugins/gtk/win32"); purple_prefs_add_none("/plugins/gtk/win32/winprefs"); purple_prefs_add_bool(PREF_DBLIST_DOCKABLE, FALSE); purple_prefs_add_bool(PREF_DBLIST_DOCKED, FALSE); purple_prefs_add_int(PREF_DBLIST_HEIGHT, 0); purple_prefs_add_int(PREF_DBLIST_SIDE, 0); /* Convert old preferences */ if(purple_prefs_exists(PREF_DBLIST_ON_TOP)) { gint blist_top = BLIST_TOP_NEVER; if(purple_prefs_get_bool(PREF_BLIST_ON_TOP)) blist_top = BLIST_TOP_ALWAYS; else if(purple_prefs_get_bool(PREF_DBLIST_ON_TOP)) blist_top = BLIST_TOP_DOCKED; purple_prefs_remove(PREF_BLIST_ON_TOP); purple_prefs_remove(PREF_DBLIST_ON_TOP); purple_prefs_add_int(PREF_BLIST_ON_TOP, blist_top); } else purple_prefs_add_int(PREF_BLIST_ON_TOP, BLIST_TOP_NEVER); purple_prefs_remove(PREF_CHAT_BLINK); handle = plugin; /* blist docking init */ if(purple_blist_get_buddy_list() && PIDGIN_BLIST(purple_blist_get_buddy_list()) && PIDGIN_BLIST(purple_blist_get_buddy_list())->window) { blist_create_cb(purple_blist_get_buddy_list(), NULL); } /* This really shouldn't happen anymore generally, but if for some strange reason, the blist is recreated, we need to set it up again. */ purple_signal_connect(pidgin_blist_get_handle(), "gtkblist-created", plugin, PURPLE_CALLBACK(blist_create_cb), NULL); purple_signal_connect((void*)purple_get_core(), "quitting", plugin, PURPLE_CALLBACK(purple_quit_cb), NULL); purple_prefs_connect_callback(handle, PREF_BLIST_ON_TOP, winprefs_set_blist_ontop, NULL); purple_prefs_connect_callback(handle, PREF_DBLIST_DOCKABLE, winprefs_set_blist_dockable, NULL); return TRUE; }
static void purple_keyring_pref_connect(void) { g_return_if_fail(purple_keyring_pref_cbid == 0); purple_keyring_pref_cbid = purple_prefs_connect_callback(NULL, "/purple/keyring/active", purple_keyring_pref_callback, NULL); }
BuddyList::BuddyList() : Window(0, 0, 80, 24) { SetColorScheme("buddylist"); CppConsUI::HorizontalListBox *lbox = new CppConsUI::HorizontalListBox(AUTOSIZE, AUTOSIZE); lbox->AppendWidget(*(new CppConsUI::Spacer(1, AUTOSIZE))); treeview = new CppConsUI::TreeView(AUTOSIZE, AUTOSIZE); lbox->AppendWidget(*treeview); lbox->AppendWidget(*(new CppConsUI::Spacer(1, AUTOSIZE))); AddWidget(*lbox, 0, 0); /* TODO Check if this has been moved to purple_blist_init(). Remove these * lines if it was as this will probably move to purple_init(), the * buddylist object should be available a lot more early and the uiops * should be set a lot more early. (All in all a lot of work.) */ buddylist = purple_blist_new(); buddylist->ui_data = this; purple_set_blist(buddylist); // load the pounces purple_pounces_load(); // init prefs purple_prefs_add_none(CONF_PREFIX "/blist"); purple_prefs_add_bool(CONF_PREFIX "/blist/show_empty_groups", false); purple_prefs_add_bool(CONF_PREFIX "/blist/show_offline_buddies", true); purple_prefs_add_string(CONF_PREFIX "/blist/colorization_mode", "none"); UpdateCachedPreference(CONF_PREFIX "/blist/show_empty_groups"); UpdateCachedPreference(CONF_PREFIX "/blist/show_offline_buddies"); UpdateCachedPreference(CONF_PREFIX "/blist/colorization_mode"); // connect callbacks purple_prefs_connect_callback(this, CONF_PREFIX "/blist", blist_pref_change_, this); // setup the callbacks for the buddylist memset(¢erim_blist_ui_ops, 0, sizeof(centerim_blist_ui_ops)); centerim_blist_ui_ops.new_list = new_list_; centerim_blist_ui_ops.new_node = new_node_; //centerim_blist_ui_ops.show = show_; centerim_blist_ui_ops.update = update_; centerim_blist_ui_ops.remove = remove_; centerim_blist_ui_ops.destroy = destroy_; //centerim_blist_ui_ops.set_visible = set_visible_; centerim_blist_ui_ops.request_add_buddy = request_add_buddy_; centerim_blist_ui_ops.request_add_chat = request_add_chat_; centerim_blist_ui_ops.request_add_group = request_add_group_; // since libpurple 2.6.0 //centerim_blist_ui_ops.save_node = save_node_; //centerim_blist_ui_ops.remove_node = remove_node_; //centerim_blist_ui_ops.save_account = save_account_; purple_blist_set_ui_ops(¢erim_blist_ui_ops); COREMANAGER->TimeoutOnceConnect(sigc::mem_fun(this, &BuddyList::Load), 0); }
/* This needs to be delayed otherwise, when the blist is originally created and * hidden, it'll trigger the blist_visible_cb */ static gboolean listen_for_blist_visible_cb(gpointer data) { if (handle != NULL) blist_visible_cb_id = purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/list_visible", blist_visible_cb, NULL); return FALSE; }
static void init_plugin(PurplePlugin *plugin) { purple_prefs_add_none("/plugins/gtk"); purple_prefs_add_none("/plugins/gtk/X11"); purple_prefs_add_none("/plugins/gtk/X11/gestures"); purple_prefs_add_bool("/plugins/gtk/X11/gestures/visual", FALSE); purple_prefs_connect_callback(plugin, "/plugins/gtk/X11/gestures/visual", visual_pref_cb, NULL); }
static gboolean purplerc_plugin_load(PurplePlugin *plugin) { purplerc_make_changes(); pref_callback = purple_prefs_connect_callback(plugin, "/plugins/gtk/purplerc", purplerc_pref_changed_cb, NULL); return TRUE; }
void ap_gtk_start () { progress_bars = g_hash_table_new (NULL, NULL); // Message queueing queue_pref_cb = purple_prefs_connect_callback ( ap_get_plugin_handle (), "/plugins/gtk/autoprofile/queue_messages_when_away", queue_cb, NULL); // Create window create_dialog (); update_summary_visibility (); }
GtkWidget *ap_prefs_labeled_entry (struct widget *w, GtkWidget *page, const gchar *title, const char *key, GtkSizeGroup *sg) { GtkWidget *result; const gchar *pref; pref = get_const_pref (w, key); result = pidgin_prefs_labeled_entry (page, title, pref, sg); purple_prefs_connect_callback (ap_get_plugin_handle (), pref, pref_callback, w); return result; }
GtkWidget *ap_prefs_checkbox (struct widget *w, const char *title, const char *key, GtkWidget *page) { GtkWidget *result; const gchar *pref; pref = get_const_pref (w, key); result = pidgin_prefs_checkbox (title, pref, page); purple_prefs_connect_callback (ap_get_plugin_handle (), pref, pref_callback, w); return result; }
static void pidgin_mini_dialog_init(PidginMiniDialog *self) { GtkBox *self_box = GTK_BOX(self); guint blist_width = purple_prefs_get_int(BLIST_WIDTH_PREF); guint label_width = blist_width - BLIST_WIDTH_OTHER_THAN_LABEL; PidginMiniDialogPrivate *priv = g_new0(PidginMiniDialogPrivate, 1); self->priv = priv; gtk_container_set_border_width(GTK_CONTAINER(self), PIDGIN_HIG_BOX_SPACE); priv->title_box = GTK_BOX(gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE)); priv->icon = GTK_IMAGE(gtk_image_new()); gtk_misc_set_alignment(GTK_MISC(priv->icon), 0, 0); priv->title = GTK_LABEL(gtk_label_new(NULL)); gtk_widget_set_size_request(GTK_WIDGET(priv->title), label_width, -1); gtk_label_set_line_wrap(priv->title, TRUE); gtk_label_set_selectable(priv->title, TRUE); gtk_misc_set_alignment(GTK_MISC(priv->title), 0, 0); gtk_box_pack_start(priv->title_box, GTK_WIDGET(priv->icon), FALSE, FALSE, 0); gtk_box_pack_start(priv->title_box, GTK_WIDGET(priv->title), TRUE, TRUE, 0); priv->desc = GTK_LABEL(gtk_label_new(NULL)); gtk_widget_set_size_request(GTK_WIDGET(priv->desc), label_width, -1); gtk_label_set_line_wrap(priv->desc, TRUE); gtk_misc_set_alignment(GTK_MISC(priv->desc), 0, 0); gtk_label_set_selectable(priv->desc, TRUE); /* make calling show_all() on the minidialog not affect desc even though * it's packed inside it. */ g_object_set(G_OBJECT(priv->desc), "no-show-all", TRUE, NULL); purple_prefs_connect_callback(self, BLIST_WIDTH_PREF, blist_width_changed_cb, self); self->contents = GTK_BOX(gtk_vbox_new(FALSE, 0)); priv->buttons = GTK_BOX(gtk_hbox_new(FALSE, 0)); gtk_box_pack_start(self_box, GTK_WIDGET(priv->title_box), FALSE, FALSE, 0); gtk_box_pack_start(self_box, GTK_WIDGET(priv->desc), FALSE, FALSE, 0); gtk_box_pack_start(self_box, GTK_WIDGET(self->contents), TRUE, TRUE, 0); gtk_box_pack_start(self_box, GTK_WIDGET(priv->buttons), FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(self)); }
GtkWidget *ap_prefs_dropdown_from_list (struct widget *w, GtkWidget *page, const gchar *title, PurplePrefType type, const char *key, GList *menuitems) { GtkWidget *result; const gchar *pref; pref = get_const_pref (w, key); result = pidgin_prefs_dropdown_from_list ( page, title, type, pref, menuitems); purple_prefs_connect_callback (ap_get_plugin_handle (), pref, pref_callback, w); return result; }
static gboolean plugin_load(PurplePlugin *plugin) { handle = plugin; /* blist docking init */ if(purple_get_blist() && PIDGIN_BLIST(purple_get_blist()) && PIDGIN_BLIST(purple_get_blist())->window) { blist_create_cb(purple_get_blist(), NULL); } /* This really shouldn't happen anymore generally, but if for some strange reason, the blist is recreated, we need to set it up again. */ purple_signal_connect(pidgin_blist_get_handle(), "gtkblist-created", plugin, PURPLE_CALLBACK(blist_create_cb), NULL); purple_signal_connect((void*)purple_get_core(), "quitting", plugin, PURPLE_CALLBACK(purple_quit_cb), NULL); purple_prefs_connect_callback(handle, PREF_BLIST_ON_TOP, winprefs_set_blist_ontop, NULL); purple_prefs_connect_callback(handle, PREF_DBLIST_DOCKABLE, winprefs_set_blist_dockable, NULL); return TRUE; }
/** * The plugin's load function * * @param[in] plugin Pointer to the plugin * @return Whether to continue loading **/ static gboolean plugin_load(PurplePlugin *plugin) { PidginBuddyList * gtkblist; /*< For determining if blist was initialized */ void *conv_handle; /*< The conversations handle */ void *gtkblist_handle; /*< The Pidgin Buddy List handle */ void *gtkconv_handle; /*< The Pidgin conversations handle */ /* XXX: There should be an interface to list available Buddy List * windows. */ gtkblist = pidgin_blist_get_default_gtk_blist(); conv_handle = purple_conversations_get_handle(); gtkblist_handle = pidgin_blist_get_handle(); gtkconv_handle = pidgin_conversations_get_handle(); /* Add the conversation placement option provided by this plugin. */ pidgin_conv_placement_add_fnc(PLUGIN_TOKEN, _(PWM_STR_CP_BLIST), &conv_placement_by_blist); purple_prefs_trigger_callback(PIDGIN_PREFS_ROOT "/conversations/placement"); /* Rebuild the layout when the preference changes. */ purple_prefs_connect_callback(plugin, PREF_SIDE, pref_convs_side_cb, NULL); /* Toggle the instruction panel as conversations come and go. */ purple_signal_connect(conv_handle, "conversation-created", plugin, PURPLE_CALLBACK(conversation_created_cb), NULL); purple_signal_connect(conv_handle, "deleting-conversation", plugin, PURPLE_CALLBACK(deleting_conversation_cb), NULL); purple_signal_connect(gtkconv_handle, "conversation-dragging", plugin, PURPLE_CALLBACK(conversation_dragging_cb), NULL); purple_signal_connect(gtkconv_handle, "conversation-hiding", plugin, PURPLE_CALLBACK(conversation_hiding_cb), NULL); purple_signal_connect(gtkconv_handle, "conversation-switched", plugin, PURPLE_CALLBACK(conversation_switched_cb), NULL); /* Hijack Buddy Lists as they are created. */ purple_signal_connect(gtkblist_handle, "gtkblist-created", plugin, PURPLE_CALLBACK(gtkblist_created_cb), NULL); /* If a default Buddy List is already available, use it immediately. */ if (gtkblist != NULL && gtkblist->window != NULL) pwm_merge_conversation(gtkblist); return TRUE; }
static gboolean plugin_load (PurplePlugin * plugin) { trace("plugin loading"); recent_contacts_plugin = plugin; /* assign this here so we have a valid handle later */ g_size = purple_prefs_get_int(PREF_SIZE); void *handle = purple_prefs_get_handle(); purple_prefs_connect_callback(handle, PREF_SIZE, pref_size_on_change, NULL); void *conv_handle = purple_conversations_get_handle(); purple_signal_connect(conv_handle, "conversation-created", plugin, PURPLE_CALLBACK(rc_at_conversation_event), NULL); purple_signal_connect(conv_handle, "deleting-conversation", plugin, PURPLE_CALLBACK(rc_at_conversation_event), NULL); return TRUE; }
static gboolean plugin_load (PurplePlugin *plugin) { void *conv_handle, *blist_handle, *conn_handle; construct_list(); if (!notify_is_initted () && !notify_init ("Pidgin")) { purple_debug_error (PLUGIN_ID, "libnotify not running!\n"); return FALSE; } conv_handle = purple_conversations_get_handle (); blist_handle = purple_blist_get_handle (); conn_handle = purple_connections_get_handle(); buddy_hash = g_hash_table_new (NULL, NULL); purple_signal_connect (blist_handle, "buddy-signed-on", plugin, PURPLE_CALLBACK(notify_buddy_signon_cb), NULL); purple_signal_connect (blist_handle, "buddy-signed-off", plugin, PURPLE_CALLBACK(notify_buddy_signoff_cb), NULL); purple_signal_connect (conv_handle, "received-im-msg", plugin, PURPLE_CALLBACK(notify_new_message_cb), NULL); purple_signal_connect (conv_handle, "received-chat-msg", plugin, PURPLE_CALLBACK(notify_chat_nick), NULL); purple_signal_connect (conv_handle, "deleting-conversation", plugin, PURPLE_CALLBACK(notify_deleting_conversation_cb), NULL); purple_prefs_connect_callback(plugin, "/plugins/gtk/libnotify/triggerMessages", (PurplePrefCallback)construct_list, NULL); /* used just to not display the flood of guifications we'd get */ purple_signal_connect (conn_handle, "signed-on", plugin, PURPLE_CALLBACK(event_connection_throttle), NULL); return TRUE; }
/* Initialize the plugin preferences. * Create the root preference directory if needed. * If the aliases preference exists, load it; * otherwise, initialize it from the default aliases value. * Then call the aliases_changed_cb function to build the aliases_list. */ static void init_prefs(PurplePlugin *plugin) { const char *aliases ; /* If the root preference directory does not exist, create it */ if (!purple_prefs_exists(PREFS_ROOT)) { purple_prefs_add_none(PREFS_ROOT) ; } /* If the alias preference exists, load it, otherwise create it from the default value */ if (purple_prefs_exists(PREFS_ALIASES)) { aliases = purple_prefs_get_string(PREFS_ALIASES) ; } else { purple_prefs_add_string(PREFS_ALIASES, DEFAULT_ALIASES) ; aliases = DEFAULT_ALIASES ; } /* initialize the alias list from the alias value loaded (or created) */ aliases_changed_cb(PREFS_ALIASES, PURPLE_PREF_STRING, aliases, NULL) ; /* connect aliases_changed_cb to be called whenever the preference * changes */ purple_prefs_connect_callback(plugin, PREFS_ALIASES, (PurplePrefCallback)(&aliases_changed_cb), NULL) ; /* Done, nothing to return */ return ; }
static void get_plugin_frame(GtkWidget *parent, GtkSizeGroup *sg, const gchar *name, const gchar *plugin_label, const gchar **plugin_strs, const gchar *plugin_pref, const gchar *device_label, const gchar *device_pref) { GtkWidget *vbox, *widget; GList *plugins, *devices; vbox = pidgin_make_frame(parent, name); /* Setup plugin preference */ plugins = get_element_plugins(plugin_strs); widget = pidgin_prefs_dropdown_from_list(vbox, plugin_label, PURPLE_PREF_STRING, plugin_pref, plugins); g_list_free(plugins); gtk_size_group_add_widget(sg, widget); gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5); /* Setup device preference */ devices = get_element_devices(purple_prefs_get_string(plugin_pref)); if (g_list_find_custom(devices, purple_prefs_get_string(device_pref), (GCompareFunc) strcmp) == NULL) purple_prefs_set_string(device_pref, g_list_next(devices)->data); widget = pidgin_prefs_dropdown_from_list(vbox, device_label, PURPLE_PREF_STRING, device_pref, devices); g_list_free(devices); gtk_widget_set_name(widget, plugin_pref); gtk_size_group_add_widget(sg, widget); gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5); purple_prefs_connect_callback(vbox, plugin_pref, device_changed_cb, sg); g_signal_connect_swapped(vbox, "destroy", G_CALLBACK(purple_prefs_disconnect_by_handle), vbox); }
/*--------------------------------------------------------------------------* * Create the main window * *--------------------------------------------------------------------------*/ static void create_dialog () { GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkWidget *message_list_view; GtkWidget *vbox, *vpane, *hbox, *config_vbox; GtkWidget *sw, *imhtml, *msg_window, *button; imhtml = gtk_imhtml_new (NULL, NULL); /* Create main display window */ dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint (GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_title (GTK_WINDOW(dialog), _("AutoProfile Summary")); gtk_widget_realize (dialog); vbox = gtk_vbox_new (FALSE, 5); gtk_container_add (GTK_CONTAINER (dialog), vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); /* Set up progress bar container */ progress_create (AP_UPDATE_PROFILE, vbox); progress_create (AP_UPDATE_STATUS, vbox); /* Set up list of past away messages */ vpane = gtk_vpaned_new (); gtk_box_pack_start (GTK_BOX(vbox), vpane, TRUE, TRUE, 0); message_list = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); message_list_view = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (message_list)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ( _("Time"), renderer, "markup", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (message_list_view), column); gtk_tree_view_column_set_sort_column_id (column, 0); column = gtk_tree_view_column_new_with_attributes ( _("Type"), renderer, "markup", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (message_list_view), column); gtk_tree_view_column_set_sort_column_id (column, 1); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes ( _("Text"), renderer, "markup", 2, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (message_list_view), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); 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_container_add (GTK_CONTAINER (sw), message_list_view); gtk_paned_add1 (GTK_PANED(vpane), sw); selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (message_list_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (display_diff_msg), imhtml); /* Set up the window to display away message in */ msg_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(msg_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(msg_window), GTK_SHADOW_IN); gtk_paned_add2 (GTK_PANED(vpane), msg_window); gtk_container_add (GTK_CONTAINER(msg_window), imhtml); pidgin_setup_imhtml (imhtml); /* Bottom area */ hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0); config_vbox = gtk_vbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX(hbox), config_vbox, TRUE, TRUE, 0); pidgin_prefs_checkbox ( _("Queue new messages while away"), "/plugins/gtk/autoprofile/queue_messages_when_away", config_vbox); button = pidgin_prefs_checkbox ( _("Play sounds while away"), "/purple/sound/while_away", config_vbox); sound_pref_cb = purple_prefs_connect_callback (ap_get_plugin_handle (), "/purple/sound/while_away", sound_cb, button); gtk_box_pack_start (GTK_BOX(hbox), gtk_vseparator_new (), FALSE, FALSE, 0); config_vbox = gtk_vbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX(hbox), config_vbox, TRUE, TRUE, 0); ap_gtk_prefs_add_summary_option (config_vbox); button = gtk_button_new_with_label (_("Hide summary now")); gtk_box_pack_start (GTK_BOX(config_vbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hide_cb), NULL); /* Finish up */ g_signal_connect (G_OBJECT(dialog), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); gtk_paned_set_position (GTK_PANED(vpane), 250); gtk_window_set_default_size (GTK_WINDOW(dialog), 430, 430); }
static void finch_sound_init(void) { void *gnt_sound_handle = finch_sound_get_handle(); void *blist_handle = purple_blist_get_handle(); void *conv_handle = purple_conversations_get_handle(); #ifdef USE_GSTREAMER GError *error = NULL; #endif purple_signal_connect(purple_connections_get_handle(), "signed-on", gnt_sound_handle, PURPLE_CALLBACK(account_signon_cb), NULL); purple_prefs_add_none(FINCH_PREFS_ROOT "/sound"); purple_prefs_add_string(FINCH_PREFS_ROOT "/sound/actprofile", DEFAULT_PROFILE); purple_prefs_add_none(FINCH_PREFS_ROOT "/sound/profiles"); purple_prefs_connect_callback(gnt_sound_handle, FINCH_PREFS_ROOT "/sound/actprofile", initialize_profile, NULL); purple_prefs_trigger_callback(FINCH_PREFS_ROOT "/sound/actprofile"); #ifdef USE_GSTREAMER purple_debug_info("sound", "Initializing sound output drivers.\n"); #if (GST_VERSION_MAJOR > 0 || \ (GST_VERSION_MAJOR == 0 && GST_VERSION_MINOR > 10) || \ (GST_VERSION_MAJOR == 0 && GST_VERSION_MINOR == 10 && GST_VERSION_MICRO >= 10)) gst_registry_fork_set_enabled(FALSE); #endif if ((gst_init_failed = !gst_init_check(NULL, NULL, &error))) { purple_notify_error(NULL, _("GStreamer Failure"), _("GStreamer failed to initialize."), error ? error->message : ""); if (error) { g_error_free(error); error = NULL; } } #endif /* USE_GSTREAMER */ purple_signal_connect(blist_handle, "buddy-signed-on", gnt_sound_handle, PURPLE_CALLBACK(buddy_state_cb), GINT_TO_POINTER(PURPLE_SOUND_BUDDY_ARRIVE)); purple_signal_connect(blist_handle, "buddy-signed-off", gnt_sound_handle, PURPLE_CALLBACK(buddy_state_cb), GINT_TO_POINTER(PURPLE_SOUND_BUDDY_LEAVE)); purple_signal_connect(conv_handle, "received-im-msg", gnt_sound_handle, PURPLE_CALLBACK(im_msg_received_cb), GINT_TO_POINTER(PURPLE_SOUND_RECEIVE)); purple_signal_connect(conv_handle, "sent-im-msg", gnt_sound_handle, PURPLE_CALLBACK(im_msg_sent_cb), GINT_TO_POINTER(PURPLE_SOUND_SEND)); purple_signal_connect(conv_handle, "chat-buddy-joined", gnt_sound_handle, PURPLE_CALLBACK(chat_buddy_join_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_JOIN)); purple_signal_connect(conv_handle, "chat-buddy-left", gnt_sound_handle, PURPLE_CALLBACK(chat_buddy_left_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_LEAVE)); purple_signal_connect(conv_handle, "sent-chat-msg", gnt_sound_handle, PURPLE_CALLBACK(chat_msg_sent_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_YOU_SAY)); purple_signal_connect(conv_handle, "received-chat-msg", gnt_sound_handle, PURPLE_CALLBACK(chat_msg_received_cb), GINT_TO_POINTER(PURPLE_SOUND_CHAT_SAY)); purple_signal_connect(conv_handle, "got-attention", gnt_sound_handle, PURPLE_CALLBACK(got_attention_cb), GINT_TO_POINTER(PURPLE_SOUND_GOT_ATTENTION)); update_profiles(); }