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
empathy_chat_text_view_init (EmpathyChatTextView *view)
{
EmpathyChatTextViewPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
EMPATHY_TYPE_CHAT_TEXT_VIEW, EmpathyChatTextViewPriv);
view->priv = priv;
priv->buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
priv->last_timestamp = 0;
priv->allow_scrolling = TRUE;
priv->smiley_manager = empathy_smiley_manager_dup_singleton ();
g_object_set (view,
"wrap-mode", GTK_WRAP_WORD_CHAR,
"editable", FALSE,
"cursor-visible", FALSE,
NULL);
priv->notify_system_fonts_id =
empathy_conf_notify_add (empathy_conf_get (),
"/desktop/gnome/interface/document_font_name",
chat_text_view_notify_system_font_cb,
view);
chat_text_view_system_font_update (view);
chat_text_view_create_tags (view);
g_signal_connect (view,
"populate-popup",
G_CALLBACK (chat_text_view_populate_popup),
NULL);
}
static void
preferences_hookup_string_combo (EmpathyPreferences *preferences,
const gchar *key,
GtkWidget *widget)
{
guint id;
preferences_widget_sync_string_combo (key, widget);
g_object_set_data_full (G_OBJECT (widget), "key",
g_strdup (key), g_free);
g_signal_connect (widget,
"changed",
G_CALLBACK (preferences_string_combo_changed_cb),
NULL);
id = empathy_conf_notify_add (empathy_conf_get (),
key,
preferences_notify_string_combo_cb,
widget);
if (id) {
preferences_add_id (preferences, id);
}
}
static void
preferences_hookup_radio_button (EmpathyPreferences *preferences,
const gchar *key,
GtkWidget *widget)
{
GSList *group, *l;
guint id;
preferences_widget_sync_string (key, widget);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
for (l = group; l; l = l->next) {
g_signal_connect (l->data,
"toggled",
G_CALLBACK (preferences_radio_button_toggled_cb),
NULL);
g_object_set_data_full (G_OBJECT (l->data), "key",
g_strdup (key), g_free);
}
id = empathy_conf_notify_add (empathy_conf_get (),
key,
preferences_notify_string_cb,
widget);
if (id) {
preferences_add_id (preferences, id);
}
}
static void
preferences_setup_widgets (EmpathyPreferences *preferences)
{
guint id;
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_SOUNDS_ENABLED,
preferences->checkbutton_sounds_enabled);
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_SOUNDS_DISABLED_AWAY,
preferences->checkbutton_sounds_disabled_away);
preferences_hookup_sensitivity (preferences,
EMPATHY_PREFS_SOUNDS_ENABLED,
preferences->checkbutton_sounds_disabled_away);
preferences_hookup_sensitivity (preferences,
EMPATHY_PREFS_SOUNDS_ENABLED,
preferences->treeview_sounds);
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_UI_SEPARATE_CHAT_WINDOWS,
preferences->checkbutton_separate_chat_windows);
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_UI_SHOW_AVATARS,
preferences->checkbutton_show_avatars);
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
preferences->checkbutton_compact_contact_list);
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_CHAT_SHOW_SMILEYS,
preferences->checkbutton_show_smileys);
preferences_hookup_string_combo (preferences,
EMPATHY_PREFS_CHAT_THEME,
preferences->combobox_chat_theme);
preferences_hookup_radio_button (preferences,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
preferences->radiobutton_contact_list_sort_by_name);
preferences_hookup_toggle_button (preferences,
EMPATHY_PREFS_AUTOCONNECT,
preferences->checkbutton_autoconnect);
id = empathy_conf_notify_add (empathy_conf_get (),
EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
preferences_compact_contact_list_changed_cb,
preferences);
if (id) {
preferences_add_id (preferences, id);
}
preferences_compact_contact_list_changed_cb (empathy_conf_get (),
EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
preferences);
}
static void
spell_setup_languages (void)
{
gchar *str;
if (!empathy_conf_notify_inited) {
empathy_conf_notify_add (empathy_conf_get (),
EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
spell_notify_languages_cb, NULL);
empathy_conf_notify_inited = TRUE;
}
if (languages) {
return;
}
if (empathy_conf_get_string (empathy_conf_get (),
EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
&str) && str) {
gchar **strv;
gint i;
strv = g_strsplit (str, ",", -1);
i = 0;
while (strv && strv[i]) {
SpellLanguage *lang;
DEBUG ("Setting up language:'%s'", strv[i]);
lang = g_slice_new0 (SpellLanguage);
lang->config = enchant_broker_init ();
lang->speller = enchant_broker_request_dict (lang->config, strv[i]);
languages = g_list_append (languages, lang);
i++;
}
if (strv) {
g_strfreev (strv);
}
g_free (str);
}
}
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 = tp_account_manager_dup ();
priv->event_manager = empathy_event_manager_dup_singleton ();
tp_account_manager_prepare_async (priv->account_manager, NULL,
account_manager_prepared_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);
status_icon_create_menu (icon);
g_signal_connect_swapped (priv->account_manager,
"most-available-presence-changed",
G_CALLBACK (status_icon_presence_changed_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);
priv->notification = NULL;
priv->notify_mgr = empathy_notify_manager_dup_singleton ();
}
static void
preferences_hookup_sensitivity (EmpathyPreferences *preferences,
const gchar *key,
GtkWidget *widget)
{
gboolean value;
guint id;
if (empathy_conf_get_bool (empathy_conf_get (), key, &value)) {
gtk_widget_set_sensitive (widget, value);
}
id = empathy_conf_notify_add (empathy_conf_get (),
key,
preferences_notify_sensitivity_cb,
widget);
if (id) {
preferences_add_id (preferences, id);
}
}
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;
}
GtkWidget *
empathy_main_window_show (void)
{
EmpathyMainWindow *window;
EmpathyContactList *list_iface;
EmpathyContactMonitor *monitor;
GtkBuilder *gui;
EmpathyConf *conf;
GtkWidget *sw;
GtkToggleAction *show_offline_widget;
GtkWidget *ebox;
GtkAction *show_map_widget;
GtkToolItem *item;
gboolean show_offline;
gchar *filename;
GSList *l;
if (main_window) {
empathy_window_present (GTK_WINDOW (main_window->window));
return main_window->window;
}
main_window = g_new0 (EmpathyMainWindow, 1);
window = main_window;
/* Set up interface */
filename = empathy_file_lookup ("empathy-main-window.ui", "src");
gui = empathy_builder_get_file (filename,
"main_window", &window->window,
"main_vbox", &window->main_vbox,
"errors_vbox", &window->errors_vbox,
"ui_manager", &window->ui_manager,
"view_show_offline", &show_offline_widget,
"view_show_protocols", &window->show_protocols,
"view_sort_by_name", &window->sort_by_name,
"view_sort_by_status", &window->sort_by_status,
"view_normal_size_with_avatars", &window->normal_with_avatars,
"view_normal_size", &window->normal_size,
"view_compact_size", &window->compact_size,
"view_history", &window->view_history,
"view_show_map", &show_map_widget,
"room_join_favorites", &window->room_join_favorites,
"presence_toolbar", &window->presence_toolbar,
"roster_scrolledwindow", &sw,
NULL);
g_free (filename);
empathy_builder_connect (gui, window,
"main_window", "destroy", main_window_destroy_cb,
"main_window", "key-press-event", main_window_key_press_event_cb,
"chat_quit", "activate", main_window_chat_quit_cb,
"chat_new_message", "activate", main_window_chat_new_message_cb,
"chat_new_call", "activate", main_window_chat_new_call_cb,
"view_history", "activate", main_window_view_history_cb,
"room_join_new", "activate", main_window_room_join_new_cb,
"room_join_favorites", "activate", main_window_room_join_favorites_cb,
"room_manage_favorites", "activate", main_window_room_manage_favorites_cb,
"chat_add_contact", "activate", main_window_chat_add_contact_cb,
"view_show_ft_manager", "activate", main_window_view_show_ft_manager,
"view_show_offline", "toggled", main_window_view_show_offline_cb,
"view_show_protocols", "toggled", main_window_view_show_protocols_cb,
"view_sort_by_name", "changed", main_window_view_sort_contacts_cb,
"view_normal_size_with_avatars", "changed", main_window_view_contacts_list_size_cb,
"view_show_map", "activate", main_window_view_show_map_cb,
"edit", "activate", main_window_edit_cb,
"edit_accounts", "activate", main_window_edit_accounts_cb,
"edit_personal_information", "activate", main_window_edit_personal_information_cb,
"edit_preferences", "activate", main_window_edit_preferences_cb,
"help_about", "activate", main_window_help_about_cb,
"help_debug", "activate", main_window_help_debug_cb,
"help_contents", "activate", main_window_help_contents_cb,
NULL);
/* Set up connection related widgets. */
main_window_connection_items_setup (window, gui);
g_object_ref (window->ui_manager);
g_object_unref (gui);
#if !HAVE_LIBCHAMPLAIN
gtk_action_set_visible (show_map_widget, FALSE);
#endif
window->account_manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (window->account_manager, NULL,
account_manager_prepared_cb, window);
window->errors = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
g_object_unref,
NULL);
window->status_changed_handlers = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
NULL);
/* Set up menu */
main_window_favorite_chatroom_menu_setup (window);
window->edit_context = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/edit/edit_context");
window->edit_context_separator = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/edit/edit_context_separator");
gtk_widget_hide (window->edit_context);
gtk_widget_hide (window->edit_context_separator);
/* Set up contact list. */
empathy_status_presets_get_all ();
/* Set up presence chooser */
window->presence_chooser = empathy_presence_chooser_new ();
gtk_widget_show (window->presence_chooser);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), window->presence_chooser);
gtk_tool_item_set_is_important (item, TRUE);
gtk_tool_item_set_expand (item, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1);
/* Set up the throbber */
ebox = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), FALSE);
gtk_widget_set_tooltip_text (ebox, _("Show and edit accounts"));
g_signal_connect (ebox,
"button-press-event",
G_CALLBACK (main_window_throbber_button_press_event_cb),
window);
gtk_widget_show (ebox);
window->throbber = ephy_spinner_new ();
ephy_spinner_set_size (EPHY_SPINNER (window->throbber), GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (ebox), window->throbber);
gtk_widget_show (window->throbber);
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), ebox);
gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1);
gtk_widget_show (GTK_WIDGET (item));
list_iface = EMPATHY_CONTACT_LIST (empathy_contact_manager_dup_singleton ());
monitor = empathy_contact_list_get_monitor (list_iface);
window->list_store = empathy_contact_list_store_new (list_iface);
window->list_view = empathy_contact_list_view_new (window->list_store,
EMPATHY_CONTACT_LIST_FEATURE_ALL,
EMPATHY_CONTACT_FEATURE_ALL);
g_signal_connect (monitor, "contact-presence-changed",
G_CALLBACK (main_window_contact_presence_changed_cb), window);
window->butterfly_log_migration_contact_added_id = g_signal_connect (monitor, "contact-added",
G_CALLBACK (main_window_contact_added_cb), window);
g_object_unref (list_iface);
gtk_widget_show (GTK_WIDGET (window->list_view));
gtk_container_add (GTK_CONTAINER (sw),
GTK_WIDGET (window->list_view));
g_signal_connect (window->list_view, "row-activated",
G_CALLBACK (main_window_row_activated_cb),
window);
/* Load user-defined accelerators. */
main_window_accels_load ();
/* Set window size. */
empathy_geometry_bind (GTK_WINDOW (window->window), GEOMETRY_NAME);
/* Enable event handling */
window->event_manager = empathy_event_manager_dup_singleton ();
g_signal_connect (window->event_manager, "event-added",
G_CALLBACK (main_window_event_added_cb),
window);
g_signal_connect (window->event_manager, "event-removed",
G_CALLBACK (main_window_event_removed_cb),
window);
g_signal_connect (window->account_manager, "account-validity-changed",
G_CALLBACK (main_window_account_validity_changed_cb),
window);
g_signal_connect (window->account_manager, "account-removed",
G_CALLBACK (main_window_account_removed_cb),
window);
g_signal_connect (window->account_manager, "account-disabled",
G_CALLBACK (main_window_account_disabled_cb),
window);
l = empathy_event_manager_get_events (window->event_manager);
while (l) {
main_window_event_added_cb (window->event_manager,
l->data, window);
l = l->next;
}
conf = empathy_conf_get ();
/* Show offline ? */
empathy_conf_get_bool (conf,
EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE,
&show_offline);
empathy_conf_notify_add (conf,
EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE,
main_window_notify_show_offline_cb,
show_offline_widget);
gtk_toggle_action_set_active (show_offline_widget, show_offline);
/* Show protocol ? */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_SHOW_PROTOCOLS,
(EmpathyConfNotifyFunc) main_window_notify_show_protocols_cb,
window);
main_window_notify_show_protocols_cb (conf,
EMPATHY_PREFS_UI_SHOW_PROTOCOLS,
window);
/* Sort by name / by status ? */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
(EmpathyConfNotifyFunc) main_window_notify_sort_contact_cb,
window);
main_window_notify_sort_contact_cb (conf,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
window);
/* Contacts list size */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
(EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb,
window);
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_SHOW_AVATARS,
(EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb,
window);
main_window_notify_contact_list_size_cb (conf,
EMPATHY_PREFS_UI_SHOW_AVATARS,
window);
return window->window;
}
int
main (int argc, char *argv[])
{
guint32 startup_timestamp;
EmpathyStatusIcon *icon;
EmpathyDispatcher *dispatcher;
GtkWidget *window;
MissionControl *mc;
EmpathyIdle *idle;
gboolean autoconnect = TRUE;
gboolean no_connect = FALSE;
gboolean hide_contact_list = 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 },
{ NULL }
};
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
startup_timestamp = get_startup_timestamp ();
if (!gtk_init_with_args (&argc, &argv,
_("- Empathy Instant Messenger"),
options, GETTEXT_PACKAGE, &error)) {
g_warning ("Error in gtk init: %s", error->message);
return EXIT_FAILURE;
}
if (g_getenv ("EMPATHY_TIMING") != NULL) {
g_log_set_default_handler (tp_debug_timestamped_log_handler, NULL);
}
empathy_debug_set_flags (g_getenv ("EMPATHY_DEBUG"));
tp_debug_divert_messages (g_getenv ("EMPATHY_LOGFILE"));
g_set_application_name (PACKAGE_NAME);
gtk_window_set_default_icon_name ("empathy");
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
PKGDATADIR G_DIR_SEPARATOR_S "icons");
/* Setting up the bacon connection */
connection = bacon_message_connection_new ("empathy");
if (connection != NULL) {
if (!bacon_message_connection_get_is_server (connection)) {
gchar *message;
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_new ();
g_signal_connect (mc, "ServiceEnded",
G_CALLBACK (service_ended_cb),
NULL);
g_signal_connect (mc, "Error",
G_CALLBACK (operation_error_cb),
NULL);
/* Setting up Idle */
idle = empathy_idle_new ();
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_new ();
g_signal_connect (dispatcher, "dispatch-channel",
G_CALLBACK (dispatch_channel_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);
return EXIT_SUCCESS;
}
