自学教程：C++ GDK_SCREEN_GET_CLASS函数代码示例

/** * 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 */gintgdk_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 **/gbooleangdk_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 **/gbooleangdk_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 */voidgdk_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 **/gintgdk_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. */voidgdk_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. */voidgdk_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 */gintgdk_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 */voidgdk_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 **/gbooleangdk_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 */gintgdk_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 */gintgdk_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 **/gbooleangdk_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 */gintgdk_screen_get_monitor_height_mm (GdkScreen *screen,                                  gint       monitor_num){  return GDK_SCREEN_GET_CLASS(screen)->get_monitor_height_mm (screen, monitor_num);}