/* GDK - The GIMP Drawing Kit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. *//* * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS * file for a list of people on the GTK+ Team.  See the ChangeLog * files for a list of changes.  These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/.  */#include <config.h>#include <X11/Xlib.h>#include <X11/Xutil.h>#include "gdkx.h"#include "gdkvisual.h"#include "gdkprivate-x11.h"#include "gdkscreen-x11.h"#include "gdkinternals.h"#include "gdkalias.h"struct _GdkVisualClass{  GObjectClass parent_class;};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 gboolean gdk_visual_equal          (Visual    *a,					   Visual    *b);#ifdef G_ENABLE_DEBUGstatic const gchar *const visual_names[] ={  "static gray",  "grayscale",  "static color",  "pseudo color",  "true color",  "direct color",};#endif /* G_ENABLE_DEBUG */static voidgdk_visual_finalize (GObject *object){  g_error ("A GdkVisual object was finalized. This should not happen");}static voidgdk_visual_class_init (GObjectClass *class){  class->finalize = gdk_visual_finalize;}GTypegdk_visual_get_type (void){  static GType object_type = 0;  if (!object_type)    {      static const GTypeInfo object_info =      {        sizeof (GdkVisualClass),        (GBaseInitFunc) NULL,        (GBaseFinalizeFunc) NULL,        (GClassInitFunc) gdk_visual_class_init,        NULL,           /* class_finalize */        NULL,           /* class_data */        sizeof (GdkVisualPrivate),        0,              /* n_preallocs */        (GInstanceInitFunc) NULL,      };            object_type = g_type_register_static (G_TYPE_OBJECT,                                            "GdkVisual",                                            &object_info, 0);    }    return object_type;}void_gdk_visual_init (GdkScreen *screen){  static const gint possible_depths[7] = { 32, 24, 16, 15, 8, 4, 1 };  static const 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    };  GdkScreenX11 *screen_x11;  XVisualInfo *visual_list;  XVisualInfo visual_template;  GdkVisualPrivate *temp_visual;  Visual *default_xvisual;  GdkVisualPrivate **visuals;  int nxvisuals;  int nvisuals;  int i, j;    g_return_if_fail (GDK_IS_SCREEN (screen));  screen_x11 = GDK_SCREEN_X11 (screen);  visual_template.screen = screen_x11->screen_num;  visual_list = XGetVisualInfo (screen_x11->xdisplay, VisualScreenMask, &visual_template, &nxvisuals);    visuals = g_new (GdkVisualPrivate *, nxvisuals);  for (i = 0; i < nxvisuals; i++)    visuals[i] = g_object_new (GDK_TYPE_VISUAL, NULL);  default_xvisual = DefaultVisual (screen_x11->xdisplay, screen_x11->screen_num);  nvisuals = 0;  for (i = 0; i < nxvisuals; i++)    {      visuals[nvisuals]->screen = screen;            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(screen_x11->xdisplay) == 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;	}    }  if (visual_list)    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)      {	screen_x11->system_visual = visuals[i];	break;      }#ifdef G_ENABLE_DEBUG   if (_gdk_debug_flags & GDK_DEBUG_MISC)    for (i = 0; i < nvisuals; i++)      g_message ("visual: %s: %d",		 visual_names[visuals[i]->visual.type],		 visuals[i]->visual.depth);#endif /* G_ENABLE_DEBUG */  screen_x11->navailable_depths = 0;  for (i = 0; i < G_N_ELEMENTS (possible_depths); i++)    {      for (j = 0; j < nvisuals; j++)	{	  if (visuals[j]->visual.depth == possible_depths[i])	    {	      screen_x11->available_depths[screen_x11->navailable_depths++] = visuals[j]->visual.depth;	      break;	    }	}    }  if (screen_x11->navailable_depths == 0)    g_error ("unable to find a usable depth");  screen_x11->navailable_types = 0;  for (i = 0; i < G_N_ELEMENTS (possible_types); i++)    {      for (j = 0; j < nvisuals; j++)	{	  if (visuals[j]->visual.type == possible_types[i])	    {	      screen_x11->available_types[screen_x11->navailable_types++] = visuals[j]->visual.type;	      break;	    }	}    }  for (i = 0; i < nvisuals; i++)    gdk_visual_add ((GdkVisual*) visuals[i]);  if (screen_x11->navailable_types == 0)    g_error ("unable to find a usable visual type");  screen_x11->visuals = visuals;  screen_x11->nvisuals = nvisuals;}/** * 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 **/gintgdk_visual_get_best_depth (void){  GdkScreen *screen = gdk_screen_get_default();    return GDK_SCREEN_X11 (screen)->available_depths[0];}/** * gdk_visual_get_best_type: *  * Return the best available visual type for the default GDK screen. *  * Return value: best visual type **/GdkVisualTypegdk_visual_get_best_type (void){