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;
}
