7 is 15bpp truecolor, 8 is 16bpp truecolor,			 9 is 24bpp truecolor.   0x00 is the speed - 1 is the normal case,                       2 means faster than normal   00x0 gets a point for being the system visual   000x gets a point for being pseudocolor   A caveat: in the 8bpp modes, being the system visual seems to be   quite important. Thus, all of the 8bpp modes should be ranked at   the same speed.*/static guint32xlib_rgb_score_visual (XVisualInfo *visual){  guint32 quality, speed, pseudo, sys;  static const char* visual_names[] =  {    "static gray",    "grayscale",    "static color",    "pseudo color",    "true color",    "direct color",  };      quality = 0;  speed = 1;  sys = 0;  if (visual->class == TrueColor ||      visual->class == DirectColor)    {      if (visual->depth == 24)	{	  quality = 9;	  /* Should test for MSB visual here, and set speed if so. */	}      else if (visual->depth == 16)	quality = 8;      else if (visual->depth == 15)	quality = 7;      else if (visual->depth == 8)	quality = 4;    }  else if (visual->class == PseudoColor ||	   visual->class == StaticColor)    {      if (visual->depth == 8)	quality = 4;      else if (visual->depth == 4)	quality = 2;      else if (visual->depth == 1)	quality = 1;    }  else if (visual->class == StaticGray#ifdef ENABLE_GRAYSCALE	   || visual->class == GrayScale#endif	   )    {      if (visual->depth == 8)	quality = 4;      else if (visual->depth == 4)	quality = 2;      else if (visual->depth == 1)	quality = 1;    }  if (quality == 0)    return 0;  sys = (visual->visualid == image_info->default_visualid->visualid);    pseudo = (visual->class == PseudoColor || visual->class == TrueColor);  if (xlib_rgb_verbose)    printf ("Visual 0x%x, type = %s, depth = %d, %ld:%ld:%ld%s; score=%x\n",	    (int)visual->visualid,	    visual_names[visual->class],	    visual->depth,	    visual->red_mask,	    visual->green_mask,	    visual->blue_mask,	    sys ? " (system)" : "",	    (quality << 12) | (speed << 8) | (sys << 4) | pseudo);    return (quality << 12) | (speed << 8) | (sys << 4) | pseudo;}static voidxlib_rgb_choose_visual (void){  XVisualInfo *visuals;  XVisualInfo *visual;  XVisualInfo *best_visual;  XVisualInfo *final_visual;  XVisualInfo template;  int num_visuals;  guint32 score, best_score;  int cur_visual = 1;  int i;    template.screen = image_info->screen_num;  visuals = XGetVisualInfo(image_info->display, VisualScreenMask,			   &template, &num_visuals);    best_visual = visuals;  best_score = xlib_rgb_score_visual (best_visual);  for (i = cur_visual; i < num_visuals; i++)    {      visual = &visuals[i];      score = xlib_rgb_score_visual  (visual);      if (score > best_score)	{	  best_score = score;	  best_visual = visual;	}    }  /* make a copy of the visual so that we can free     the allocated visual list above. */  final_visual = malloc(sizeof(XVisualInfo));  memcpy(final_visual, best_visual, sizeof(XVisualInfo));  image_info->x_visual_info = final_visual;  XFree(visuals);  /* set up the shift and the precision for the red, green and blue.     this only applies to cool visuals like true color and direct color. */  if (image_info->x_visual_info->class == TrueColor ||      image_info->x_visual_info->class == DirectColor) {    image_info->red_shift = xlib_get_shift_from_mask(image_info->x_visual_info->red_mask);    image_info->red_prec = xlib_get_prec_from_mask(image_info->x_visual_info->red_mask);    image_info->green_shift = xlib_get_shift_from_mask(image_info->x_visual_info->green_mask);    image_info->green_prec = xlib_get_prec_from_mask(image_info->x_visual_info->green_mask);    image_info->blue_shift = xlib_get_shift_from_mask(image_info->x_visual_info->blue_mask);    image_info->blue_prec = xlib_get_prec_from_mask(image_info->x_visual_info->blue_mask);  }}static voidxlib_rgb_choose_visual_for_xprint (int aDepth){  XVisualInfo *visuals;  XVisualInfo *visual;  XVisualInfo *best_visual;  XVisualInfo *final_visual;  XVisualInfo template;  int num_visuals;  int cur_visual = 1;  int i;  XWindowAttributes win_att;  Status ret_stat;  Visual      *root_visual;  ret_stat = XGetWindowAttributes(image_info->display, 			RootWindow(image_info->display, image_info->screen_num),			&win_att);  root_visual = win_att.visual;  template.screen = image_info->screen_num;  visuals = XGetVisualInfo(image_info->display, VisualScreenMask,			   &template, &num_visuals);   best_visual = visuals;  if (best_visual->visual != root_visual) {     for (i = cur_visual; i < num_visuals; i++) {        visual = &visuals[i];        if (visual->visual == root_visual) {           best_visual = visual;           break;        }      }   }  /* make a copy of the visual so that we can free     the allocated visual list above. */  final_visual = malloc(sizeof(XVisualInfo));  memcpy(final_visual, best_visual, sizeof(XVisualInfo));  image_info->x_visual_info = final_visual;  XFree(visuals);  /* set up the shift and the precision for the red, green and blue.     this only applies to cool visuals like true color and direct color. */  if (image_info->x_visual_info->class == TrueColor ||      image_info->x_visual_info->class == DirectColor) {    image_info->red_shift = xlib_get_shift_from_mask(image_info->x_visual_info->red_mask);    image_info->red_prec = xlib_get_prec_from_mask(image_info->x_visual_info->red_mask);    image_info->green_shift = xlib_get_shift_from_mask(image_info->x_visual_info->green_mask);    image_info->green_prec = xlib_get_prec_from_mask(image_info->x_visual_info->green_mask);    image_info->blue_shift = xlib_get_shift_from_mask(image_info->x_visual_info->blue_mask);    image_info->blue_prec = xlib_get_prec_from_mask(image_info->x_visual_info->blue_mask);  }}static void xlib_rgb_select_conv (XImage *image, ByteOrder byte_order);static voidxlib_rgb_set_gray_cmap (Colormap cmap){  int i;  XColor color;  int status;  unsigned long pixels[256];  int r, g, b, gray;  for (i = 0; i < 256; i++)    {      color.pixel = i;      color.red = i * 257;      color.green = i * 257;      color.blue = i * 257;      status = XAllocColor(image_info->display, cmap, &color);      pixels[i] = color.pixel;#ifdef VERBOSE      printf ("allocating pixel %d, %x %x %x, result %d\n",	       color.pixel, color.red, color.green, color.blue, status);#endif    }  /* Now, we make fake colorcubes - we ultimately just use the pseudocolor     methods. */  colorcube = malloc(sizeof(unsigned char) * 4096);  for (i = 0; i < 4096; i++)    {      r = (i >> 4) & 0xf0;      r = r | r >> 4;      g = i & 0xf0;      g = g | g >> 4;      b = (i << 4 & 0xf0);      b = b | b >> 4;      gray = (g + ((r + b) >> 1)) >> 1;      colorcube[i] = pixels[gray];    }}/** * xlib_rgb_init: * @display: X Display to use. * @screen: Screen to use. *  * Initializes the XlibRGB machinery with the default depth.  If you use this * function XlibRGB will automatically pick the best visual available on your * display.  This function or xlib_rgb_init_with_depth() must be called before * using any of the other functions in XlibRGB. **/voidxlib_rgb_init (Display *display, Screen *screen){  int prefDepth = -1;            /*  let the function do the visual scoring */  xlib_rgb_init_with_depth(display, screen, prefDepth);}