static void empathy_presence_chooser_init (EmpathyPresenceChooser *chooser) { GtkWidget *arrow; GtkWidget *alignment; EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser, EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv); chooser->priv = priv; gtk_button_set_relief (GTK_BUTTON (chooser), GTK_RELIEF_NONE); gtk_button_set_focus_on_click (GTK_BUTTON (chooser), FALSE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (chooser), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 1, 0); priv->hbox = gtk_hbox_new (FALSE, 1); gtk_widget_show (priv->hbox); gtk_container_add (GTK_CONTAINER (alignment), priv->hbox); priv->image = gtk_image_new (); gtk_widget_show (priv->image); gtk_box_pack_start (GTK_BOX (priv->hbox), priv->image, FALSE, TRUE, 0); priv->label = gtk_label_new (NULL); gtk_widget_show (priv->label); gtk_box_pack_start (GTK_BOX (priv->hbox), priv->label, TRUE, TRUE, 0); gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (priv->label), 0, 0.5); gtk_misc_set_padding (GTK_MISC (priv->label), 4, 1); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (priv->hbox), alignment, FALSE, FALSE, 0); arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT); gtk_widget_show (arrow); gtk_container_add (GTK_CONTAINER (alignment), arrow); g_signal_connect (chooser, "toggled", G_CALLBACK (presence_chooser_toggled_cb), NULL); g_signal_connect (chooser, "button-press-event", G_CALLBACK (presence_chooser_button_press_event_cb), NULL); g_signal_connect (chooser, "scroll-event", G_CALLBACK (presence_chooser_scroll_event_cb), NULL); priv->idle = empathy_idle_dup_singleton (); presence_chooser_presence_changed_cb (chooser); g_signal_connect_swapped (priv->idle, "notify", G_CALLBACK (presence_chooser_presence_changed_cb), chooser); }
static void presence_chooser_set_state (McPresence state, const gchar *status) { EmpathyIdle *idle; idle = empathy_idle_dup_singleton (); empathy_idle_set_presence (idle, state, status); g_object_unref (idle); }
static void account_manager_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; EmpathyIdle *idle; EmpathyConnectivity *connectivity; gboolean autoconnect = TRUE; if (!tp_account_manager_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } /* Autoconnect */ idle = empathy_idle_dup_singleton (); connectivity = empathy_connectivity_dup_singleton (); empathy_conf_get_bool (empathy_conf_get (), EMPATHY_PREFS_AUTOCONNECT, &autoconnect); if (autoconnect && !no_connect && tp_connection_presence_type_cmp_availability (empathy_idle_get_state (idle), TP_CONNECTION_PRESENCE_TYPE_OFFLINE) <= 0) /* if current state is Offline, then put it online */ empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE); if (should_create_salut_account (manager) || !empathy_import_mc4_has_imported ()) { EmpathyConnectionManagers *managers; managers = empathy_connection_managers_dup_singleton (); if (!check_connection_managers_ready (managers)) { g_signal_connect (managers, "notify::ready", G_CALLBACK (connection_managers_ready_cb), NULL); } } else if (!start_hidden) { maybe_show_account_assistant (); } g_object_unref (idle); g_object_unref (connectivity); }
static void empathy_status_icon_init (EmpathyStatusIcon *icon) { EmpathyStatusIconPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (icon, EMPATHY_TYPE_STATUS_ICON, EmpathyStatusIconPriv); icon->priv = priv; priv->icon = gtk_status_icon_new (); priv->account_manager = empathy_account_manager_dup_singleton (); priv->idle = empathy_idle_dup_singleton (); priv->event_manager = empathy_event_manager_dup_singleton (); g_signal_connect (priv->account_manager, "account-connection-changed", G_CALLBACK (status_icon_connection_changed_cb), icon); /* make icon listen and respond to MAIN_WINDOW_HIDDEN changes */ empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_UI_MAIN_WINDOW_HIDDEN, status_icon_notify_visibility_cb, icon); #ifdef HAVE_LIBINDICATE empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_UI_USE_LIBINDICATE, status_icon_notify_libindicate_cb, icon); #endif status_icon_create_menu (icon); status_icon_idle_notify_cb (icon); g_signal_connect_swapped (priv->idle, "notify", G_CALLBACK (status_icon_idle_notify_cb), icon); g_signal_connect (priv->event_manager, "event-added", G_CALLBACK (status_icon_event_added_cb), icon); g_signal_connect (priv->event_manager, "event-removed", G_CALLBACK (status_icon_event_removed_cb), icon); g_signal_connect (priv->event_manager, "event-updated", G_CALLBACK (status_icon_event_updated_cb), icon); g_signal_connect (priv->icon, "activate", G_CALLBACK (status_icon_activate_cb), icon); g_signal_connect (priv->icon, "popup-menu", G_CALLBACK (status_icon_popup_menu_cb), icon); }
static void main_window_contact_presence_changed_cb (EmpathyContactMonitor *monitor, EmpathyContact *contact, TpConnectionPresenceType current, TpConnectionPresenceType previous, EmpathyMainWindow *window) { TpAccount *account; gboolean should_play = FALSE; EmpathyIdle *idle; account = empathy_contact_get_account (contact); idle = empathy_idle_dup_singleton (); should_play = !empathy_idle_account_is_just_connected (idle, account); if (!should_play) goto out; if (tp_connection_presence_type_cmp_availability (previous, TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0) { /* contact was online */ if (tp_connection_presence_type_cmp_availability (current, TP_CONNECTION_PRESENCE_TYPE_OFFLINE) <= 0) /* someone is logging off */ empathy_sound_play (GTK_WIDGET (window->window), EMPATHY_SOUND_CONTACT_DISCONNECTED); } else { /* contact was offline */ if (tp_connection_presence_type_cmp_availability (current, TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0) /* someone is logging in */ empathy_sound_play (GTK_WIDGET (window->window), EMPATHY_SOUND_CONTACT_CONNECTED); } out: g_object_unref (idle); }
int main (int argc, char *argv[]) { guint32 startup_timestamp; EmpathyStatusIcon *icon; EmpathyDispatcher *dispatcher; EmpathyChatroomManager *chatroom_manager; EmpathyCallFactory *call_factory; GtkWidget *window; MissionControl *mc; EmpathyIdle *idle; gboolean autoconnect = TRUE; gboolean no_connect = FALSE; gboolean hide_contact_list = FALSE; gboolean accounts_dialog = FALSE; GError *error = NULL; GOptionEntry options[] = { { "no-connect", 'n', 0, G_OPTION_ARG_NONE, &no_connect, N_("Don't connect on startup"), NULL }, { "hide-contact-list", 'h', 0, G_OPTION_ARG_NONE, &hide_contact_list, N_("Don't show the contact list on startup"), NULL }, { "accounts", 'a', 0, G_OPTION_ARG_NONE, &accounts_dialog, N_("Show the accounts dialog"), NULL }, { "version", 'v', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb, NULL, NULL }, { NULL } }; /* Init */ g_thread_init (NULL); empathy_init (); if (!gtk_init_with_args (&argc, &argv, N_("- Empathy Instant Messenger"), options, GETTEXT_PACKAGE, &error)) { g_warning ("Error in empathy init: %s", error->message); return EXIT_FAILURE; } empathy_gtk_init (); g_set_application_name (_(PACKAGE_NAME)); gst_init (&argc, &argv); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); /* Setting up the bacon connection */ startup_timestamp = get_startup_timestamp (); connection = bacon_message_connection_new ("empathy"); if (connection != NULL) { if (!bacon_message_connection_get_is_server (connection)) { gchar *message; if (accounts_dialog) { DEBUG ("Showing accounts dialog from existing Empathy instance"); message = g_strdup ("accounts"); } else { DEBUG ("Activating existing instance"); message = g_strdup_printf ("%" G_GUINT32_FORMAT, startup_timestamp); } bacon_message_connection_send (connection, message); /* We never popup a window, so tell startup-notification * that we are done. */ gdk_notify_startup_complete (); g_free (message); bacon_message_connection_free (connection); return EXIT_SUCCESS; } } else { g_warning ("Cannot create the 'empathy' bacon connection."); } /* Setting up MC */ mc = empathy_mission_control_dup_singleton (); g_signal_connect (mc, "ServiceEnded", G_CALLBACK (service_ended_cb), NULL); g_signal_connect (mc, "Error", G_CALLBACK (operation_error_cb), NULL); if (accounts_dialog) { GtkWidget *dialog; dialog = empathy_accounts_dialog_show (NULL, NULL); g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_main (); return 0; } /* Setting up Idle */ idle = empathy_idle_dup_singleton (); empathy_idle_set_auto_away (idle, TRUE); use_nm_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_NM, idle); empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_NM, use_nm_notify_cb, idle); /* Autoconnect */ empathy_conf_get_bool (empathy_conf_get(), EMPATHY_PREFS_AUTOCONNECT, &autoconnect); if (autoconnect && ! no_connect && empathy_idle_get_state (idle) <= MC_PRESENCE_OFFLINE) { empathy_idle_set_state (idle, MC_PRESENCE_AVAILABLE); } create_salut_account (); /* Setting up UI */ window = empathy_main_window_show (); icon = empathy_status_icon_new (GTK_WINDOW (window), hide_contact_list); if (connection) { /* We se the callback here because we need window */ bacon_message_connection_set_callback (connection, on_bacon_message_received, window); } /* Handle channels */ dispatcher = empathy_dispatcher_dup_singleton (); g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL); chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL); empathy_chatroom_manager_observe (chatroom_manager, dispatcher); notify_init (_(PACKAGE_NAME)); /* Create the call factory */ call_factory = empathy_call_factory_initialise (); g_signal_connect (G_OBJECT (call_factory), "new-call-handler", G_CALLBACK (new_call_handler_cb), NULL); gtk_main (); empathy_idle_set_state (idle, MC_PRESENCE_OFFLINE); g_object_unref (mc); g_object_unref (idle); g_object_unref (icon); g_object_unref (dispatcher); g_object_unref (chatroom_manager); notify_uninit (); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { #if HAVE_GEOCLUE EmpathyLocationManager *location_manager = NULL; #endif EmpathyStatusIcon *icon; EmpathyDispatcher *dispatcher; TpAccountManager *account_manager; EmpathyLogManager *log_manager; EmpathyChatroomManager *chatroom_manager; EmpathyCallFactory *call_factory; EmpathyFTFactory *ft_factory; GtkWidget *window; EmpathyIdle *idle; EmpathyConnectivity *connectivity; GError *error = NULL; TpDBusDaemon *dbus_daemon; UniqueApp *unique_app; gboolean chatroom_manager_ready; GOptionContext *optcontext; GOptionEntry options[] = { { "no-connect", 'n', 0, G_OPTION_ARG_NONE, &no_connect, N_("Don't connect on startup"), NULL }, { "start-hidden", 'h', 0, G_OPTION_ARG_NONE, &start_hidden, N_("Don't display the contact list or any other dialogs on startup"), NULL }, { "accounts", 'a', 0, G_OPTION_ARG_NONE, &account_dialog_only, N_("Show the accounts dialog"), NULL }, { "version", 'v', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb, NULL, NULL }, { NULL } }; /* Init */ g_thread_init (NULL); empathy_init (); optcontext = g_option_context_new (N_("- Empathy IM Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command line options.\n", error->message, argv[0]); g_warning ("Error in empathy init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); empathy_gtk_init (); g_set_application_name (_(PACKAGE_NAME)); g_setenv ("PULSE_PROP_media.role", "phone", TRUE); #if HAVE_LIBCHAMPLAIN gtk_clutter_init (&argc, &argv); #endif gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); #ifdef ENABLE_DEBUG /* Set up debugger */ g_log_set_default_handler (default_log_handler, NULL); #endif unique_app = unique_app_new_with_commands ("org.gnome.Empathy", NULL, "accounts_dialog", COMMAND_ACCOUNTS_DIALOG, NULL); if (unique_app_is_running (unique_app)) { unique_app_send_message (unique_app, account_dialog_only ? COMMAND_ACCOUNTS_DIALOG : UNIQUE_ACTIVATE, NULL); g_object_unref (unique_app); return EXIT_SUCCESS; } /* Take well-known name */ dbus_daemon = tp_dbus_daemon_dup (&error); if (error == NULL) { if (!tp_dbus_daemon_request_name (dbus_daemon, "org.gnome.Empathy", TRUE, &error)) { DEBUG ("Failed to request well-known name: %s", error ? error->message : "no message"); g_clear_error (&error); } g_object_unref (dbus_daemon); } else { DEBUG ("Failed to dup dbus daemon: %s", error ? error->message : "no message"); g_clear_error (&error); } if (account_dialog_only) { account_manager = tp_account_manager_dup (); show_accounts_ui (NULL, TRUE); gtk_main (); g_object_unref (account_manager); return 0; } notify_init (_(PACKAGE_NAME)); /* Setting up Idle */ idle = empathy_idle_dup_singleton (); empathy_idle_set_auto_away (idle, TRUE); /* Setting up Connectivity */ connectivity = empathy_connectivity_dup_singleton (); use_conn_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_CONN, connectivity); empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_CONN, use_conn_notify_cb, connectivity); /* account management */ account_manager = tp_account_manager_dup (); tp_account_manager_prepare_async (account_manager, NULL, account_manager_ready_cb, NULL); /* Handle channels */ dispatcher = setup_dispatcher (); g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL); migrate_config_to_xdg_dir (); /* Setting up UI */ window = empathy_main_window_show (); icon = empathy_status_icon_new (GTK_WINDOW (window), start_hidden); g_signal_connect (unique_app, "message-received", G_CALLBACK (unique_app_message_cb), window); /* Logging */ log_manager = empathy_log_manager_dup_singleton (); empathy_log_manager_observe (log_manager, dispatcher); chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL); empathy_chatroom_manager_observe (chatroom_manager, dispatcher); g_object_get (chatroom_manager, "ready", &chatroom_manager_ready, NULL); if (!chatroom_manager_ready) { g_signal_connect (G_OBJECT (chatroom_manager), "notify::ready", G_CALLBACK (chatroom_manager_ready_cb), account_manager); } else { chatroom_manager_ready_cb (chatroom_manager, NULL, account_manager); } /* Create the call factory */ call_factory = empathy_call_factory_initialise (); g_signal_connect (G_OBJECT (call_factory), "new-call-handler", G_CALLBACK (new_call_handler_cb), NULL); /* Create the FT factory */ ft_factory = empathy_ft_factory_dup_singleton (); g_signal_connect (ft_factory, "new-ft-handler", G_CALLBACK (new_ft_handler_cb), NULL); g_signal_connect (ft_factory, "new-incoming-transfer", G_CALLBACK (new_incoming_transfer_cb), NULL); /* Location mananger */ #if HAVE_GEOCLUE location_manager = empathy_location_manager_dup_singleton (); #endif gtk_main (); empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_OFFLINE); g_object_unref (idle); g_object_unref (connectivity); g_object_unref (icon); g_object_unref (account_manager); g_object_unref (log_manager); g_object_unref (dispatcher); g_object_unref (chatroom_manager); #if HAVE_GEOCLUE g_object_unref (location_manager); #endif g_object_unref (ft_factory); g_object_unref (unique_app); notify_uninit (); return EXIT_SUCCESS; }
static void do_constructed (GObject *obj) { EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj); EmpathyAccountWidgetPriv *priv = GET_PRIV (self); TpAccount *account; const gchar *protocol, *cm_name; guint i = 0; struct { const gchar *cm_name; const gchar *protocol; const char *file; void (*func)(EmpathyAccountWidget *self, const gchar *filename); } widgets [] = { { "salut", "local-xmpp", "empathy-account-widget-local-xmpp.ui", account_widget_build_salut }, WIDGET (gabble, jabber), WIDGET (butterfly, msn), WIDGET (haze, icq), WIDGET (haze, aim), WIDGET (haze, yahoo), WIDGET (haze, groupwise), WIDGET (idle, irc), WIDGET (sofiasip, sip), }; cm_name = empathy_account_settings_get_cm (priv->settings); protocol = empathy_account_settings_get_protocol (priv->settings); for (i = 0 ; i < G_N_ELEMENTS (widgets); i++) { if (!tp_strdiff (widgets[i].cm_name, cm_name) && !tp_strdiff (widgets[i].protocol, protocol)) { gchar *filename; filename = empathy_file_lookup (widgets[i].file, "libempathy-gtk"); widgets[i].func (self, filename); g_free (filename); break; } } if (i == G_N_ELEMENTS (widgets)) { gchar *filename = empathy_file_lookup ( "empathy-account-widget-generic.ui", "libempathy-gtk"); account_widget_build_generic (self, filename); g_free (filename); } /* handle default focus */ if (self->ui_details->default_focus != NULL) { GObject *default_focus_entry; default_focus_entry = gtk_builder_get_object (self->ui_details->gui, self->ui_details->default_focus); g_signal_connect (default_focus_entry, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL); } /* handle forget button */ if (self->ui_details->add_forget) { const gchar *password = NULL; priv->button_forget = GTK_WIDGET (gtk_builder_get_object (self->ui_details->gui, "button_forget")); priv->entry_password = GTK_WIDGET (gtk_builder_get_object (self->ui_details->gui, "entry_password")); password = empathy_account_settings_get_string (priv->settings, "password"); gtk_widget_set_sensitive (priv->button_forget, !EMP_STR_EMPTY (password)); g_signal_connect (priv->button_forget, "clicked", G_CALLBACK (account_widget_forget_clicked_cb), self); g_signal_connect (priv->entry_password, "changed", G_CALLBACK (account_widget_password_changed_cb), self); } /* handle apply and cancel button */ if (!priv->simple) { GtkWidget *hbox = gtk_hbox_new (TRUE, 3); priv->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); if (priv->creating_account) { TpConnectionPresenceType state; priv->idle = empathy_idle_dup_singleton (); empathy_signal_connect_weak (priv->idle, "notify::state", G_CALLBACK (idle_state_change_cb), obj); state = empathy_idle_get_state (priv->idle); if (state > TP_CONNECTION_PRESENCE_TYPE_OFFLINE) { /* We are online, display a Login button */ GtkWidget *image; priv->apply_button = gtk_button_new_with_mnemonic (_("L_og in")); image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (priv->apply_button), image); } else { /* We are offline, display a Save button */ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_SAVE); } } else { /* We are editing an existing account, display an Apply button */ priv->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY); } gtk_box_pack_end (GTK_BOX (hbox), priv->apply_button, TRUE, TRUE, 3); gtk_box_pack_end (GTK_BOX (hbox), priv->cancel_button, TRUE, TRUE, 3); gtk_box_pack_end (GTK_BOX (self->ui_details->widget), hbox, FALSE, FALSE, 3); g_signal_connect (priv->cancel_button, "clicked", G_CALLBACK (account_widget_cancel_clicked_cb), self); g_signal_connect (priv->apply_button, "clicked", G_CALLBACK (account_widget_apply_clicked_cb), self); gtk_widget_show_all (hbox); if (priv->creating_account) /* When creating an account, the user might have nothing to enter. * That means that no control interaction might occur, * so we update the control button sensitivity manually. */ account_widget_handle_control_buttons_sensitivity (self); else account_widget_set_control_buttons_sensitivity (self, FALSE); } account = empathy_account_settings_get_account (priv->settings); if (account != NULL) { g_signal_connect (account, "notify::enabled", G_CALLBACK (empathy_account_widget_enabled_cb), self); } /* handle the "Enabled" checkbox. We only add it when modifying an account */ if (!priv->creating_account && priv->table_common_settings != NULL) { #ifdef HAVE_MOBLIN GtkWidget *w; #endif guint nb_rows, nb_columns; gboolean is_enabled; is_enabled = tp_account_is_enabled (account); #ifndef HAVE_MOBLIN priv->enabled_checkbox = gtk_check_button_new_with_label (_("Enabled")); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (priv->enabled_checkbox), is_enabled); #else /* Translators: this is used only when built on a moblin platform */ w = gtk_label_new (_("Account:")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); priv->enabled_checkbox = nbtk_gtk_light_switch_new (); nbtk_gtk_light_switch_set_active ( NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox), is_enabled); gtk_widget_show (w); #endif /* HAVE_MOBLIN */ g_object_get (priv->table_common_settings, "n-rows", &nb_rows, "n-columns", &nb_columns, NULL); gtk_table_resize (GTK_TABLE (priv->table_common_settings), ++nb_rows, nb_columns); #ifndef HAVE_MOBLIN gtk_table_attach (GTK_TABLE (priv->table_common_settings), priv->enabled_checkbox, 0, nb_columns, nb_rows - 1, nb_rows, GTK_EXPAND | GTK_FILL, 0, 0, 0); #else gtk_table_attach (GTK_TABLE (priv->table_common_settings), w, 0, 1, nb_rows - 1, nb_rows, GTK_FILL, 0, 0, 0); gtk_table_attach (GTK_TABLE (priv->table_common_settings), priv->enabled_checkbox, 1, nb_columns, nb_rows - 1, nb_rows, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif /* HAVE_MOBLIN */ gtk_widget_show (priv->enabled_checkbox); #ifndef HAVE_MOBLIN g_signal_connect (G_OBJECT (priv->enabled_checkbox), "released", G_CALLBACK (account_widget_enabled_released_cb), self); #else g_signal_connect (G_OBJECT (priv->enabled_checkbox), "switch-flipped", G_CALLBACK (account_widget_switch_flipped_cb), self); #endif /* HAVE_MOBLIN */ } /* hook up to widget destruction to unref ourselves */ g_signal_connect (self->ui_details->widget, "destroy", G_CALLBACK (account_widget_destroy_cb), self); empathy_builder_unref_and_keep_widget (self->ui_details->gui, self->ui_details->widget); self->ui_details->gui = NULL; }
static void empathy_presence_chooser_init (EmpathyPresenceChooser *chooser) { EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser, EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv); GtkWidget *entry; GtkCellRenderer *renderer; chooser->priv = priv; presence_chooser_create_model (chooser); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (chooser), COL_STATUS_TEXT); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser), combo_row_separator_func, NULL, NULL); entry = gtk_bin_get_child (GTK_BIN (chooser)); gtk_entry_set_icon_activatable (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, FALSE); g_signal_connect_swapped (entry, "icon-release", G_CALLBACK (presence_chooser_entry_icon_release_cb), chooser); g_signal_connect_swapped (entry, "activate", G_CALLBACK (presence_chooser_entry_activate_cb), chooser); g_signal_connect_swapped (entry, "key-press-event", G_CALLBACK (presence_chooser_entry_key_press_event_cb), chooser); g_signal_connect_swapped (entry, "button-press-event", G_CALLBACK (presence_chooser_entry_button_press_event_cb), chooser); gtk_cell_layout_clear (GTK_CELL_LAYOUT (chooser)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (chooser), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (chooser), renderer, "icon-name", COL_STATE_ICON_NAME, NULL); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_MENU, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (chooser), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (chooser), renderer, "markup", COL_DISPLAY_MARKUP, NULL); g_signal_connect (chooser, "notify::popup-shown", G_CALLBACK (presence_chooser_popup_shown_cb), NULL); g_signal_connect (chooser, "changed", G_CALLBACK (presence_chooser_changed_cb), NULL); g_signal_connect_swapped (entry, "changed", G_CALLBACK (presence_chooser_entry_changed_cb), chooser); g_signal_connect_swapped (entry, "focus-out-event", G_CALLBACK (presence_chooser_entry_focus_out_cb), chooser); priv->idle = empathy_idle_dup_singleton (); presence_chooser_presence_changed_cb (chooser); g_signal_connect_swapped (priv->idle, "notify", G_CALLBACK (presence_chooser_presence_changed_cb), chooser); /* FIXME: this string sucks */ gtk_widget_set_tooltip_text (GTK_WIDGET (chooser), _("Set your presence and current status")); }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; EmpathyChatManager *chat_mgr; EmpathyIdle *idle; gint retval; /* Init */ g_thread_init (NULL); optcontext = g_option_context_new (N_("- Empathy Chat Client")); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-av init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); empathy_gtk_init (); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); app = gtk_application_new (EMPATHY_CHAT_DBUS_NAME, G_APPLICATION_IS_SERVICE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif /* Setting up Idle */ idle = empathy_idle_dup_singleton (); chat_mgr = empathy_chat_manager_dup_singleton (); g_signal_connect (chat_mgr, "handled-chats-changed", G_CALLBACK (handled_chats_changed_cb), GUINT_TO_POINTER (1)); if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); DEBUG ("Waiting for text channels to handle"); retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (app); g_object_unref (idle); g_object_unref (chat_mgr); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }