int
main (int argc, char **argv)
{
gint lastentry = 0;
guint32 timestamp;
const gchar* startup_id = g_getenv ("DESKTOP_STARTUP_ID");
//printf ("startup id is %s\n", startup_id);
if (startup_id && (startup_id[0] != '\0'))
{
gchar **results = g_strsplit (startup_id, "_TIME", 0);
while (results[lastentry] != NULL)
lastentry++;
timestamp = (guint32) g_strtod (results[lastentry - 1], NULL);
g_strfreev (results);
}
else
timestamp = GDK_CURRENT_TIME;
gdk_init (&argc, &argv);
run_dialog (NULL, NULL, timestamp);
gdk_notify_startup_complete ();
return 0;
}
int main(int argc, char *argv[])
{
UniqueApp *app;
GtkWidget *window;
GtkWidget *notebook;
GError *error = NULL;
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
if (gtk_init_with_args(&argc, &argv, NULL,
options, GETTEXT_PACKAGE, &error) == FALSE) {
if (error) {
g_print("%s\n", error->message);
g_error_free(error);
} else
g_print("An unknown error occurred\n");
return 1;
}
if (option_dump != FALSE) {
dump_devices ();
return 0;
}
app = unique_app_new ("org.mate.Bluetooth.properties", NULL);
if (unique_app_is_running (app)) {
gdk_notify_startup_complete ();
unique_app_send_message (app, UNIQUE_ACTIVATE, NULL);
return 0;
}
g_set_application_name(_("Bluetooth Properties"));
gtk_window_set_default_icon_name("bluetooth");
bluetooth_plugin_manager_init ();
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
setup_adapter(GTK_NOTEBOOK(notebook));
window = create_window(notebook);
g_signal_connect (app, "message-received",
G_CALLBACK (message_received_cb), window);
gtk_main();
bluetooth_plugin_manager_cleanup ();
cleanup_adapter();
g_object_unref(app);
return 0;
}
int main(int argc, char *argv[])
{
if (set_reciteword_data_dir())
return 0;
bindtextdomain (GETTEXT_PACKAGE, HO22BUS_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_thread_init(NULL);
gtk_set_locale ();
gtk_init (&argc, &argv);
gint i;
gboolean onlyshowdict=FALSE;
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
{
/* is an option */
if (strcmp(argv[i], "-d") == 0)
{
onlyshowdict=TRUE;
}
}
}
g_pReciteWord = new CReciteWord;
Skin = new struct _Skin;
if (conf_load_user (onlyshowdict))
{
g_print("%s","load setting error!");
gdk_notify_startup_complete ();
delete Skin;
delete g_pReciteWord;
return 0;
}
if (onlyshowdict)
{
g_pReciteWord->dict_window = new CDict;
g_pReciteWord->dict_window->create();
}
else
{
g_pReciteWord->create ();
}
delete Skin;
delete g_pReciteWord;
return 0;
}
void
totem_options_process_early (Totem *totem, const TotemCmdLineOptions* options)
{
if (options->quit) {
/* If --quit is one of the commands, just quit */
gdk_notify_startup_complete ();
exit (0);
}
mateconf_client_set_bool (totem->gc, MATECONF_PREFIX"/debug",
options->debug, NULL);
}
static VALUE
rg_s_notify_startup_complete(int argc, VALUE *argv, VALUE self)
{
VALUE startup_id;
rb_scan_args(argc, argv, "01", &startup_id);
if (NIL_P(startup_id)) {
gdk_notify_startup_complete();
} else {
gdk_notify_startup_complete_with_id(RVAL2CSTR(startup_id));
}
return self;
}
static void
fr_application_activate (GApplication *application)
{
GList *link;
for (link = gtk_application_get_windows (GTK_APPLICATION (application));
link != NULL;
link = link->next)
{
if (! fr_window_is_batch_mode (FR_WINDOW (link->data)))
gtk_widget_show (GTK_WIDGET (link->data));
}
gdk_notify_startup_complete ();
}
static int
fr_application_command_line_finished (GApplication *application,
int status)
{
if (status == EXIT_SUCCESS)
gdk_notify_startup_complete ();
/* reset arguments */
remaining_args = NULL;
arg_add_to = NULL;
arg_add = FALSE;
arg_extract_to = NULL;
arg_extract = FALSE;
arg_extract_here = FALSE;
arg_default_dir = NULL;
arg_version = FALSE;
return status;
}
static VALUE
gdk_s_notify_startup_complete(int argc, VALUE *argv, VALUE self)
{
VALUE startup_id;
rb_scan_args(argc, argv, "01", &startup_id);
if (NIL_P(startup_id)) {
gdk_notify_startup_complete();
} else {
#if GTK_CHECK_VERSION(2, 12, 0)
gdk_notify_startup_complete_with_id(RVAL2CSTR(startup_id));
#else
rb_raise(rb_eNotImpError,
"GTK+ >= 2.12 is required to use "
"Gdk.notify_startup_complete with startup ID.");
#endif
}
return self;
}
static int
goo_application_command_line_finished (GApplication *application,
int status)
{
if (status == EXIT_SUCCESS)
gdk_notify_startup_complete ();
/* reset the arguments */
arg_auto_play = FALSE;
arg_toggle_play = FALSE;
arg_stop = FALSE;
arg_next = FALSE;
arg_prev = FALSE;
arg_eject = FALSE;
arg_toggle_visibility = FALSE;
arg_quit = FALSE;
g_free (arg_device);
arg_device = NULL;
return status;
}
static void
on_reload_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusConnection *connection = G_DBUS_CONNECTION (source_object);
GVariant *value;
GError *error = NULL;
value = g_dbus_connection_call_finish (connection, res, &error);
if (!value) {
g_warning ("Failed to Reload: %s", error->message);
g_error_free (error);
}
g_variant_unref (value);
/* We did not open a window, so manually clear the startup
* notification. */
gdk_notify_startup_complete ();
ev_application_shutdown (EV_APP);
}
gint
main(gint argc, gchar **argv)
{
GtkWidget *dialog;
GtkWidget *settings_editor;
GtkWidget *plug;
GError *error = NULL;
/* setup translation domain */
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
/* initialize Gtk+ */
if (!gtk_init_with_args (&argc, &argv, "", option_entries, GETTEXT_PACKAGE, &error))
{
if (G_LIKELY (error))
{
/* print error */
g_print ("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_print (_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_print ("\n");
/* cleanup */
g_error_free (error);
}
else
{
g_error ("Unable to open display.");
}
return EXIT_FAILURE;
}
/* print version information */
if (G_UNLIKELY (opt_version))
{
g_print ("%s %s (Xfce %s)\n\n", G_LOG_DOMAIN, PACKAGE_VERSION, xfce_version_string ());
g_print ("%s\n", "Copyright (c) 2008-2011");
g_print ("\t%s\n\n", _("The Xfce development team. All rights reserved."));
g_print (_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print ("\n");
return EXIT_SUCCESS;
}
/* initialize xfconf */
if (G_UNLIKELY (!xfconf_init (&error)))
{
/* print error and leave */
g_critical ("Failed to connect to Xfconf daemon: %s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
channel = xfconf_channel_new ("xfce4-settings-editor");
settings_editor = xfce_settings_editor_box_new (
xfconf_channel_get_int (channel, "/last/paned-position", 180));
if (G_UNLIKELY (opt_socket_id == 0))
{
dialog = xfce_titled_dialog_new_with_buttons (_("Settings Editor"), NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-help", GTK_RESPONSE_HELP,
"gtk-close", GTK_RESPONSE_OK,
NULL);
xfce_titled_dialog_set_subtitle (XFCE_TITLED_DIALOG (dialog),
_("Customize settings stored by Xfconf"));
gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-system");
gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_default_size (GTK_WINDOW (dialog),
xfconf_channel_get_int (channel, "/last/window-width", 640),
xfconf_channel_get_int (channel, "/last/window-height", 500));
gtk_container_add_with_properties(
GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
settings_editor,
"expand", TRUE,
"fill", TRUE,
NULL);
g_signal_connect (dialog, "response",
G_CALLBACK (settings_dialog_response), settings_editor);
gtk_widget_show_all (dialog);
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (plug_delete_event), settings_editor);
gtk_window_set_default_size (GTK_WINDOW (plug),
xfconf_channel_get_int (channel, "/last/window-width", 640),
xfconf_channel_get_int (channel, "/last/window-height", 500));
gtk_widget_show (plug);
gtk_container_add (GTK_CONTAINER(plug), settings_editor);
/* Stop startup notification */
gdk_notify_startup_complete ();
gtk_widget_show (GTK_WIDGET (settings_editor));
}
gtk_main ();
g_object_unref(channel);
/* shutdown xfconf */
xfconf_shutdown ();
return EXIT_SUCCESS;
}
/* Create the windows. */
static void
prepare_app (void)
{
CORBA_Object factory;
gboolean use_factory = FALSE;
CORBA_Environment env;
GNOME_GThumb_Application app;
GList *scan;
factory = bonobo_activation_activate_from_id ("OAFIID:GNOME_GThumb_Application_Factory",
Bonobo_ACTIVATION_FLAG_EXISTING_ONLY,
NULL, NULL);
if (factory != NULL) {
use_factory = TRUE;
CORBA_exception_init (&env);
app = bonobo_activation_activate_from_id ("OAFIID:GNOME_GThumb_Application", 0, NULL, &env);
}
if (session_is_restored ()) {
load_session (use_factory, app, &env);
return;
}
if (ImportPhotos) {
if (use_factory)
GNOME_GThumb_Application_import_photos (app, &env);
else
gth_browser_activate_action_file_camera_import (NULL, NULL);
}
else if (! view_comline_catalog
&& (n_dir_urls == 0)
&& (n_file_urls == 0))
{
open_browser_window (NULL, TRUE, use_factory, app, &env);
}
else if (view_single_image) {
if (use_factory && eel_gconf_get_boolean (PREF_SINGLE_WINDOW, FALSE))
{
GNOME_GThumb_Application_load_image (app, file_urls->data, &env);
}
else {
if (UseViewer)
open_viewer_window (file_urls->data, use_factory, app, &env);
else
open_browser_window (file_urls->data, TRUE, use_factory, app, &env);
}
}
else if (view_comline_catalog) {
char *catalog_path;
char *catalog_uri;
ViewFirstImage = TRUE;
HideSidebar = TRUE;
catalog_path = get_command_line_catalog_path ();
catalog_uri = g_strconcat ("catalog://", remove_host_from_uri (catalog_path), NULL);
open_browser_window (catalog_uri, TRUE, use_factory, app, &env);
g_free (catalog_path);
g_free (catalog_uri);
}
for (scan = dir_urls; scan; scan = scan->next) {
/* Go to the specified directory. */
open_browser_window (scan->data, TRUE, use_factory, app, &env);
}
path_list_free (file_urls);
path_list_free (dir_urls);
/**/
if (use_factory) {
bonobo_object_release_unref (app, &env);
CORBA_exception_free (&env);
gdk_notify_startup_complete ();
exit (0);
}
else
gth_application = gth_application_new (gdk_screen_get_default ());
}
int
main (int argc, char **argv)
{
DBusGConnection *session_bus;
GError *error = NULL;
RBShell *rb_shell;
gboolean activated;
gboolean autostarted;
char *accel_map_file = NULL;
char *desktop_file_path;
GOptionContext *context;
static const GOptionEntry options [] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, N_("Enable debug output"), NULL },
{ "debug-match", 'D', 0, G_OPTION_ARG_STRING, &debug_match, N_("Enable debug output matching a specified string"), NULL },
{ "no-update", 0, 0, G_OPTION_ARG_NONE, &no_update, N_("Do not update the library with file changes"), NULL },
{ "no-registration", 'n', 0, G_OPTION_ARG_NONE, &no_registration, N_("Do not register the shell"), NULL },
{ "dry-run", 0, 0, G_OPTION_ARG_NONE, &dry_run, N_("Don't save any data permanently (implies --no-registration)"), NULL },
{ "disable-plugins", 0, 0, G_OPTION_ARG_NONE, &disable_plugins, N_("Disable loading of plugins"), NULL },
{ "rhythmdb-file", 0, 0, G_OPTION_ARG_STRING, &rhythmdb_file, N_("Path for database file to use"), NULL },
{ "playlists-file", 0, 0, G_OPTION_ARG_STRING, &playlists_file, N_("Path for playlists file to use"), NULL },
{ "quit", 'q', 0, G_OPTION_ARG_NONE, &quit, N_("Quit Rhythmbox"), NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining_args, NULL, N_("[URI...]") },
{ NULL }
};
g_thread_init (NULL);
rb_profile_start ("starting rhythmbox");
autostarted = (g_getenv ("DESKTOP_AUTOSTART_ID") != NULL);
#ifdef USE_UNINSTALLED_DIRS
desktop_file_path = g_build_filename (SHARE_UNINSTALLED_BUILDDIR, "rhythmbox.desktop", NULL);
g_setenv ("GSETTINGS_SCHEMA_DIR", SHARE_UNINSTALLED_BUILDDIR, TRUE);
#else
desktop_file_path = g_build_filename (DATADIR, "applications", "rhythmbox.desktop", NULL);
#endif
egg_set_desktop_file (desktop_file_path);
g_free (desktop_file_path);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
rb_profile_start ("initializing gstreamer");
g_option_context_add_group (context, gst_init_get_option_group ());
rb_profile_end ("initializing gstreamer");
g_option_context_add_group (context, egg_sm_client_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
setlocale (LC_ALL, NULL);
rb_profile_start ("parsing command line options");
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"),
error->message, argv[0]);
g_error_free (error);
g_option_context_free (context);
exit (1);
}
g_option_context_free (context);
rb_profile_end ("parsing command line options");
g_random_set_seed (time (0));
#ifdef ENABLE_NLS
/* initialize i18n */
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
/* ask for utf-8 message text from GStreamer too,
* since it doesn't do that itself.
*/
bind_textdomain_codeset ("gstreamer-0.10", "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!debug && debug_match)
rb_debug_init_match (debug_match);
else
rb_debug_init (debug);
rb_debug ("initializing Rhythmbox %s", VERSION);
#if defined(USE_UNINSTALLED_DIRS)
g_irepository_prepend_search_path (SHARE_UNINSTALLED_BUILDDIR "/../bindings/gi");
#endif
/* TODO: kill this function */
rb_threads_init ();
gdk_threads_enter ();
activated = FALSE;
rb_debug ("going to create DBus object");
dbus_g_thread_init ();
session_bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (session_bus == NULL) {
g_warning ("couldn't connect to session bus: %s", (error) ? error->message : "(null)");
g_clear_error (&error);
} else if (!no_registration) {
guint request_name_reply;
int flags;
#ifndef DBUS_NAME_FLAG_DO_NOT_QUEUE
flags = DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT;
#else
flags = DBUS_NAME_FLAG_DO_NOT_QUEUE;
#endif
DBusGProxy *bus_proxy;
bus_proxy = dbus_g_proxy_new_for_name (session_bus,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus");
if (!dbus_g_proxy_call (bus_proxy,
"RequestName",
&error,
G_TYPE_STRING,
"org.gnome.Rhythmbox",
G_TYPE_UINT,
flags,
G_TYPE_INVALID,
G_TYPE_UINT,
&request_name_reply,
G_TYPE_INVALID)) {
g_warning ("Failed to invoke RequestName: %s",
error->message);
}
g_object_unref (bus_proxy);
if (request_name_reply == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
|| request_name_reply == DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER)
activated = FALSE;
else if (request_name_reply == DBUS_REQUEST_NAME_REPLY_EXISTS
|| request_name_reply == DBUS_REQUEST_NAME_REPLY_IN_QUEUE)
activated = TRUE;
else {
g_warning ("Got unhandled reply %u from RequestName",
request_name_reply);
activated = FALSE;
}
}
if (!activated) {
if (quit) {
rb_debug ("was asked to quit, but no instance was running");
gdk_notify_startup_complete ();
exit (0);
}
#ifdef WITH_RHYTHMDB_GDA
gda_init (PACKAGE, VERSION, argc, argv);
#endif
rb_refstring_system_init ();
#ifdef USE_UNINSTALLED_DIRS
rb_file_helpers_init (TRUE);
#else
rb_file_helpers_init (FALSE);
#endif
/* XXX not sure what to do with this. should we move it to
* the config dir, or leave it where it is?
*/
accel_map_file = g_build_filename (g_get_home_dir (),
".gnome2",
"accels",
"rhythmbox",
NULL);
gtk_accel_map_load (accel_map_file);
rb_debug ("Going to create a new shell");
rb_stock_icons_init ();
g_setenv ("PULSE_PROP_media.role", "music", TRUE);
rb_shell = rb_shell_new (no_registration, no_update, dry_run, autostarted, disable_plugins, rhythmdb_file, playlists_file);
g_object_weak_ref (G_OBJECT (rb_shell), main_shell_weak_ref_cb, NULL);
if (!no_registration && session_bus != NULL) {
dbus_g_object_type_install_info (RB_TYPE_SHELL, &dbus_glib_rb_shell_object_info);
dbus_g_connection_register_g_object (session_bus, "/org/gnome/Rhythmbox/Shell", G_OBJECT (rb_shell));
g_signal_connect (G_OBJECT (rb_shell),
"database-load-complete",
G_CALLBACK (database_load_complete),
NULL);
}
} else if (!no_registration && session_bus != NULL) {
DBusGProxy *shell_proxy;
guint32 current_time;
current_time = gdk_x11_display_get_user_time (gdk_display_get_default ());
shell_proxy = dbus_g_proxy_new_for_name_owner (session_bus,
"org.gnome.Rhythmbox",
"/org/gnome/Rhythmbox/Shell",
"org.gnome.Rhythmbox.Shell",
&error);
if (!shell_proxy) {
g_warning ("Couldn't create proxy for Rhythmbox shell: %s",
error->message);
} else {
if (quit) {
dbus_g_proxy_call_no_reply (shell_proxy, "quit",
G_TYPE_INVALID);
} else {
load_uri_args ((const char **) remaining_args, (GFunc) dbus_load_uri, shell_proxy);
dbus_g_proxy_call_no_reply (shell_proxy, "present",
G_TYPE_UINT, current_time,
G_TYPE_INVALID);
}
g_object_unref (G_OBJECT (shell_proxy));
}
}
if (activated) {
gdk_notify_startup_complete ();
} else {
rb_profile_start ("mainloop");
#ifdef ENABLE_PYTHON
if (rb_python_init_successful ()) {
pyg_begin_allow_threads;
gtk_main ();
pyg_end_allow_threads;
} else {
gtk_main ();
}
#else
gtk_main ();
#endif
rb_profile_end ("mainloop");
rb_debug ("out of toplevel loop");
rb_file_helpers_shutdown ();
rb_stock_icons_shutdown ();
rb_refstring_system_shutdown ();
}
gst_deinit ();
rb_debug ("THE END");
rb_profile_end ("starting rhythmbox");
if (accel_map_file != NULL) {
gtk_accel_map_save (accel_map_file);
}
gdk_threads_leave ();
exit (0);
}
static int
gth_application_command_line (GApplication *application,
GApplicationCommandLine *command_line)
{
char **argv;
int argc;
GOptionContext *context;
GError *error = NULL;
const char *arg;
int i;
GList *files;
GList *dirs;
GFile *location;
gboolean singleton;
GList *scan;
argv = g_application_command_line_get_arguments (command_line, &argc);
/* parse command line options */
context = gth_application_create_option_context ();
if (! g_option_context_parse (context, &argc, &argv, &error)) {
g_critical ("Failed to parse arguments: %s", error->message);
g_error_free (error);
g_option_context_free (context);
return EXIT_FAILURE;
}
g_option_context_free (context);
g_strfreev (argv);
gdk_notify_startup_complete ();
/* exec the command line */
if (ImportPhotos) {
GFile *location = NULL;
if (remaining_args != NULL)
location = g_file_new_for_commandline_arg (remaining_args[0]);
import_photos_from_location (location);
return 0;
}
if (remaining_args == NULL) { /* No location specified. */
GFile *location;
GSettings *settings;
char *file_to_select_uri;
GFile *file_to_select;
location = g_file_new_for_uri (gth_pref_get_startup_location ());
settings = g_settings_new (GTHUMB_BROWSER_SCHEMA);
file_to_select_uri = _g_settings_get_uri (settings, PREF_BROWSER_STARTUP_CURRENT_FILE);
if (file_to_select_uri != NULL)
file_to_select = g_file_new_for_uri (file_to_select_uri);
else
file_to_select = NULL;
open_browser_window (location, file_to_select, TRUE);
_g_object_unref (file_to_select);
g_free (file_to_select_uri);
g_object_unref (settings);
g_object_unref (location);
return 0;
}
/* At least a location was specified */
files = NULL;
dirs = NULL;
for (i = 0; (arg = remaining_args[i]) != NULL; i++) {
GFile *location;
GFileType file_type;
location = g_file_new_for_commandline_arg (arg);
file_type = _g_file_get_standard_type (location);
if (file_type == G_FILE_TYPE_REGULAR)
files = g_list_prepend (files, location);
else
dirs = g_list_prepend (dirs, location);
}
files = g_list_reverse (files);
dirs = g_list_reverse (dirs);
location = gth_hook_invoke_get ("command-line-files", files);
if (location != NULL) {
open_browser_window (location, NULL, FALSE);
g_object_unref (location);
}
else {
/* Open each file in a new window */
singleton = (files != NULL) && (files->next == NULL);
for (scan = files; scan; scan = scan->next)
open_browser_window ((GFile *) scan->data, NULL, ! singleton);
}
/* Open each dir in a new window */
for (scan = dirs; scan; scan = scan->next)
open_browser_window ((GFile *) scan->data, NULL, TRUE);
_g_object_list_unref (dirs);
_g_object_list_unref (files);
return 0;
}
int
main (int argc, char **argv)
{
GOptionContext *context;
CheeseDbus *dbus_server;
GError *error = NULL;
GOptionEntry options[] = {
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &CheeseOptions.verbose,
_("Be verbose"), NULL},
{"wide", 'w', 0, G_OPTION_ARG_NONE, &CheeseOptions.wide_mode,
_("Enable wide mode"), NULL},
{"version", 0, 0, G_OPTION_ARG_NONE, &CheeseOptions.version,
_("output version information and exit"), NULL},
{NULL}
};
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_rc_parse (APPNAME_DATA_DIR G_DIR_SEPARATOR_S "gtkrc");
g_thread_init (NULL);
gdk_threads_init ();
/* initialize rsvg */
/* needed to load the camera icon for the countdown widget */
rsvg_init ();
g_set_application_name (_("Cheese"));
context = g_option_context_new (N_("- Take photos and videos with your webcam, with fun graphical effects"));
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_add_group (context, gst_init_get_option_group ());
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE)
{
gchar *help_text = g_option_context_get_help (context, TRUE, NULL);
g_print ("%s\n\n%s", error->message, help_text);
g_free (help_text);
g_error_free (error);
g_option_context_free (context);
return -1;
}
g_option_context_free (context);
if (CheeseOptions.version)
{
g_print ("Cheese " VERSION " \n");
return 0;
}
dbus_server = cheese_dbus_new ();
if (dbus_server == NULL)
{
gdk_notify_startup_complete ();
return -1;
}
g_set_print_handler ((GPrintFunc) cheese_print_handler);
g_print ("Cheese " VERSION " \n");
gtk_window_set_default_icon_name ("cheese");
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
APPNAME_DATA_DIR G_DIR_SEPARATOR_S "icons");
CheeseWindow *window = g_object_new (CHEESE_TYPE_WINDOW,
"startup-wide", CheeseOptions.wide_mode,
NULL);
cheese_dbus_set_window (window);
gtk_widget_show (GTK_WIDGET (window));
gdk_threads_enter ();
gtk_main ();
gdk_threads_leave ();
/* cleanup rsvg */
/* Note: this function is bad with multithread applications as it
* calls xmlCleanupParser() and should be only called right before
* exit */
rsvg_term ();
return 0;
}
int
main (int argc, gchar **argv)
{
GtkWidget *dialog;
GtkWidget *plug;
GtkWidget *plug_child;
GtkBuilder *builder;
GError *cli_error = NULL;
const gchar *wm_name;
#ifdef ENABLE_NLS
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
#endif
if (!gtk_init_with_args (&argc, &argv, _ ("."), entries, PACKAGE, &cli_error))
{
if (cli_error != NULL)
{
g_print (_ ("%s: %s\nTry %s --help to see a full list of available command line options.\n"), PACKAGE, cli_error->message, PACKAGE_NAME);
g_error_free (cli_error);
return 1;
}
}
wm_name = gdk_x11_screen_get_window_manager_name (gdk_screen_get_default ());
if (G_UNLIKELY (g_ascii_strcasecmp (wm_name, "Xfwm4")))
{
g_print ("These settings cannot work with your current window manager (%s)\n", wm_name);
return 1;
}
if (opt_version)
{
g_print ("%s\n", PACKAGE_STRING);
return 0;
}
xfconf_init (NULL);
builder = gtk_builder_new ();
if (xfce_titled_dialog_get_type () == 0)
return 1;
gtk_builder_add_from_string (builder, tweaks_dialog_ui, tweaks_dialog_ui_length, NULL);
if (builder)
{
wm_tweaks_dialog_configure_widgets (builder);
if (opt_socket_id == 0)
{
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "main-dialog"));
gtk_widget_show (dialog);
g_signal_connect (dialog, "response", G_CALLBACK (wm_tweaks_dialog_response), NULL);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main ();
gtk_widget_destroy (dialog);
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (plug);
/* Get plug child widget */
plug_child = GTK_WIDGET (gtk_builder_get_object (builder, "plug-child"));
gtk_widget_reparent (plug_child, plug);
gtk_widget_show (plug_child);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
/* Stop startup notification */
gdk_notify_startup_complete ();
/* Enter main loop */
gtk_main ();
}
g_object_unref (builder);
}
xfconf_shutdown ();
return 0;
}
int
main (int argc,
char **argv)
{
GOptionContext *context;
GError *error = NULL;
const gchar *abort_message;
gchar *basename;
GFile *system_gimprc_file = NULL;
GFile *user_gimprc_file = NULL;
gint i;
#if defined (__GNUC__) && defined (_WIN64)
/* mingw-w64, at least the unstable build from late July 2008,
* starts subsystem:windows programs in main(), but passes them
* bogus argc and argv. __argc and __argv are OK, though, so just
* use them.
*/
argc = __argc;
argv = __argv;
#endif
#ifdef G_OS_WIN32
/* Reduce risks */
{
typedef BOOL (WINAPI *t_SetDllDirectoryA) (LPCSTR lpPathName);
t_SetDllDirectoryA p_SetDllDirectoryA;
p_SetDllDirectoryA =
(t_SetDllDirectoryA) GetProcAddress (GetModuleHandle ("kernel32.dll"),
"SetDllDirectoryA");
if (p_SetDllDirectoryA)
(*p_SetDllDirectoryA) ("");
}
/* On Windows, set DLL search path to $INSTALLDIR/bin so that .exe
plug-ins in the plug-ins directory can find libgimp and file
library DLLs without needing to set external PATH. */
{
const gchar *install_dir;
gchar *bin_dir;
LPWSTR w_bin_dir;
int n;
w_bin_dir = NULL;
install_dir = gimp_installation_directory ();
bin_dir = g_build_filename (install_dir, "bin", NULL);
n = MultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS,
bin_dir, -1, NULL, 0);
if (n == 0)
goto out;
w_bin_dir = g_malloc_n (n + 1, sizeof (wchar_t));
n = MultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS,
bin_dir, -1,
w_bin_dir, (n + 1) * sizeof (wchar_t));
if (n == 0)
goto out;
SetDllDirectoryW (w_bin_dir);
out:
if (w_bin_dir)
g_free (w_bin_dir);
g_free (bin_dir);
}
#ifdef HAVE_EXCHNDL
/* Use Dr. Mingw (dumps backtrace on crash) if it is available. */
{
time_t t;
gchar *filename;
gchar *dir;
gchar *path;
/* This has to be the non-roaming directory (i.e., the local
directory) as backtraces correspond to the binaries on this
system. */
dir = g_build_filename (g_get_user_data_dir (),
GIMPDIR, GIMP_USER_VERSION, "CrashLog",
NULL);
/* Ensure the path exists. */
g_mkdir_with_parents (dir, 0700);
time (&t);
filename = g_strdup_printf ("%s-crash-%" G_GUINT64_FORMAT ".txt",
g_get_prgname(), t);
path = g_build_filename (dir, filename, NULL);
g_free (filename);
g_free (dir);
ExcHndlInit ();
ExcHndlSetLogFileNameA (path);
g_free (path);
}
#endif
#ifndef _WIN64
{
typedef BOOL (WINAPI *t_SetProcessDEPPolicy) (DWORD dwFlags);
t_SetProcessDEPPolicy p_SetProcessDEPPolicy;
p_SetProcessDEPPolicy =
(t_SetProcessDEPPolicy) GetProcAddress (GetModuleHandle ("kernel32.dll"),
"SetProcessDEPPolicy");
if (p_SetProcessDEPPolicy)
(*p_SetProcessDEPPolicy) (PROCESS_DEP_ENABLE|PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION);
}
#endif
/* Group all our windows together on the taskbar */
{
typedef HRESULT (WINAPI *t_SetCurrentProcessExplicitAppUserModelID) (PCWSTR lpPathName);
t_SetCurrentProcessExplicitAppUserModelID p_SetCurrentProcessExplicitAppUserModelID;
p_SetCurrentProcessExplicitAppUserModelID =
(t_SetCurrentProcessExplicitAppUserModelID) GetProcAddress (GetModuleHandle ("shell32.dll"),
"SetCurrentProcessExplicitAppUserModelID");
if (p_SetCurrentProcessExplicitAppUserModelID)
(*p_SetCurrentProcessExplicitAppUserModelID) (L"gimp.GimpApplication");
}
#endif
#ifdef GIMP_UNSTABLE
gimp_open_console_window ();
#endif
gimp_init_malloc ();
gimp_env_init (FALSE);
gimp_log_init ();
gimp_init_i18n ();
g_set_application_name (GIMP_NAME);
#ifdef G_OS_WIN32
argv = g_win32_get_command_line ();
#else
argv = g_strdupv (argv);
#endif
basename = g_path_get_basename (argv[0]);
g_set_prgname (basename);
g_free (basename);
/* Check argv[] for "--verbose" first */
for (i = 1; i < argc; i++)
{
const gchar *arg = argv[i];
if (arg[0] != '-')
continue;
if ((strcmp (arg, "--verbose") == 0) || (strcmp (arg, "-v") == 0))
{
be_verbose = TRUE;
}
}
/* Check argv[] for "--no-interface" before trying to initialize gtk+. */
for (i = 1; i < argc; i++)
{
const gchar *arg = argv[i];
if (arg[0] != '-')
continue;
if ((strcmp (arg, "--no-interface") == 0) || (strcmp (arg, "-i") == 0))
{
no_interface = TRUE;
}
else if ((strcmp (arg, "--version") == 0) || (strcmp (arg, "-v") == 0))
{
gimp_show_version_and_exit ();
}
#if defined (G_OS_WIN32) && !defined (GIMP_CONSOLE_COMPILATION)
else if ((strcmp (arg, "--help") == 0) ||
(strcmp (arg, "-?") == 0) ||
(strncmp (arg, "--help-", 7) == 0))
{
gimp_open_console_window ();
}
#endif
}
#ifdef GIMP_CONSOLE_COMPILATION
no_interface = TRUE;
#endif
context = g_option_context_new (_("[FILE|URI...]"));
g_option_context_set_summary (context, GIMP_NAME);
g_option_context_add_main_entries (context, main_entries, GETTEXT_PACKAGE);
app_libs_init (context, no_interface);
if (! g_option_context_parse_strv (context, &argv, &error))
{
if (error)
{
gimp_open_console_window ();
g_print ("%s\n", error->message);
g_error_free (error);
}
else
{
g_print ("%s\n",
_("GIMP could not initialize the graphical user interface.\n"
"Make sure a proper setup for your display environment "
"exists."));
}
app_exit (EXIT_FAILURE);
}
if (no_interface || be_verbose || console_messages || batch_commands != NULL)
gimp_open_console_window ();
if (no_interface)
new_instance = TRUE;
#ifndef GIMP_CONSOLE_COMPILATION
if (! new_instance && gimp_unique_open (filenames, as_new))
{
if (be_verbose)
g_print ("%s\n",
_("Another GIMP instance is already running."));
if (batch_commands)
gimp_unique_batch_run (batch_interpreter, batch_commands);
gdk_notify_startup_complete ();
return EXIT_SUCCESS;
}
#endif
abort_message = sanity_check ();
if (abort_message)
app_abort (no_interface, abort_message);
gimp_init_signal_handlers (stack_trace_mode);
if (system_gimprc)
system_gimprc_file = g_file_new_for_commandline_arg (system_gimprc);
if (user_gimprc)
user_gimprc_file = g_file_new_for_commandline_arg (user_gimprc);
app_run (argv[0],
filenames,
system_gimprc_file,
user_gimprc_file,
session_name,
batch_interpreter,
batch_commands,
as_new,
no_interface,
no_data,
no_fonts,
no_splash,
be_verbose,
use_shm,
use_cpu_accel,
console_messages,
use_debug_handler,
show_playground,
stack_trace_mode,
pdb_compat_mode);
if (system_gimprc_file)
g_object_unref (system_gimprc_file);
if (user_gimprc_file)
g_object_unref (user_gimprc_file);
g_strfreev (argv);
g_option_context_free (context);
return EXIT_SUCCESS;
}
static void
gui_restore_after_callback (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config);
GimpDisplay *display;
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
gimp->message_handler = GIMP_MESSAGE_BOX;
if (gui_config->restore_accels)
menus_restore (gimp);
ui_configurer = g_object_new (GIMP_TYPE_UI_CONFIGURER,
"gimp", gimp,
NULL);
image_ui_manager = gimp_menu_factory_manager_new (global_menu_factory,
"<Image>",
gimp,
gui_config->tearoff_menus);
gimp_ui_manager_update (image_ui_manager, gimp);
#ifdef GDK_WINDOWING_QUARTZ
{
GtkosxApplication *osx_app;
GtkWidget *menu;
GtkWidget *item;
osx_app = gtkosx_application_get ();
menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager),
"/image-menubar");
if (GTK_IS_MENU_ITEM (menu))
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu));
gtkosx_application_set_menu_bar (osx_app, GTK_MENU_SHELL (menu));
gtkosx_application_set_use_quartz_accelerators (osx_app, FALSE);
gui_add_to_app_menu (image_ui_manager, osx_app,
"/image-menubar/Help/dialogs-about", 0);
#define PREFERENCES "/image-menubar/Edit/Preferences/"
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-preferences", 2);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-input-devices", 3);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-keyboard-shortcuts", 4);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-module-dialog", 5);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "plug-in-unit-editor", 6);
#undef PREFERENCES
item = gtk_separator_menu_item_new ();
gtkosx_application_insert_app_menu_item (osx_app, item, 7);
item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager),
"/image-menubar/File/file-quit");
gtk_widget_hide (item);
g_signal_connect (osx_app, "NSApplicationBlockTermination",
G_CALLBACK (gui_quartz_quit_callback),
image_ui_manager);
gtkosx_application_ready (osx_app);
}
#endif /* GDK_WINDOWING_QUARTZ */
g_signal_connect_object (gui_config, "notify::single-window-mode",
G_CALLBACK (gui_single_window_mode_notify),
ui_configurer, 0);
g_signal_connect_object (gui_config, "notify::tearoff-menus",
G_CALLBACK (gui_tearoff_menus_notify),
image_ui_manager, 0);
g_signal_connect (image_ui_manager, "show-tooltip",
G_CALLBACK (gui_menu_show_tooltip),
gimp);
g_signal_connect (image_ui_manager, "hide-tooltip",
G_CALLBACK (gui_menu_hide_tooltip),
gimp);
gimp_devices_restore (gimp);
gimp_controllers_restore (gimp, image_ui_manager);
if (status_callback == splash_update)
splash_destroy ();
color_history_restore (gimp);
if (gimp_get_show_gui (gimp))
{
GimpDisplayShell *shell;
/* create the empty display */
display = GIMP_DISPLAY (gimp_create_display (gimp,
NULL,
GIMP_UNIT_PIXEL,
1.0));
shell = gimp_display_get_shell (display);
if (gui_config->restore_session)
session_restore (gimp);
/* move keyboard focus to the display */
gtk_window_present (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (shell))));
}
/* indicate that the application has finished loading */
gdk_notify_startup_complete ();
}
gboolean
gwy_remote_open_files(GwyRemote *remote,
int argc,
char **argv)
{
GdkNativeWindow xid;
GdkDragContext *context;
GdkDragProtocol protocol;
GtkWidget *source;
GdkAtom sel_type, sel_id;
GString *file_list;
GList *targetlist;
gchar *cwd;
gint i;
if (!remote)
return FALSE;
xid = gdk_drag_get_protocol_for_display(remote->display, remote->winid,
&protocol);
/* FIXME: Here we may need some platform-dependent protocol check.
* protocol should be GDK_DRAG_PROTO_XDND on X11, but on win32
* gdk_drag_get_protocol_for_display returns 0, which means there
* is no DnD support for target window. */
if (!xid) {
g_printerr("Gwyddion window doesn't support DnD.\n");
return FALSE;
}
/* Now we have the toolbox, it seems to support DnD and we have some files
* to send to it. So build the list. */
cwd = g_get_current_dir();
file_list = g_string_sized_new(32*argc);
for (i = 0; i < argc; i++) {
gchar *s, *t;
if (i)
g_string_append_c(file_list, '\n');
if (g_path_is_absolute(argv[i]))
s = g_filename_to_uri(argv[i], NULL, NULL);
else {
t = g_build_filename(cwd, argv[i], NULL);
s = g_filename_to_uri(t, NULL, NULL);
g_free(t);
}
g_string_append(file_list, s);
g_free(s);
}
/* Don't hang when the toolbox is non-responsive.
* This may not be necessary in Gwyddion, but it does not hurt either. */
g_timeout_add(2000, toolbox_timeout, NULL);
/* Set up an DnD-source. */
source = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(source, "selection-get",
G_CALLBACK(source_selection_get), file_list->str);
gtk_widget_realize(source);
/* Specify the id and the content-type of the selection used to
* pass the URIs to Gwyddion toolbox. */
sel_id = gdk_atom_intern("XdndSelection", FALSE);
sel_type = gdk_atom_intern("text/plain", FALSE);
targetlist = g_list_prepend(NULL, GUINT_TO_POINTER(sel_type));
/* Assign the selection to our DnD-source. */
gtk_selection_owner_set(source, sel_id, GDK_CURRENT_TIME);
gtk_selection_add_target(source, sel_id, sel_type, 0);
/* Drag_begin/motion/drop. */
context = gdk_drag_begin(source->window, targetlist);
gdk_drag_motion(context, remote->toolbox, protocol, 0, 0,
GDK_ACTION_COPY, GDK_ACTION_COPY, GDK_CURRENT_TIME);
gdk_drag_drop(context, GDK_CURRENT_TIME);
/* Finally enter the mainloop to handle the events. */
gtk_main();
gdk_notify_startup_complete();
return TRUE;
}
static void
gui_restore_after_callback (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config);
GimpDisplay *display;
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
gimp->message_handler = GIMP_MESSAGE_BOX;
/* load the recent documents after gimp_real_restore() because we
* need the mime-types implemented by plug-ins
*/
status_callback (NULL, _("Documents"), 0.9);
gimp_recent_list_load (gimp);
/* enable this to always have icons everywhere */
if (g_getenv ("GIMP_ICONS_LIKE_A_BOSS"))
{
GdkScreen *screen = gdk_screen_get_default ();
g_object_set (G_OBJECT (gtk_settings_get_for_screen (screen)),
"gtk-button-images", TRUE,
"gtk-menu-images", TRUE,
NULL);
}
if (gui_config->restore_accels)
menus_restore (gimp);
ui_configurer = g_object_new (GIMP_TYPE_UI_CONFIGURER,
"gimp", gimp,
NULL);
image_ui_manager = gimp_menu_factory_manager_new (global_menu_factory,
"<Image>",
gimp,
gui_config->tearoff_menus);
gimp_ui_manager_update (image_ui_manager, gimp);
gimp_action_history_init (gimp);
#ifdef GDK_WINDOWING_QUARTZ
{
GtkosxApplication *osx_app;
GtkWidget *menu;
GtkWidget *item;
osx_app = gtkosx_application_get ();
menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager),
"/image-menubar");
if (GTK_IS_MENU_ITEM (menu))
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu));
gtkosx_application_set_menu_bar (osx_app, GTK_MENU_SHELL (menu));
gtkosx_application_set_use_quartz_accelerators (osx_app, FALSE);
gui_add_to_app_menu (image_ui_manager, osx_app,
"/image-menubar/Help/dialogs-about", 0);
gui_add_to_app_menu (image_ui_manager, osx_app,
"/image-menubar/Help/dialogs-search-action", 1);
#define PREFERENCES "/image-menubar/Edit/Preferences/"
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-preferences", 3);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-input-devices", 4);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-keyboard-shortcuts", 5);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-module-dialog", 6);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "plug-in-unit-editor", 7);
#undef PREFERENCES
item = gtk_separator_menu_item_new ();
gtkosx_application_insert_app_menu_item (osx_app, item, 8);
item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager),
"/image-menubar/File/file-quit");
gtk_widget_hide (item);
g_signal_connect (osx_app, "NSApplicationBlockTermination",
G_CALLBACK (gui_quartz_quit_callback),
image_ui_manager);
gtkosx_application_ready (osx_app);
}
#endif /* GDK_WINDOWING_QUARTZ */
g_signal_connect_object (gui_config, "notify::single-window-mode",
G_CALLBACK (gui_single_window_mode_notify),
ui_configurer, 0);
g_signal_connect_object (gui_config, "notify::tearoff-menus",
G_CALLBACK (gui_tearoff_menus_notify),
image_ui_manager, 0);
g_signal_connect (image_ui_manager, "show-tooltip",
G_CALLBACK (gui_menu_show_tooltip),
gimp);
g_signal_connect (image_ui_manager, "hide-tooltip",
G_CALLBACK (gui_menu_hide_tooltip),
gimp);
gimp_devices_restore (gimp);
gimp_controllers_restore (gimp, image_ui_manager);
if (status_callback == splash_update)
splash_destroy ();
color_history_restore (gimp);
if (gimp_get_show_gui (gimp))
{
GimpDisplayShell *shell;
GtkWidget *toplevel;
/* create the empty display */
display = GIMP_DISPLAY (gimp_create_display (gimp, NULL,
GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (initial_screen),
initial_monitor));
shell = gimp_display_get_shell (display);
if (gui_config->restore_session)
session_restore (gimp,
initial_screen,
initial_monitor);
/* move keyboard focus to the display */
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (shell));
gtk_window_present (GTK_WINDOW (toplevel));
}
/* indicate that the application has finished loading */
gdk_notify_startup_complete ();
/* clear startup monitor variables */
initial_screen = NULL;
initial_monitor = -1;
}
gint
main (gint argc, gchar **argv)
{
GObject *dialog, *plug_child;
GtkWidget *plug;
GtkBuilder *builder;
GError *error = NULL;
/* setup translation domain */
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
/* initialize Gtk+ */
if(!gtk_init_with_args (&argc, &argv, "", entries, PACKAGE, &error))
{
if (G_LIKELY (error))
{
/* print error */
g_print ("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_print (_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_print ("\n");
/* cleanup */
g_error_free (error);
}
else
{
g_error ("Unable to open display.");
}
return EXIT_FAILURE;
}
/* check if we should print version information */
if (G_UNLIKELY (opt_version))
{
g_print ("%s %s (Xfce %s)\n\n", G_LOG_DOMAIN, PACKAGE_VERSION, xfce_version_string ());
g_print ("%s\n", "Copyright (c) 2008-2011");
g_print ("\t%s\n\n", _("The Xfce development team. All rights reserved."));
g_print (_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print ("\n");
return EXIT_SUCCESS;
}
/* initialize xfconf */
if (!xfconf_init (&error))
{
/* print error and exit */
g_error ("Failed to connect to xfconf daemon: %s.", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
/* open the channels */
accessibility_channel = xfconf_channel_new ("accessibility");
session_channel = xfconf_channel_new ("xfce4-session");
/* hook to make sure the libxfce4ui library is linked */
if (xfce_titled_dialog_get_type () == 0)
return EXIT_FAILURE;
/* load the Gtk user-interface file */
builder = gtk_builder_new ();
if (gtk_builder_add_from_string (builder, accessibility_dialog_ui,
accessibility_dialog_ui_length, &error) != 0)
{
/* Configure widgets */
accessibility_settings_dialog_configure_widgets (builder);
if (G_UNLIKELY (opt_socket_id == 0))
{
/* Get the dialog widget */
dialog = gtk_builder_get_object (builder, "dialog");
g_signal_connect (dialog, "response",
G_CALLBACK (accessibility_settings_dialog_response), NULL);
gtk_window_present (GTK_WINDOW (dialog));
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main ();
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (plug);
/* Stop startup notification */
gdk_notify_startup_complete ();
/* Get plug child widget */
plug_child = gtk_builder_get_object (builder, "plug-child");
gtk_widget_reparent (GTK_WIDGET (plug_child), plug);
gtk_widget_show (GTK_WIDGET (plug_child));
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
/* Enter main loop */
gtk_main ();
}
}
else
{
g_error ("Failed to load the UI file: %s.", error->message);
g_error_free (error);
}
/* Release Builder */
g_object_unref (G_OBJECT (builder));
/* release the channels */
g_object_unref (G_OBJECT (accessibility_channel));
g_object_unref (G_OBJECT (session_channel));
/* shutdown xfconf */
xfconf_shutdown();
return EXIT_SUCCESS;
}
static int
application_command_line_cb (GApplication *application,
GApplicationCommandLine *command_line,
GnomeControlCenter *shell)
{
int argc;
char **argv;
int retval = 0;
GOptionContext *context;
GError *error = NULL;
verbose = FALSE;
show_overview = FALSE;
show_help = FALSE;
start_panels = NULL;
argv = g_application_command_line_get_arguments (command_line, &argc);
context = g_option_context_new (N_("- System Settings"));
g_option_context_add_main_entries (context, all_options, GETTEXT_PACKAGE);
g_option_context_set_translation_domain(context, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_set_help_enabled (context, FALSE);
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE)
{
g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"),
error->message, argv[0]);
g_error_free (error);
g_option_context_free (context);
return 1;
}
if (show_help || show_help_all || show_help_gtk)
{
gchar *help;
GOptionGroup *group;
if (show_help || show_help_all)
group = NULL;
else
group = gtk_get_option_group (FALSE);
help = g_option_context_get_help (context, FALSE, group);
g_print ("%s", help);
g_free (help);
g_option_context_free (context);
return 0;
}
g_option_context_free (context);
cc_shell_log_set_debug (verbose);
gnome_control_center_show (shell, GTK_APPLICATION (application));
if (show_overview)
{
gnome_control_center_set_overview_page (shell);
}
else if (start_panels != NULL && start_panels[0] != NULL)
{
const char *start_id;
GError *err = NULL;
start_id = start_panels[0];
if (start_panels[1])
g_debug ("Extra argument: %s", start_panels[1]);
else
g_debug ("No extra argument");
if (!cc_shell_set_active_panel_from_id (CC_SHELL (shell), start_id, (const gchar**)start_panels+1, &err))
{
g_warning ("Could not load setting panel \"%s\": %s", start_id,
(err) ? err->message : "Unknown error");
retval = 1;
if (err)
{
g_error_free (err);
err = NULL;
}
}
}
gnome_control_center_present (shell);
gdk_notify_startup_complete ();
g_strfreev (argv);
if (start_panels != NULL)
{
g_strfreev (start_panels);
start_panels = NULL;
}
show_overview = FALSE;
return retval;
}
int
main (int argc, char *argv[])
{
GOptionContext *context;
PlumaPluginsEngine *engine;
PlumaWindow *window;
PlumaApp *app;
gboolean restored = FALSE;
GError *error = NULL;
gchar *dir;
gchar *icon_dir;
/* Setup debugging */
pluma_debug_init ();
pluma_debug_message (DEBUG_APP, "Startup");
setlocale (LC_ALL, "");
dir = pluma_dirs_get_pluma_locale_dir ();
bindtextdomain (GETTEXT_PACKAGE, dir);
g_free (dir);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
startup_timestamp = get_startup_timestamp();
/* Setup command line options */
context = g_option_context_new (_("- Edit text files"));
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
g_option_context_add_group (context, egg_sm_client_get_option_group ());
gtk_init (&argc, &argv);
if (!g_option_context_parse (context, &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_error_free (error);
g_option_context_free (context);
return 1;
}
g_option_context_free (context);
pluma_debug_message (DEBUG_APP, "Create bacon connection");
connection = bacon_message_connection_new ("pluma");
if (connection != NULL)
{
if (!bacon_message_connection_get_is_server (connection))
{
pluma_debug_message (DEBUG_APP, "I'm a client");
pluma_get_command_line_data ();
send_bacon_message ();
free_command_line_data ();
/* we never popup a window... tell startup-notification
* that we are done.
*/
gdk_notify_startup_complete ();
bacon_message_connection_free (connection);
exit (0);
}
else
{
pluma_debug_message (DEBUG_APP, "I'm a server");
bacon_message_connection_set_callback (connection,
on_message_received,
NULL);
}
}
else
{
g_warning ("Cannot create the 'pluma' connection.");
}
pluma_debug_message (DEBUG_APP, "Set icon");
dir = pluma_dirs_get_pluma_data_dir ();
icon_dir = g_build_filename (dir,
"icons",
NULL);
g_free (dir);
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
icon_dir);
g_free (icon_dir);
/* Set the associated .desktop file */
egg_set_desktop_file (DATADIR "/applications/pluma.desktop");
/* Load user preferences */
pluma_debug_message (DEBUG_APP, "Init prefs manager");
pluma_prefs_manager_app_init ();
/* Init plugins engine */
pluma_debug_message (DEBUG_APP, "Init plugins");
engine = pluma_plugins_engine_get_default ();
/* Initialize session management */
pluma_debug_message (DEBUG_APP, "Init session manager");
pluma_session_init ();
if (pluma_session_is_restored ())
restored = pluma_session_load ();
if (!restored)
{
pluma_debug_message (DEBUG_APP, "Analyze command line data");
pluma_get_command_line_data ();
pluma_debug_message (DEBUG_APP, "Get default app");
app = pluma_app_get_default ();
pluma_debug_message (DEBUG_APP, "Create main window");
window = pluma_app_create_window (app, NULL);
if (file_list != NULL)
{
const PlumaEncoding *encoding = NULL;
if (encoding_charset)
encoding = pluma_encoding_get_from_charset (encoding_charset);
pluma_debug_message (DEBUG_APP, "Load files");
_pluma_cmd_load_files_from_prompt (window,
file_list,
encoding,
line_position);
}
else
{
pluma_debug_message (DEBUG_APP, "Create tab");
pluma_window_create_tab (window, TRUE);
}
pluma_debug_message (DEBUG_APP, "Show window");
gtk_widget_show (GTK_WIDGET (window));
free_command_line_data ();
}
pluma_debug_message (DEBUG_APP, "Start gtk-main");
gtk_main();
bacon_message_connection_free (connection);
/* We kept the original engine reference here. So let's unref it to
* finalize it properly.
*/
g_object_unref (engine);
pluma_prefs_manager_app_shutdown ();
#ifndef ENABLE_GVFS_METADATA
pluma_metadata_manager_shutdown ();
#endif
return 0;
}
static gboolean
idle_cb (gchar **uris)
{
GNOME_Evolution_Shell corba_shell;
CORBA_Environment ev;
EShellConstructResult result;
EShellStartupLineMode startup_line_mode;
g_return_val_if_fail (uris == NULL || g_strv_length (uris) > 0, FALSE);
#ifdef KILL_PROCESS_CMD
kill_old_dataserver ();
#endif
CORBA_exception_init (&ev);
if (! start_online && ! start_offline)
startup_line_mode = E_SHELL_STARTUP_LINE_MODE_CONFIG;
else if (start_online)
startup_line_mode = E_SHELL_STARTUP_LINE_MODE_ONLINE;
else
startup_line_mode = E_SHELL_STARTUP_LINE_MODE_OFFLINE;
shell = e_shell_new (startup_line_mode, &result);
switch (result) {
case E_SHELL_CONSTRUCT_RESULT_OK:
g_signal_connect (shell, "no_windows_left", G_CALLBACK (no_windows_left_cb), NULL);
g_object_weak_ref (G_OBJECT (shell), shell_weak_notify, NULL);
corba_shell = bonobo_object_corba_objref (BONOBO_OBJECT (shell));
corba_shell = CORBA_Object_duplicate (corba_shell, &ev);
break;
case E_SHELL_CONSTRUCT_RESULT_CANNOTREGISTER:
corba_shell = bonobo_activation_activate_from_id (E_SHELL_OAFIID, 0, NULL, &ev);
if (ev._major != CORBA_NO_EXCEPTION || corba_shell == CORBA_OBJECT_NIL) {
e_error_run(NULL, "shell:noshell", NULL);
CORBA_exception_free (&ev);
bonobo_main_quit ();
return FALSE;
}
break;
default:
e_error_run(NULL, "shell:noshell-reason",
e_shell_construct_result_to_string(result), NULL);
CORBA_exception_free (&ev);
bonobo_main_quit ();
return FALSE;
}
if (shell != NULL) {
if (uris != NULL)
open_uris (corba_shell, uris);
else {
GConfClient *client = gconf_client_get_default ();
if (gconf_client_get_bool (client, RECOVERY_KEY, NULL) && e_file_lock_exists ()) {
/* It should have crashed last time or a force-shutdown */
gboolean skip = gconf_client_get_bool (client, SKIP_RECOVERY_DIALOG_KEY, NULL);
gboolean recover = TRUE;
if (!skip){
int flags = show_recovery_warning ();
gconf_client_set_bool (client, SKIP_RECOVERY_DIALOG_KEY, (flags & (1<<2)) ? TRUE : FALSE, NULL);
recover = (flags & (1<<1)) ? TRUE: FALSE;
}
if (recover) {
/* Disable the previews */
gconf_client_set_bool (client, "/apps/evolution/mail/display/show_preview", FALSE, NULL);
gconf_client_set_bool (client, "/apps/evolution/mail/display/safe_list", TRUE, NULL);
gconf_client_set_bool (client, "/apps/evolution/addressbook/display/show_preview", FALSE, NULL);
gconf_client_set_bool (client, "/apps/evolution/calendar/display/show_task_preview", FALSE, NULL);
}
/* Let us not delete and recreate a lock, instead reuse it. We don't use timestamps anyways */
} else {
/* What great can we do, if lock creation fails ?*/
e_file_lock_create ();
}
g_object_unref (client);
e_shell_create_window (shell, default_component_id, NULL);
}
} else {
CORBA_Environment ev;
CORBA_exception_init (&ev);
if (uris != NULL)
open_uris (corba_shell, uris);
else
if (default_component_id == NULL)
GNOME_Evolution_Shell_createNewWindow (corba_shell, "", &ev);
else
GNOME_Evolution_Shell_createNewWindow (corba_shell, default_component_id, &ev);
CORBA_exception_free (&ev);
}
CORBA_Object_release (corba_shell, &ev);
CORBA_exception_free (&ev);
if (shell == NULL) {
/*there is another instance but because we don't open any windows
we must notify the startup was complete manually*/
gdk_notify_startup_complete ();
bonobo_main_quit ();
}
return FALSE;
}
int
main(int argc,
char **argv)
{
GtkBuilder *builder;
GtkWidget *notebook, *xfae_page, *lbl;
GError *error = NULL;
XfconfChannel *channel;
xfce_textdomain(GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
if(!gtk_init_with_args (&argc, &argv, "", option_entries,
GETTEXT_PACKAGE, &error))
{
if(G_LIKELY(error)) {
g_print("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_print(_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_print("\n");
g_error_free (error);
} else
g_error("Unable to open display.");
return EXIT_FAILURE;
}
if(G_UNLIKELY(opt_version)) {
g_print("%s %s (Xfce %s)\n\n", G_LOG_DOMAIN, PACKAGE_VERSION, xfce_version_string ());
g_print("%s\n", "Copyright (c) 2004-2014");
g_print("\t%s\n\n", _("The Xfce development team. All rights reserved."));
g_print(_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print("\n");
return EXIT_SUCCESS;
}
if(G_UNLIKELY(!xfconf_init(&error))) {
xfce_dialog_show_error (NULL,
error,
_("Unable to contact settings server"));
g_error_free(error);
return EXIT_FAILURE;
}
gtk_window_set_default_icon_name("xfce4-session");
/* hook to make sure the libxfce4ui library is linked */
if (xfce_titled_dialog_get_type() == 0)
return EXIT_FAILURE;
builder = gtk_builder_new();
gtk_builder_add_from_string(builder,
xfce4_session_settings_ui,
xfce4_session_settings_ui_length,
&error);
if(!builder) {
xfce_dialog_show_error(NULL, error,
_("Unable to create user interface from embedded definition data"));
g_error_free (error);
return EXIT_FAILURE;
}
splash_settings_init(builder);
session_editor_init(builder);
/* FIXME: someday, glade-ify this, maybe. */
xfae_page = xfae_window_new();
gtk_widget_show(xfae_page);
notebook = GTK_WIDGET(gtk_builder_get_object(builder, "plug-child"));
lbl = gtk_label_new_with_mnemonic(_("App_lication Autostart"));
gtk_widget_show(lbl);
gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), xfae_page, lbl, 2);
channel = xfconf_channel_get(SETTINGS_CHANNEL);
/* bind widgets to xfconf */
xfconf_g_property_bind(channel, "/chooser/AlwaysDisplay", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_display_chooser"),
"active");
xfconf_g_property_bind(channel, "/general/AutoSave", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_session_autosave"),
"active");
xfconf_g_property_bind(channel, "/general/PromptOnLogout", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_logout_prompt"),
"active");
xfconf_g_property_bind(channel, "/compat/LaunchGNOME", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_compat_gnome"),
"active");
xfconf_g_property_bind(channel, "/compat/LaunchKDE", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_compat_kde"),
"active");
xfconf_g_property_bind(channel, "/security/EnableTcp", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_enable_tcp"),
"active");
xfconf_g_property_bind(channel, "/shutdown/LockScreen", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_lock_screen"),
"active");
if(G_UNLIKELY(opt_socket_id == 0)) {
GtkWidget *dialog = GTK_WIDGET(gtk_builder_get_object(builder, "xfce4_session_settings_dialog"));
g_signal_connect(dialog, "response", G_CALLBACK(xfce4_session_settings_dialog_response), NULL);
g_signal_connect(dialog, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show(dialog);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main();
} else {
GtkWidget *plug, *plug_child;
plug = gtk_plug_new(opt_socket_id);
gtk_widget_show(plug);
g_signal_connect(plug, "delete-event",
G_CALLBACK(gtk_main_quit), NULL);
plug_child = GTK_WIDGET(gtk_builder_get_object(builder, "plug-child"));
gtk_widget_reparent(plug_child, plug);
gtk_widget_show(plug_child);
/* Stop startup notification */
gdk_notify_startup_complete();
gtk_main();
}
g_object_unref(builder);
return EXIT_SUCCESS;
}
/* Main entry point */
int main(int argc, char **argv)
{
XfdashboardApplication *app=NULL;
gint status;
#ifdef ENABLE_NLS
/* Set up localization */
xfce_textdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8");
#endif
#if !GLIB_CHECK_VERSION(2, 36, 0)
/* Initialize GObject type system */
g_type_init();
#endif
#if CLUTTER_CHECK_VERSION(1, 16, 0)
/* Enforce X11 backend in Clutter. This function must be called before any
* other Clutter API function.
*/
clutter_set_windowing_backend("x11");
#endif
/* Tell clutter to try to initialize an RGBA visual */
clutter_x11_set_use_argb_visual(TRUE);
/* Initialize GTK+ and Clutter */
gtk_init(&argc, &argv);
if(!clutter_init(&argc, &argv))
{
g_error(_("Initializing clutter failed!"));
return(1);
}
/* Notify that application has started and main loop will be entered */
gdk_notify_startup_complete();
/* Start application as primary or remote instace */
app=xfdashboard_application_get_default();
if(!app)
{
g_warning(_("Failed to create application instance"));
return(XFDASHBOARD_APPLICATION_ERROR_FAILED);
}
status=g_application_run(G_APPLICATION(app), argc, argv);
if(status==XFDASHBOARD_APPLICATION_ERROR_RESTART &&
g_application_get_is_remote(G_APPLICATION(app)))
{
/* Wait for existing primary instance to quit */
if(_restart(app))
{
g_debug("Reached clean state to restart application");
/* Destroy remote instance application object for restart */
g_object_unref(app);
app=NULL;
/* Create new application instance which should become
* the new primary instance.
*/
app=xfdashboard_application_get_default();
if(!app)
{
g_warning(_("Failed to create application instance"));
return(XFDASHBOARD_APPLICATION_ERROR_FAILED);
}
g_debug("Starting new primary instance");
status=g_application_run(G_APPLICATION(app), argc, argv);
}
else
{
g_warning(_("Could not restart application because existing instance seems still to be running."));
}
}
/* Clean up, release allocated resources */
g_object_unref(app);
return(status);
}
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[])
#endif
{
gboolean opt_force_online = FALSE;
gboolean opt_help = FALSE;
gboolean opt_login = FALSE;
gboolean opt_nologin = FALSE;
gboolean opt_version = FALSE;
gboolean opt_si = TRUE; /* Check for single instance? */
char *opt_config_dir_arg = NULL;
char *opt_login_arg = NULL;
char *opt_session_arg = NULL;
char *search_path;
GList *accounts;
#ifdef HAVE_SIGNAL_H
int sig_indx; /* for setting up signal catching */
sigset_t sigset;
RETSIGTYPE (*prev_sig_disp)(int);
char errmsg[BUFSIZ];
GIOChannel *signal_channel;
GIOStatus signal_status;
guint signal_channel_watcher;
#ifndef DEBUG
char *segfault_message_tmp;
#endif
GError *error;
#endif
int opt;
gboolean gui_check;
gboolean debug_enabled;
gboolean migration_failed = FALSE;
GList *active_accounts;
struct stat st;
struct option long_options[] = {
{"config", required_argument, NULL, 'c'},
{"debug", no_argument, NULL, 'd'},
{"force-online", no_argument, NULL, 'f'},
{"help", no_argument, NULL, 'h'},
{"login", optional_argument, NULL, 'l'},
{"multiple", no_argument, NULL, 'm'},
{"nologin", no_argument, NULL, 'n'},
{"session", required_argument, NULL, 's'},
{"version", no_argument, NULL, 'v'},
{"display", required_argument, NULL, 'D'},
{"sync", no_argument, NULL, 'S'},
{0, 0, 0, 0}
};
#ifdef DEBUG
debug_enabled = TRUE;
#else
debug_enabled = FALSE;
#endif
/* Initialize GThread before calling any Glib or GTK+ functions. */
g_thread_init(NULL);
g_set_prgname("Pidgin");
#ifdef ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
#endif
#ifdef HAVE_SETLOCALE
/* Locale initialization is not complete here. See gtk_init_check() */
setlocale(LC_ALL, "");
#endif
#ifdef HAVE_SIGNAL_H
#ifndef DEBUG
/* We translate this here in case the crash breaks gettext. */
segfault_message_tmp = g_strdup_printf(_(
"%s %s has segfaulted and attempted to dump a core file.\n"
"This is a bug in the software and has happened through\n"
"no fault of your own.\n\n"
"If you can reproduce the crash, please notify the developers\n"
"by reporting a bug at:\n"
"%ssimpleticket/\n\n"
"Please make sure to specify what you were doing at the time\n"
"and post the backtrace from the core file. If you do not know\n"
"how to get the backtrace, please read the instructions at\n"
"%swiki/GetABacktrace\n"),
PIDGIN_NAME, DISPLAY_VERSION, PURPLE_DEVEL_WEBSITE, PURPLE_DEVEL_WEBSITE
);
/* we have to convert the message (UTF-8 to console
charset) early because after a segmentation fault
it's not a good practice to allocate memory */
error = NULL;
segfault_message = g_locale_from_utf8(segfault_message_tmp,
-1, NULL, NULL, &error);
if (segfault_message != NULL) {
g_free(segfault_message_tmp);
}
else {
/* use 'segfault_message_tmp' (UTF-8) as a fallback */
g_warning("%s\n", error->message);
g_error_free(error);
segfault_message = segfault_message_tmp;
}
#else
/* Don't mark this for translation. */
segfault_message = g_strdup(
"Hi, user. We need to talk.\n"
"I think something's gone wrong here. It's probably my fault.\n"
"No, really, it's not you... it's me... no no no, I think we get along well\n"
"it's just that.... well, I want to see other people. I... what?!? NO! I \n"
"haven't been cheating on you!! How many times do you want me to tell you?! And\n"
"for the last time, it's just a rash!\n"
);
#endif
/*
* Create a socket pair for receiving unix signals from a signal
* handler.
*/
if (socketpair(AF_UNIX, SOCK_STREAM, 0, signal_sockets) < 0) {
perror("Failed to create sockets for GLib signal handling");
exit(1);
}
signal_channel = g_io_channel_unix_new(signal_sockets[1]);
/*
* Set the channel encoding to raw binary instead of the default of
* UTF-8, because we'll be sending integers across instead of strings.
*/
error = NULL;
signal_status = g_io_channel_set_encoding(signal_channel, NULL, &error);
if (signal_status != G_IO_STATUS_NORMAL) {
fprintf(stderr, "Failed to set the signal channel to raw "
"binary: %s", error->message);
exit(1);
}
signal_channel_watcher = g_io_add_watch(signal_channel, G_IO_IN, mainloop_sighandler, NULL);
g_io_channel_unref(signal_channel);
/* 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)) {
snprintf(errmsg, sizeof(errmsg), "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) {
snprintf(errmsg, sizeof(errmsg), "Warning: couldn't set signal %d for catching",
catch_sig_list[sig_indx]);
perror(errmsg);
}
if(sigaddset(&sigset, catch_sig_list[sig_indx])) {
snprintf(errmsg, sizeof(errmsg), "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) {
snprintf(errmsg, sizeof(errmsg), "Warning: couldn't set signal %d to ignore",
ignore_sig_list[sig_indx]);
perror(errmsg);
}
}
if (sigprocmask(SIG_UNBLOCK, &sigset, NULL)) {
snprintf(errmsg, sizeof(errmsg), "Warning: couldn't unblock signals");
perror(errmsg);
}
#endif
/* scan command-line options */
opterr = 1;
while ((opt = getopt_long(argc, argv,
#ifndef _WIN32
"c:dfhmnl::s:v",
#else
"c:dfhmnl::v",
#endif
long_options, NULL)) != -1) {
switch (opt) {
case 'c': /* config dir */
g_free(opt_config_dir_arg);
opt_config_dir_arg = g_strdup(optarg);
break;
case 'd': /* debug */
debug_enabled = TRUE;
break;
case 'f': /* force-online */
opt_force_online = TRUE;
break;
case 'h': /* help */
opt_help = TRUE;
break;
case 'n': /* no autologin */
opt_nologin = TRUE;
break;
case 'l': /* login, option username */
opt_login = TRUE;
g_free(opt_login_arg);
if (optarg != NULL)
opt_login_arg = g_strdup(optarg);
break;
case 's': /* use existing session ID */
g_free(opt_session_arg);
opt_session_arg = g_strdup(optarg);
break;
case 'v': /* version */
opt_version = TRUE;
break;
case 'm': /* do not ensure single instance. */
opt_si = FALSE;
break;
case 'D': /* --display */
case 'S': /* --sync */
/* handled by gtk_init_check below */
break;
case '?': /* show terse help */
default:
show_usage(argv[0], TRUE);
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
return 0;
break;
}
}
/* show help message */
if (opt_help) {
show_usage(argv[0], FALSE);
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
return 0;
}
/* show version message */
if (opt_version) {
printf("%s %s (libpurple %s)\n", PIDGIN_NAME, DISPLAY_VERSION,
purple_core_get_version());
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
return 0;
}
/* set a user-specified config directory */
if (opt_config_dir_arg != NULL) {
purple_util_set_user_dir(opt_config_dir_arg);
}
/*
* We're done piddling around with command line arguments.
* Fire up this baby.
*/
purple_debug_set_enabled(debug_enabled);
/* If we're using a custom configuration directory, we
* do NOT want to migrate, or weird things will happen. */
if (opt_config_dir_arg == NULL)
{
if (!purple_core_migrate())
{
migration_failed = TRUE;
}
}
search_path = g_build_filename(purple_user_dir(), "gtkrc-2.0", NULL);
gtk_rc_add_default_file(search_path);
g_free(search_path);
gui_check = gtk_init_check(&argc, &argv);
if (!gui_check) {
char *display = gdk_get_display();
printf("%s %s\n", PIDGIN_NAME, DISPLAY_VERSION);
g_warning("cannot open display: %s", display ? display : "unset");
g_free(display);
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
return 1;
}
g_set_application_name(PIDGIN_NAME);
#ifdef _WIN32
winpidgin_init(hint);
#endif
if (migration_failed)
{
char *old = g_strconcat(purple_home_dir(),
G_DIR_SEPARATOR_S ".gaim", NULL);
const char *text = _(
"%s encountered errors migrating your settings "
"from %s to %s. Please investigate and complete the "
"migration by hand. Please report this error at http://developer.pidgin.im");
GtkWidget *dialog;
dialog = gtk_message_dialog_new(NULL,
0,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
text, PIDGIN_NAME,
old, purple_user_dir());
g_free(old);
g_signal_connect_swapped(dialog, "response",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(dialog);
gtk_main();
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
return 0;
}
purple_core_set_ui_ops(pidgin_core_get_ui_ops());
purple_eventloop_set_ui_ops(pidgin_eventloop_get_ui_ops());
/*
* Set plugin search directories. Give priority to the plugins
* in user's home directory.
*/
search_path = g_build_filename(purple_user_dir(), "plugins", NULL);
if (!g_stat(search_path, &st))
g_mkdir(search_path, S_IRUSR | S_IWUSR | S_IXUSR);
purple_plugins_add_search_path(search_path);
g_free(search_path);
purple_plugins_add_search_path(LIBDIR);
if (!purple_core_init(PIDGIN_UI)) {
fprintf(stderr,
"Initialization of the libpurple core failed. Dumping core.\n"
"Please report this!\n");
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
abort();
}
if (opt_si && !purple_core_ensure_single_instance()) {
#ifdef HAVE_DBUS
DBusConnection *conn = purple_dbus_get_connection();
DBusMessage *message = dbus_message_new_method_call(DBUS_SERVICE_PURPLE, DBUS_PATH_PURPLE,
DBUS_INTERFACE_PURPLE, "PurpleBlistSetVisible");
gboolean tr = TRUE;
dbus_message_append_args(message, DBUS_TYPE_INT32, &tr, DBUS_TYPE_INVALID);
dbus_connection_send_with_reply_and_block(conn, message, -1, NULL);
dbus_message_unref(message);
#endif
gdk_notify_startup_complete();
purple_core_quit();
g_printerr(_("Exiting because another libpurple client is already running.\n"));
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
#endif
return 0;
}
/* TODO: Move blist loading into purple_blist_init() */
purple_set_blist(purple_blist_new());
purple_blist_load();
/* load plugins we had when we quit */
purple_plugins_load_saved(PIDGIN_PREFS_ROOT "/plugins/loaded");
/* TODO: Move pounces loading into purple_pounces_init() */
purple_pounces_load();
ui_main();
#ifdef USE_SM
pidgin_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;
}
/* This needs to be before purple_blist_show() so the
* statusbox gets the forced online status. */
if (opt_force_online)
purple_network_force_online();
/*
* We want to show the blist early in the init process so the
* user feels warm and fuzzy (not cold and prickley).
*/
purple_blist_show();
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/debug/enabled"))
pidgin_debug_window_show();
if (opt_login) {
/* disable all accounts */
for (accounts = purple_accounts_get_all(); accounts != NULL; accounts = accounts->next) {
PurpleAccount *account = accounts->data;
purple_account_set_enabled(account, PIDGIN_UI, FALSE);
}
/* honor the startup status preference */
if (!purple_prefs_get_bool("/purple/savedstatus/startup_current_status"))
purple_savedstatus_activate(purple_savedstatus_get_startup());
/* now enable the requested ones */
dologin_named(opt_login_arg);
if (opt_login_arg != NULL) {
g_free(opt_login_arg);
opt_login_arg = NULL;
}
} else if (opt_nologin) {
/* Set all accounts to "offline" */
PurpleSavedStatus *saved_status;
/* If we've used this type+message before, lookup the transient status */
saved_status = purple_savedstatus_find_transient_by_type_and_message(
PURPLE_STATUS_OFFLINE, NULL);
/* If this type+message is unique then create a new transient saved status */
if (saved_status == NULL)
saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_OFFLINE);
/* Set the status for each account */
purple_savedstatus_activate(saved_status);
} else {
/* Everything is good to go--sign on already */
if (!purple_prefs_get_bool("/purple/savedstatus/startup_current_status"))
purple_savedstatus_activate(purple_savedstatus_get_startup());
purple_accounts_restore_current_statuses();
}
if ((active_accounts = purple_accounts_get_all_active()) == NULL)
{
pidgin_accounts_window_show();
}
else
{
g_list_free(active_accounts);
}
/* GTK clears the notification for us when opening the first window,
* but we may have launched with only a status icon, so clear the it
* just in case. */
gdk_notify_startup_complete();
#ifdef _WIN32
winpidgin_post_init();
#endif
gtk_main();
#ifdef HAVE_SIGNAL_H
g_free(segfault_message);
g_source_remove(signal_channel_watcher);
close(signal_sockets[0]);
close(signal_sockets[1]);
#endif
#ifdef _WIN32
winpidgin_cleanup();
#endif
return 0;
}
int main(int argc, char *argv[])
{
UniqueApp *app;
GtkStatusIcon *statusicon;
GtkWidget *menu;
GOptionContext *context;
GError *error = NULL;
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#if !GLIB_CHECK_VERSION (2, 36, 0)
g_type_init ();
#endif
/* Parse command-line options */
context = g_option_context_new (N_("- Bluetooth applet"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"),
error->message, argv[0]);
g_error_free (error);
return 1;
}
if (option_debug == FALSE) {
app = unique_app_new ("org.mate.Bluetooth.applet", NULL);
if (unique_app_is_running (app)) {
gdk_notify_startup_complete ();
g_warning ("Applet is already running, exiting");
return 0;
}
} else {
app = NULL;
}
g_set_application_name(_("Bluetooth Applet"));
gtk_window_set_default_icon_name("bluetooth");
killswitch = bluetooth_killswitch_new ();
g_signal_connect (G_OBJECT (killswitch), "state-changed",
G_CALLBACK (killswitch_state_changed), NULL);
menu = create_popupmenu();
client = bluetooth_client_new();
devices_model = bluetooth_client_get_model(client);
g_signal_connect(G_OBJECT(devices_model), "row-inserted",
G_CALLBACK(device_added), NULL);
g_signal_connect(G_OBJECT(devices_model), "row-deleted",
G_CALLBACK(device_removed), NULL);
g_signal_connect (G_OBJECT (devices_model), "row-changed",
G_CALLBACK (device_changed), NULL);
/* Set the default adapter */
device_changed (devices_model, NULL, NULL, NULL);
if (bluetooth_killswitch_has_killswitches (killswitch) != FALSE) {
killswitch_state_changed (killswitch,
bluetooth_killswitch_get_state (killswitch));
}
/* Make sure all the unblocked adapters are powered,
* so as to avoid seeing unpowered, but unblocked
* devices */
bluetooth_set_adapter_powered ();
settings = g_settings_new (SCHEMA_NAME);
show_icon_pref = g_settings_get_boolean (settings, PREF_SHOW_ICON);
g_signal_connect (G_OBJECT (settings), "changed::" PREF_SHOW_ICON,
G_CALLBACK (show_icon_changed), NULL);
statusicon = init_notification();
update_icon_visibility();
g_signal_connect(statusicon, "activate",
G_CALLBACK(activate_callback), menu);
g_signal_connect(statusicon, "popup-menu",
G_CALLBACK(popup_callback), menu);
setup_agents();
gtk_main();
gtk_widget_destroy(menu);
g_object_unref(settings);
cleanup_agents();
cleanup_notification();
g_object_unref(devices_model);
g_object_unref(client);
if (app != NULL)
g_object_unref (app);
return 0;
}
gint
main (gint argc, gchar **argv)
{
WikipadApplication *application;
GError *error = NULL;
gchar *working_directory;
#ifdef HAVE_DBUS
WikipadDBusService *dbus_service;
#endif
/* bind the text domain to the locale directory */
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
/* set the package textdomain */
textdomain (GETTEXT_PACKAGE);
/* default application name */
g_set_application_name (_("Wikipad"));
#ifdef G_ENABLE_DEBUG
/* crash when something went wrong */
g_log_set_always_fatal (G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
#endif
#if !GLIB_CHECK_VERSION (2, 30, 0)
/* initialize the gthread system */
if (G_LIKELY (!g_thread_supported ()))
g_thread_init (NULL);
#endif
/* initialize gtk+ */
if (!gtk_init_with_args (&argc, &argv, _("[FILES...]"), (GOptionEntry *) option_entries, (gchar *) GETTEXT_PACKAGE, &error))
{
/* check if we have an error message */
if (G_LIKELY (error == NULL))
{
/* no error message, the gui initialization failed */
g_error ("%s", _("Failed to open display."));
}
else
{
/* print the error message */
g_error ("%s", error->message);
g_error_free (error);
}
return EXIT_FAILURE;
}
/* check if we should print version information */
if (G_UNLIKELY (opt_version))
{
g_print ("%s %s\n\n", PACKAGE_NAME, PACKAGE_VERSION);
g_print ("%s\n", "Copyright (c) 2016");
g_print ("\t%s\n\n", _("phm. Some rights reserved."));
g_print (_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print ("\n");
return EXIT_SUCCESS;
}
#ifdef HAVE_DBUS
/* check if we need to terminate a running Mousepad instance */
if (G_UNLIKELY (opt_quit))
{
/* try to terminate whatever is running */
if (!wikipad_dbus_client_terminate (&error))
{
g_error ("Failed to terminate a running instance: %s\n", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
#endif /* !HAVE_DBUS */
/* get the current working directory */
working_directory = g_get_current_dir ();
#ifdef HAVE_DBUS
if (G_LIKELY (!opt_disable_server))
{
/* check if we can reuse an existing instance */
if (wikipad_dbus_client_launch_files (filenames, working_directory, &error))
{
/* stop any running startup notification */
gdk_notify_startup_complete ();
/* cleanup */
g_free (working_directory);
g_strfreev (filenames);
/* print errors, if needed */
if (G_UNLIKELY (error))
{
g_error ("Wikipad: %s\n", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
}
#endif /* !HAVE_DBUS */
/* use the Mousepad icon as default for new windows */
gtk_window_set_default_icon_name ("accessories-text-editor");
/* create a new wikipad application */
application = wikipad_application_get ();
/* open an empty window (with an empty document or the files) */
wikipad_application_new_window_with_files (application, NULL, working_directory, filenames);
/* cleanup */
g_free (working_directory);
g_strfreev (filenames);
/* do not enter the main loop, unless we have atleast one window */
if (G_LIKELY (wikipad_application_has_windows (application)))
{
#ifdef HAVE_DBUS
/* register with dbus */
dbus_service = g_object_new (WIKIPAD_TYPE_DBUS_SERVICE, NULL);
#endif
/* enter the main loop */
gtk_main ();
#ifdef HAVE_DBUS
/* release dbus service reference */
g_object_unref (G_OBJECT (dbus_service));
#endif
}
/* release application reference */
g_object_unref (G_OBJECT (application));
return EXIT_SUCCESS;
}
