int main (int argc, char **argv) { GtkApplication *app; gint retval; g_thread_init (NULL); gtk_init (&argc, &argv); empathy_gtk_init (); app = gtk_application_new (EMPATHY_DEBUGGER_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); g_set_application_name (_("Empathy Debugger")); /* Make empathy and empathy-debugger appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (app); return retval; }
/** * gimp_ui_init: * @prog_name: The name of the plug-in which will be passed as argv[0] to * gtk_init(). It's a convention to use the name of the * executable and _not_ the PDB procedure name. * @preview: This parameter is unused and exists for historical * reasons only. * * This function initializes GTK+ with gtk_init() and initializes GDK's * image rendering subsystem (GdkRGB) to follow the GIMP main program's * colormap allocation/installation policy. * * It also sets up various other things so that the plug-in user looks * and behaves like the GIMP core. This includes selecting the GTK+ * theme and setting up the help system as chosen in the GIMP * preferences. Any plug-in that provides a user interface should call * this function. **/ void gimp_ui_init (const gchar *prog_name, gboolean preview) { GdkScreen *screen; const gchar *display_name; gchar *themerc; g_return_if_fail (prog_name != NULL); if (gimp_ui_initialized) return; g_set_prgname (prog_name); display_name = gimp_display_name (); if (display_name) { #if defined (GDK_WINDOWING_X11) g_setenv ("DISPLAY", display_name, TRUE); #else g_setenv ("GDK_DISPLAY", display_name, TRUE); #endif } if (gimp_user_time ()) { /* Construct a fake startup ID as we only want to pass the * interaction timestamp, see _gdk_windowing_set_default_display(). */ gchar *startup_id = g_strdup_printf ("_TIME%u", gimp_user_time ()); g_setenv ("DESKTOP_STARTUP_ID", startup_id, TRUE); g_free (startup_id); } gtk_init (NULL, NULL); themerc = gimp_personal_rc_file ("themerc"); gtk_rc_add_default_file (themerc); g_free (themerc); gdk_set_program_class (gimp_wm_class ()); screen = gdk_screen_get_default (); gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen)); gimp_widgets_init (gimp_ui_help_func, gimp_context_get_foreground, gimp_context_get_background, gimp_ensure_modules); if (! gimp_show_tool_tips ()) gimp_help_disable_tooltips (); gimp_dialogs_show_help_button (gimp_show_help_button ()); gimp_ui_initialized = TRUE; }
static gboolean gdk_arg_class_cb (const char *key, const char *value, gpointer user_data, GError **error) { gdk_set_program_class (value); return TRUE; }
int main (int argc, char *argv[]) { GtkApplication *app; GObjectClass *app_class; gint retval; g_type_init (); #ifdef HAVE_CHEESE /* Used by the avatar chooser */ g_return_val_if_fail (cheese_gtk_init (&argc, &argv), 1); #endif empathy_init (); g_set_application_name (_("Empathy Accounts")); /* Make empathy and empathy-accounts appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); app = gtk_application_new (EMPATHY_ACCOUNTS_DBUS_NAME, G_APPLICATION_FLAGS_NONE); app_class = G_OBJECT_GET_CLASS (app); G_APPLICATION_CLASS (app_class)->local_command_line = local_cmdline; G_APPLICATION_CLASS (app_class)->activate = app_activate; retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (app); return retval; }
static void terminal_app_startup (GApplication *application) { const GActionEntry app_menu_actions[] = { { "preferences", app_menu_preferences_cb, NULL, NULL, NULL }, { "help", app_menu_help_cb, NULL, NULL, NULL }, { "about", app_menu_about_cb, NULL, NULL, NULL }, { "quit", app_menu_quit_cb, NULL, NULL, NULL } }; gs_unref_object GtkBuilder *builder; GError *error = NULL; G_APPLICATION_CLASS (terminal_app_parent_class)->startup (application); /* Need to set the WM class (bug #685742) */ gdk_set_program_class("Gnome-terminal"); g_action_map_add_action_entries (G_ACTION_MAP (application), app_menu_actions, G_N_ELEMENTS (app_menu_actions), application); builder = gtk_builder_new (); gtk_builder_add_from_resource (builder, TERMINAL_RESOURCES_PATH_PREFIX "ui/terminal-appmenu.ui", &error); g_assert_no_error (error); gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "appmenu"))); _terminal_debug_print (TERMINAL_DEBUG_SERVER, "Startup complete\n"); }
static void terminal_app_startup (GApplication *application) { const GActionEntry app_menu_actions[] = { { "preferences", app_menu_preferences_cb, NULL, NULL, NULL }, { "help", app_menu_help_cb, NULL, NULL, NULL }, { "about", app_menu_about_cb, NULL, NULL, NULL }, { "quit", app_menu_quit_cb, NULL, NULL, NULL } }; g_application_set_resource_base_path (application, TERMINAL_RESOURCES_PATH_PREFIX); G_APPLICATION_CLASS (terminal_app_parent_class)->startup (application); /* Need to set the WM class (bug #685742) */ gdk_set_program_class("Gnome-terminal"); g_action_map_add_action_entries (G_ACTION_MAP (application), app_menu_actions, G_N_ELEMENTS (app_menu_actions), application); app_load_css (application); _terminal_debug_print (TERMINAL_DEBUG_SERVER, "Startup complete\n"); }
/** * gimp_ui_init: * @prog_name: The name of the plug-in which will be passed as argv[0] to * gtk_init(). It's a convention to use the name of the * executable and _not_ the PDB procedure name or something. * @preview: This parameter is unused and exists for historical * reasons only. * * This function initializes GTK+ with gtk_init() and initializes GDK's * image rendering subsystem (GdkRGB) to follow the GIMP main program's * colormap allocation/installation policy. * * GIMP's colormap policy can be determinded by the user with the * gimprc variables @min_colors and @install_cmap. **/ void gimp_ui_init (const gchar *prog_name, gboolean preview) { const gchar *display_name; gchar *themerc; GdkScreen *screen; g_return_if_fail (prog_name != NULL); if (gimp_ui_initialized) return; g_set_prgname (prog_name); display_name = gimp_display_name (); if (display_name) { #if defined (GDK_WINDOWING_X11) const gchar var_name[] = "DISPLAY"; #else const gchar var_name[] = "GDK_DISPLAY"; #endif putenv (g_strdup_printf ("%s=%s", var_name, display_name)); } gtk_init (NULL, NULL); themerc = gimp_personal_rc_file ("themerc"); gtk_rc_add_default_file (themerc); g_free (themerc); gdk_set_program_class (gimp_wm_class ()); gdk_rgb_set_min_colors (gimp_min_colors ()); gdk_rgb_set_install (gimp_install_cmap ()); screen = gdk_screen_get_default (); gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen)); gimp_widgets_init (gimp_ui_help_func, gimp_context_get_foreground, gimp_context_get_background, gimp_ensure_modules); if (! gimp_show_tool_tips ()) gimp_help_disable_tooltips (); gimp_dialogs_show_help_button (gimp_show_help_button ()); gimp_ui_initialized = TRUE; }
void ephy_web_application_setup_from_profile_directory (const char *profile_directory) { const char *program_name; const char *id; char *app_icon; char *desktop_basename; char *desktop_filename; GDesktopAppInfo *desktop_info; g_assert (profile_directory != NULL); program_name = ephy_web_application_get_program_name_from_profile_directory (profile_directory); if (!program_name) exit (1); g_set_prgname (program_name); id = get_app_id_from_program_name (program_name); if (!id) exit (1); /* Get display name from desktop file */ desktop_basename = get_app_desktop_filename (id); desktop_filename = g_build_filename (profile_directory, desktop_basename, NULL); desktop_info = g_desktop_app_info_new_from_filename (desktop_filename); if (!desktop_info) { g_warning ("Required desktop file not present at %s", desktop_filename); exit (1); } g_set_application_name (g_app_info_get_name (G_APP_INFO (desktop_info))); app_icon = g_build_filename (profile_directory, EPHY_WEB_APP_ICON_NAME, NULL); gtk_window_set_default_icon_from_file (app_icon, NULL); /* We need to re-set this because we have already parsed the * options, which inits GTK+ and sets this as a side effect. */ gdk_set_program_class (program_name); g_free (app_icon); g_free (desktop_basename); g_free (desktop_filename); g_object_unref (desktop_info); }
int main (int argc, char *argv[]) { TpAccountManager *account_manager; GtkApplication *app; GObjectClass *app_class; gint retval; g_thread_init (NULL); empathy_init (); gtk_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Accounts")); /* Make empathy and empathy-accounts appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); app = gtk_application_new (EMPATHY_ACCOUNTS_DBUS_NAME, G_APPLICATION_HANDLES_COMMAND_LINE); app_class = G_OBJECT_GET_CLASS (app); G_APPLICATION_CLASS (app_class)->local_command_line = local_cmdline; account_manager = tp_account_manager_dup (); tp_proxy_prepare_async (account_manager, NULL, account_manager_ready_for_accounts_cb, NULL); g_signal_connect (app, "command-line", G_CALLBACK (app_command_line_cb), NULL); retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (account_manager); g_object_unref (app); return retval; }
void ephy_web_application_setup_from_desktop_file (GDesktopAppInfo *desktop_info) { GAppInfo *app_info; const char *wm_class; GIcon *icon; g_assert (G_IS_DESKTOP_APP_INFO (desktop_info)); app_info = G_APP_INFO (desktop_info); g_set_prgname (g_app_info_get_name (app_info)); g_set_application_name (g_app_info_get_display_name (app_info)); icon = g_app_info_get_icon (app_info); if (G_IS_FILE_ICON (icon)) { GFile *file = g_file_icon_get_file (G_FILE_ICON (icon)); char *path = file ? g_file_get_path (file) : NULL; if (path) { gtk_window_set_default_icon_from_file (path, NULL); g_free (path); } g_clear_object (&file); } else if (G_IS_THEMED_ICON (icon)) { const char * const *names = g_themed_icon_get_names (G_THEMED_ICON (icon)); if (names) gtk_window_set_default_icon_name (names[0]); } g_clear_object (&icon); /* We need to re-set this because we have already parsed the * options, which inits GTK+ and sets this as a side effect. */ wm_class = g_desktop_app_info_get_startup_wm_class (desktop_info); if (wm_class) gdk_set_program_class (wm_class); }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; gint retval; GtkSettings *gtk_settings; /* Init */ g_thread_init (NULL); #ifdef GDK_WINDOWING_X11 /* We can't call clutter_gst_init() before gtk_clutter_init(), so no choice * but to intiialise X11 threading ourself */ XInitThreads (); #endif /* Clutter needs this */ gdk_disable_multidevice (); optcontext = g_option_context_new (N_("- Empathy Audio/Video Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_group (optcontext, cogl_get_option_group ()); g_option_context_add_group (optcontext, clutter_get_option_group_without_init ()); g_option_context_add_group (optcontext, gtk_clutter_get_option_group ()); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-call init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); clutter_gst_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Audio/Video Client")); /* Make empathy and empathy-call appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); gtk_settings = gtk_settings_get_default (); g_object_set (G_OBJECT (gtk_settings), "gtk-application-prefer-dark-theme", TRUE, NULL); app = gtk_application_new (EMPATHY_CALL_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } call_windows = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL); /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); retval = g_application_run (G_APPLICATION (app), argc, argv); g_hash_table_unref (call_windows); g_object_unref (app); tp_clear_object (&call_factory); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }
static VALUE gdk_s_set_program_class(VALUE self, VALUE program_class) { gdk_set_program_class(RVAL2CSTR(program_class)); return self; }
void pApplication::initialize() { #if defined(DISPLAY_XORG) display = XOpenDisplay(nullptr); #endif settings = new Settings; settings->load(); //set WM_CLASS to Application::name() if(Application::state.name) gdk_set_program_class(Application::state.name); #if 1 int argc = 1; char* argv[] = {new char[5], nullptr}; strcpy(argv[0], "hiro"); #else //--g-fatal-warnings will force a trap on Gtk-CRITICAL errors //this allows gdb to perform a backtrace to find an error's origin point int argc = 2; char* argv[] = {new char[5], new char[19], nullptr}; strcpy(argv[0], "hiro"); strcpy(argv[1], "--g-fatal-warnings"); #endif char** argvp = argv; gtk_init(&argc, &argvp); GtkSettings* gtkSettings = gtk_settings_get_default(); //allow buttons to show icons g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON)); g_object_set(gtkSettings, "gtk-button-images", true, nullptr); #if defined(DISPLAY_WINDOWS) //there is a serious bug in GTK 2.24 for Windows with the "ime" (Windows IME) input method: //by default, it will be impossible to type in text fields at all. //there are various tricks to get around this; but they are unintuitive and unreliable. //the "ime" method is chosen when various international system locales (eg Japanese) are selected. //here, we override the default input method to use the "Simple" type instead to avoid the bug. //obviously, this has a drawback: in-place editing for IMEs will not work in this mode. g_object_set(gtkSettings, "gtk-im-module", "gtk-im-context-simple", nullptr); #endif gtk_rc_parse_string(R"( style "HiroWindow" { GtkWindow::resize-grip-width = 0 GtkWindow::resize-grip-height = 0 } class "GtkWindow" style "HiroWindow" style "HiroTreeView" { GtkTreeView::vertical-separator = 0 } class "GtkTreeView" style "HiroTreeView" style "HiroTabFrameCloseButton" { GtkWidget::focus-line-width = 0 GtkWidget::focus-padding = 0 GtkButton::default-border = {0, 0, 0, 0} GtkButton::default-outer-border = {0, 0, 0, 0} GtkButton::inner-border = {0, 1, 0, 0} } widget_class "*.<GtkNotebook>.<GtkHBox>.<GtkButton>" style "HiroTabFrameCloseButton" )"); pKeyboard::initialize(); }
bool GRELoadAndLaunch(const char* firefoxDir, const char* profile) { char xpcomDllPath[MAXPATHLEN]; snprintf(xpcomDllPath, MAXPATHLEN, "%s/%s", firefoxDir, XPCOM_DLL); if (NS_FAILED(XPCOMGlueStartup(xpcomDllPath))) { ErrorDialog("Couldn't load the XPCOM library"); return false; } if (NS_FAILED(XPCOMGlueLoadXULFunctions(kXULFuncs))) { ErrorDialog("Couldn't load libxul"); return false; } // Override the class name part of the WM_CLASS property, so that the // DE can match our window to the correct launcher char programClass[MAXPATHLEN]; snprintf(programClass, MAXPATHLEN, "owa-%s", profile); gdk_set_program_class(programClass); // NOTE: The GRE has successfully loaded, so we can use XPCOM now { // Scope for any XPCOM stuff we create ScopedLogging log; // Get the path to the runtime char rtPath[MAXPATHLEN]; snprintf(rtPath, MAXPATHLEN, "%s/%s", firefoxDir, kWEBAPPRT_PATH); // Get the path to the runtime's INI file char rtIniPath[MAXPATHLEN]; snprintf(rtIniPath, MAXPATHLEN, "%s/%s", rtPath, kWEBAPPRT_INI); // Load the runtime's INI from its path nsCOMPtr<nsIFile> rtINI; if (NS_FAILED(XRE_GetFileFromPath(rtIniPath, getter_AddRefs(rtINI)))) { ErrorDialog("Couldn't load the runtime INI"); return false; } bool exists; nsresult rv = rtINI->Exists(&exists); if (NS_FAILED(rv) || !exists) { ErrorDialog("The runtime INI doesn't exist"); return false; } nsXREAppData *webShellAppData; if (NS_FAILED(XRE_CreateAppData(rtINI, &webShellAppData))) { ErrorDialog("Couldn't read WebappRT application.ini"); return false; } SetAllocatedString(webShellAppData->profile, profile); SetAllocatedString(webShellAppData->name, profile); nsCOMPtr<nsIFile> directory; if (NS_FAILED(XRE_GetFileFromPath(rtPath, getter_AddRefs(directory)))) { ErrorDialog("Couldn't open runtime directory"); return false; } nsCOMPtr<nsIFile> xreDir; if (NS_FAILED(XRE_GetFileFromPath(firefoxDir, getter_AddRefs(xreDir)))) { ErrorDialog("Couldn't open XRE directory"); return false; } xreDir.forget(&webShellAppData->xreDirectory); NS_IF_RELEASE(webShellAppData->directory); directory.forget(&webShellAppData->directory); XRE_main(*pargc, *pargv, webShellAppData, 0); XRE_FreeAppData(webShellAppData); } return true; }
MidoriBrowser* midori_web_app_new (const gchar* webapp, gchar** open_uris, gchar** execute_commands, gint inactivity_reset, const gchar* block_uris) { guint i; g_return_val_if_fail (webapp != NULL, NULL); midori_paths_init (MIDORI_RUNTIME_MODE_APP, webapp); /* Set sanitized URI as class name which .desktop files use as StartupWMClass So dock type launchers can distinguish different apps with the same executable */ gchar* wm_class = g_strdelimit (g_strdup (webapp), ":.\\/", '_'); gdk_set_program_class (wm_class); g_free (wm_class); MidoriBrowser* browser = midori_browser_new (); g_signal_connect (browser, "new-window", G_CALLBACK (midori_frontend_browser_new_window_cb), NULL); g_signal_connect (browser, "show-preferences", G_CALLBACK (midori_browser_privacy_preferences_cb), NULL); midori_browser_set_action_visible (browser, "Menubar", FALSE); midori_browser_set_action_visible (browser, "CompactMenu", FALSE); #if ENABLE_ADDSPEEDDIAL midori_browser_set_action_visible (browser, "AddSpeedDial", FALSE); #endif midori_browser_set_action_visible (browser, "Navigationbar", FALSE); MidoriWebSettings* settings = midori_settings_new_full (NULL); g_object_set (settings, "show-menubar", FALSE, "show-navigationbar", FALSE, "toolbar-items", "Back,Forward,ReloadStop,Location,Homepage,Preferences", "show-statusbar", FALSE, "show-panel", FALSE, "last-window-state", MIDORI_WINDOW_NORMAL, "inactivity-reset", inactivity_reset, "block-uris", block_uris, NULL); midori_load_soup_session_full (settings); KatzeArray* search_engines = midori_search_engines_new_from_folder (NULL); g_object_set (browser, "show-tabs", open_uris != NULL, "settings", settings, NULL); midori_browser_set_action_visible (browser, "Panel", FALSE); g_object_unref (search_engines); if (webapp != NULL) { gchar* tmp_uri = sokoke_magic_uri (webapp, FALSE, TRUE); g_object_set (settings, "homepage", tmp_uri, NULL); midori_browser_add_uri (browser, tmp_uri); g_free (tmp_uri); } for (i = 0; open_uris && open_uris[i]; i++) { gchar* new_uri = sokoke_magic_uri (open_uris[i], FALSE, TRUE); midori_browser_add_uri (browser, new_uri); g_free (new_uri); } if (midori_browser_get_n_pages (browser) == 0) midori_browser_add_uri (browser, "about:blank"); gtk_widget_show (GTK_WIDGET (browser)); for (i = 0; execute_commands && execute_commands[i]; i++) { midori_browser_assert_action (browser, execute_commands[i]); midori_browser_activate_action (browser, execute_commands[i]); } midori_session_persistent_settings (settings, NULL); return browser; }
static void xpad_app_init (int argc, char **argv) { gboolean first_time; gboolean have_gtk; /* GdkVisual *visual;*/ /* Set up i18n */ #ifdef ENABLE_NLS gtk_set_locale (); bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif have_gtk = gtk_init_check (&argc, &argv); xpad_argc = argc; xpad_argv = argv; output = stdout; /* Set up config directory. */ first_time = !config_dir_exists (); config_dir = make_config_dir (); /* create master socket name */ server_filename = g_build_filename (xpad_app_get_config_dir (), "server", NULL); if (!have_gtk) { /* We don't have GTK+, but we can still do --version or --help and such. Plus, we can pass commands to a remote instance. */ process_local_args (&xpad_argc, &xpad_argv); if (!xpad_app_pass_args ()) { process_remote_args (&xpad_argc, &xpad_argv, FALSE); fprintf (output, "%s\n", _("Xpad is a graphical program. Please run it from your desktop.")); } exit (0); } g_set_application_name (_("Xpad")); gdk_set_program_class (PACKAGE); /* Set up translucency. */ /* visual = gdk_visual_get_best_with_depth (32); if (visual) { GdkColormap *colormap; colormap = gdk_colormap_new (visual, TRUE); gtk_widget_set_default_colormap (colormap); xpad_translucent = TRUE; }*/ /* Set up program path. */ if (xpad_argc > 0) program_path = g_find_program_in_path (xpad_argv[0]); else program_path = NULL; process_local_args (&xpad_argc, &xpad_argv); if (xpad_app_pass_args ()) exit (0); /* Race condition here, between calls */ xpad_app_open_proc_file (); register_stock_icons (); gtk_window_set_default_icon_name (PACKAGE); pad_group = xpad_pad_group_new(); process_remote_args (&xpad_argc, &xpad_argv, TRUE); xpad_tray_open (); xpad_session_manager_init (); /* load all pads */ pads_loaded_on_start = xpad_app_load_pads (); if (pads_loaded_on_start == 0 && !option_new) { if (!option_nonew) { GtkWidget *pad = xpad_pad_new (pad_group); gtk_widget_show (pad); } } g_idle_add ((GSourceFunc)xpad_app_first_idle_check, pad_group); if (first_time) show_help (); g_free (server_filename); server_filename = NULL; }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; gint retval; /* Init */ g_thread_init (NULL); optcontext = g_option_context_new (N_("- Empathy Audio/Video Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-av init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); clutter_gst_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Audio/Video Client")); g_setenv ("PULSE_PROP_media.role", "phone", TRUE); /* Make empathy and empathy-av appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); app = gtk_application_new (EMPATHY_AV_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (app); tp_clear_object (&call_factory); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }