BonoboObject *
gwget_application_server_new (GdkScreen *screen)
{
BonoboGenericFactory *factory;
char *display_name;
char *registration_id;
/* We must ensure an instance of gwget per screen
* as gwget has no multiscreen support
*/
display_name = gdk_screen_make_display_name (screen);
registration_id = bonobo_activation_make_registration_id (
"OAFIID:GNOME_Gwget_Factory",
display_name);
factory = bonobo_generic_factory_new ("OAFIID:GNOME_Gwget_Factory",
gwget_application_server_factory,
NULL);
if (!BONOBO_IS_GENERIC_FACTORY(factory))
g_message("Cant create corba factory");
g_free (display_name);
g_free (registration_id);
return BONOBO_OBJECT (factory);
}
static gchar *
gui_get_display_name (Gimp *gimp,
gint display_ID,
gint *monitor_number)
{
GimpDisplay *display = NULL;
GdkScreen *screen;
gint monitor;
if (display_ID > 0)
display = gimp_display_get_by_ID (gimp, display_ID);
if (display)
{
screen = gtk_widget_get_screen (display->shell);
monitor = gdk_screen_get_monitor_at_window (screen,
display->shell->window);
}
else
{
gint x, y;
gdk_display_get_pointer (gdk_display_get_default (),
&screen, &x, &y, NULL);
monitor = gdk_screen_get_monitor_at_point (screen, x, y);
}
*monitor_number = monitor;
if (screen)
return gdk_screen_make_display_name (screen);
return NULL;
}
void
window_actions_update (GimpActionGroup *group,
GtkWidget *window)
{
const gchar *group_name;
gint show_menu = FALSE;
gchar *name;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GTK_IS_WINDOW (window))
{
GdkDisplay *display;
GdkScreen *screen;
gchar *screen_name;
display = gtk_widget_get_display (window);
show_menu = (gdk_display_get_n_screens (display) > 1);
#ifdef GIMP_UNSTABLE
show_menu = TRUE;
#endif
if (! show_menu)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays;
displays = gdk_display_manager_list_displays (manager);
show_menu = (displays->next != NULL);
g_slist_free (displays);
}
screen = gtk_widget_get_screen (window);
screen_name = gdk_screen_make_display_name (screen);
name = g_strdup_printf ("%s-move-to-screen-%s", group_name, screen_name);
g_free (screen_name);
SET_ACTIVE (name, TRUE);
g_free (name);
}
name = g_strdup_printf ("%s-move-to-screen-menu", group_name);
SET_VISIBLE (name, show_menu);
g_free (name);
#undef SET_ACTIVE
#undef SET_VISIBLE
}
gboolean
panel_launch_desktop_file_with_fallback (const char *desktop_file,
const char *fallback_exec,
GdkScreen *screen,
GError **error)
{
char *argv[2] = { (char *) fallback_exec, NULL };
GError *local_error;
gboolean retval;
GPid pid;
char *display;
g_return_val_if_fail (desktop_file != NULL, FALSE);
g_return_val_if_fail (fallback_exec != NULL, FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* need to pass a non-NULL error to avoid getting a dialog */
local_error = NULL;
if (panel_launch_desktop_file (desktop_file, screen, &local_error))
return TRUE;
if (local_error) {
g_error_free (local_error);
local_error = NULL;
}
display = gdk_screen_make_display_name (screen);
retval = g_spawn_async (NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH,
set_environment,
&display,
&pid,
&local_error);
g_free (display);
if (local_error == NULL && retval == TRUE) {
g_child_watch_add (pid, dummy_child_watch, NULL);
}
return TRUE;
return _panel_launch_handle_error (fallback_exec,
screen, local_error, error);
}
static void
window_actions_display_closed (GdkDisplay *display,
gboolean is_error,
GimpActionGroup *group)
{
const gchar *group_name;
gint n_screens;
gint i;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
GtkAction *action;
gchar *screen_name;
gchar *action_name;
screen_name = gdk_screen_make_display_name (screen);
action_name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
g_free (screen_name);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
if (action)
{
GSList *radio_group;
radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (action));
if (radio_group->data == (gpointer) action)
radio_group = radio_group->next;
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group",
radio_group);
}
g_free (action_name);
}
}
static gchar *
gdk_app_launch_context_get_display (GAppLaunchContext *context,
GAppInfo *info,
GList *files)
{
GdkAppLaunchContext *ctx = GDK_APP_LAUNCH_CONTEXT (context);
GdkDisplay *display;
if (ctx->screen)
return gdk_screen_make_display_name (ctx->screen);
if (ctx->display)
display = ctx->display;
else
display = gdk_display_get_default ();
return g_strdup (gdk_display_get_name (display));
}
BonoboObject *
gth_application_new (GdkScreen *screen)
{
BonoboGenericFactory *factory;
char *display_name;
char *registration_id;
display_name = gdk_screen_make_display_name (screen);
registration_id = bonobo_activation_make_registration_id ("OAFIID:GNOME_GThumb_Application_Factory", display_name);
factory = bonobo_generic_factory_new (registration_id,
gth_application_factory,
NULL);
g_free (display_name);
g_free (registration_id);
return BONOBO_OBJECT (factory);
}
JNIEXPORT jstring JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeGetIDString
(JNIEnv *env, jobject obj)
{
GdkScreen *screen;
gchar* displayName;
jstring string;
screen = (GdkScreen *) NSA_GET_SCREEN_PTR(env, obj);
gdk_threads_enter();
displayName = gdk_screen_make_display_name(screen);
gdk_threads_leave();
string = (*env)->NewStringUTF(env, displayName);
g_free(displayName);
return string;
}
BonoboObject *
stardict_application_server_new (GdkScreen *screen)
{
BonoboGenericFactory *factory;
char *display_name;
char *registration_id;
/* We must ensure an instance of stardict per screen
* as stardict has no multiscreen support
*/
display_name = gdk_screen_make_display_name (screen);
registration_id = bonobo_activation_make_registration_id (
"OAFIID:GNOME_Stardict_Factory",
display_name);
factory = bonobo_generic_factory_new (registration_id,
stardict_application_server_factory,
NULL);
g_free (display_name);
g_free (registration_id);
return BONOBO_OBJECT (factory);
}
static void
window_actions_display_opened (GdkDisplayManager *manager,
GdkDisplay *display,
GimpActionGroup *group)
{
GimpRadioActionEntry *entries;
const gchar *help_id;
const gchar *group_name;
GSList *radio_group;
gint n_screens;
gint i;
help_id = g_object_get_data (G_OBJECT (group), "change-to-screen-help-id");
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
n_screens = gdk_display_get_n_screens (display);
entries = g_new0 (GimpRadioActionEntry, n_screens);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
gchar *screen_name;
screen_name = gdk_screen_make_display_name (screen);
entries[i].name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
entries[i].stock_id = GIMP_STOCK_MOVE_TO_SCREEN;
entries[i].label = g_strdup_printf (_("Screen %s"), screen_name);
entries[i].accelerator = NULL;
entries[i].tooltip = g_strdup_printf (_("Move this window to "
"screen %s"), screen_name);
entries[i].value = g_quark_from_string (screen_name);
entries[i].help_id = help_id;
g_free (screen_name);
}
radio_group = g_object_get_data (G_OBJECT (group),
"change-to-screen-radio-group");
radio_group = gimp_action_group_add_radio_actions (group, entries, n_screens,
radio_group, 0,
G_CALLBACK (window_move_to_screen_cmd_callback));
g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group",
radio_group);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
GtkAction *action;
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
entries[i].name);
if (action)
g_object_set_data (G_OBJECT (action), "screen", screen);
g_free ((gchar *) entries[i].name);
g_free ((gchar *) entries[i].tooltip);
g_free ((gchar *) entries[i].label);
}
g_free (entries);
g_signal_connect_object (display, "closed",
G_CALLBACK (window_actions_display_closed),
G_OBJECT (group), 0);
}
gboolean vfs_exec_on_screen( GdkScreen* screen,
const char* work_dir,
char** argv, char** envp,
const char* disp_name,
GSpawnFlags flags,
GError **err )
{
#ifdef HAVE_SN
SnLauncherContext * ctx = NULL;
SnDisplay* display;
#endif
gboolean ret;
GSpawnChildSetupFunc setup_func = NULL;
extern char **environ;
char** new_env = envp;
int i, n_env = 0;
char* display_name;
int display_index = -1, startup_id_index = -1;
if ( ! envp )
envp = environ;
n_env = g_strv_length(envp);
new_env = g_new0( char*, n_env + 4 );
for ( i = 0; i < n_env; ++i )
{
/* g_debug( "old envp[%d] = \"%s\"" , i, envp[i]); */
if ( 0 == strncmp( envp[ i ], "DISPLAY=", 8 ) )
display_index = i;
else
{
if ( 0 == strncmp( envp[ i ], "DESKTOP_STARTUP_ID=", 19 ) )
startup_id_index = i;
new_env[i] = g_strdup( envp[ i ] );
}
}
#ifdef HAVE_SN
display = sn_display_new ( GDK_SCREEN_XDISPLAY ( screen ),
( SnDisplayErrorTrapPush ) gdk_error_trap_push,
( SnDisplayErrorTrapPush ) gdk_error_trap_pop );
if ( G_LIKELY ( display ) )
{
if ( !disp_name )
disp_name = argv[ 0 ];
ctx = sn_launcher_context_new( display, gdk_screen_get_number( screen ) );
sn_launcher_context_set_description( ctx, disp_name );
sn_launcher_context_set_name( ctx, g_get_prgname() );
sn_launcher_context_set_binary_name( ctx, argv[ 0 ] );
sn_launcher_context_set_workspace ( ctx, tvsn_get_active_workspace_number( screen ) );
/* FIXME: I don't think this is correct, other people seem to use CurrentTime here.
However, using CurrentTime causes problems, so I so it like this.
Maybe this is incorrect, but it works, so, who cares?
*/
/* time( &cur_time ); */
sn_launcher_context_initiate( ctx, g_get_prgname(),
argv[ 0 ], gtk_get_current_event_time() /*cur_time*/ );
setup_func = (GSpawnChildSetupFunc) sn_launcher_context_setup_child_process;
if( startup_id_index >= 0 )
g_free( new_env[i] );
else
startup_id_index = i++;
new_env[ startup_id_index ] = g_strconcat( "DESKTOP_STARTUP_ID=",
sn_launcher_context_get_startup_id ( ctx ), NULL );
}
#endif
/* This is taken from gdk_spawn_on_screen */
display_name = gdk_screen_make_display_name ( screen );
if ( display_index >= 0 )
new_env[ display_index ] = g_strconcat( "DISPLAY=", display_name, NULL );
else
new_env[ i++ ] = g_strconcat( "DISPLAY=", display_name, NULL );
g_free( display_name );
new_env[ i ] = NULL;
ret = g_spawn_async( work_dir,
argv, new_env,
flags,
NULL, NULL,
NULL, err );
/* for debugging */
#if 0
g_debug( "debug vfs_execute_on_screen(): flags: %d, display_index=%d", flags, display_index );
for( i = 0; argv[i]; ++i ) {
g_debug( "argv[%d] = \"%s\"" , i, argv[i] );
}
for( i = 0; i < n_env /*new_env[i]*/; ++i ) {
g_debug( "new_env[%d] = \"%s\"" , i, new_env[i] );
}
if( ret )
g_debug( "the program was executed without error" );
else
g_debug( "launch failed: %s", (*err)->message );
#endif
g_strfreev( new_env );
#ifdef HAVE_SN
if ( G_LIKELY ( ctx ) )
{
if ( G_LIKELY ( ret ) )
g_timeout_add ( 20 * 1000, sn_timeout, ctx );
else
{
sn_launcher_context_complete ( ctx );
sn_launcher_context_unref ( ctx );
}
}
if ( G_LIKELY ( display ) )
sn_display_unref ( display );
#endif
return ret;
}
static void
terminal_nautilus_menu_item_activate (NautilusMenuItem *item)
{
TerminalNautilusMenuItem *menu_item = TERMINAL_NAUTILUS_MENU_ITEM (item);
TerminalNautilus *nautilus = menu_item->nautilus;
char *uri, *path;
TerminalFileInfo info;
ExecData *data;
uri = nautilus_file_info_get_activation_uri (menu_item->file_info);
if (uri == NULL)
return;
path = NULL;
info = get_terminal_file_info_from_uri (uri);
switch (info) {
case FILE_INFO_LOCAL:
path = g_filename_from_uri (uri, NULL, NULL);
break;
case FILE_INFO_DESKTOP:
if (desktop_is_home_dir (nautilus) || desktop_opens_home_dir (nautilus)) {
path = g_strdup (g_get_home_dir ());
} else {
path = g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP));
}
break;
case FILE_INFO_SFTP:
if (menu_item->remote_terminal)
break;
/* fall through */
case FILE_INFO_OTHER: {
GFile *file;
/* map back remote URI to local path */
file = g_file_new_for_uri (uri);
path = g_file_get_path (file);
g_object_unref (file);
break;
}
default:
g_assert_not_reached ();
}
if (path == NULL && (info != FILE_INFO_SFTP || !menu_item->remote_terminal)) {
g_free (uri);
return;
}
data = g_new (ExecData, 1);
data->nautilus = g_object_ref (nautilus);
data->timestamp = gtk_get_current_event_time ();
data->path = path;
data->uri = uri;
data->display = gdk_screen_make_display_name (menu_item->screen);
data->info = info;
data->remote = menu_item->remote_terminal;
data->run_in_mc = menu_item->run_in_mc;
create_terminal (data);
}
static void
window_menu_display_opened (GdkDisplayManager *disp_manager,
GdkDisplay *display,
GimpUIManager *manager)
{
GtkUIManager *ui_manager = GTK_UI_MANAGER (manager);
const gchar *group_name;
const gchar *ui_path;
const gchar *display_name;
gchar *action_path;
gchar *merge_key;
guint merge_id;
gint n_screens;
gint i;
group_name = g_object_get_data (G_OBJECT (manager),
"move-to-screen-group-name");
ui_path = g_object_get_data (G_OBJECT (manager),
"move-to-screen-ui-path");
action_path = g_strdup_printf ("%s/Move to Screen", ui_path);
display_name = gdk_display_get_name (display);
if (! display_name)
display_name = "eek";
merge_key = g_strdup_printf ("%s-display-merge-id", display_name);
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
g_object_set_data (G_OBJECT (manager), merge_key,
GUINT_TO_POINTER (merge_id));
g_free (merge_key);
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen;
gchar *screen_name;
gchar *action_name;
screen = gdk_display_get_screen (display, i);
screen_name = gdk_screen_make_display_name (screen);
action_name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
g_free (screen_name);
gtk_ui_manager_add_ui (ui_manager, merge_id,
action_path, action_name, action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
g_free (action_name);
}
g_free (action_path);
g_signal_connect_object (display, "closed",
G_CALLBACK (window_menu_display_closed),
G_OBJECT (manager), 0);
}
/**
* thunar_dbus_client_bulk_rename:
* @working_directory : the default working directory for the bulk rename dialog.
* @filenames : the list of files that should be displayed by default or
* the empty list to start with an empty bulk rename dialog.
* @standalone : whether to run the bulk renamer in standalone mode.
* @screen : the #GdkScreen on which to display the dialog or %NULL to
* use the default #GdkScreen.
* @error : return location for errors or %NULL.
*
* Tries to invoke the BulkRename() method on a running Thunar instance, that is
* registered with the current D-BUS session bus. Returns %TRUE if the method was
* successfully invoked, else %FALSE.
*
* If %TRUE is returned, the current process may afterwards just terminate, as
* all @filenames will be handled by the remote instance.
*
* Return value: %TRUE on success, else %FALSE.
**/
gboolean
thunar_dbus_client_bulk_rename (const gchar *working_directory,
gchar **filenames,
gboolean standalone,
GdkScreen *screen,
GError **error)
{
DBusConnection *connection;
DBusMessage *message;
DBusMessage *result;
DBusError derror;
gchar *display_name;
_thunar_return_val_if_fail (screen == NULL || GDK_IS_SCREEN (screen), FALSE);
_thunar_return_val_if_fail (g_path_is_absolute (working_directory), FALSE);
_thunar_return_val_if_fail (error == NULL || *error == NULL, FALSE);
_thunar_return_val_if_fail (filenames != NULL, FALSE);
/* initialize the DBusError struct */
dbus_error_init (&derror);
/* fallback to default screen if no other is specified */
if (G_LIKELY (screen == NULL))
screen = gdk_screen_get_default ();
/* try to connect to the session bus */
connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
if (G_UNLIKELY (connection == NULL))
{
dbus_set_g_error (error, &derror);
dbus_error_free (&derror);
return FALSE;
}
/* determine the display name for the screen */
display_name = gdk_screen_make_display_name (screen);
/* generate the BulkRename() method (disable activation!) */
message = dbus_message_new_method_call ("org.xfce.Thunar", "/org/xfce/FileManager", "org.xfce.Thunar", "BulkRename");
dbus_message_set_auto_start (message, FALSE);
dbus_message_append_args (message,
DBUS_TYPE_STRING, &working_directory,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &filenames, g_strv_length (filenames),
DBUS_TYPE_BOOLEAN, &standalone,
DBUS_TYPE_STRING, &display_name,
DBUS_TYPE_INVALID);
/* release the display name */
g_free (display_name);
/* send the message and release our references on connection and message */
result = dbus_connection_send_with_reply_and_block (connection, message, -1, &derror);
dbus_message_unref (message);
/* check if no reply was received */
if (G_UNLIKELY (result == NULL))
{
dbus_set_g_error (error, &derror);
dbus_error_free (&derror);
return FALSE;
}
/* but maybe we received an error */
if (dbus_message_get_type (result) == DBUS_MESSAGE_TYPE_ERROR)
{
dbus_set_error_from_message (&derror, result);
dbus_set_g_error (error, &derror);
dbus_message_unref (result);
dbus_error_free (&derror);
return FALSE;
}
/* let's asume that it worked */
dbus_message_unref (result);
return TRUE;
}
void
gimp_remote_launch (GdkScreen *screen,
const gchar *argv0,
const gchar *startup_id,
gboolean no_splash,
GString *file_list)
{
gchar *display_name;
gchar **argv;
gchar *gimp, *path, *name, *pwd;
const gchar *spath;
gint i;
if (startup_id)
g_setenv ("DESKTOP_STARTUP_ID", startup_id, TRUE);
if (file_list->len > 0)
file_list = g_string_prepend (file_list, "\n");
display_name = gdk_screen_make_display_name (screen);
file_list = g_string_prepend (file_list, display_name);
file_list = g_string_prepend (file_list, "--display\n");
g_free (display_name);
if (no_splash)
file_list = g_string_prepend (file_list, "--no-splash\n");
file_list = g_string_prepend (file_list, "gimp\n");
argv = g_strsplit (file_list->str, "\n", 0);
/* We are searching for the path the gimp-remote executable lives in */
/*
* the "_" environment variable usually gets set by the sh-family of
* shells. We have to sanity-check it. If we do not find anything
* usable in it try argv[0], then fall back to search the path.
*/
gimp = NULL;
spath = NULL;
for (i = 0; i < 2; i++)
{
if (i == 0)
{
spath = g_getenv ("_");
}
else if (i == 1)
{
spath = argv0;
}
if (spath)
{
name = g_path_get_basename (spath);
if (! strncmp (name, "gimp-remote", 11))
{
path = g_path_get_dirname (spath);
if (g_path_is_absolute (spath))
{
gimp = g_build_filename (path, GIMP_BINARY, NULL);
}
else
{
pwd = g_get_current_dir ();
gimp = g_build_filename (pwd, path, GIMP_BINARY, NULL);
g_free (pwd);
}
g_free (path);
}
g_free (name);
}
if (gimp)
break;
}
/* We must ensure that gimp is started with a different PID.
Otherwise it could happen that (when it opens it's display) it sends
the same auth token again (because that one is uniquified with PID
and time()), which the server would deny. */
switch (fork ())
{
case -1:
exit (EXIT_FAILURE);
case 0: /* child */
execv (gimp, argv);
execvp (GIMP_BINARY, argv);
/* if execv and execvp return, there was an error */
g_printerr (_("Couldn't start '%s': %s"),
GIMP_BINARY, g_strerror (errno));
g_printerr ("\n");
exit (EXIT_FAILURE);
default: /* parent */
break;
}
exit (EXIT_SUCCESS);
}
static gboolean
myScreenSetWMAtom (ScreenInfo *screen_info, gboolean replace_wm)
{
const char *wm_name;
gchar selection[32];
gchar *display_name;
gulong wait, timeout;
DisplayInfo *display_info;
XSetWindowAttributes attrs;
Window current_wm;
XEvent event;
Atom wm_sn_atom;
g_return_val_if_fail (screen_info, FALSE);
g_return_val_if_fail (screen_info->display_info, FALSE);
TRACE ("entering myScreenReplaceWM");
display_info = screen_info->display_info;
g_snprintf (selection, sizeof (selection), "WM_S%d", screen_info->screen);
wm_sn_atom = XInternAtom (display_info->dpy, selection, FALSE);
display_name = gdk_screen_make_display_name (screen_info->gscr);
wm_name = gdk_x11_screen_get_window_manager_name (screen_info->gscr);
XSync (display_info->dpy, FALSE);
current_wm = XGetSelectionOwner (display_info->dpy, wm_sn_atom);
if (current_wm)
{
if (!replace_wm)
{
g_message ("Another Window Manager (%s) is already running on screen %s", wm_name, display_name);
g_message ("To replace the current window manager, try \"--replace\"");
g_free (display_name);
return FALSE;
}
gdk_error_trap_push ();
attrs.event_mask = StructureNotifyMask;
XChangeWindowAttributes (display_info->dpy, current_wm, CWEventMask, &attrs);
if (gdk_error_trap_pop ())
{
current_wm = None;
}
}
if (!setXAtomManagerOwner (display_info, wm_sn_atom, screen_info->xroot, screen_info->xfwm4_win))
{
g_warning ("Cannot acquire window manager selection on screen %s", display_name);
g_free (display_name);
return FALSE;
}
/* Waiting for previous window manager to exit */
if (current_wm)
{
g_print ("Waiting for current window manager (%s) on screen %s to exit:", wm_name, display_name);
wait = 0;
timeout = WM_EXITING_TIMEOUT * G_USEC_PER_SEC;
while (wait < timeout)
{
if (XCheckWindowEvent (display_info->dpy, current_wm, StructureNotifyMask, &event) && (event.type == DestroyNotify))
{
break;
}
g_usleep(G_USEC_PER_SEC / 10);
wait += G_USEC_PER_SEC / 10;
if (wait % G_USEC_PER_SEC == 0)
{
g_print (".");
}
}
if (wait >= timeout)
{
g_print(" Failed\n");
g_warning("Previous window manager (%s) on screen %s is not exiting", wm_name, display_name);
g_free (display_name);
return FALSE;
}
g_print(" Done\n");
}
g_free (display_name);
return TRUE;
}
int main(int argc, char **argv)
{
gboolean listen = FALSE;
int n;
const char *profile = NULL;
const char *colour_scheme = NULL;
char *logo_filename;
gboolean persist = FALSE;
gboolean open_configlet = FALSE;
gboolean dbus_ok;
GdkScreen *scrn;
char *disp_name;
g_set_application_name(_("roxterm-config"));
global_options_init_appdir(argc, argv);
#if ENABLE_NLS
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, global_options_appdir ?
g_strdup_printf("%s/locale", global_options_appdir) : LOCALEDIR);
textdomain(PACKAGE);
#endif
gtk_init(&argc, &argv);
scrn = gdk_screen_get_default();
disp_name = gdk_screen_make_display_name(scrn);
logo_filename = logo_find();
gtk_window_set_default_icon_from_file(logo_filename, NULL);
g_free(logo_filename);
for (n = 1; n < argc; ++n)
{
if (!strcmp(argv[n], "--listen"))
listen = TRUE;
else if (!strncmp(argv[n], "--EditProfile=", 14))
profile = argv[n] + 14;
else if (!strncmp(argv[n], "--EditColourScheme=", 19))
colour_scheme = argv[n] + 19;
else if (!strcmp(argv[n], "--Configlet"))
open_configlet = TRUE;
}
if (!open_configlet)
open_configlet = !profile && !colour_scheme && !listen;
dbus_ok = rtdbus_init();
if (dbus_ok && optsdbus_init())
{
/* Defer to another instance */
if (profile)
{
if (optsdbus_send_edit_profile_message(profile, disp_name))
profile = NULL;
}
if (colour_scheme)
{
if (optsdbus_send_edit_colour_scheme_message(colour_scheme,
disp_name))
{
colour_scheme = NULL;
}
}
if (open_configlet)
{
if (optsdbus_send_edit_opts_message("Configlet", "", disp_name))
{
open_configlet = FALSE;
}
}
}
if (profile)
{
profilegui_open(profile, scrn);
persist = TRUE;
}
if (colour_scheme)
{
colourgui_open(colour_scheme, scrn);
persist = TRUE;
}
if (open_configlet)
{
if (configlet_open(scrn))
persist = TRUE;
}
if (dbus_ok && listen)
persist = TRUE;
g_free(disp_name);
if (persist)
gtk_main();
return 0;
}
static gboolean save_session_to_fp(FILE *fp, const char *session_id)
{
GList *wlink;
SLOG("Saving session with id %s", sd->client_id);
if (fprintf(fp, "<roxterm_session id='%s'>\n", session_id) < 0)
return FALSE;
for (wlink = multi_win_all; wlink; wlink = g_list_next(wlink))
{
MultiWin *win = wlink->data;
GtkWindow *gwin = GTK_WINDOW(multi_win_get_widget(win));
int w, h;
int x, y;
int result;
char *disp = gdk_screen_make_display_name(gtk_window_get_screen(gwin));
const char *tt = multi_win_get_title_template(win);
const char *title = multi_win_get_title(win);
gpointer user_data = multi_win_get_user_data_for_current_tab(win);
VteTerminal *vte;
char *font_name;
gboolean disable_menu_shortcuts, disable_tab_shortcuts;
char *s;
SLOG("Saving window with title '%s'", title);
if (!user_data)
{
g_warning(_("Window with no user data"));
continue;
}
vte = roxterm_get_vte_terminal(user_data);
font_name = pango_font_description_to_string(
vte_terminal_get_font(vte));
multi_win_get_disable_menu_shortcuts(user_data,
&disable_menu_shortcuts, &disable_tab_shortcuts);
roxterm_get_nonfs_dimensions(user_data, &w, &h);
gtk_window_get_position(gwin, &x, &y);
s = g_markup_printf_escaped(" <window disp='%s'\n"
" geometry='%dx%d+%d+%d'\n"
" title_template='%s' font='%s'\n"
" title_template_locked='%d'\n"
" title='%s' role='%s'\n"
" shortcut_scheme='%s' show_menubar='%d'\n"
" always_show_tabs='%d' tab_pos='%d'\n"
" show_add_tab_btn='%d'\n"
" disable_menu_shortcuts='%d' disable_tab_shortcuts='%d'\n"
" maximised='%d' fullscreen='%d' zoom='%f'>\n",
disp, w, h, x, y,
tt ? tt : "", font_name,
multi_win_get_title_template_locked(win),
title, gtk_window_get_role(gwin),
multi_win_get_shortcuts_scheme_name(win),
multi_win_get_show_menu_bar(win),
multi_win_get_always_show_tabs(win),
multi_win_get_tab_pos(win),
multi_win_get_show_add_tab_button(win),
disable_menu_shortcuts, disable_tab_shortcuts,
multi_win_is_maximised(win),
multi_win_is_fullscreen(win),
roxterm_get_zoom_factor(user_data));
result = fputs(s, fp);
g_free(s);
g_free(disp);
g_free(font_name);
SLOG("Saved the window");
if (result < 0)
{
SLOG("But it failed!");
return FALSE;
}
multi_win_foreach_tab(win, save_tab_to_fp, fp);
if (fprintf(fp, " </window>\n") < 0)
return FALSE;
}
return fprintf(fp, "</roxterm_session>\n") > 0;
}
static gboolean
egg_desktop_file_launchv (EggDesktopFile *desktop_file,
GSList *documents, va_list args,
GError **error)
{
EggDesktopFileLaunchOption option;
GSList *translated_documents = NULL, *docs = NULL;
char *command, **argv;
int argc, i, screen_num;
gboolean success, current_success;
GdkDisplay *display;
char *startup_id;
GPtrArray *env = NULL;
char **variables = NULL;
GdkScreen *screen = NULL;
int workspace = -1;
const char *directory = NULL;
guint32 launch_time = (guint32)-1;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH;
GSpawnChildSetupFunc setup_func = NULL;
gpointer setup_data = NULL;
GPid *ret_pid = NULL;
int *ret_stdin = NULL, *ret_stdout = NULL, *ret_stderr = NULL;
char **ret_startup_id = NULL;
if (documents && desktop_file->document_code == 0)
{
g_set_error (error, EGG_DESKTOP_FILE_ERROR,
EGG_DESKTOP_FILE_ERROR_NOT_LAUNCHABLE,
_("Application does not accept documents on command line"));
return FALSE;
}
/* Read the options: technically it's incorrect for the caller to
* NULL-terminate the list of options (rather than 0-terminating
* it), but NULL-terminating lets us use G_GNUC_NULL_TERMINATED,
* it's more consistent with other glib/gtk methods, and it will
* work as long as sizeof (int) <= sizeof (NULL), and NULL is
* represented as 0. (Which is true everywhere we care about.)
*/
while ((option = va_arg (args, EggDesktopFileLaunchOption)))
{
switch (option)
{
case EGG_DESKTOP_FILE_LAUNCH_CLEARENV:
if (env)
g_ptr_array_free (env, TRUE);
env = g_ptr_array_new ();
break;
case EGG_DESKTOP_FILE_LAUNCH_PUTENV:
variables = va_arg (args, char **);
for (i = 0; variables[i]; i++)
env = array_putenv (env, variables[i]);
break;
case EGG_DESKTOP_FILE_LAUNCH_SCREEN:
screen = va_arg (args, GdkScreen *);
break;
case EGG_DESKTOP_FILE_LAUNCH_WORKSPACE:
workspace = va_arg (args, int);
break;
case EGG_DESKTOP_FILE_LAUNCH_DIRECTORY:
directory = va_arg (args, const char *);
break;
case EGG_DESKTOP_FILE_LAUNCH_TIME:
launch_time = va_arg (args, guint32);
break;
case EGG_DESKTOP_FILE_LAUNCH_FLAGS:
flags |= va_arg (args, GSpawnFlags);
/* Make sure they didn't set any flags that don't make sense. */
flags &= ~G_SPAWN_FILE_AND_ARGV_ZERO;
break;
case EGG_DESKTOP_FILE_LAUNCH_SETUP_FUNC:
setup_func = va_arg (args, GSpawnChildSetupFunc);
setup_data = va_arg (args, gpointer);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_PID:
ret_pid = va_arg (args, GPid *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDIN_PIPE:
ret_stdin = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDOUT_PIPE:
ret_stdout = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDERR_PIPE:
ret_stderr = va_arg (args, int *);
break;
case EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID:
ret_startup_id = va_arg (args, char **);
break;
default:
g_set_error (error, EGG_DESKTOP_FILE_ERROR,
EGG_DESKTOP_FILE_ERROR_UNRECOGNIZED_OPTION,
_("Unrecognized launch option: %d"),
GPOINTER_TO_INT (option));
success = FALSE;
goto out;
}
}
if (screen)
{
char *display_name = gdk_screen_make_display_name (screen);
char *display_env = g_strdup_printf ("DISPLAY=%s", display_name);
env = array_putenv (env, display_env);
g_free (display_name);
g_free (display_env);
display = gdk_screen_get_display (screen);
}
else
{
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
}
screen_num = gdk_screen_get_number (screen);
translated_documents = translate_document_list (desktop_file, documents);
docs = translated_documents;
success = FALSE;
do
{
command = parse_exec (desktop_file, &docs, error);
if (!command)
goto out;
if (!g_shell_parse_argv (command, &argc, &argv, error))
{
g_free (command);
goto out;
}
g_free (command);
#if GTK_CHECK_VERSION (2, 12, 0)
startup_id = start_startup_notification (display, desktop_file,
argv[0], screen_num,
workspace, launch_time);
if (startup_id)
{
char *startup_id_env = g_strdup_printf ("DESKTOP_STARTUP_ID=%s",
startup_id);
env = array_putenv (env, startup_id_env);
g_free (startup_id_env);
}
#else
startup_id = NULL;
#endif /* GTK 2.12 */
if (env != NULL)
g_ptr_array_add (env, NULL);
current_success =
g_spawn_async_with_pipes (directory,
argv,
env ? (char **)(env->pdata) : NULL,
flags,
setup_func, setup_data,
ret_pid,
ret_stdin, ret_stdout, ret_stderr,
error);
g_strfreev (argv);
if (startup_id)
{
#if GTK_CHECK_VERSION (2, 12, 0)
if (current_success)
{
set_startup_notification_timeout (display, startup_id);
if (ret_startup_id)
*ret_startup_id = startup_id;
else
g_free (startup_id);
}
else
#endif /* GTK 2.12 */
g_free (startup_id);
}
else if (ret_startup_id)
*ret_startup_id = NULL;
if (current_success)
{
/* If we successfully launch any instances of the app, make
* sure we return TRUE and don't set @error.
*/
success = TRUE;
error = NULL;
/* Also, only set the output params on the first one */
ret_pid = NULL;
ret_stdin = ret_stdout = ret_stderr = NULL;
ret_startup_id = NULL;
}
}
while (docs && current_success);
out:
if (env)
{
g_ptr_array_foreach (env, (GFunc)g_free, NULL);
g_ptr_array_free (env, TRUE);
}
free_document_list (translated_documents);
return success;
}
static void
display_fortune_dialog (FishApplet *fish)
{
GError *error = NULL;
gboolean user_command;
int output;
const char *charset;
int argc;
char **argv;
GdkScreen *screen;
char *display;
/* if there is still a pipe, close it */
if (fish->source_id)
g_source_remove (fish->source_id);
fish->source_id = 0;
fish_close_channel (fish);
user_command = locate_fortune_command (fish, &argc, &argv);
if (!argv)
return;
if (!fish->fortune_dialog) {
GtkWidget *scrolled;
GtkWidget *vbox;
GdkScreen *screen;
int screen_width;
int screen_height;
fish->fortune_dialog =
gtk_dialog_new_with_buttons (
"", NULL, 0,
_("_Speak again"), FISH_RESPONSE_SPEAK,
_("_Close"), GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_icon_name (GTK_WINDOW (fish->fortune_dialog),
FISH_ICON);
gtk_dialog_set_default_response (
GTK_DIALOG (fish->fortune_dialog), GTK_RESPONSE_CLOSE);
g_signal_connect (fish->fortune_dialog, "delete_event",
G_CALLBACK (delete_event), fish);
g_signal_connect (fish->fortune_dialog, "response",
G_CALLBACK (handle_fortune_response), fish);
gtk_window_set_wmclass (GTK_WINDOW (fish->fortune_dialog), "fish", "Fish");
screen = gtk_widget_get_screen (GTK_WIDGET (fish));
screen_width = gdk_screen_get_width (screen);
screen_height = gdk_screen_get_height (screen);
gtk_window_set_default_size (GTK_WINDOW (fish->fortune_dialog),
MIN (600, screen_width * 0.9),
MIN (350, screen_height * 0.9));
fish->fortune_view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (fish->fortune_view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (fish->fortune_view), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (fish->fortune_view), 10);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (fish->fortune_view), 10);
fish->fortune_buffer =
gtk_text_view_get_buffer (GTK_TEXT_VIEW (fish->fortune_view));
gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (fish->fortune_buffer),
"monospace_tag", "family",
"Monospace", NULL);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (scrolled), fish->fortune_view);
fish->fortune_label = gtk_label_new ("");
gtk_label_set_ellipsize (GTK_LABEL (fish->fortune_label),
PANGO_ELLIPSIZE_MIDDLE);
fish->fortune_cmd_label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (fish->fortune_cmd_label),
0, 0.5);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (fish->fortune_dialog));
gtk_box_pack_start (GTK_BOX (vbox),
fish->fortune_label,
FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox),
scrolled,
TRUE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (vbox),
fish->fortune_cmd_label,
FALSE, FALSE, 6);
update_fortune_dialog (fish);
/* We don't show_all for the dialog since fortune_cmd_label
* might need to be hidden
* The dialog will be shown with gtk_window_present later */
gtk_widget_show (scrolled);
gtk_widget_show (fish->fortune_view);
gtk_widget_show (fish->fortune_label);
}
if (!user_command) {
char *command;
char * text;
command = g_markup_printf_escaped ("<tt>%s</tt>", argv[0]);
text = g_strdup_printf (_("The configured command is not "
"working and has been replaced by: "
"%s"), command);
gtk_label_set_markup (GTK_LABEL (fish->fortune_cmd_label),
text);
g_free (command);
g_free (text);
gtk_widget_show (fish->fortune_cmd_label);
} else {
gtk_widget_hide (fish->fortune_cmd_label);
}
clear_fortune_text (fish);
screen = gtk_widget_get_screen (GTK_WIDGET (fish));
display = gdk_screen_make_display_name (screen);
g_spawn_async_with_pipes (NULL, /* working directory */
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH|G_SPAWN_STDERR_TO_DEV_NULL,
set_environment,
&display,
NULL, /* child pid */
NULL, /* stdin */
&output,
NULL, /* stderr */
&error);
g_free (display);
if (error) {
char *message;
message = g_strdup_printf (_("Unable to execute '%s'\n\nDetails: %s"),
argv[0], error->message);
something_fishy_going_on (fish, message);
g_free (message);
g_error_free (error);
g_strfreev (argv);
return;
}
fish->io_channel = g_io_channel_unix_new (output);
/* set the correct encoding if the locale is not using UTF-8 */
if (!g_get_charset (&charset))
g_io_channel_set_encoding(fish->io_channel, charset, &error);
if (error) {
char *message;
message = g_strdup_printf (_("Unable to read from '%s'\n\nDetails: %s"),
argv[0], error->message);
something_fishy_going_on (fish, message);
g_free (message);
g_error_free (error);
g_strfreev (argv);
return;
}
g_strfreev (argv);
fish->source_id = g_io_add_watch (fish->io_channel,
G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL,
fish_read_output, fish);
gtk_window_set_screen (GTK_WINDOW (fish->fortune_dialog),
gtk_widget_get_screen (GTK_WIDGET (fish)));
gtk_window_present (GTK_WINDOW (fish->fortune_dialog));
}
