/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ * gdkvisual.c
+ *
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * Erwann Chenede <erwann.chenede@sun.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include "gdk.h"
-#include "gdkprivate.h"
+#include "config.h"
-static void gdk_visual_add (GdkVisual *visual);
-static void gdk_visual_decompose_mask (gulong mask,
- gint *shift,
- gint *prec);
-static guint gdk_visual_hash (Visual *key);
-static gint gdk_visual_compare (Visual *a,
- Visual *b);
+#include "gdkvisualprivate.h"
+#include "gdkscreenprivate.h"
-static GdkVisualPrivate *system_visual;
-static GdkVisualPrivate *visuals;
-static gint nvisuals;
-
-static gint available_depths[4];
-static gint navailable_depths;
+/**
+ * SECTION:visuals
+ * @Short_description: Low-level display hardware information
+ * @Title: Visuals
+ *
+ * A #GdkVisual describes a particular video hardware display format.
+ * It includes information about the number of bits used for each color,
+ * the way the bits are translated into an RGB value for display, and
+ * the way the bits are stored in memory. For example, a piece of display
+ * hardware might support 24-bit color, 16-bit color, or 8-bit color;
+ * meaning 24/16/8-bit pixel sizes. For a given pixel size, pixels can
+ * be in different formats; for example the "red" element of an RGB pixel
+ * may be in the top 8 bits of the pixel, or may be in the lower 4 bits.
+ *
+ * There are several standard visuals. The visual returned by
+ * gdk_screen_get_system_visual() is the system's default visual.
+ *
+ * A number of functions are provided for determining the "best" available
+ * visual. For the purposes of making this determination, higher bit depths
+ * are considered better, and for visuals of the same bit depth,
+ * %GDK_VISUAL_PSEUDO_COLOR is preferred at 8bpp, otherwise, the visual
+ * types are ranked in the order of(highest to lowest)
+ * %GDK_VISUAL_DIRECT_COLOR, %GDK_VISUAL_TRUE_COLOR,
+ * %GDK_VISUAL_PSEUDO_COLOR, %GDK_VISUAL_STATIC_COLOR,
+ * %GDK_VISUAL_GRAYSCALE, then %GDK_VISUAL_STATIC_GRAY.
+ */
-static GdkVisualType available_types[6];
-static gint navailable_types;
+G_DEFINE_TYPE (GdkVisual, gdk_visual, G_TYPE_OBJECT)
-static gchar* visual_names[] =
+static void
+gdk_visual_init (GdkVisual *visual)
{
- "static gray",
- "grayscale",
- "static color",
- "pseudo color",
- "true color",
- "direct color",
-};
+}
-static GHashTable *visual_hash = NULL;
+static void
+gdk_visual_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (gdk_visual_parent_class)->finalize (object);
+}
-void
-gdk_visual_init ()
+static void
+gdk_visual_class_init (GdkVisualClass *visual_class)
{
- static gint possible_depths[6] = { 32, 24, 16, 15, 8, 1 };
- static GdkVisualType possible_types[6] =
- {
- GDK_VISUAL_DIRECT_COLOR,
- GDK_VISUAL_TRUE_COLOR,
- GDK_VISUAL_PSEUDO_COLOR,
- GDK_VISUAL_STATIC_COLOR,
- GDK_VISUAL_GRAYSCALE,
- GDK_VISUAL_STATIC_GRAY
- };
-
- static gint npossible_depths = 6;
- static gint npossible_types = 6;
-
- XVisualInfo *visual_list;
- XVisualInfo visual_template;
- GdkVisualPrivate temp_visual;
- Visual *default_xvisual;
- int nxvisuals;
- int i, j;
-
- visual_template.screen = gdk_screen;
- visual_list = XGetVisualInfo (gdk_display, VisualScreenMask, &visual_template, &nxvisuals);
- visuals = g_new (GdkVisualPrivate, nxvisuals);
-
- default_xvisual = DefaultVisual (gdk_display, gdk_screen);
-
- nvisuals = 0;
- for (i = 0; i < nxvisuals; i++)
- {
- if (visual_list[i].depth >= 1)
- {
-#ifdef __cplusplus
- switch (visual_list[i].c_class)
-#else /* __cplusplus */
- switch (visual_list[i].class)
-#endif /* __cplusplus */
- {
- case StaticGray:
- visuals[nvisuals].visual.type = GDK_VISUAL_STATIC_GRAY;
- break;
- case GrayScale:
- visuals[nvisuals].visual.type = GDK_VISUAL_GRAYSCALE;
- break;
- case StaticColor:
- visuals[nvisuals].visual.type = GDK_VISUAL_STATIC_COLOR;
- break;
- case PseudoColor:
- visuals[nvisuals].visual.type = GDK_VISUAL_PSEUDO_COLOR;
- break;
- case TrueColor:
- visuals[nvisuals].visual.type = GDK_VISUAL_TRUE_COLOR;
- break;
- case DirectColor:
- visuals[nvisuals].visual.type = GDK_VISUAL_DIRECT_COLOR;
- break;
- }
-
- visuals[nvisuals].visual.depth = visual_list[i].depth;
- visuals[nvisuals].visual.byte_order =
- (ImageByteOrder(gdk_display) == LSBFirst) ?
- GDK_LSB_FIRST : GDK_MSB_FIRST;
- visuals[nvisuals].visual.red_mask = visual_list[i].red_mask;
- visuals[nvisuals].visual.green_mask = visual_list[i].green_mask;
- visuals[nvisuals].visual.blue_mask = visual_list[i].blue_mask;
- visuals[nvisuals].visual.colormap_size = visual_list[i].colormap_size;
- visuals[nvisuals].visual.bits_per_rgb = visual_list[i].bits_per_rgb;
- visuals[nvisuals].xvisual = visual_list[i].visual;
-
- if ((visuals[nvisuals].visual.type == GDK_VISUAL_TRUE_COLOR) ||
- (visuals[nvisuals].visual.type == GDK_VISUAL_DIRECT_COLOR))
- {
- gdk_visual_decompose_mask (visuals[nvisuals].visual.red_mask,
- &visuals[nvisuals].visual.red_shift,
- &visuals[nvisuals].visual.red_prec);
-
- gdk_visual_decompose_mask (visuals[nvisuals].visual.green_mask,
- &visuals[nvisuals].visual.green_shift,
- &visuals[nvisuals].visual.green_prec);
-
- gdk_visual_decompose_mask (visuals[nvisuals].visual.blue_mask,
- &visuals[nvisuals].visual.blue_shift,
- &visuals[nvisuals].visual.blue_prec);
- }
- else
- {
- visuals[nvisuals].visual.red_mask = 0;
- visuals[nvisuals].visual.red_shift = 0;
- visuals[nvisuals].visual.red_prec = 0;
-
- visuals[nvisuals].visual.green_mask = 0;
- visuals[nvisuals].visual.green_shift = 0;
- visuals[nvisuals].visual.green_prec = 0;
-
- visuals[nvisuals].visual.blue_mask = 0;
- visuals[nvisuals].visual.blue_shift = 0;
- visuals[nvisuals].visual.blue_prec = 0;
- }
-
- nvisuals += 1;
- }
- }
-
- XFree (visual_list);
-
- for (i = 0; i < nvisuals; i++)
- {
- for (j = i+1; j < nvisuals; j++)
- {
- if (visuals[j].visual.depth >= visuals[i].visual.depth)
- {
- if ((visuals[j].visual.depth == 8) && (visuals[i].visual.depth == 8))
- {
- if (visuals[j].visual.type == GDK_VISUAL_PSEUDO_COLOR)
- {
- temp_visual = visuals[j];
- visuals[j] = visuals[i];
- visuals[i] = temp_visual;
- }
- else if ((visuals[i].visual.type != GDK_VISUAL_PSEUDO_COLOR) &&
- visuals[j].visual.type > visuals[i].visual.type)
- {
- temp_visual = visuals[j];
- visuals[j] = visuals[i];
- visuals[i] = temp_visual;
- }
- }
- else if ((visuals[j].visual.depth > visuals[i].visual.depth) ||
- ((visuals[j].visual.depth == visuals[i].visual.depth) &&
- (visuals[j].visual.type > visuals[i].visual.type)))
- {
- temp_visual = visuals[j];
- visuals[j] = visuals[i];
- visuals[i] = temp_visual;
- }
- }
- }
- }
-
- for (i = 0; i < nvisuals; i++)
- if (default_xvisual->visualid == visuals[i].xvisual->visualid)
- {
- system_visual = &visuals[i];
- break;
- }
-
-#ifdef G_ENABLE_DEBUG
- if (gdk_debug_flags & GDK_DEBUG_MISC)
- for (i = 0; i < nvisuals; i++)
- g_print ("visual: %s: %d\n",
- visual_names[visuals[i].visual.type],
- visuals[i].visual.depth);
-#endif /* G_ENABLE_DEBUG */
-
- navailable_depths = 0;
- for (i = 0; i < npossible_depths; i++)
- {
- for (j = 0; j < nvisuals; j++)
- {
- if (visuals[j].visual.depth == possible_depths[i])
- {
- available_depths[navailable_depths++] = visuals[j].visual.depth;
- break;
- }
- }
- }
-
- if (navailable_depths == 0)
- g_error ("unable to find a usable depth");
-
- navailable_types = 0;
- for (i = 0; i < npossible_types; i++)
- {
- for (j = 0; j < nvisuals; j++)
- {
- if (visuals[j].visual.type == possible_types[i])
- {
- available_types[navailable_types++] = visuals[j].visual.type;
- break;
- }
- }
- }
-
- for (i = 0; i < nvisuals; i++)
- gdk_visual_add ((GdkVisual*) &visuals[i]);
-
- if (npossible_types == 0)
- g_error ("unable to find a usable visual type");
+ GObjectClass *object_class = G_OBJECT_CLASS (visual_class);
+
+ object_class->finalize = gdk_visual_finalize;
}
-GdkVisual*
-gdk_visual_ref (GdkVisual *visual)
+/**
+ * gdk_list_visuals:
+ *
+ * Lists the available visuals for the default screen.
+ * (See gdk_screen_list_visuals())
+ * 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
+ */
+GList*
+gdk_list_visuals (void)
{
- return visual;
+ return gdk_screen_list_visuals (gdk_screen_get_default ());
}
-void
-gdk_visual_unref (GdkVisual *visual)
+/**
+ * gdk_visual_get_system:
+ *
+ * Get the system's default visual for the default GDK screen.
+ * This is the visual for the root window of the display.
+ * The return value should not be freed.
+ *
+ * Return value: (transfer none): system visual
+ */
+GdkVisual*
+gdk_visual_get_system (void)
{
- return;
+ return gdk_screen_get_system_visual (gdk_screen_get_default());
}
+/**
+ * gdk_visual_get_best_depth:
+ *
+ * Get the best available depth for the default GDK screen. "Best"
+ * means "largest," i.e. 32 preferred over 24 preferred over 8 bits
+ * per pixel.
+ *
+ * Return value: best available depth
+ */
gint
-gdk_visual_get_best_depth ()
+gdk_visual_get_best_depth (void)
{
- return available_depths[0];
+ GdkScreen *screen = gdk_screen_get_default();
+
+ return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_depth (screen);
}
+/**
+ * gdk_visual_get_best_type:
+ *
+ * Return the best available visual type for the default GDK screen.
+ *
+ * Return value: best visual type
+ */
GdkVisualType
-gdk_visual_get_best_type ()
+gdk_visual_get_best_type (void)
{
- return available_types[0];
-}
+ GdkScreen *screen = gdk_screen_get_default();
-GdkVisual*
-gdk_visual_get_system ()
-{
- return ((GdkVisual*) system_visual);
+ return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_type (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.
+ *
+ * Return value: (transfer none): best visual
+ */
GdkVisual*
-gdk_visual_get_best ()
+gdk_visual_get_best (void)
{
- return ((GdkVisual*) &(visuals[0]));
+ GdkScreen *screen = gdk_screen_get_default();
+
+ return GDK_SCREEN_GET_CLASS(screen)->visual_get_best (screen);
}
+/**
+ * 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.
+ *
+ * Return value: (transfer none): best visual for the given depth
+ */
GdkVisual*
gdk_visual_get_best_with_depth (gint depth)
{
- GdkVisual *return_val;
- int i;
-
- return_val = NULL;
- for (i = 0; i < nvisuals; i++)
- if (depth == visuals[i].visual.depth)
- {
- return_val = (GdkVisual*) &(visuals[i]);
- break;
- }
-
- return return_val;
+ GdkScreen *screen = gdk_screen_get_default();
+
+ return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_with_depth (screen, depth);
}
+/**
+ * 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.
+ *
+ * Return value: (transfer none): best visual of the given type
+ */
GdkVisual*
gdk_visual_get_best_with_type (GdkVisualType visual_type)
{
- GdkVisual *return_val;
- int i;
-
- return_val = NULL;
- for (i = 0; i < nvisuals; i++)
- if (visual_type == visuals[i].visual.type)
- {
- return_val = (GdkVisual*) &(visuals[i]);
- break;
- }
-
- return return_val;
+ GdkScreen *screen = gdk_screen_get_default();
+
+ return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_with_type (screen,
+ visual_type);
}
+/**
+ * gdk_visual_get_best_with_both:
+ * @depth: a bit depth
+ * @visual_type: a visual type
+ *
+ * Combines gdk_visual_get_best_with_depth() and
+ * gdk_visual_get_best_with_type().
+ *
+ * Return value: (transfer none): best visual with both @depth and
+ * @visual_type, or %NULL if none
+ */
GdkVisual*
gdk_visual_get_best_with_both (gint depth,
GdkVisualType visual_type)
{
- GdkVisual *return_val;
- int i;
-
- return_val = NULL;
- for (i = 0; i < nvisuals; i++)
- if ((depth == visuals[i].visual.depth) &&
- (visual_type == visuals[i].visual.type))
- {
- return_val = (GdkVisual*) &(visuals[i]);
- break;
- }
-
- return return_val;
+ GdkScreen *screen = gdk_screen_get_default();
+
+ return GDK_SCREEN_GET_CLASS(screen)->visual_get_best_with_both (screen, depth, 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)
+gdk_query_depths (gint **depths,
+ gint *count)
{
- *count = navailable_depths;
- *depths = available_depths;
+ GdkScreen *screen = gdk_screen_get_default();
+
+ GDK_SCREEN_GET_CLASS(screen)->query_depths (screen, depths, count);
}
+/**
+ * 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)
+ gint *count)
{
- *count = navailable_types;
- *visual_types = available_types;
+ GdkScreen *screen = gdk_screen_get_default();
+
+ GDK_SCREEN_GET_CLASS(screen)->query_visual_types (screen, visual_types, count);
}
-void
-gdk_query_visuals (GdkVisual **visual_return,
- gint *count)
+/**
+ * gdk_visual_get_visual_type:
+ * @visual: A #GdkVisual.
+ *
+ * Returns the type of visual this is (PseudoColor, TrueColor, etc).
+ *
+ * Return value: A #GdkVisualType stating the type of @visual.
+ *
+ * Since: 2.22
+ */
+GdkVisualType
+gdk_visual_get_visual_type (GdkVisual *visual)
{
- *count = nvisuals;
- *visual_return = (GdkVisual*) visuals;
-}
+ g_return_val_if_fail (GDK_IS_VISUAL (visual), 0);
+ return visual->type;
+}
-GdkVisual*
-gdk_visual_lookup (Visual *xvisual)
+/**
+ * gdk_visual_get_depth:
+ * @visual: A #GdkVisual.
+ *
+ * Returns the bit depth of this visual.
+ *
+ * Return value: The bit depth of this visual.
+ *
+ * Since: 2.22
+ */
+gint
+gdk_visual_get_depth (GdkVisual *visual)
{
- GdkVisual *visual;
-
- if (!visual_hash)
- return NULL;
+ g_return_val_if_fail (GDK_IS_VISUAL (visual), 0);
- visual = g_hash_table_lookup (visual_hash, xvisual);
- return visual;
+ return visual->depth;
}
-GdkVisual*
-gdkx_visual_get (VisualID xvisualid)
+/**
+ * gdk_visual_get_byte_order:
+ * @visual: A #GdkVisual.
+ *
+ * Returns the byte order of this visual.
+ *
+ * Return value: A #GdkByteOrder stating the byte order of @visual.
+ *
+ * Since: 2.22
+ */
+GdkByteOrder
+gdk_visual_get_byte_order (GdkVisual *visual)
{
- int i;
+ g_return_val_if_fail (GDK_IS_VISUAL (visual), 0);
- for (i = 0; i < nvisuals; i++)
- if (xvisualid == visuals[i].xvisual->visualid)
- return (GdkVisual*) &visuals[i];
+ return visual->byte_order;
+}
- return NULL;
+/**
+ * gdk_visual_get_colormap_size:
+ * @visual: A #GdkVisual.
+ *
+ * Returns the size of a colormap for this visual.
+ *
+ * Return value: The size of a colormap that is suitable for @visual.
+ *
+ * Since: 2.22
+ */
+gint
+gdk_visual_get_colormap_size (GdkVisual *visual)
+{
+ g_return_val_if_fail (GDK_IS_VISUAL (visual), 0);
+
+ return visual->colormap_size;
}
+/**
+ * gdk_visual_get_bits_per_rgb:
+ * @visual: a #GdkVisual
+ *
+ * Returns the number of significant bits per red, green and blue value.
+ *
+ * Return value: The number of significant bits per color value for @visual.
+ *
+ * Since: 2.22
+ */
+gint
+gdk_visual_get_bits_per_rgb (GdkVisual *visual)
+{
+ g_return_val_if_fail (GDK_IS_VISUAL (visual), 0);
+
+ return visual->bits_per_rgb;
+}
-static void
-gdk_visual_add (GdkVisual *visual)
+/**
+ * gdk_visual_get_red_pixel_details:
+ * @visual: A #GdkVisual
+ * @mask: (out) (allow-none): A pointer to a #guint32 to be filled in, or %NULL
+ * @shift: (out) (allow-none): A pointer to a #gint to be filled in, or %NULL
+ * @precision: (out) (allow-none): A pointer to a #gint to be filled in, or %NULL
+ *
+ * Obtains values that are needed to calculate red pixel values in TrueColor
+ * and DirectColor. The "mask" is the significant bits within the pixel.
+ * The "shift" is the number of bits left we must shift a primary for it
+ * to be in position (according to the "mask"). Finally, "precision" refers
+ * to how much precision the pixel value contains for a particular primary.
+ *
+ * Since: 2.22
+ */
+void
+gdk_visual_get_red_pixel_details (GdkVisual *visual,
+ guint32 *mask,
+ gint *shift,
+ gint *precision)
{
- GdkVisualPrivate *private;
+ g_return_if_fail (GDK_IS_VISUAL (visual));
- if (!visual_hash)
- visual_hash = g_hash_table_new ((GHashFunc) gdk_visual_hash,
- (GCompareFunc) gdk_visual_compare);
+ if (mask)
+ *mask = visual->red_mask;
- private = (GdkVisualPrivate*) visual;
+ if (shift)
+ *shift = visual->red_shift;
- g_hash_table_insert (visual_hash, private->xvisual, visual);
+ if (precision)
+ *precision = visual->red_prec;
}
-static void
-gdk_visual_decompose_mask (gulong mask,
- gint *shift,
- gint *prec)
+/**
+ * gdk_visual_get_green_pixel_details:
+ * @visual: a #GdkVisual
+ * @mask: (out) (allow-none): A pointer to a #guint32 to be filled in, or %NULL
+ * @shift: (out) (allow-none): A pointer to a #gint to be filled in, or %NULL
+ * @precision: (out) (allow-none): A pointer to a #gint to be filled in, or %NULL
+ *
+ * Obtains values that are needed to calculate green pixel values in TrueColor
+ * and DirectColor. The "mask" is the significant bits within the pixel.
+ * The "shift" is the number of bits left we must shift a primary for it
+ * to be in position (according to the "mask"). Finally, "precision" refers
+ * to how much precision the pixel value contains for a particular primary.
+ *
+ * Since: 2.22
+ */
+void
+gdk_visual_get_green_pixel_details (GdkVisual *visual,
+ guint32 *mask,
+ gint *shift,
+ gint *precision)
{
- *shift = 0;
- *prec = 0;
-
- while (!(mask & 0x1))
- {
- (*shift)++;
- mask >>= 1;
- }
-
- while (mask & 0x1)
- {
- (*prec)++;
- mask >>= 1;
- }
+ g_return_if_fail (GDK_IS_VISUAL (visual));
+
+ if (mask)
+ *mask = visual->green_mask;
+
+ if (shift)
+ *shift = visual->green_shift;
+
+ if (precision)
+ *precision = visual->green_prec;
}
-static guint
-gdk_visual_hash (Visual *key)
+/**
+ * gdk_visual_get_blue_pixel_details:
+ * @visual: a #GdkVisual
+ * @mask: (out) (allow-none): A pointer to a #guint32 to be filled in, or %NULL
+ * @shift: (out) (allow-none): A pointer to a #gint to be filled in, or %NULL
+ * @precision: (out) (allow-none): A pointer to a #gint to be filled in, or %NULL
+ *
+ * Obtains values that are needed to calculate blue pixel values in TrueColor
+ * and DirectColor. The "mask" is the significant bits within the pixel.
+ * The "shift" is the number of bits left we must shift a primary for it
+ * to be in position (according to the "mask"). Finally, "precision" refers
+ * to how much precision the pixel value contains for a particular primary.
+ *
+ * Since: 2.22
+ */
+void
+gdk_visual_get_blue_pixel_details (GdkVisual *visual,
+ guint32 *mask,
+ gint *shift,
+ gint *precision)
{
- return key->visualid;
+ g_return_if_fail (GDK_IS_VISUAL (visual));
+
+ if (mask)
+ *mask = visual->blue_mask;
+
+ if (shift)
+ *shift = visual->blue_shift;
+
+ if (precision)
+ *precision = visual->blue_prec;
}
-static gint
-gdk_visual_compare (Visual *a,
- Visual *b)
+/**
+ * gdk_visual_get_screen:
+ * @visual: a #GdkVisual
+ *
+ * Gets the screen to which this visual belongs
+ *
+ * Return value: (transfer none): the screen to which this visual belongs.
+ *
+ * Since: 2.2
+ */
+GdkScreen *
+gdk_visual_get_screen (GdkVisual *visual)
{
- return (a->visualid == b->visualid);
+ g_return_val_if_fail (GDK_IS_VISUAL (visual), NULL);
+
+ return visual->screen;
}
projects / ~andy / gtk / blobdiff