libnm_glib_ctx *
libnm_glib_init (void)
{
libnm_glib_ctx *ctx = NULL;
#if !GLIB_CHECK_VERSION (2, 35, 0)
g_type_init ();
#endif
if (!g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
if (!(ctx = _libnm_glib_ctx_new ()))
return NULL;
ctx->thread = g_thread_create (_libnm_glib_dbus_worker, ctx, TRUE, NULL);
if (!ctx->thread)
goto error;
/* Wait until initialization of the thread */
while (!ctx->thread_inited)
g_usleep (G_USEC_PER_SEC / 20);
return ctx;
error:
_libnm_glib_ctx_free (ctx);
return NULL;
}
// General initialization. Takes care of all the other stuff.
const backend_kwallet_context_t* dt_pwstorage_kwallet_new()
{
_context = g_malloc(sizeof(backend_kwallet_context_t));
// NULL the context
memset(_context, 0, sizeof(backend_kwallet_context_t));
#if GLIB_MAJOR_VERSION <= 2
#if GLIB_MINOR_VERSION < 31
// Initialize threading in dbus-glib - it should be fine for
// dbus_g_thread_init to be called multiple times.
if (!g_thread_supported())
g_thread_init(NULL);
#endif
#endif
dbus_g_thread_init();
GError* error = NULL;
// Get a connection to the session bus.
_context->connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
if (CheckError(error))
return NULL;
if (!init_kwallet())
{
// kwalletd may not be running. Try to start it and try again.
if (!start_kwallet() || !init_kwallet())
return NULL;
}
return _context;
}
void* dbus_listen_for_signals(void* user_data)
{
DBusError error;
dbus_error_init(&error);
GMainContext* mainContext=g_main_context_new();
GMainLoop* loop = g_main_loop_new (mainContext, 0);
dbus_g_thread_init();
bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (bus == NULL) {
g_printerr("Failed to open connection to bus: %s", error.message);
dbus_error_free(&error);
return NULL;
}
dbus_connection_setup_with_g_main (bus, mainContext);
dbus_bus_add_match(bus, "interface='" SERVICE_NAME "'", &error);
if(dbus_connection_add_filter(bus, signal_filter, user_data, NULL)==FALSE)
qDebug("dbus_connection_add_filter returned false !\n");
g_main_loop_run(loop);
return NULL;
}
int main(int argc, char **argv)
{
QSibDiscovery *dis;
QTestApp *t_app;
QApplication app(argc, argv);
g_type_init();
dbus_g_thread_init();
dis = new QSibDiscovery(&app);
t_app = new QTestApp;
QObject::connect( dis, SIGNAL( sibList(const QList<QSibInfo *>& ) ),
t_app, SLOT( sibList(const QList<QSibInfo *>& ) ) );
QObject::connect( dis, SIGNAL( sibInserted(const QSibInfo *) ),
t_app, SLOT( sibInserted(const QSibInfo * ) ) );
QObject::connect( dis, SIGNAL( sibRemoved( QString) ),
t_app, SLOT( sibRemoved( QString ) ) );
dis->getSibs();
t_app->show();
return app.exec();
}
void gnome_remote_init ()
{
DBusGConnection *bus;
GError *error = NULL;
dbus_g_thread_init();
bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if ((bus == NULL) || error) {
g_warning ("Error connecting to DBus: %s", error->message);
} else {
media_player_keys_proxy = dbus_g_proxy_new_for_name (bus,
"org.gnome.SettingsDaemon",
"/org/gnome/SettingsDaemon/MediaKeys",
"org.gnome.SettingsDaemon.MediaKeys");
if (media_player_keys_proxy == NULL) return;
dbus_g_proxy_call (media_player_keys_proxy,
"GrabMediaPlayerKeys", &error,
G_TYPE_STRING, "Audacious",
G_TYPE_UINT, 0,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error != NULL) {
g_error_free (error);
error = NULL;
g_object_unref(media_player_keys_proxy);
media_player_keys_proxy = NULL;
media_player_keys_proxy = dbus_g_proxy_new_for_name (bus,
"org.gnome.SettingsDaemon",
"/org/gnome/SettingsDaemon",
"org.gnome.SettingsDaemon");
if (media_player_keys_proxy == NULL) return;
dbus_g_proxy_call (media_player_keys_proxy,
"GrabMediaPlayerKeys", &error,
G_TYPE_STRING, "Audacious",
G_TYPE_UINT, 0,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error != NULL) {
g_warning ("Could not grab media player keys: %s", error->message);
g_error_free (error);
g_object_unref(media_player_keys_proxy);
media_player_keys_proxy = NULL;
return;
}
}
dbus_g_object_register_marshaller (hotkey_marshal_VOID__STRING_STRING,
G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_add_signal (media_player_keys_proxy, "MediaPlayerKeyPressed",
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (media_player_keys_proxy, "MediaPlayerKeyPressed",
G_CALLBACK (on_media_player_key_pressed), NULL, NULL);
}
}
int
main (int argc, char *argv[])
{
g_thread_init (NULL);
dbus_g_thread_init ();
#ifndef DBUS_DISABLE_ASSERT
g_printerr ("You should probably --disable-asserts before you profile as they have noticeable overhead\n");
#endif
#if DBUS_ENABLE_VERBOSE_MODE
g_printerr ("You should probably --disable-verbose-mode before you profile as verbose has noticeable overhead\n");
#endif
payload = g_malloc (PAYLOAD_SIZE);
/* The actual size of the DBusMessage on the wire, as of Nov 23 2004,
* without the payload
*/
echo_call_size = 140 + PAYLOAD_SIZE;
echo_return_size = 32;
if (argc > 1 && strcmp (argv[1], "plain_sockets") == 0)
do_profile_run (&plain_sockets_vtable);
else if (argc > 1 && strcmp (argv[1], "plain_sockets_with_malloc") == 0)
do_profile_run (&plain_sockets_with_malloc_vtable);
else if (argc > 1 && strcmp (argv[1], "no_bus") == 0)
do_profile_run (&no_bus_vtable);
else if (argc > 1 && strcmp (argv[1], "with_bus") == 0)
do_profile_run (&with_bus_vtable);
else if (argc > 1 && strcmp (argv[1], "all") == 0)
{
double e1, e2, e3, e4;
e1 = do_profile_run (&plain_sockets_vtable);
e2 = do_profile_run (&plain_sockets_with_malloc_vtable);
e3 = do_profile_run (&no_bus_vtable);
e4 = do_profile_run (&with_bus_vtable);
g_printerr ("Baseline plain sockets time %g seconds for %d iterations\n",
e1, N_ITERATIONS);
print_result (&plain_sockets_vtable, e1, e1);
print_result (&plain_sockets_with_malloc_vtable, e2, e1);
print_result (&no_bus_vtable, e3, e1);
print_result (&with_bus_vtable, e4, e1);
}
else
{
g_printerr ("Specify profile type plain_sockets, plain_sockets_with_malloc, no_bus, with_bus, all\n");
exit (1);
}
/* Make valgrind happy */
dbus_shutdown ();
return 0;
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
GsdDatetimeMechanism *mechanism;
DBusGProxy *bus_proxy;
DBusGConnection *connection;
int ret;
ret = 1;
if (! g_thread_supported ()) {
g_thread_init (NULL);
}
dbus_g_thread_init ();
g_type_init ();
connection = get_system_bus ();
if (connection == NULL) {
goto out;
}
bus_proxy = get_bus_proxy (connection);
if (bus_proxy == NULL) {
g_warning ("Could not construct bus_proxy object; bailing out");
goto out;
}
if (!acquire_name_on_proxy (bus_proxy) ) {
g_warning ("Could not acquire name; bailing out");
goto out;
}
mechanism = gsd_datetime_mechanism_new ();
if (mechanism == NULL) {
goto out;
}
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_object_unref (mechanism);
g_main_loop_unref (loop);
ret = 0;
out:
return ret;
}
/**
* mate_vfs_init:
*
* If mate-vfs is not already initialized, initialize it. This must be
* called prior to performing any other mate-vfs operations, and may
* be called multiple times without error.
*
* Return value: %TRUE if mate-vfs is successfully initialized (or was
* already initialized).
*/
gboolean
mate_vfs_init (void)
{
gboolean retval;
/*
char *bogus_argv[2] = { "dummy", NULL };
*/
if (!ensure_dot_mate_exists ()) {
return FALSE;
}
if (!g_thread_supported ())
g_thread_init (NULL);
G_LOCK (vfs_already_initialized);
if (!vfs_already_initialized) {
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, MATE_VFS_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
mate_vfs_thread_init ();
#ifdef USE_DAEMON
dbus_g_thread_init ();
#endif
/* Make sure the type system is inited. */
g_type_init ();
retval = mate_vfs_method_init ();
if (retval) {
retval = _mate_vfs_configuration_init ();
}
#ifdef SIGPIPE
if (retval) {
signal (SIGPIPE, SIG_IGN);
}
#endif
} else {
retval = TRUE; /* Who cares after all. */
}
vfs_already_initialized = TRUE;
G_UNLOCK (vfs_already_initialized);
return retval;
}
int
main (int argc, char **argv)
{
GtkTreeModel *model;
GtkWidget *tree;
GtkWidget *window;
GtkWidget *scrolled;
if (!g_thread_supported ())
{
g_thread_init (NULL);
}
gtk_init (&argc, &argv);
dbus_g_thread_init ();
dbus_g_object_register_marshaller (connman_marshal_VOID__STRING_BOXED,
/* return */
G_TYPE_NONE,
/* args */
G_TYPE_STRING,
G_TYPE_VALUE,
/* eom */
G_TYPE_INVALID);
model = carrick_network_model_new ();
tree = create_tree (model);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree),
GTK_TREE_MODEL (model));
gtk_widget_show (tree);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled),
tree);
gtk_widget_show (scrolled);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window,
"delete-event",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_container_add (GTK_CONTAINER (window),
scrolled);
gtk_widget_show (window);
gtk_main ();
return 0;
}
int
main ()
{
CalcServer *server;
GMainLoop *loop;
dbus_g_thread_init ();
loop = g_main_loop_new (NULL, FALSE);
server = g_object_new (TYPE_CALC_SERVER, NULL);
if (calc_server_init (server))
{
g_main_loop_run (loop);
}
return 0;
}
int main(int argc, char *argv[])
{
GError *error = NULL;
gint32 err;
g_type_init();
g_thread_init(NULL);
err = process_args(argc, argv);
if (err < 0) {
usage(argv[0]);
exit(1);
}
dbus_g_thread_init();
dbus_threads_init_default();
init_log("notifucation_test", verbose);
connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
if (connection == NULL) {
log(LOG_ERR, "Can't connect to system bus: %s\n",
error->message);
g_error_free(error);
return -1;
}
proxy = dbus_g_proxy_new_for_name(connection, "com.test.Notification",
"/com/test/Notification", "com.test.Notification");
dbus_g_proxy_add_signal(proxy, "Notify",G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "Notify", test_callback, NULL, NULL);
// proxy = dbus_g_proxy_new_for_name(connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus");
// dbus_g_proxy_add_signal(proxy, "NameOwnerChanged", G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING, G_TYPE_INVALID);
// dbus_g_proxy_connect_signal(proxy, "NameOwnerChanged", test_callback, NULL, NULL);
err = run_main_loop();
if (err < 0) {
log(LOG_ERR, "Can't run main loop\n");
exit(1);
}
return 0;
}
int main (int argc, char *argv[])
{
struct sigaction sig_action, old_action;
MBMManager *manager;
MBMManagerPrivate *priv;
sig_action.sa_handler = sig_quit;
sigemptyset (&sig_action.sa_mask);
sigaddset (&sig_action.sa_mask, SIGINT);
sigaddset (&sig_action.sa_mask, SIGTERM);
sigaddset (&sig_action.sa_mask, SIGHUP);
sig_action.sa_flags = 0;
sigaction (SIGINT, &sig_action, &old_action);
sigaction (SIGTERM, &sig_action, NULL);
sigaction (SIGHUP, &sig_action, NULL);
mbm_options_parse (argc, argv);
g_type_init ();
if (!g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
g_debug ("Started version: %s", VERSION);
init_settings_table ();
load_settings ();
save_settings ();
g_loop = g_main_loop_new (NULL, FALSE);
if (!dbus_init (g_loop))
return -1;
g_manager = manager = mbm_manager_new ();
priv = MBM_MANAGER_GET_PRIVATE (manager);
g_main_loop_run (g_loop);
g_object_unref (manager);
}
int
main (int argc, char *argv[])
{
GMainLoop *loop;
DBusServer *server;
DBusError error;
g_thread_init (NULL);
dbus_g_thread_init ();
if (argc < 2)
{
fprintf (stderr, "Give the server address as an argument\n");
return 1;
}
dbus_error_init (&error);
#ifndef __SYMBIAN32__
server = dbus_server_listen (argv[1], &error);
#else
server = dbus_server_listen ("tcp:host=localhost,port=12435", &error);
#endif
if (server == NULL)
{
fprintf (stderr, "Failed to start server on %s: %s\n",
argv[1], error.message);
dbus_error_free (&error);
return 1;
}
dbus_server_set_new_connection_function (server,
new_connection_callback,
NULL, NULL);
dbus_server_setup_with_g_main (server, NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_run (loop);
return 0;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
gboolean program_version = FALSE;
gboolean timed_exit = FALSE;
GpkCheckUpdate *cupdate = NULL;
GpkWatch *watch = NULL;
GpkFirmware *firmware = NULL;
GpkHardware *hardware = NULL;
GOptionContext *context;
UniqueApp *unique_app;
gboolean ret;
const GOptionEntry options[] = {
{ "timed-exit", '\0', 0, G_OPTION_ARG_NONE, &timed_exit,
_("Exit after a small delay"), NULL },
{ "version", '\0', 0, G_OPTION_ARG_NONE, &program_version,
_("Show the program version and exit"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
if (! g_thread_supported ())
g_thread_init (NULL);
g_type_init ();
gtk_init (&argc, &argv);
dbus_g_thread_init ();
notify_init ("gpk-update-icon");
/* TRANSLATORS: program name, a session wide daemon to watch for updates and changing system state */
g_set_application_name (_("Update Applet"));
context = g_option_context_new (NULL);
g_option_context_set_summary (context, _("Update Applet"));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, egg_debug_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
if (program_version) {
g_print (VERSION "\n");
return 0;
}
/* TRANSLATORS: title to pass to to the user if there are not enough privs */
ret = gpk_check_privileged_user (_("Update applet"), FALSE);
if (!ret) {
egg_warning ("Exit: gpk_check_privileged_user returned FALSE");
return 1;
}
/* are we already activated? */
unique_app = unique_app_new ("org.freedesktop.PackageKit.UpdateIcon", NULL);
if (unique_app_is_running (unique_app)) {
egg_debug ("You have another instance running. This program will now close");
unique_app_send_message (unique_app, UNIQUE_ACTIVATE, NULL);
goto unique_out;
}
/* add application specific icons to search path */
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
GPK_DATA G_DIR_SEPARATOR_S "icons");
/* create new objects */
cupdate = gpk_check_update_new ();
watch = gpk_watch_new ();
firmware = gpk_firmware_new ();
hardware = gpk_hardware_new ();
/* Only timeout if we have specified iton the command line */
if (timed_exit)
g_timeout_add_seconds (120, (GSourceFunc) gtk_main_quit, NULL);
/* wait */
gtk_main ();
g_object_unref (cupdate);
g_object_unref (watch);
g_object_unref (firmware);
g_object_unref (hardware);
unique_out:
g_object_unref (unique_app);
return 0;
}
/*
* main
*
*/
int
main (int argc, char *argv[])
{
GOptionContext *opt_ctx = NULL;
gboolean become_daemon = FALSE;
gboolean g_fatal_warnings = FALSE;
char *pidfile = NULL, *state_file = NULL, *dhcp = NULL;
char *config = NULL, *plugins = NULL, *conf_plugins = NULL;
char *log_level = NULL, *log_domains = NULL;
char **dns = NULL;
gboolean success;
BMPolicy *policy = NULL;
BMDBusManager *dbus_mgr = NULL;
GError *error = NULL;
gboolean wrote_pidfile = FALSE;
char *cfg_log_level = NULL, *cfg_log_domains = NULL;
GOptionEntry options[] = {
{ "no-daemon", 0, 0, G_OPTION_ARG_NONE, &become_daemon, "Don't become a daemon", NULL },
{ "g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, "Make all warnings fatal", NULL },
{ "pid-file", 0, 0, G_OPTION_ARG_FILENAME, &pidfile, "Specify the location of a PID file", "filename" },
{ "state-file", 0, 0, G_OPTION_ARG_FILENAME, &state_file, "State file location", "/path/to/state.file" },
{ "config", 0, 0, G_OPTION_ARG_FILENAME, &config, "Config file location", "/path/to/config.file" },
{ "plugins", 0, 0, G_OPTION_ARG_STRING, &plugins, "List of plugins separated by ','", "plugin1,plugin2" },
{ "log-level", 0, 0, G_OPTION_ARG_STRING, &log_level, "Log level: one of [ERR, WARN, INFO, DEBUG]", "INFO" },
{ "log-domains", 0, 0, G_OPTION_ARG_STRING, &log_domains,
"Log domains separated by ',': any combination of [NONE,HW,BT,USER_SET,SYS_SET,SUSPEND,CORE,DEVICE]",
"HW" },
{NULL}
};
if (getuid () != 0) {
fprintf (stderr, "You must be root to run BarcodeManager!\n");
exit (1);
}
if (!g_module_supported ()) {
fprintf (stderr, "GModules are not supported on your platform!\n");
exit (1);
}
bindtextdomain (GETTEXT_PACKAGE, BMLOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Parse options */
opt_ctx = g_option_context_new ("");
g_option_context_set_translation_domain (opt_ctx, "UTF-8");
g_option_context_set_ignore_unknown_options (opt_ctx, FALSE);
g_option_context_set_help_enabled (opt_ctx, TRUE);
g_option_context_add_main_entries (opt_ctx, options, NULL);
g_option_context_set_summary (opt_ctx,
"BarcodeManager monitors all barcode scanners automatically.");
success = g_option_context_parse (opt_ctx, &argc, &argv, NULL);
g_option_context_free (opt_ctx);
if (!success) {
fprintf (stderr, _("Invalid option. Please use --help to see a list of valid options.\n"));
exit (1);
}
/* Make GIO ignore the remote VFS service; otherwise it tries to use the
* session bus to contact the remote service, and NM shouldn't ever be
* talking on the session bus. See rh #588745
*/
setenv ("GIO_USE_VFS", "local", 1);
pidfile = pidfile ? pidfile : g_strdup (BM_DEFAULT_PID_FILE);
state_file = state_file ? state_file : g_strdup (BM_DEFAULT_SYSTEM_STATE_FILE);
/* check pid file */
if (check_pidfile (pidfile))
exit (1);
/* Parse the config file */
if (config) {
if (!parse_config_file (config, &conf_plugins, &dhcp, &dns, &cfg_log_level, &cfg_log_domains, &error)) {
fprintf (stderr, "Config file %s invalid: (%d) %s\n",
config,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
exit (1);
}
} else {
gboolean parsed = FALSE;
/* Even though we prefer BarcodeManager.conf, we need to check the
* old bm-system-settings.conf first to preserve compat with older
* setups. In package managed systems dropping a BarcodeManager.conf
* onto the system would make NM use it instead of bm-system-settings.conf,
* changing behavior during an upgrade. We don't want that.
*/
/* Try deprecated bm-system-settings.conf first */
if (g_file_test (BM_OLD_SYSTEM_CONF_FILE, G_FILE_TEST_EXISTS)) {
config = g_strdup (BM_OLD_SYSTEM_CONF_FILE);
parsed = parse_config_file (config, &conf_plugins, &dhcp, &dns, &cfg_log_level, &cfg_log_domains, &error);
if (!parsed) {
fprintf (stderr, "Default config file %s invalid: (%d) %s\n",
config,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
g_free (config);
config = NULL;
g_clear_error (&error);
}
}
/* Try the preferred BarcodeManager.conf last */
if (!parsed && g_file_test (BM_DEFAULT_SYSTEM_CONF_FILE, G_FILE_TEST_EXISTS)) {
config = g_strdup (BM_DEFAULT_SYSTEM_CONF_FILE);
parsed = parse_config_file (config, &conf_plugins, &dhcp, &dns, &cfg_log_level, &cfg_log_domains, &error);
if (!parsed) {
fprintf (stderr, "Default config file %s invalid: (%d) %s\n",
config,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
g_free (config);
config = NULL;
g_clear_error (&error);
}
}
}
/* Logging setup */
if (!bm_logging_setup (log_level ? log_level : cfg_log_level,
log_domains ? log_domains : cfg_log_domains,
&error)) {
fprintf (stderr,
_("%s. Please use --help to see a list of valid options.\n"),
error->message);
exit (1);
}
/* Plugins specified with '--plugins' override those of config file */
plugins = plugins ? plugins : g_strdup (conf_plugins);
g_free (conf_plugins);
/* Parse the state file */
if (!parse_state_file (state_file, &error)) {
fprintf (stderr, "State file %s parsing failed: (%d) %s\n",
state_file,
error ? error->code : -1,
(error && error->message) ? error->message : "unknown");
/* Not a hard failure */
}
g_clear_error (&error);
/* Tricky: become_daemon is FALSE by default, so unless it's TRUE because
* of a CLI option, it'll become TRUE after this
*/
become_daemon = !become_daemon;
if (become_daemon) {
if (daemon (0, 0) < 0) {
int saved_errno;
saved_errno = errno;
fprintf (stderr, "Could not daemonize: %s [error %u]\n",
g_strerror (saved_errno),
saved_errno);
exit (1);
}
if (write_pidfile (pidfile))
wrote_pidfile = TRUE;
}
if (g_fatal_warnings) {
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
}
/*
* Set the umask to 0022, which results in 0666 & ~0022 = 0644.
* Otherwise, if root (or an su'ing user) has a wacky umask, we could
* write out an unreadable resolv.conf.
*/
umask (022);
g_type_init ();
if (!g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
#ifndef HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS
#error HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS not defined
#endif
#if HAVE_DBUS_GLIB_DISABLE_LEGACY_PROP_ACCESS
/* Ensure that non-exported properties don't leak out, and that the
* introspection 'access' permissions are respected.
*/
dbus_glib_global_set_disable_legacy_property_access ();
#endif
setup_signals ();
bm_logging_start (become_daemon);
bm_log_info (LOGD_CORE, "BarcodeManager (version " BM_DIST_VERSION ") is starting...");
success = FALSE;
if (config)
bm_log_info (LOGD_CORE, "Read config file %s", config);
main_loop = g_main_loop_new (NULL, FALSE);
/* Initialize our DBus service & connection */
dbus_mgr = bm_dbus_manager_get ();
manager = bm_manager_get (config, plugins, state_file, &error);
if (manager == NULL) {
bm_log_err (LOGD_CORE, "failed to initialize the barcode manager: %s",
error && error->message ? error->message : "(unknown)");
goto done;
}
policy = bm_policy_new (manager);
if (policy == NULL) {
bm_log_err (LOGD_CORE, "failed to initialize the policy.");
goto done;
}
/* Start our DBus service */
if (!bm_dbus_manager_start_service (dbus_mgr)) {
bm_log_err (LOGD_CORE, "failed to start the dbus service.");
goto done;
}
bm_manager_start (manager);
success = TRUE;
/* Told to quit before getting to the mainloop by the signal handler */
if (quit_early == TRUE)
goto done;
g_main_loop_run (main_loop);
done:
if (policy)
bm_policy_destroy (policy);
if (manager)
g_object_unref (manager);
bm_logging_shutdown ();
if (pidfile && wrote_pidfile)
unlink (pidfile);
/* Free options */
g_free (pidfile);
g_free (state_file);
g_free (config);
g_free (plugins);
g_free (dhcp);
g_strfreev (dns);
g_free (log_level);
g_free (log_domains);
g_free (cfg_log_level);
g_free (cfg_log_domains);
bm_log_info (LOGD_CORE, "exiting (%s)", success ? "success" : "error");
exit (success ? 0 : 1);
}
int
main (int argc, char **argv)
{
DBusGConnection *connection;
GError *error;
DBusGProxy *driver_proxy;
guint32 request_name_ret;
g_type_init ();
dbus_g_thread_init ();
dbus_g_error_domain_register (MY_OBJECT_ERROR,
NULL,
MY_TYPE_ERROR);
g_printerr ("Launching test-service-glib\n");
loop = g_main_loop_new (NULL, FALSE);
{
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
}
error = NULL;
connection = dbus_g_bus_get (DBUS_BUS_STARTER,
&error);
if (connection == NULL)
{
g_printerr ("Failed to open connection to bus: %s\n",
error->message);
g_error_free (error);
exit (1);
}
obj = g_object_new (MY_TYPE_OBJECT, NULL);
obj2 = g_object_new (MY_TYPE_OBJECT, NULL);
subobj = g_object_new (MY_TYPE_OBJECT_SUBCLASS, NULL);
dbus_g_connection_register_g_object (connection,
"/org/freedesktop/DBus/GLib/Tests/MyTestObject",
obj);
/* Register a second time; we want the object to also be reachable through this interface */
dbus_g_connection_register_g_object (connection,
"/org/freedesktop/DBus/GLib/Tests/Compat/MyTestObjectCompat",
obj);
dbus_g_connection_register_g_object (connection,
"/org/freedesktop/DBus/GLib/Tests/MyTestObject2",
obj2);
dbus_g_connection_register_g_object (connection,
"/org/freedesktop/DBus/GLib/Tests/MyTestObjectSubclass",
subobj);
driver_proxy = dbus_g_proxy_new_for_name (connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
if (!org_freedesktop_DBus_request_name (driver_proxy,
TEST_SERVICE_NAME,
0, &request_name_ret, &error))
{
g_assert (error != NULL);
g_printerr ("Failed to get name: %s\n",
error->message);
g_clear_error (&error);
exit (1);
}
if (!(request_name_ret == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER))
{
g_printerr ("Got result code %u from requesting name\n", request_name_ret);
exit (1);
}
g_printerr ("GLib test service has name '%s'\n", TEST_SERVICE_NAME);
g_printerr ("GLib test service entering main loop\n");
g_main_loop_run (loop);
g_printerr ("Successfully completed %s\n", argv[0]);
return 0;
}
/**
Application main.
Initializes internationalization, libosso, app and appview.
Calls user interface creation functions and gtk_main.
Follows the component initialization order of
osso-filemanager main.
@param argc Number of command line arguments
@param argv Command line arguments
@return 0 if successful; otherwise error code
*/
int
main(int argc, char *argv[])
{
gboolean result;
g_thread_init(NULL);
dbus_g_thread_init();
gdk_threads_init();
mainThread = g_thread_self();
/* Allocate application data structures */
app_data = g_new0(AppData, 1);
if (app_data == NULL)
{
OSSO_LOG_CRIT("Failed memory allocation: AppData");
exit(1);
}
/* there was no low memory ind from HW yet. */
app_data->low_memory = FALSE;
app_data->app_ui_data = g_new0(AppUIData, 1);
if (app_data->app_ui_data == NULL)
{
OSSO_LOG_CRIT("Failed memory allocation: AppUIData");
// free_app_data();
exit(1);
}
/* Add reference back to parent structure (AppData) */
app_data->app_ui_data->app_data = app_data;
/* init comapp_system */
init_comapp_system(app_data);
/* Initialize GnomeVFS */
result = gnome_vfs_init();
if (!result)
{
OSSO_LOG_CRIT("Failed initializing GnomeVFS");
return OSSO_ERROR;
}
/* Initialize GConf and read application configuration */
if (!init_settings(app_data))
{
OSSO_LOG_CRIT("Failed initializing GConf");
return OSSO_ERROR;
}
if (!get_configuration(argc, argv, app_data))
{
OSSO_LOG_CRIT("Failed reading configuration");
return OSSO_ERROR;
}
#ifdef ENABLE_NLS
/* Initialize localization */
/* Gettext does not seem to work properly without the following function
* call */
setlocale(LC_ALL, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif /* ENABLE_NLS */
/* Initialize GTK */
//gtk_init(&argc, &argv);
/* Initialize GTK+ and Hildon */
hildon_gtk_init(&argc, &argv);
/* Create application UI */
ui_create_main_window(app_data);
/* Initialize engine */
pdf_viewer_init(app_data->app_ui_data);
app_data->app_ui_data->password_dialog = NULL;
app_data->app_ui_data->replace_dialog = NULL;
//hildon_gtk_window_take_screenshot(GTK_WINDOW(app_data->app_ui_data->app_view), TRUE);
g_signal_connect(G_OBJECT(app_data->app_ui_data->app_view), "map-event",
G_CALLBACK(game_get_screenshot), NULL); //prasanna
GDK_THR_ENTER;
gtk_main();
GDK_THR_LEAVE;
if( !just_exit ) {
g_debug( "Save configuration..." );
save_configuration(app_data);
g_debug( "Deinit engine..." );
pdf_viewer_deinit();
g_debug( "Deinit compapp systems..." );
deinit_comapp_system(app_data);
g_debug( "Deinit settings..." );
deinit_settings();
g_debug( "Deinit mime..." );
free_mime_filters();
free_application_mime_types();
g_debug( "Deinit gnomevfs..." );
if (gnome_vfs_initialized()) {
gnome_vfs_shutdown();
}
}
/* Exit successfully, regardless of any errors */
g_debug( "Exit success" );
exit(EXIT_SUCCESS);
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
GConfDefaults *mechanism;
DBusGProxy *bus_proxy;
DBusGConnection *connection;
int ret;
GOptionContext *options;
GError *error = NULL;
ret = 1;
if (! g_thread_supported ()) {
g_thread_init (NULL);
}
dbus_g_thread_init ();
options = g_option_context_new (NULL);
g_option_context_add_main_entries (options, entries, NULL);
if (!g_option_context_parse (options, &argc, &argv, &error)) {
g_warning ("Failed to parse options: %s\n", error->message);
g_error_free (error);
}
g_option_context_free (options);
g_log_set_default_handler (log_default_handler, NULL);
if (debug) {
log_levels = log_levels | G_LOG_LEVEL_DEBUG;
}
connection = get_system_bus ();
if (connection == NULL) {
g_warning ("Could not get system bus connection; bailing out");
goto out;
}
bus_proxy = get_bus_proxy (connection);
if (bus_proxy == NULL) {
g_warning ("Could not construct bus_proxy object; bailing out");
goto out;
}
mechanism = gconf_defaults_new ();
if (mechanism == NULL) {
goto out;
}
if (!acquire_name_on_proxy (bus_proxy)) {
g_warning ("Could not acquire name; bailing out");
goto out;
}
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_object_unref (mechanism);
g_main_loop_unref (loop);
ret = 0;
out:
return ret;
}
void
hexchat_remote (void)
/* TODO: dbus_g_connection_unref (connection) are commented because it makes
* dbus to crash. Fixed in dbus >=0.70 ?!?
* https://launchpad.net/distros/ubuntu/+source/dbus/+bug/54375
*/
{
DBusGConnection *connection;
DBusGProxy *dbus = NULL;
DBusGProxy *remote_object = NULL;
gboolean hexchat_running;
GError *error = NULL;
char *command = NULL;
/* GnomeVFS >=2.15 uses D-Bus and threads, so threads should be
* initialised before opening for the first time a D-Bus connection */
if (!g_thread_supported ()) {
g_thread_init (NULL);
}
dbus_g_thread_init ();
/* if there is nothing to do, return now. */
if (!arg_existing || !(arg_url || arg_command)) {
return;
}
arg_dont_autoconnect = TRUE;
connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (!connection) {
write_error (_("Couldn't connect to session bus"), &error);
return;
}
/* Checks if HexChat is already running */
dbus = dbus_g_proxy_new_for_name (connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
if (!dbus_g_proxy_call (dbus, "NameHasOwner", &error,
G_TYPE_STRING, DBUS_SERVICE,
G_TYPE_INVALID,
G_TYPE_BOOLEAN, &hexchat_running,
G_TYPE_INVALID)) {
write_error (_("Failed to complete NameHasOwner"), &error);
hexchat_running = FALSE;
}
g_object_unref (dbus);
if (!hexchat_running) {
//dbus_g_connection_unref (connection);
return;
}
remote_object = dbus_g_proxy_new_for_name (connection,
DBUS_SERVICE,
DBUS_REMOTE,
DBUS_REMOTE_INTERFACE);
if (arg_url) {
command = g_strdup_printf ("url %s", arg_url);
} else if (arg_command) {
command = g_strdup (arg_command);
}
if (command) {
if (!dbus_g_proxy_call (remote_object, "Command",
&error,
G_TYPE_STRING, command,
G_TYPE_INVALID,G_TYPE_INVALID)) {
write_error (_("Failed to complete Command"), &error);
}
g_free (command);
}
exit (0);
}
void dbus_init()
{
dbus_g_thread_init();
init = TRUE;
}
int main (int argc, char *argv[])
{
struct sigaction sig_action, old_action;
MBMManager *manager;
sig_action.sa_handler = sig_quit;
sigemptyset (&sig_action.sa_mask);
sigaddset (&sig_action.sa_mask, SIGINT);
sigaddset (&sig_action.sa_mask, SIGTERM);
sigaddset (&sig_action.sa_mask, SIGHUP);
sig_action.sa_flags = 0;
sigaction (SIGINT, &sig_action, &old_action);
sigaction (SIGTERM, &sig_action, NULL);
sigaction (SIGHUP, &sig_action, NULL);
mbm_options_parse (argc, argv);
if (!mbm_foreground()) {
pid_t pid, sid;
pid = fork();
if (pid < 0) exit(EXIT_FAILURE);
if (pid > 0) exit(EXIT_SUCCESS);
umask(0);
sid = setsid();
if (sid < 0) exit(EXIT_FAILURE);
if ((chdir("/")) < 0) exit(EXIT_FAILURE);
g_log_set_default_handler(nolog, NULL);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}
/*
* Threading is always enabled starting from GLib 2.31.0.
* See also http://developer.gnome.org/glib/2.31/glib-Deprecated-Thread-APIs.html.
*/
#if !GLIB_CHECK_VERSION (2,31,0)
if (!g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
#else
dbus_threads_init_default ();
#endif
g_debug ("Started version: %s", VERSION);
init_settings_table ();
load_settings ();
save_settings ();
g_loop = g_main_loop_new (NULL, FALSE);
if (!dbus_init (g_loop))
return -1;
g_manager = manager = mbm_manager_new ();
g_main_loop_run (g_loop);
g_object_unref (manager);
}
int
main(int argc, char *argv[])
{
signal_user_data_t *ud;
GError *error = NULL;
GOptionContext *context;
#if defined(_WIN32)
// Tell gdk pixbuf where it's loader config file is.
_putenv_s("GDK_PIXBUF_MODULE_FILE", "ghb.exe.local/loaders.cache");
_putenv_s("GST_PLUGIN_PATH", "lib/gstreamer-1.0");
#endif
hb_global_init();
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
context = g_option_context_new(_("- Transcode media formats"));
g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
#if defined(_ENABLE_GST)
g_option_context_add_group(context, gst_init_get_option_group());
#endif
g_option_context_parse(context, &argc, &argv, &error);
if (error != NULL)
{
g_warning("%s: %s", G_STRFUNC, error->message);
g_clear_error(&error);
}
g_option_context_free(context);
#if defined(_WIN32)
if (win32_console)
{
// Enable console logging
if(AttachConsole(ATTACH_PARENT_PROCESS) || AllocConsole()){
close(STDOUT_FILENO);
freopen("CONOUT$", "w", stdout);
close(STDERR_FILENO);
freopen("CONOUT$", "w", stderr);
}
}
else
{
// Non-console windows apps do not have a stderr->_file
// assigned properly
stderr->_file = STDERR_FILENO;
stdout->_file = STDOUT_FILENO;
}
#endif
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_init(&argc, &argv);
GtkCssProvider *css = gtk_css_provider_new();
error = NULL;
gtk_css_provider_load_from_data(css, MyCSS, -1, &error);
if (error == NULL)
{
GdkScreen *ss = gdk_screen_get_default();
gtk_style_context_add_provider_for_screen(ss, GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
else
{
g_warning("%s: %s", G_STRFUNC, error->message);
g_clear_error(&error);
}
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->globals = ghb_dict_new();
ud->prefs = ghb_dict_new();
ud->settings_array = ghb_array_new();
ud->settings = ghb_dict_new();
ghb_array_append(ud->settings_array, ud->settings);
ud->builder = create_builder_or_die(BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes(ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
#if defined(_NO_UPDATE_CHECK)
GtkWidget *widget;
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
// Must set the names of the widgets that I want to modify
// style for.
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_hud"), "preview_hud");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_frame"), "preview_frame");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_play"), "live_preview_play");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_progress"), "live_preview_progress");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_encode_progress"), "live_encode_progress");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_duration"), "live_duration");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_show_crop"), "preview_show_crop");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_fullscreen"), "preview_fullscreen");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "activity_view"), "activity_view");
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "VideoOptionExtra"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)video_option_changed_cb, ud);
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "MetaLongDescription"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)plot_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full(ud->builder, MyConnect, ud);
ghb_init_audio_defaults_ui(ud);
ghb_init_subtitle_defaults_ui(ud);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_init(ud);
// Load prefs before presets. Some preset defaults may depend
// on preference settings.
// First load default values
ghb_settings_init(ud->prefs, "Preferences");
ghb_settings_init(ud->globals, "Globals");
ghb_settings_init(ud->settings, "Initialization");
ghb_settings_init(ud->settings, "OneTimeInitialization");
// Load user preferences file
ghb_prefs_load(ud);
// Store user preferences into ud->prefs
ghb_prefs_to_settings(ud->prefs);
int logLevel = ghb_dict_get_int(ud->prefs, "LoggingLevel");
ghb_backend_init(logLevel);
// Load the presets files
ghb_presets_load(ud);
// Note that ghb_preset_to_settings(ud->settings) is called when
// the default preset is selected.
ghb_settings_to_ui(ud, ud->globals);
ghb_settings_to_ui(ud, ud->prefs);
// Note that ghb_settings_to_ui(ud->settings) happens when initial
// empty title is initialized.
if (ghb_dict_get_bool(ud->prefs, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
const gchar *source = ghb_dict_get_string(ud->prefs, "default_source");
ghb_dvd_set_current(source, ud);
// Populate the presets tree view
ghb_presets_list_init(ud, NULL);
// Get the first preset name
if (arg_preset != NULL)
{
ghb_select_preset(ud->builder, arg_preset);
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies(ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_dict_set_string(ud->globals, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
else
{
GhbValue *gval = ghb_dict_get_value(ud->prefs, "default_source");
ghb_dict_set(ud->globals, "scan_source", ghb_value_dup(gval));
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add(200, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
GHB_THREAD_NEW("Cache Volume Names", (GThreadFunc)ghb_cache_volnames, ud);
GtkWidget *ghb_window = GHB_WIDGET(ud->builder, "hb_window");
gint window_width, window_height;
GdkGeometry geo = {
-1, -1, 1920, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
};
GdkWindowHints geo_mask;
geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
gtk_window_set_geometry_hints(GTK_WINDOW(ghb_window), ghb_window,
&geo, geo_mask);
window_width = ghb_dict_get_int(ud->prefs, "window_width");
window_height = ghb_dict_get_int(ud->prefs, "window_height");
/*
* Filter objects in GtkBuilder xml
* Unfortunately, GtkFilter is poorly supported by GtkBuilder,
* so a lot of the setup must happen in code.
SourceFilterAll
SourceFilterVideo
SourceFilterTS
SourceFilterMPG
SourceFilterEVO
SourceFilterVOB
SourceFilterMKV
SourceFilterMP4
SourceFilterAVI
SourceFilterMOV
SourceFilterOGG
SourceFilterFLV
SourceFilterWMV
*/
// Add filters to source chooser
GtkFileFilter *filter;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_filter_set_name(filter, _("All"));
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));
gtk_file_filter_set_name(filter, _("Video"));
gtk_file_filter_add_mime_type(filter, "video/*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));
gtk_file_filter_set_name(filter, "TS");
gtk_file_filter_add_pattern(filter, "*.ts");
gtk_file_filter_add_pattern(filter, "*.TS");
gtk_file_filter_add_pattern(filter, "*.m2ts");
gtk_file_filter_add_pattern(filter, "*.M2TS");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));
gtk_file_filter_set_name(filter, "MPG");
gtk_file_filter_add_pattern(filter, "*.mpg");
gtk_file_filter_add_pattern(filter, "*.MPG");
gtk_file_filter_add_pattern(filter, "*.mepg");
gtk_file_filter_add_pattern(filter, "*.MEPG");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));
gtk_file_filter_set_name(filter, "EVO");
gtk_file_filter_add_pattern(filter, "*.evo");
gtk_file_filter_add_pattern(filter, "*.EVO");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));
gtk_file_filter_set_name(filter, "VOB");
gtk_file_filter_add_pattern(filter, "*.vob");
gtk_file_filter_add_pattern(filter, "*.VOB");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV"));
gtk_file_filter_set_name(filter, "MKV");
gtk_file_filter_add_pattern(filter, "*.mkv");
gtk_file_filter_add_pattern(filter, "*.MKV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4"));
gtk_file_filter_set_name(filter, "MP4");
gtk_file_filter_add_pattern(filter, "*.mp4");
gtk_file_filter_add_pattern(filter, "*.MP4");
gtk_file_filter_add_pattern(filter, "*.m4v");
gtk_file_filter_add_pattern(filter, "*.M4V");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV"));
gtk_file_filter_set_name(filter, "MOV");
gtk_file_filter_add_pattern(filter, "*.mov");
gtk_file_filter_add_pattern(filter, "*.MOV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI"));
gtk_file_filter_set_name(filter, "AVI");
gtk_file_filter_add_pattern(filter, "*.avi");
gtk_file_filter_add_pattern(filter, "*.AVI");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG"));
gtk_file_filter_set_name(filter, "OGG");
gtk_file_filter_add_pattern(filter, "*.ogg");
gtk_file_filter_add_pattern(filter, "*.OGG");
gtk_file_filter_add_pattern(filter, "*.ogv");
gtk_file_filter_add_pattern(filter, "*.OGV");
gtk_file_filter_add_pattern(filter, "*.ogm");
gtk_file_filter_add_pattern(filter, "*.OGM");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV"));
gtk_file_filter_set_name(filter, "FLV");
gtk_file_filter_add_pattern(filter, "*.flv");
gtk_file_filter_add_pattern(filter, "*.FLV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV"));
gtk_file_filter_set_name(filter, "WMV");
gtk_file_filter_add_pattern(filter, "*.wmv");
gtk_file_filter_add_pattern(filter, "*.WMV");
gtk_file_chooser_add_filter(chooser, filter);
// Gtk has a really stupid bug. If the file chooser is showing
// hidden files AND there is no filter set, it will not select
// the filename when gtk_file_chooser_set_filename is called.
// So add a completely unnessary filter to prevent this behavior.
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_chooser_set_filter(chooser, filter);
#if !GTK_CHECK_VERSION(3, 16, 0)
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string("monospace 10");
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "activity_view"));
gtk_widget_override_font(GTK_WIDGET(textview), font_desc);
pango_font_description_free(font_desc);
#endif
// Grrrr! Gtk developers !!!hard coded!!! the width of the
// radio buttons in GtkStackSwitcher to 100!!!
//
// Thankfully, GtkStackSwitcher is a regular container object
// and we can access the buttons to change their width.
GList *stack_switcher_children, *link;
GtkContainer * stack_switcher = GTK_CONTAINER(
GHB_WIDGET(ud->builder, "SettingsStackSwitcher"));
link = stack_switcher_children = gtk_container_get_children(stack_switcher);
while (link != NULL)
{
GtkWidget *widget = link->data;
gtk_widget_set_size_request(widget, -1, -1);
gtk_widget_set_hexpand(widget, TRUE);
gtk_widget_set_halign(widget, GTK_ALIGN_FILL);
link = link->next;
}
g_list_free(stack_switcher_children);
gtk_window_resize(GTK_WINDOW(ghb_window), window_width, window_height);
gtk_widget_show(ghb_window);
// Everything should be go-to-go. Lets rock!
gtk_main();
ghb_backend_close();
ghb_value_free(&ud->queue);
ghb_value_free(&ud->settings_array);
ghb_value_free(&ud->prefs);
ghb_value_free(&ud->globals);
ghb_value_free(&ud->x264_priv);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
ghb_resource_free();
#if !defined(_WIN32)
notify_uninit();
#endif
g_object_unref(ud->builder);
g_free(ud->current_dvd_device);
g_free(ud);
return 0;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
gboolean program_version = FALSE;
GpkUpdateViewer *update_viewer = NULL;
GOptionContext *context;
UniqueApp *unique_app;
gboolean ret;
const GOptionEntry options[] = {
{ "version", '\0', 0, G_OPTION_ARG_NONE, &program_version,
/* TRANSLATORS: show the program version */
_("Show the program version and exit"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
if (! g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
g_type_init ();
gtk_init (&argc, &argv);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, _("Add/Remove Software"));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, egg_debug_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
if (program_version) {
g_print (VERSION "\n");
return 0;
}
/* add application specific icons to search path */
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
GPK_DATA G_DIR_SEPARATOR_S "icons");
/* TRANSLATORS: title to pass to to the user if there are not enough privs */
ret = gpk_check_privileged_user (_("Software Update Viewer"), TRUE);
if (!ret)
return 1;
/* are we already activated? */
unique_app = unique_app_new ("org.freedesktop.PackageKit.UpdateViewer", NULL);
if (unique_app_is_running (unique_app)) {
egg_debug ("You have another instance running. This program will now close");
unique_app_send_message (unique_app, UNIQUE_ACTIVATE, NULL);
goto unique_out;
}
/* create a new update_viewer object */
update_viewer = gpk_update_viewer_new ();
g_signal_connect (unique_app, "message-received",
G_CALLBACK (gpk_update_viewer_message_received_cb), update_viewer);
g_signal_connect (update_viewer, "action-close",
G_CALLBACK (gpk_update_viewer_close_cb), NULL);
/* wait */
gtk_main ();
g_object_unref (update_viewer);
unique_out:
g_object_unref (unique_app);
return 0;
}
/*
activesyncd entry point
*/
int main (int argc, char** argv)
{
DBusGConnection* bus = NULL;
DBusGProxy* busProxy = NULL;
EasSync* EasSyncObj = NULL;
EasCommon* EasCommonObj = NULL;
EasMail*EasMailObj = NULL;
EasTest* EasTestObj = NULL;
GMainLoop* loop = NULL;
guint result;
GError* error = NULL;
#if !GLIB_CHECK_VERSION(2,36,0)
g_type_init();
#endif
dbus_g_thread_init();
#if 0
g_log_set_handler (NULL,
G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL,
eas_logger,
NULL);
#endif
g_log_set_default_handler (eas_logger, NULL);
signal (SIGABRT, &signalHandler);
signal (SIGTERM, &signalHandler);
signal (SIGINT, &signalHandler);
loop = g_main_loop_new (NULL, FALSE);
if (loop == NULL) {
g_debug ("Error: Couldn't create GMainLoop");
exit (EXIT_FAILURE);
}
// Give signalHandler() access to the main loop.
g_mainloop = loop;
//Creating all the GObjects
g_debug ("activesyncd Daemon Started");
g_debug ("Creating eas_sync gobject.");
EasSyncObj = eas_sync_new();
if (EasSyncObj == NULL) {
g_debug ("Error: Failed to create calendar instance");
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
g_debug ("Creating common gobject.");
EasCommonObj = g_object_new (EAS_TYPE_COMMON , NULL);
if (EasCommonObj == NULL) {
g_debug ("Error: Failed to create common instance");
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
g_debug ("Creating mail gobject.");
EasMailObj = eas_mail_new ();
if (EasMailObj == NULL) {
g_debug ("Error: Failed to create common instance");
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
EasTestObj = eas_test_new ();
if (NULL == EasTestObj) {
g_debug ("Failed to make EasTest instance");
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
g_debug ("Connecting to the session DBus");
bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (error != NULL) {
g_debug ("Error: Connecting to the session DBus (%s)", error->message);
g_clear_error (&error);
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
g_debug ("Registering the well-known name (%s)", EAS_SERVICE_NAME);
busProxy = dbus_g_proxy_new_for_name (bus,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
if (busProxy == NULL) {
g_debug ("Error: Failed to get a proxy for D-Bus");
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
dbus_g_proxy_set_default_timeout (busProxy, 1000000);
/* register the well-known name.*/
g_debug ("D-Bus RequestName RPC ");
if (!dbus_g_proxy_call (busProxy,
"RequestName",
&error,
G_TYPE_STRING,
EAS_SERVICE_NAME,
G_TYPE_UINT,
0,
G_TYPE_INVALID,
G_TYPE_UINT,
&result,
G_TYPE_INVALID)) {
g_debug ("Error: D-Bus RequestName RPC failed (%s)", error->message);
g_clear_error (&error);
g_main_loop_quit (loop);
exit (EXIT_FAILURE);
}
g_debug ("RequestName returned %d", result);
if (result != 1) {
g_debug ("Error: Failed to get the primary well-known name");
exit (EXIT_FAILURE);
}
// Registering sync Gobject
dbus_g_connection_register_g_object (bus,
EAS_SERVICE_SYNC_OBJECT_PATH,
G_OBJECT (EasSyncObj));
// Registering common Gobject
dbus_g_connection_register_g_object (bus,
EAS_SERVICE_COMMON_OBJECT_PATH,
G_OBJECT (EasCommonObj));
// Registering mail Gobject
dbus_g_connection_register_g_object (bus,
EAS_SERVICE_MAIL_OBJECT_PATH,
G_OBJECT (EasMailObj));
dbus_g_connection_register_g_object (bus,
EAS_SERVICE_TEST_OBJECT_PATH,
G_OBJECT (EasTestObj));
g_debug ("Ready to serve requests");
#ifndef DISABLE_EAS_DAEMON
if (daemon (0, 0) != 0) {
g_debug ("Failed to daemonize");
}
#else
g_debug ("Not daemonizing (built with DISABLE_EAS_DAEMON)");
#endif
g_main_loop_run (loop);
// Clean up
g_debug ("Main Cleanup");
g_mainloop = NULL;
g_main_loop_unref (loop);
// clean up dbus and all its objects
if (EasSyncObj) {
g_debug ("Unregister and unref EasSyncObj");
dbus_g_connection_unregister_g_object (bus, G_OBJECT (EasSyncObj));
g_object_unref(EasSyncObj);
}
if (EasCommonObj) {
g_debug ("Unregister and unref EasCommonObj");
dbus_g_connection_unregister_g_object (bus, G_OBJECT (EasCommonObj));
g_object_unref(EasCommonObj);
}
if (EasMailObj) {
g_debug ("Unregister and unref EasMailObj");
dbus_g_connection_unregister_g_object (bus, G_OBJECT (EasMailObj));
g_object_unref(EasMailObj);
}
if (EasTestObj) {
g_debug ("Unregister and unref EasTestObj");
dbus_g_connection_unregister_g_object (bus, G_OBJECT (EasTestObj));
g_object_unref(EasTestObj);
}
if (busProxy) {
g_debug ("Unref busProxy");
g_object_unref(busProxy);
}
if(bus)
{
g_debug ("Flush and unref DBusConnection bus");
dbus_g_connection_flush (bus);
dbus_g_connection_unref(bus);
}
g_debug ("Exiting main()");
return 0;
}
int main (int argc, char **argv)
{
DBusGConnection *bus;
GError *error = NULL;
DBusGProxy *proxy;
gboolean run = FALSE;
gboolean quit = FALSE;
gboolean config = FALSE;
gboolean version = FALSE;
gboolean reload = FALSE;
gboolean no_daemon = FALSE;
gboolean debug = FALSE;
gboolean dump = FALSE;
gchar *client_id = NULL;
GOptionEntry option_entries[] =
{
{ "run",'r', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &run, NULL, NULL },
{ "no-daemon",'\0' , G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &no_daemon, N_("Do not daemonize"), NULL },
{ "debug",'\0' , G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &debug, N_("Enable debugging"), NULL },
{ "dump",'\0' , G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &dump, N_("Dump all information"), NULL },
{ "restart", '\0', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &reload, N_("Restart the running instance of Xfce power manager"), NULL},
{ "customize", 'c', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &config, N_("Show the configuration dialog"), NULL },
{ "quit", 'q', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &quit, N_("Quit any running xfce power manager"), NULL },
{ "version", 'V', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &version, N_("Version information"), NULL },
{ "sm-client-id", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_STRING, &client_id, NULL, NULL },
{ NULL, },
};
#if !GLIB_CHECK_VERSION (2, 32, 0)
if ( !g_thread_supported () )
g_thread_init (NULL);
#endif
dbus_g_thread_init ();
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
g_set_application_name (PACKAGE_NAME);
if (!gtk_init_with_args (&argc, &argv, (gchar *)"", option_entries, (gchar *)PACKAGE, &error))
{
if (G_LIKELY (error))
{
g_printerr ("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_printerr (_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_printerr ("\n");
g_error_free (error);
}
else
{
g_error ("Unable to open display.");
}
return EXIT_FAILURE;
}
if ( version )
{
show_version ();
}
xfpm_debug_init (debug);
if ( dump == FALSE && debug == FALSE && no_daemon == FALSE && daemon(0,0) )
{
g_critical ("Could not daemonize");
}
bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if ( error )
{
xfce_dialog_show_error (NULL,
error,
"%s",
_("Unable to get connection to the message bus session"));
g_error ("%s: \n", error->message);
}
if ( quit )
{
if (!xfpm_dbus_name_has_owner (dbus_g_connection_get_connection(bus),
"org.xfce.PowerManager") )
{
g_print (_("Xfce power manager is not running"));
g_print ("\n");
return EXIT_SUCCESS;
}
else
{
proxy = dbus_g_proxy_new_for_name (bus,
"org.xfce.PowerManager",
"/org/xfce/PowerManager",
"org.xfce.Power.Manager");
if ( !proxy )
{
g_critical ("Failed to get proxy");
dbus_g_connection_unref(bus);
return EXIT_FAILURE;
}
xfpm_manager_dbus_client_quit (proxy , &error);
g_object_unref (proxy);
if ( error)
{
g_critical ("Failed to send quit message %s:\n", error->message);
g_error_free (error);
}
}
return EXIT_SUCCESS;
}
if ( config )
{
g_spawn_command_line_async ("xfce4-power-manager-settings", &error);
if ( error )
{
g_critical ("Failed to execute xfce4-power-manager-settings: %s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
if ( reload )
{
if (!xfpm_dbus_name_has_owner (dbus_g_connection_get_connection (bus), "org.xfce.PowerManager") &&
!xfpm_dbus_name_has_owner (dbus_g_connection_get_connection (bus), "org.freedesktop.PowerManagement"))
{
g_print ("Xfce power manager is not running\n");
xfpm_start (bus, client_id, dump);
}
proxy = dbus_g_proxy_new_for_name (bus,
"org.xfce.PowerManager",
"/org/xfce/PowerManager",
"org.xfce.Power.Manager");
if ( !proxy )
{
g_critical ("Failed to get proxy");
dbus_g_connection_unref (bus);
return EXIT_FAILURE;
}
if ( !xfpm_manager_dbus_client_restart (proxy, NULL) )
{
g_critical ("Unable to send reload message");
g_object_unref (proxy);
dbus_g_connection_unref (bus);
return EXIT_SUCCESS;
}
return EXIT_SUCCESS;
}
if (dump)
{
if (xfpm_dbus_name_has_owner (dbus_g_connection_get_connection (bus),
"org.xfce.PowerManager"))
{
xfpm_dump_remote (bus);
return EXIT_SUCCESS;
}
}
if (xfpm_dbus_name_has_owner (dbus_g_connection_get_connection (bus), "org.freedesktop.PowerManagement") )
{
g_print ("%s: %s\n",
_("Xfce Power Manager"),
_("Another power manager is already running"));
}
else if (xfpm_dbus_name_has_owner (dbus_g_connection_get_connection(bus),
"org.xfce.PowerManager"))
{
g_print (_("Xfce power manager is already running"));
g_print ("\n");
return EXIT_SUCCESS;
}
else
{
xfpm_start (bus, client_id, dump);
}
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
signal_user_data_t *ud;
GValue *preset;
GError *error = NULL;
GOptionContext *context;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!g_thread_supported())
g_thread_init(NULL);
context = g_option_context_new ("- Transcode media formats");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#if defined(_ENABLE_GST)
g_option_context_add_group (context, gst_init_get_option_group ());
#endif
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free(context);
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_init (&argc, &argv);
gtk_rc_parse_string(hud_rcstyle);
g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON));
g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL);
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_register_transforms();
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->settings = ghb_settings_new();
ud->builder = create_builder_or_die (BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes (ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
GtkWidget *widget;
#if defined(_NO_UPDATE_CHECK)
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
widget = GHB_WIDGET(ud->builder, "preview_hud");
gtk_widget_set_name(widget, "preview_hud");
widget = GHB_WIDGET(ud->builder, "preview_window");
gtk_widget_set_name(widget, "preview_window");
// Set up the "hud" control overlay for the preview window
GtkWidget *draw, *hud, *blender, *align;
align = GHB_WIDGET(ud->builder, "preview_window_alignment");
draw = GHB_WIDGET(ud->builder, "preview_image_align");
hud = GHB_WIDGET(ud->builder, "preview_hud");
// Set up compositing for hud
blender = ghb_compositor_new();
gtk_container_add(GTK_CONTAINER(align), blender);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85);
gtk_widget_show(blender);
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer (textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full (ud->builder, MyConnect, ud);
// Load all internal settings
ghb_settings_init(ud);
// Load the presets files
ghb_presets_load(ud);
ghb_prefs_load(ud);
ghb_prefs_to_ui(ud);
gint logLevel;
logLevel = ghb_settings_get_int(ud->settings, "LoggingLevel");
ghb_backend_init(logLevel);
if (ghb_settings_get_boolean(ud->settings, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
gchar *source = ghb_settings_get_string(ud->settings, "default_source");
ghb_dvd_set_current(source, ud);
g_free(source);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_parse_options(ud, "");
// Populate the presets tree view
ghb_presets_list_init(ud, NULL, 0);
// Get the first preset name
if (arg_preset != NULL)
{
preset = ghb_parse_preset_path(arg_preset);
if (preset)
{
ghb_select_preset(ud->builder, preset);
ghb_value_free(preset);
}
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies (ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_settings_set_string(ud->settings, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add (500, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
#if defined(_USE_APP_IND)
GtkUIManager * uim = GTK_UI_MANAGER(GHB_OBJECT(ud->builder, "uimanager1"));
GtkMenu *ai_menu = GTK_MENU(gtk_ui_manager_get_widget(uim, "/ui/tray_menu"));
ud->ai = app_indicator_new("HandBrake", "hb-icon", APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_menu( ud->ai, ai_menu );
app_indicator_set_label( ud->ai, "", "99.99%");
if (ghb_settings_get_boolean(ud->settings, "show_status"))
{
app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_ACTIVE );
}
else
{
app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_PASSIVE );
}
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si, FALSE );
#else
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si,
ghb_settings_get_boolean(ud->settings, "show_status"));
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_status_icon_set_has_tooltip(si, TRUE);
g_signal_connect(si, "query-tooltip",
status_icon_query_tooltip_cb, ud);
#else
gtk_status_icon_set_tooltip(si, "HandBrake");
#endif
#endif
// Ugly hack to keep subtitle table from bouncing around as I change
// which set of controls are visible
GtkRequisition req;
gint width, height;
widget = GHB_WIDGET(ud->builder, "SrtCodeset");
gtk_widget_size_request( widget, &req );
height = req.height;
widget = GHB_WIDGET(ud->builder, "srt_code_label");
gtk_widget_size_request( widget, &req );
height += req.height;
widget = GHB_WIDGET(ud->builder, "subtitle_table");
gtk_widget_set_size_request(widget, -1, height);
widget = GHB_WIDGET (ud->builder, "hb_window");
GdkGeometry geo = {
-1, -1, 1024, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
};
GdkWindowHints geo_mask;
geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
gtk_window_set_geometry_hints( GTK_WINDOW(widget), widget, &geo, geo_mask);
width = ghb_settings_get_int(ud->settings, "window_width");
height = ghb_settings_get_int(ud->settings, "window_height");
gtk_window_resize(GTK_WINDOW(widget), width, height);
gtk_widget_show(widget);
/*
* Filter objects in GtkBuilder xml
* Unfortunately, GtkFilter is poorly supported by GtkBuilder,
* so a lot of the setup must happen in code.
SourceFilterAll
SourceFilterVideo
SourceFilterTS
SourceFilterMPG
SourceFilterEVO
SourceFilterVOB
SourceFilterMKV
SourceFilterMP4
SourceFilterAVI
SourceFilterMOV
SourceFilterOGG
SourceFilterFLV
SourceFilterWMV
*/
// Add filters to source chooser
GtkFileFilter *filter;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_filter_set_name(filter, "All");
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));
gtk_file_filter_set_name(filter, "Video");
gtk_file_filter_add_mime_type(filter, "video/*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));
gtk_file_filter_set_name(filter, "TS");
gtk_file_filter_add_pattern(filter, "*.ts");
gtk_file_filter_add_pattern(filter, "*.TS");
gtk_file_filter_add_pattern(filter, "*.m2ts");
gtk_file_filter_add_pattern(filter, "*.M2TS");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));
gtk_file_filter_set_name(filter, "MPG");
gtk_file_filter_add_pattern(filter, "*.mpg");
gtk_file_filter_add_pattern(filter, "*.MPG");
gtk_file_filter_add_pattern(filter, "*.mepg");
gtk_file_filter_add_pattern(filter, "*.MEPG");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));
gtk_file_filter_set_name(filter, "EVO");
gtk_file_filter_add_pattern(filter, "*.evo");
gtk_file_filter_add_pattern(filter, "*.EVO");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));
gtk_file_filter_set_name(filter, "VOB");
gtk_file_filter_add_pattern(filter, "*.vob");
gtk_file_filter_add_pattern(filter, "*.VOB");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV"));
gtk_file_filter_set_name(filter, "MKV");
gtk_file_filter_add_pattern(filter, "*.mkv");
gtk_file_filter_add_pattern(filter, "*.MKV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4"));
gtk_file_filter_set_name(filter, "MP4");
gtk_file_filter_add_pattern(filter, "*.mp4");
gtk_file_filter_add_pattern(filter, "*.MP4");
gtk_file_filter_add_pattern(filter, "*.m4v");
gtk_file_filter_add_pattern(filter, "*.M4V");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV"));
gtk_file_filter_set_name(filter, "MOV");
gtk_file_filter_add_pattern(filter, "*.mov");
gtk_file_filter_add_pattern(filter, "*.MOV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI"));
gtk_file_filter_set_name(filter, "AVI");
gtk_file_filter_add_pattern(filter, "*.avi");
gtk_file_filter_add_pattern(filter, "*.AVI");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG"));
gtk_file_filter_set_name(filter, "OGG");
gtk_file_filter_add_pattern(filter, "*.ogg");
gtk_file_filter_add_pattern(filter, "*.OGG");
gtk_file_filter_add_pattern(filter, "*.ogv");
gtk_file_filter_add_pattern(filter, "*.OGV");
gtk_file_filter_add_pattern(filter, "*.ogm");
gtk_file_filter_add_pattern(filter, "*.OGM");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV"));
gtk_file_filter_set_name(filter, "FLV");
gtk_file_filter_add_pattern(filter, "*.flv");
gtk_file_filter_add_pattern(filter, "*.FLV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV"));
gtk_file_filter_set_name(filter, "WMV");
gtk_file_filter_add_pattern(filter, "*.wmv");
gtk_file_filter_add_pattern(filter, "*.WMV");
gtk_file_chooser_add_filter(chooser, filter);
// Gtk has a really stupid bug. If the file chooser is showing
// hidden files AND there is no filter set, it will not select
// the filename when gtk_file_chooser_set_filename is called.
// So add a completely unnessary filter to prevent this behavior.
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_chooser_set_filter(chooser, filter);
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string ("monospace 10");
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "activity_view"));
gtk_widget_modify_font(GTK_WIDGET(textview), font_desc);
pango_font_description_free (font_desc);
// Everything should be go-to-go. Lets rock!
gtk_main ();
gtk_status_icon_set_visible(si, FALSE);
ghb_backend_close();
if (ud->queue)
ghb_value_free(ud->queue);
ghb_value_free(ud->settings);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
#if !defined(_WIN32)
notify_uninit();
#endif
g_free(ud);
return 0;
}
int main(void)
{
#if !GLIB_CHECK_VERSION(2, 31, 0)
g_thread_init(NULL);
#endif
dbus_g_thread_init();
////////////////////////////////////
/// set to ignore child process terminated signal.
signal( SIGCHLD, SIG_IGN );
////////////////////////////////////
MSG_DEBUG("===========START MESSAGING FRAMEWORK==========");
// Reset message server ready flag
MsgSettingSetBool(VCONFKEY_MSG_SERVER_READY, false);
// Connect to DB
// MsgStoConnectDB();
// Open Contact Service
MsgOpenContactSvc();
// Clean up mms dir
InitMmsDir();
// Regist vconf CB.
MsgSettingRegVconfCB();
pthread_t startThreadId;
// start transaction manager
if (pthread_create(&startThreadId, NULL, StartMsgServer, NULL) != 0)
{
MSG_DEBUG("StartMsgServer not invoked: %s", strerror(errno));
return -1;
}
MsgTransactionManager::instance()->getTMStatus();
mainloop = g_main_loop_new(NULL, FALSE);
g_type_init();
g_idle_add(InitThreadFunc, NULL);
if (mainloop != NULL)
{
MSG_DEBUG("Start Messaging Framework!!!");
// Run GMainLoop
g_main_loop_run(mainloop);
}
else
{
MSG_DEBUG("Fail to start Messaging Framework!!!");
}
// Remove vconf CB
MsgSettingRemoveVconfCB();
// Close Contact Sevice
MsgCloseContactSvc();
// Disconnect to DB
MsgStoDisconnectDB();
return 0;
}
int
main (int argc, char *argv[])
{
UniqueApp *app;
UniqueMessageData *msg;
GError *error = NULL;
GOptionContext *context;
GOptionGroup *debug;
gulong debug_flags = 0;
LifereaDBus *dbus = NULL;
const gchar *initial_state = "shown";
gchar *feed = NULL;
int initialState;
gboolean show_tray_icon, start_in_tray;
#ifdef USE_SM
gchar *opt_session_arg = NULL;
#endif
GOptionEntry entries[] = {
{ "mainwindow-state", 'w', 0, G_OPTION_ARG_STRING, &initial_state, N_("Start Liferea with its main window in STATE. STATE may be `shown', `iconified', or `hidden'"), N_("STATE") },
#ifdef USE_SM
{ "session", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_STRING, &opt_session_arg, NULL, NULL },
#endif
{ "version", 'v', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version, N_("Show version information and exit"), NULL },
{ "add-feed", 'a', 0, G_OPTION_ARG_STRING, &feed, N_("Add a new subscription"), N_("uri") },
{ NULL }
};
GOptionEntry debug_entries[] = {
{ "debug-all", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all types"), NULL },
{ "debug-cache", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the cache handling"), NULL },
{ "debug-conf", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the configuration handling"), NULL },
{ "debug-db", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the database handling"), NULL },
{ "debug-gui", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all GUI functions"), NULL },
{ "debug-html", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Enables HTML rendering debugging. Each time Liferea renders HTML output it will also dump the generated HTML into ~/.liferea_1.6/output.xhtml"), NULL },
{ "debug-net", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all network activity"), NULL },
{ "debug-parsing", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all parsing functions"), NULL },
{ "debug-performance", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when a function takes too long to process"), NULL },
{ "debug-trace", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when entering/leaving functions"), NULL },
{ "debug-update", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the feed update processing"), NULL },
{ "debug-vfolder", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the search folder matching"), NULL },
{ "debug-verbose", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print verbose debugging messages"), NULL },
{ NULL }
};
if (!g_thread_supported ()) g_thread_init (NULL);
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
debug = g_option_group_new ("debug",
_("Print debugging messages for the given topic"),
_("Print debugging messages for the given topic"),
&debug_flags,
NULL);
g_option_group_set_translation_domain(debug, GETTEXT_PACKAGE);
g_option_group_add_entries (debug, debug_entries);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, N_("Liferea, the Linux Feed Reader"));
g_option_context_set_description (context, N_("For more information, please visit http://liferea.sourceforge.net/"));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_set_translation_domain(context, GETTEXT_PACKAGE);
g_option_context_add_group (context, debug);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error) {
g_print ("Error parsing options: %s\n", error->message);
}
set_debug_level (debug_flags);
/* Configuration necessary for network options, so it
has to be initialized before update_init() */
conf_init ();
#ifdef USE_DBUS
dbus_g_thread_init ();
#endif
/* We need to do the network initialization here to allow
network-manager to be setup before gtk_init() */
update_init ();
gtk_init (&argc, &argv);
/* Single instance checks */
app = unique_app_new_with_commands ("net.sourceforge.liferea", NULL,
"add_feed", COMMAND_ADD_FEED,
NULL);
if (unique_app_is_running (app)) {
g_print ("Liferea is already running\n");
unique_app_send_message (app, UNIQUE_ACTIVATE, NULL);
if (feed) {
msg = unique_message_data_new ();
unique_message_data_set_text (msg, feed, -1);
unique_app_send_message (app, COMMAND_ADD_FEED, msg);
}
return 1;
} else {
g_signal_connect (app, "message-received", G_CALLBACK (message_received_cb), NULL);
}
/* GTK theme support */
g_set_application_name (_("Liferea"));
gtk_window_set_default_icon_name ("liferea");
debug_start_measurement (DEBUG_DB);
/* order is important! */
db_init (); /* initialize sqlite */
xml_init (); /* initialize libxml2 */
#ifdef HAVE_LIBNOTIFY
notification_plugin_register (&libnotify_plugin);
#endif
social_init (); /* initialize social bookmarking */
#ifdef USE_DBUS
dbus = liferea_dbus_new ();
#else
debug0 (DEBUG_GUI, "Compiled without DBUS support.");
#endif
#ifdef USE_AVAHI
if (conf_get_bool_value (SYNC_AVAHI_ENABLED)) {
LifereaAvahiPublisher *avahiPublisher = NULL;
debug0 (DEBUG_CACHE, "Registering with AVAHI");
avahiPublisher = liferea_avahi_publisher_new ();
liferea_avahi_publisher_publish (avahiPublisher, conf_get_str_value (SYNC_AVAHI_SERVICE_NAME), 23632);
} else {
debug0 (DEBUG_CACHE, "Avahi support available, but disabled by preferences.");
}
#else
debug0 (DEBUG_CACHE, "Compiled without AVAHI support");
#endif
/* how to start liferea, command line takes precedence over preferences */
conf_get_bool_value (SHOW_TRAY_ICON, &show_tray_icon);
conf_get_bool_value (START_IN_TRAY, &start_in_tray);
if (g_str_equal(initial_state, "iconified")) {
initialState = MAINWINDOW_ICONIFIED;
} else if (g_str_equal(initial_state, "hidden") ||
(show_tray_icon && start_in_tray)) {
initialState = MAINWINDOW_HIDDEN;
} else {
initialState = MAINWINDOW_SHOWN;
}
liferea_shell_create (initialState);
g_set_prgname ("liferea");
#ifdef USE_SM
/* This must be after feedlist reading because some session
managers will tell Liferea to exit if Liferea does not
respond to SM requests within a minute or two. This starts
the main loop soon after opening the SM connection. */
session_init (BIN_DIR G_DIR_SEPARATOR_S "liferea", opt_session_arg);
session_set_cmd (NULL, initialState);
#endif
signal (SIGTERM, signal_handler);
signal (SIGINT, signal_handler);
signal (SIGHUP, signal_handler);
#ifndef G_OS_WIN32
signal (SIGBUS, fatal_signal_handler);
signal (SIGSEGV, fatal_signal_handler);
#endif
/* Note: we explicitely do not use the gdk_thread_*
locking in Liferea because it freezes the program
when running Flash applets in gtkmozembed */
runState = STATE_STARTING;
debug_end_measurement (DEBUG_DB, "startup");
if (feed)
feedlist_add_subscription (feed, NULL, NULL, 0);
gtk_main ();
g_object_unref (G_OBJECT (dbus));
return 0;
}
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);
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
gboolean program_version = FALSE;
GOptionContext *context;
GtkWidget *main_window;
GtkWidget *widget;
PkControl *control;
UniqueApp *unique_app;
guint retval;
guint xid = 0;
GError *error = NULL;
GMainLoop *loop;
const GOptionEntry options[] = {
{ "version", '\0', 0, G_OPTION_ARG_NONE, &program_version,
_("Show the program version and exit"), NULL },
{ "parent-window", 'p', 0, G_OPTION_ARG_INT, &xid,
/* TRANSLATORS: we can make this modal (stay on top of) another window */
_("Set the parent window to make this modal"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
if (! g_thread_supported ())
g_thread_init (NULL);
dbus_g_thread_init ();
g_type_init ();
gtk_init (&argc, &argv);
context = g_option_context_new (NULL);
/* TRANSLATORS: program name, an application to set per-user policy for updates */
g_option_context_set_summary(context, _("Software Update Preferences"));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, egg_debug_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
if (program_version) {
g_print (VERSION "\n");
return 0;
}
/* are we already activated? */
unique_app = unique_app_new ("org.freedesktop.PackageKit.Prefs", NULL);
if (unique_app_is_running (unique_app)) {
egg_debug ("You have another instance running. This program will now close");
unique_app_send_message (unique_app, UNIQUE_ACTIVATE, NULL);
goto unique_out;
}
g_signal_connect (unique_app, "message-received",
G_CALLBACK (gpk_prefs_message_received_cb), NULL);
/* get actions */
loop = g_main_loop_new (NULL, FALSE);
control = pk_control_new ();
g_signal_connect (control, "notify::network-state",
G_CALLBACK (gpk_prefs_notify_network_state_cb), NULL);
/* get UI */
builder = gtk_builder_new ();
retval = gtk_builder_add_from_file (builder, GPK_DATA "/gpk-prefs.ui", &error);
if (retval == 0) {
egg_warning ("failed to load ui: %s", error->message);
g_error_free (error);
goto out_build;
}
main_window = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_prefs"));
/* Hide window first so that the dialogue resizes itself without redrawing */
gtk_widget_hide (main_window);
gtk_window_set_icon_name (GTK_WINDOW (main_window), GPK_ICON_SOFTWARE_UPDATE_PREFS);
g_signal_connect (main_window, "delete_event",
G_CALLBACK (gpk_prefs_delete_event_cb), loop);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "checkbutton_mobile_broadband"));
gpk_prefs_notify_checkbutton_setup (widget, GPK_CONF_CONNECTION_USE_MOBILE);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close"));
g_signal_connect (widget, "clicked",
G_CALLBACK (gpk_prefs_close_cb), loop);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_help"));
g_signal_connect (widget, "clicked",
G_CALLBACK (gpk_prefs_help_cb), NULL);
/* update the combo boxes */
gpk_prefs_update_freq_combo_setup ();
gpk_prefs_upgrade_freq_combo_setup ();
gpk_prefs_auto_update_combo_setup ();
gtk_widget_show (main_window);
/* set the parent window if it is specified */
if (xid != 0) {
egg_debug ("Setting xid %i", xid);
gpk_window_set_parent_xid (GTK_WINDOW (main_window), xid);
}
/* get some data */
pk_control_get_properties_async (control, NULL, (GAsyncReadyCallback) gpk_prefs_get_properties_cb, loop);
/* wait */
g_main_loop_run (loop);
out_build:
g_main_loop_unref (loop);
g_object_unref (control);
g_object_unref (builder);
unique_out:
g_object_unref (unique_app);
return 0;
}
