## Xfce Gdk extensions Xfce Gdk extensions — Additional Gdk related functions. |

## Synopsis

    #include <libxfcegui4/libxfcegui4.h>

    gchar *             xfce_gdk_display_get_fullname       (GdkDisplay *display);
    GdkScreen *         xfce_gdk_display_locate_monitor_with_pointer
                                                            (GdkDisplay *display,
                                                             gint *monitor_return);
    gchar *             xfce_gdk_screen_get_fullname        (GdkScreen *screen);
    gboolean            xfce_gdk_spawn_on_screen            (GdkScreen *screen,
                                                             const gchar *working_directory,
                                                             gchar **argv,
                                                             gchar **envp,
                                                             GSpawnFlags flags,
                                                             GSpawnChildSetupFunc child_setup,
                                                             gpointer user_data,
                                                             gint *child_pid,
                                                             GError **error);
    gboolean            xfce_gdk_spawn_on_screen_with_pipes (GdkScreen *screen,
                                                             const gchar *working_directory,
                                                             gchar **argv,
                                                             gchar **envp,
                                                             GSpawnFlags flags,
                                                             GSpawnChildSetupFunc child_setup,
                                                             gpointer user_data,
                                                             gint *child_pid,
                                                             gint *standard_input,
                                                             gint *standard_output,
                                                             gint *standard_error,
                                                             GError **error);
    gboolean            xfce_gdk_spawn_command_line_on_screen
                                                            (GdkScreen *screen,
                                                             const gchar *command_line,
                                                             GError **error);

## Description

## Details

### xfce_gdk_display_get_fullname ()

    gchar *             xfce_gdk_display_get_fullname       (GdkDisplay *display);

Determines the full qualified name of `display`. The full name includes both the hostname of the Xserver node and the display number of the Xserver.

`display` : | A valid Gdk display.
Returns : | The full qualified name of `display`.

Since 4.2

### xfce_gdk_display_locate_monitor_with_pointer ()

    GdkScreen *         xfce_gdk_display_locate_monitor_with_pointer
                                                            (GdkDisplay *display,
                                                             gint *monitor_return);

Locates the monitor and the screen which contains the pointer. If it is not possible to determine the current pointer position, `NULL` is returned.

`display` : | A Gdk display or `NULL` to choose the default display.
`monitor_return` : | Address to store the monitor number to or `NULL`.
Returns : | The screen that contains the pointer.

Since 4.2

### xfce_gdk_screen_get_fullname ()

    gchar *             xfce_gdk_screen_get_fullname        (GdkScreen *screen);

Like `xfce_gdk_display_get_fullname()`, but also includes the screen number.

`screen` : | A Gdk screen.
Returns : | The full qualified name of `screen`.

Since 4.2

### xfce_gdk_spawn_on_screen ()

    gboolean            xfce_gdk_spawn_on_screen            (GdkScreen *screen,
                                                             const gchar *working_directory,
                                                             gchar **argv,
                                                             gchar **envp,
                                                             GSpawnFlags flags,
                                                             GSpawnChildSetupFunc child_setup,
                                                             gpointer user_data,
                                                             gint *child_pid,
                                                             GError **error);

Like `g_spawn_async()`, except the child process is spawned in such an environment that on calling `gdk_display_open()` it would be returned a GdkDisplay with `screen` as the default screen.

This is useful for applications which wish to launch an application on a specific screen.

`screen` : | a GdkScreen
`working_directory` : | child's current working directory, or `NULL` to inherit parent's
`argv` : | child's argument vector
`envp` : | child's environment, or `NULL` to inherit parent's
`flags` : | flags from GSpawnFlags
`child_setup` : | function to run in the child just before `exec()`
`user_data` : | user data for `child_setup`
`child_pid` : | return location for child process ID, or `NULL`
`error` : | return location for error
Returns : | `TRUE` on success, `FALSE` if error is set

Since 4.2

### xfce_gdk_spawn_on_screen_with_pipes ()

    gboolean            xfce_gdk_spawn_on_screen_with_pipes (GdkScreen *screen,
                                                             const gchar *working_directory,
                                                             gchar **argv,
                                                             gchar **envp,
                                                             GSpawnFlags flags,
                                                             GSpawnChildSetupFunc child_setup,
                                                             gpointer user_data,
                                                             gint *child_pid,
                                                             gint *standard_input,
                                                             gint *standard_output,
                                                             gint *standard_error,
                                                             GError **error);

Like `g_spawn_async_with_pipes()`, except the child process is spawned in such an environment that on calling `gdk_display_open()` it would be returned a GdkDisplay with `screen` as the default screen.

This is useful for applications which wish to launch an application on a specific screen.

`screen` : | a GdkScreen
`working_directory` : | child's current working directory, or `NULL` to inherit parent's
`argv` : | child's argument vector
`envp` : | child's environment, or `NULL` to inherit parent's
`flags` : | flags from GSpawnFlags
`child_setup` : | function to run in the child just before `exec()`
`user_data` : | user data for `child_setup`
`child_pid` : | return location for child process ID, or `NULL`
`standard_input` : | return location for file descriptor to write to child's stdin, or `NULL`
`standard_output` : | return location for file descriptor to read child's stdout, or `NULL`
`standard_error` : | return location for file descriptor to read child's stderr, or `NULL`
`error` : | return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

Since 4.2

### xfce_gdk_spawn_command_line_on_screen ()

    gboolean            xfce_gdk_spawn_command_line_on_screen
                                                            (GdkScreen *screen,
                                                             const gchar *command_line,
                                                             GError **error);

Like `g_spawn_command_line_async()`, except the child process is spawned in such an environment that on calling `gdk_display_open()` it would be returned a GdkDisplay with `screen` as the default screen.

This is useful for applications which wish to launch an application on a specific screen.

`screen` : | a GdkScreen
`command_line` : | a command line
`error` : | return location for errors
Returns : | `TRUE` on success, `FALSE` if error is set.

Since 4.2

## See Also

Gdk reference manual