/** * gdk_screen_get_window_stack: * @screen: a #GdkScreen * * Returns a #GList of #GdkWindows representing the current * window stack. * * On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING * property on the root window, as described in the * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec). * If the window manager does not support the * _NET_CLIENT_LIST_STACKING hint, this function returns %NULL. * * On other platforms, this function may return %NULL, depending on whether * it is implementable on that platform. * * The returned list is newly allocated and owns references to the * windows it contains, so it should be freed using g_list_free() and * its windows unrefed using g_object_unref() when no longer needed. * * Returns: (nullable) (transfer full) (element-type GdkWindow): a * list of #GdkWindows for the current window stack, or %NULL. * * Since: 2.10 **/ GList * gdk_screen_get_window_stack (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->get_window_stack (screen); }
/** * gdk_screen_get_root_window: * @screen: a #GdkScreen * * Gets the root window of @screen. * * Returns: (transfer none): the root window * * Since: 2.2 **/ GdkWindow * gdk_screen_get_root_window (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->get_root_window (screen); }
/** * gdk_screen_get_primary_monitor: * @screen: a #GdkScreen. * * Gets the primary monitor for @screen. The primary monitor * is considered the monitor where the “main desktop” lives. * While normal application windows typically allow the window * manager to place the windows, specialized desktop applications * such as panels should place themselves on the primary monitor. * * If no primary monitor is configured by the user, the return value * will be 0, defaulting to the first monitor. * * Returns: An integer index for the primary monitor, or 0 if none is configured. * * Since: 2.20 */ gint gdk_screen_get_primary_monitor (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), 0); return GDK_SCREEN_GET_CLASS (screen)->get_primary_monitor (screen); }
/** * gdk_screen_get_setting: * @screen: the #GdkScreen where the setting is located * @name: the name of the setting * @value: location to store the value of the setting * * Retrieves a desktop-wide setting such as double-click time * for the #GdkScreen @screen. * * FIXME needs a list of valid settings here, or a link to * more information. * * Returns: %TRUE if the setting existed and a value was stored * in @value, %FALSE otherwise. * * Since: 2.2 **/ gboolean gdk_screen_get_setting (GdkScreen *screen, const gchar *name, GValue *value) { return GDK_SCREEN_GET_CLASS(screen)->get_setting (screen, name, value); }
/** * gdk_screen_get_rgba_visual: * @screen: a #GdkScreen * * Gets a visual to use for creating windows with an alpha channel. * The windowing system on which GTK+ is running * may not support this capability, in which case %NULL will * be returned. Even if a non-%NULL value is returned, its * possible that the window’s alpha channel won’t be honored * when displaying the window on the screen: in particular, for * X an appropriate windowing manager and compositing manager * must be running to provide appropriate display. * * This functionality is not implemented in the Windows backend. * * For setting an overall opacity for a top-level window, see * gdk_window_set_opacity(). * * Returns: (nullable) (transfer none): a visual to use for windows * with an alpha channel or %NULL if the capability is not * available. * * Since: 2.8 **/ GdkVisual * gdk_screen_get_rgba_visual (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->get_rgba_visual (screen); }
/** * gdk_screen_list_visuals: * @screen: the relevant #GdkScreen. * * Lists the available visuals for the specified @screen. * A visual describes a hardware image data format. * For example, a visual might support 24-bit color, or 8-bit color, * and might expect pixels to be in a certain format. * * Call g_list_free() on the return value when you’re finished with it. * * Returns: (transfer container) (element-type GdkVisual): * a list of visuals; the list must be freed, but not its contents * * Since: 2.2 **/ GList * gdk_screen_list_visuals (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->list_visuals (screen); }
/** * gdk_screen_make_display_name: * @screen: a #GdkScreen * * Determines the name to pass to gdk_display_open() to get * a #GdkDisplay with this screen as the default screen. * * Returns: a newly allocated string, free with g_free() * * Since: 2.2 **/ gchar * gdk_screen_make_display_name (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->make_display_name (screen); }
/** * gdk_screen_is_composited: * @screen: a #GdkScreen * * Returns whether windows with an RGBA visual can reasonably * be expected to have their alpha channel drawn correctly on * the screen. * * On X11 this function returns whether a compositing manager is * compositing @screen. * * Returns: Whether windows with RGBA visuals can reasonably be * expected to have their alpha channels drawn correctly on the screen. * * Since: 2.10 **/ gboolean gdk_screen_is_composited (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); return GDK_SCREEN_GET_CLASS (screen)->is_composited (screen); }
/** * gdk_visual_get_best: * * Get the visual with the most available colors for the default * GDK screen. The return value should not be freed. * * Returns: (transfer none): best visual */ GdkVisual* gdk_visual_get_best (void) { GdkScreen *screen = gdk_screen_get_default(); return GDK_SCREEN_GET_CLASS(screen)->visual_get_best (screen); }
/** * gdk_screen_get_monitor_workarea: * @screen: a #GdkScreen * @monitor_num: the monitor number * @dest: (out) (allow-none): a #GdkRectangle to be filled with * the monitor workarea * * Retrieves the #GdkRectangle representing the size and position of * the "work area" on a monitor within the entire screen area. * * The work area should be considered when positioning menus and * similar popups, to avoid placing them below panels, docks or other * desktop components. * * Monitor numbers start at 0. To obtain the number of monitors of * @screen, use gdk_screen_get_n_monitors(). * * Since: 3.4 */ void gdk_screen_get_monitor_workarea (GdkScreen *screen, gint monitor_num, GdkRectangle *dest) { GDK_SCREEN_GET_CLASS(screen)->get_monitor_workarea (screen, monitor_num, dest); }
/** * gdk_visual_get_best_with_depth: * @depth: a bit depth * * Get the best visual with depth @depth for the default GDK screen. * Color visuals and visuals with mutable colormaps are preferred * over grayscale or fixed-colormap visuals. The return value should * not be freed. %NULL may be returned if no visual supports @depth. * * Returns: (transfer none): best visual for the given depth */ GdkVisual* gdk_visual_get_best_with_depth (gint depth) { GdkScreen *screen = gdk_screen_get_default(); return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_with_depth (screen, depth); }
/** * gdk_screen_get_display: * @screen: a #GdkScreen * * Gets the display to which the @screen belongs. * * Returns: (transfer none): the display to which @screen belongs * * Since: 2.2 **/ GdkDisplay * gdk_screen_get_display (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->get_display (screen); }
/** * gdk_screen_get_height_mm: * @screen: a #GdkScreen * * Returns the height of @screen in millimeters. * * Note that this value is somewhat ill-defined when the screen * has multiple monitors of different resolution. It is recommended * to use the monitor dimensions instead. * * Returns: the heigth of @screen in millimeters. * * Since: 2.2 **/ gint gdk_screen_get_height_mm (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), 0); return GDK_SCREEN_GET_CLASS (screen)->get_height_mm (screen); }
/** * gdk_query_visual_types: * @visual_types: (out) (array length=count) (transfer none): return * location for the available visual types * @count: return location for the number of available visual types * * This function returns the available visual types for the default * screen. It’s equivalent to listing the visuals * (gdk_list_visuals()) and then looking at the type field in each * visual, removing duplicates. * * The array returned by this function should not be freed. */ void gdk_query_visual_types (GdkVisualType **visual_types, gint *count) { GdkScreen *screen = gdk_screen_get_default(); GDK_SCREEN_GET_CLASS(screen)->query_visual_types (screen, visual_types, count); }
/** * gdk_visual_get_best_with_type: * @visual_type: a visual type * * Get the best visual of the given @visual_type for the default GDK screen. * Visuals with higher color depths are considered better. The return value * should not be freed. %NULL may be returned if no visual has type * @visual_type. * * Returns: (transfer none): best visual of the given type */ GdkVisual* gdk_visual_get_best_with_type (GdkVisualType visual_type) { GdkScreen *screen = gdk_screen_get_default(); return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_with_type (screen, visual_type); }
/** * gdk_query_depths: * @depths: (out) (array length=count) (transfer none): return * location for available depths * @count: return location for number of available depths * * This function returns the available bit depths for the default * screen. It’s equivalent to listing the visuals * (gdk_list_visuals()) and then looking at the depth field in each * visual, removing duplicates. * * The array returned by this function should not be freed. */ void gdk_query_depths (gint **depths, gint *count) { GdkScreen *screen = gdk_screen_get_default(); GDK_SCREEN_GET_CLASS(screen)->query_depths (screen, depths, count); }
/** * gdk_screen_get_monitor_plug_name: * @screen: a #GdkScreen * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) * * Returns the output name of the specified monitor. * Usually something like VGA, DVI, or TV, not the actual * product name of the display device. * * Returns: (nullable): a newly-allocated string containing the name * of the monitor, or %NULL if the name cannot be determined * * Since: 2.14 */ gchar * gdk_screen_get_monitor_plug_name (GdkScreen *screen, gint monitor_num) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); g_return_val_if_fail (monitor_num >= 0, NULL); g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), NULL); return GDK_SCREEN_GET_CLASS (screen)->get_monitor_plug_name (screen, monitor_num); }
/** * gdk_screen_get_monitor_height_mm: * @screen: a #GdkScreen * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) * * Gets the height in millimeters of the specified monitor. * * Returns: the height of the monitor, or -1 if not available * * Since: 2.14 */ gint gdk_screen_get_monitor_height_mm (GdkScreen *screen, gint monitor_num) { g_return_val_if_fail (GDK_IS_SCREEN (screen), -1); g_return_val_if_fail (monitor_num >= 0, -1); g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), -1); return GDK_SCREEN_GET_CLASS (screen)->get_monitor_height_mm (screen, monitor_num); }
/** * gdk_screen_get_monitor_workarea: * @screen: a #GdkScreen * @monitor_num: the monitor number * @dest: (out) (allow-none): a #GdkRectangle to be filled with * the monitor workarea * * Retrieves the #GdkRectangle representing the size and position of * the “work area” on a monitor within the entire screen area. The returned * geometry is in ”application pixels”, not in ”device pixels” (see * gdk_screen_get_monitor_scale_factor()). * * The work area should be considered when positioning menus and * similar popups, to avoid placing them below panels, docks or other * desktop components. * * Note that not all backends may have a concept of workarea. This * function will return the monitor geometry if a workarea is not * available, or does not apply. * * Monitor numbers start at 0. To obtain the number of monitors of * @screen, use gdk_screen_get_n_monitors(). * * Since: 3.4 */ void gdk_screen_get_monitor_workarea (GdkScreen *screen, gint monitor_num, GdkRectangle *dest) { g_return_if_fail (GDK_IS_SCREEN (screen)); g_return_if_fail (monitor_num >= 0); g_return_if_fail (monitor_num < gdk_screen_get_n_monitors (screen)); GDK_SCREEN_GET_CLASS (screen)->get_monitor_workarea (screen, monitor_num, dest); }
/** * gdk_screen_get_setting: * @screen: the #GdkScreen where the setting is located * @name: the name of the setting * @value: location to store the value of the setting * * Retrieves a desktop-wide setting such as double-click time * for the #GdkScreen @screen. * * FIXME needs a list of valid settings here, or a link to * more information. * * Returns: %TRUE if the setting existed and a value was stored * in @value, %FALSE otherwise. * * Since: 2.2 **/ gboolean gdk_screen_get_setting (GdkScreen *screen, const gchar *name, GValue *value) { g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); g_return_val_if_fail (name != NULL, FALSE); g_return_val_if_fail (value != NULL, FALSE); return GDK_SCREEN_GET_CLASS (screen)->get_setting (screen, name, value); }
/** * gdk_screen_get_monitor_scale_factor: * @screen: screen to get scale factor for * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) * * Returns the internal scale factor that maps from monitor coordinates * to the actual device pixels. On traditional systems this is 1, but * on very high density outputs this can be a higher value (often 2). * * This can be used if you want to create pixel based data for a * particular monitor, but most of the time you’re drawing to a window * where it is better to use gdk_window_get_scale_factor() instead. * * Since: 3.10 * Returns: the scale factor */ gint gdk_screen_get_monitor_scale_factor (GdkScreen *screen, gint monitor_num) { GdkScreenClass *screen_class; g_return_val_if_fail (GDK_IS_SCREEN (screen), 1); g_return_val_if_fail (monitor_num >= 0, 1); g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), 1); screen_class = GDK_SCREEN_GET_CLASS (screen); if (screen_class->get_monitor_scale_factor) return screen_class->get_monitor_scale_factor (screen, monitor_num); return 1; }
/** * gdk_screen_get_primary_monitor: * @screen: a #GdkScreen. * * Gets the primary monitor for @screen. The primary monitor * is considered the monitor where the 'main desktop' lives. * While normal application windows typically allow the window * manager to place the windows, specialized desktop applications * such as panels should place themselves on the primary monitor. * * If no primary monitor is configured by the user, the return value * will be 0, defaulting to the first monitor. * * Returns: An integer index for the primary monitor, or 0 if none is configured. * * Since: 2.20 */ gint gdk_screen_get_primary_monitor (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->get_primary_monitor (screen); }
/** * gdk_screen_get_monitor_plug_name: * @screen: a #GdkScreen * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) * * Returns the output name of the specified monitor. * Usually something like VGA, DVI, or TV, not the actual * product name of the display device. * * Returns: a newly-allocated string containing the name of the monitor, * or %NULL if the name cannot be determined * * Since: 2.14 */ gchar * gdk_screen_get_monitor_plug_name (GdkScreen *screen, gint monitor_num) { return GDK_SCREEN_GET_CLASS(screen)->get_monitor_plug_name (screen, monitor_num); }
/** * gdk_screen_list_visuals: * @screen: the relevant #GdkScreen. * * Lists the available visuals for the specified @screen. * A visual describes a hardware image data format. * For example, a visual might support 24-bit color, or 8-bit color, * and might expect pixels to be in a certain format. * * Call g_list_free() on the return value when you're finished with it. * * Return value: (transfer container) (element-type GdkVisual): * a list of visuals; the list must be freed, but not its contents * * Since: 2.2 **/ GList * gdk_screen_list_visuals (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->list_visuals (screen); }
/** * gdk_screen_get_rgba_visual: * @screen: a #GdkScreen * * Gets a visual to use for creating windows with an alpha channel. * The windowing system on which GTK+ is running * may not support this capability, in which case %NULL will * be returned. Even if a non-%NULL value is returned, its * possible that the window's alpha channel won't be honored * when displaying the window on the screen: in particular, for * X an appropriate windowing manager and compositing manager * must be running to provide appropriate display. * * This functionality is not implemented in the Windows backend. * * For setting an overall opacity for a top-level window, see * gdk_window_set_opacity(). * * Return value: (transfer none): a visual to use for windows with an * alpha channel or %NULL if the capability is not available. * * Since: 2.8 **/ GdkVisual * gdk_screen_get_rgba_visual (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->get_rgba_visual (screen); }
/** * gdk_screen_is_composited: * @screen: a #GdkScreen * * Returns whether windows with an RGBA visual can reasonably * be expected to have their alpha channel drawn correctly on * the screen. * * On X11 this function returns whether a compositing manager is * compositing @screen. * * Return value: Whether windows with RGBA visuals can reasonably be * expected to have their alpha channels drawn correctly on the screen. * * Since: 2.10 **/ gboolean gdk_screen_is_composited (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->is_composited (screen); }
/** * gdk_screen_make_display_name: * @screen: a #GdkScreen * * Determines the name to pass to gdk_display_open() to get * a #GdkDisplay with this screen as the default screen. * * Return value: a newly allocated string, free with g_free() * * Since: 2.2 **/ gchar * gdk_screen_make_display_name (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->make_display_name (screen); }
/** * gdk_screen_get_active_window: * @screen: a #GdkScreen * * Returns the screen's currently active window. * * On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property * on the root window, as described in the <ulink * url="http://www.freedesktop.org/Standards/wm-spec">Extended Window * Manager Hints</ulink>. If there is no currently currently active * window, or the window manager does not support the * _NET_ACTIVE_WINDOW hint, this function returns %NULL. * * On other platforms, this function may return %NULL, depending on whether * it is implementable on that platform. * * The returned window should be unrefed using g_object_unref() when * no longer needed. * * Return value: (transfer full): the currently active window, or %NULL. * * Since: 2.10 **/ GdkWindow * gdk_screen_get_active_window (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->get_active_window (screen); }
/** * gdk_screen_get_window_stack: * @screen: a #GdkScreen * * Returns a #GList of #GdkWindow<!-- -->s representing the current * window stack. * * On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING * property on the root window, as described in the <ulink * url="http://www.freedesktop.org/Standards/wm-spec">Extended Window * Manager Hints</ulink>. If the window manager does not support the * _NET_CLIENT_LIST_STACKING hint, this function returns %NULL. * * On other platforms, this function may return %NULL, depending on whether * it is implementable on that platform. * * The returned list is newly allocated and owns references to the * windows it contains, so it should be freed using g_list_free() and * its windows unrefed using g_object_unref() when no longer needed. * * Return value: (transfer full) (element-type GdkWindow): * a list of #GdkWindow<!-- -->s for the current window stack, * or %NULL. * * Since: 2.10 **/ GList * gdk_screen_get_window_stack (GdkScreen *screen) { return GDK_SCREEN_GET_CLASS(screen)->get_window_stack (screen); }
/** * gdk_screen_get_monitor_height_mm: * @screen: a #GdkScreen * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) * * Gets the height in millimeters of the specified monitor. * * Returns: the height of the monitor, or -1 if not available * * Since: 2.14 */ gint gdk_screen_get_monitor_height_mm (GdkScreen *screen, gint monitor_num) { return GDK_SCREEN_GET_CLASS(screen)->get_monitor_height_mm (screen, monitor_num); }