Back to index

kdeartwork  4.3.2
Defines | Functions
xs_visual.c File Reference
#include "xs_utils.h"
#include "xs_visual.h"
#include <X11/Xutil.h>

Go to the source code of this file.

Defines

#define isupper(c)   ((c) >= 'A' && (c) <= 'Z')
#define _tolower(c)   ((c) - 'A' + 'a')
#define DEFAULT_VISUAL   -1
#define BEST_VISUAL   -2
#define MONO_VISUAL   -3
#define GRAY_VISUAL   -4
#define COLOR_VISUAL   -5
#define SPECIFIC_VISUAL   -6
#define TRY_CLASS(CLASS)

Functions

static Visual * pick_best_visual (Screen *, Bool, Bool)
static Visual * pick_mono_visual (Screen *)
static Visual * pick_best_visual_of_class (Screen *, int)
static Visual * id_to_visual (Screen *, int)
Visual * get_visual (Screen *screen, const char *string, Bool prefer_writable_cells, Bool verbose_p)
Visual * get_visual_resource (Screen *screen, char *name, char *class, Bool prefer_writable_cells)
int visual_depth (Screen *screen, Visual *visual)
int visual_class (Screen *screen, Visual *visual)
Bool has_writable_cells (Screen *screen, Visual *visual)
void describe_visual (FILE *f, Screen *screen, Visual *visual, Bool private_cmap_p)
int screen_number (Screen *screen)
int visual_cells (Screen *screen, Visual *visual)
Visual * find_similar_visual (Screen *screen, Visual *old_visual)

Define Documentation

#define _tolower (   c)    ((c) - 'A' + 'a')

Definition at line 31 of file xs_visual.c.

#define BEST_VISUAL   -2

Definition at line 43 of file xs_visual.c.

#define COLOR_VISUAL   -5

Definition at line 46 of file xs_visual.c.

#define DEFAULT_VISUAL   -1

Definition at line 42 of file xs_visual.c.

#define GRAY_VISUAL   -4

Definition at line 45 of file xs_visual.c.

#define isupper (   c)    ((c) >= 'A' && (c) <= 'Z')

Definition at line 28 of file xs_visual.c.

#define MONO_VISUAL   -3

Definition at line 44 of file xs_visual.c.

#define SPECIFIC_VISUAL   -6

Definition at line 47 of file xs_visual.c.

#define TRY_CLASS (   CLASS)
Value:
if ((visual = pick_best_visual_of_class (screen, CLASS)) && \
      (!color_only || visual_depth(screen, visual) > 1)) \
    return visual

Function Documentation

void describe_visual ( FILE *  f,
Screen screen,
Visual *  visual,
Bool  private_cmap_p 
)

Definition at line 378 of file xs_visual.c.

{
  char n[10];
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count;
  vi_in.screen = screen_number (screen);
  vi_in.visualid = XVisualIDFromVisual (visual);
  vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
                        &vi_in, &out_count);
  if (! vi_out) abort ();
  if (private_cmap_p)
    sprintf(n, "%3d", vi_out->colormap_size);
  else
    strcpy(n, "default");

  fprintf (f, "0x%02x (%s depth: %2d, cmap: %s)\n",
          (unsigned int) vi_out->visualid,
          (vi_out->class == StaticGray  ? "StaticGray, " :
           vi_out->class == StaticColor ? "StaticColor," :
           vi_out->class == TrueColor   ? "TrueColor,  " :
           vi_out->class == GrayScale   ? "GrayScale,  " :
           vi_out->class == PseudoColor ? "PseudoColor," :
           vi_out->class == DirectColor ? "DirectColor," :
                                      "UNKNOWN:    "),
          vi_out->depth, n);
  XFree ((char *) vi_out);
}

Here is the call graph for this function:

Visual* find_similar_visual ( Screen screen,
Visual *  old_visual 
)

Definition at line 435 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  Visual *result = 0;
  int out_count;

  vi_in.screen = screen_number (screen);
  vi_in.class  = visual_class (screen, old_visual);
  vi_in.depth  = visual_depth (screen, old_visual);

  /* Look for a visual of the same class and depth.
   */
  vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualClassMask |
                             VisualDepthMask),
                        &vi_in, &out_count);
  if (vi_out && out_count > 0)
    result = vi_out[0].visual;
  if (vi_out) XFree (vi_out);
  vi_out = 0;

  /* Failing that, look for a visual of the same class.
   */
  if (!result)
    {
      vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualClassMask),
                            &vi_in, &out_count);
      if (vi_out && out_count > 0)
       result = vi_out[0].visual;
      if (vi_out) XFree (vi_out);
      vi_out = 0;
    }

  /* Failing that, return the default visual. */
  if (!result)
    result = DefaultVisualOfScreen (screen);

  return result;
}

Here is the call graph for this function:

Visual* get_visual ( Screen screen,
const char *  string,
Bool  prefer_writable_cells,
Bool  verbose_p 
)

Definition at line 50 of file xs_visual.c.

{
  char *v = (string ? strdup(string) : 0);
  char c, *tmp;
  int vclass;
  unsigned long id;
  Visual *result = 0;

  if (v)
    for (tmp = v; *tmp; tmp++)
      if (isupper (*tmp)) *tmp = _tolower (*tmp);

  if (!v)                                   vclass = BEST_VISUAL;
  else if (!strcmp (v, "default"))          vclass = DEFAULT_VISUAL;
  else if (!strcmp (v, "best"))             vclass = BEST_VISUAL;
  else if (!strcmp (v, "mono"))             vclass = MONO_VISUAL;
  else if (!strcmp (v, "monochrome"))              vclass = MONO_VISUAL;
  else if (!strcmp (v, "gray"))             vclass = GRAY_VISUAL;
  else if (!strcmp (v, "grey"))             vclass = GRAY_VISUAL;
  else if (!strcmp (v, "color"))            vclass = COLOR_VISUAL;
  else if (!strcmp (v, "staticgray"))              vclass = StaticGray;
  else if (!strcmp (v, "staticcolor"))             vclass = StaticColor;
  else if (!strcmp (v, "truecolor"))               vclass = TrueColor;
  else if (!strcmp (v, "grayscale"))               vclass = GrayScale;
  else if (!strcmp (v, "greyscale"))               vclass = GrayScale;
  else if (!strcmp (v, "pseudocolor"))             vclass = PseudoColor;
  else if (!strcmp (v, "directcolor"))             vclass = DirectColor;
  else if (1 == sscanf (v, " %ld %c", &id, &c))    vclass = SPECIFIC_VISUAL;
  else if (1 == sscanf (v, " 0x%lx %c", &id, &c)) vclass = SPECIFIC_VISUAL;
  else
    {
      fprintf (stderr, "%s: unrecognized visual \"%s\".\n", "kscreensaver", v);
      vclass = DEFAULT_VISUAL;
    }

  if (vclass == DEFAULT_VISUAL)
    result = DefaultVisualOfScreen (screen);
  else if (vclass == BEST_VISUAL)
    result = pick_best_visual (screen, prefer_writable_cells, False);
  else if (vclass == MONO_VISUAL)
    {
      result = pick_mono_visual (screen);
      if (!result && verbose_p)
       fprintf (stderr, "%s: no monochrome visuals.\n", "kscreensaver");
    }
  else if (vclass == GRAY_VISUAL)
    {
      if (prefer_writable_cells)
       result = pick_best_visual_of_class (screen, GrayScale);
      if (!result)
       result = pick_best_visual_of_class (screen, StaticGray);
      if (!result)
       result = pick_best_visual_of_class (screen, GrayScale);
      if (!result && verbose_p)
       fprintf (stderr, "%s: no GrayScale or StaticGray visuals.\n",
               "kscreensaver");
    }
  else if (vclass == COLOR_VISUAL)
    {
      int class;
      /* First see if the default visual will do. */
      result = DefaultVisualOfScreen (screen);
      class = visual_class(screen, result);
      if (class != TrueColor &&
         class != PseudoColor &&
         class != DirectColor &&
         class != StaticColor)
       result = 0;
      if (result && visual_depth(screen, result) <= 1)
       result = 0;

      /* Else, find the best non-default color visual */
      if (!result)
       result = pick_best_visual (screen, prefer_writable_cells, True);

      if (!result && verbose_p)
       fprintf (stderr, "%s: no color visuals.\n", "kscreensaver");
    }
  else if (vclass == SPECIFIC_VISUAL)
    {
      result = id_to_visual (screen, id);
      if (!result && verbose_p)
       fprintf (stderr, "%s: no visual with id 0x%x.\n", "kscreensaver",
               (unsigned int) id);
    }
  else
    {
      Visual *visual = pick_best_visual_of_class (screen, vclass);
      if (visual)
       result = visual;
      else if (verbose_p)
       fprintf (stderr, "%s: no visual of class %s.\n", "kscreensaver", v);
    }

  if (v) free (v);
  return result;
}

Here is the call graph for this function:

Visual* get_visual_resource ( Screen screen,
char *  name,
char *  class,
Bool  prefer_writable_cells 
)

Definition at line 150 of file xs_visual.c.

{
/*
  char *string = get_string_resource (name, class);
  Visual *v = get_visual (screen, string, prefer_writable_cells, True);
  if (string)
    free(string);
  if (v)
    return v;
  else
*/
    return DefaultVisualOfScreen (screen);
}
Bool has_writable_cells ( Screen screen,
Visual *  visual 
)

Definition at line 358 of file xs_visual.c.

{
  switch (visual_class (screen, visual))
    {
    case GrayScale:  /* Mappable grays. */
    case PseudoColor:       /* Mappable colors. */
      return True;
    case StaticGray: /* Fixed grays. */
    case TrueColor:  /* Fixed colors. */
    case StaticColor:       /* (What's the difference again?) */
    case DirectColor:       /* DirectColor visuals are like TrueColor, but have
                        three colormaps - one for each component of RGB.
                        Screw it. */
      return False;
    default:
      abort();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Visual * id_to_visual ( Screen screen,
int  id 
) [static]

Definition at line 273 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count;
  vi_in.screen = screen_number (screen);
  vi_in.visualid = id;
  vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
                        &vi_in, &out_count);
  if (vi_out)
    {
      Visual *v = vi_out[0].visual;
      XFree ((char *) vi_out);
      return v;
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Visual * pick_best_visual ( Screen screen,
Bool  prefer_writable_cells,
Bool  color_only 
) [static]

Definition at line 167 of file xs_visual.c.

{
  Visual *visual;

  if (!prefer_writable_cells)
    {
      /* If we don't prefer writable cells, then the "best" visual is the one
        on which we can allocate the largest range and number of colors.

        Therefore, a TrueColor visual which is at least 16 bits deep is best.
        (The assumption here being that a TrueColor of less than 16 bits is
        really just a PseudoColor visual with a pre-allocated color cube.)

        The next best thing is a PseudoColor visual of any type.  After that
        come the non-colormappable visuals, and non-color visuals.
       */
      if ((visual = pick_best_visual_of_class (screen, TrueColor)) &&
         visual_depth (screen, visual) >= 16)
       return visual;
    }

#define TRY_CLASS(CLASS) \
  if ((visual = pick_best_visual_of_class (screen, CLASS)) && \
      (!color_only || visual_depth(screen, visual) > 1)) \
    return visual
  TRY_CLASS(PseudoColor);
  TRY_CLASS(TrueColor);
  TRY_CLASS(DirectColor);
  TRY_CLASS(StaticColor);
  if (!color_only)
    {
      TRY_CLASS(GrayScale);
      TRY_CLASS(StaticGray);
    }
#undef TRY_CLASS

  visual = DefaultVisualOfScreen (screen);
  if (!color_only || visual_depth(screen, visual) > 1)
    return visual;
  else
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Visual * pick_best_visual_of_class ( Screen screen,
int  visual_class 
) [static]

Definition at line 235 of file xs_visual.c.

{
  /* The best visual of a class is the one which on which we can allocate
     the largest range and number of colors, which means the one with the
     greatest depth and number of cells.

     (But actually, for XDaliClock, all visuals of the same class are
     probably equivalent - either we have writable cells or we don't.)
   */
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count;

  vi_in.class = visual_class;
  vi_in.screen = screen_number (screen);
  vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask),
                        &vi_in, &out_count);
  if (vi_out)
    {
      /* choose the 'best' one, if multiple */
      int i, best;
      Visual *visual;
      for (i = 0, best = 0; i < out_count; i++)
       /* It's better if it's deeper, or if it's the same depth with
          more cells (does that ever happen?  Well, it could...) */
       if ((vi_out [i].depth > vi_out [best].depth) ||
           ((vi_out [i].depth == vi_out [best].depth) &&
            (vi_out [i].colormap_size > vi_out [best].colormap_size)))
         best = i;
      visual = (best < out_count ? vi_out [best].visual : 0);
      XFree ((char *) vi_out);
      return visual;
    }
  else
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Visual * pick_mono_visual ( Screen screen) [static]

Definition at line 211 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count;

  vi_in.depth = 1;
  vi_in.screen = screen_number (screen);
  vi_out = XGetVisualInfo (dpy, (VisualDepthMask | VisualScreenMask),
                        &vi_in, &out_count);
  if (vi_out)
    {
      Visual *v = (out_count > 0 ? vi_out [0].visual : 0);
      if (v && vi_out[0].depth != 1)
       v = 0;
      XFree ((char *) vi_out);
      return v;
    }
  else
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int screen_number ( Screen screen)

Definition at line 408 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  int i;
  for (i = 0; i < ScreenCount (dpy); i++)
    if (ScreenOfDisplay (dpy, i) == screen)
      return i;
  abort ();
}

Here is the caller graph for this function:

int visual_cells ( Screen screen,
Visual *  visual 
)

Definition at line 419 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count, c;
  vi_in.screen = screen_number (screen);
  vi_in.visualid = XVisualIDFromVisual (visual);
  vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
                        &vi_in, &out_count);
  if (! vi_out) abort ();
  c = vi_out [0].colormap_size;
  XFree ((char *) vi_out);
  return c;
}

Here is the call graph for this function:

int visual_class ( Screen screen,
Visual *  visual 
)

Definition at line 342 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count, c;
  vi_in.screen = screen_number (screen);
  vi_in.visualid = XVisualIDFromVisual (visual);
  vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
                        &vi_in, &out_count);
  if (! vi_out) abort ();
  c = vi_out [0].class;
  XFree ((char *) vi_out);
  return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int visual_depth ( Screen screen,
Visual *  visual 
)

Definition at line 292 of file xs_visual.c.

{
  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count, d;
  vi_in.screen = screen_number (screen);
  vi_in.visualid = XVisualIDFromVisual (visual);
  vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
                        &vi_in, &out_count);
  if (! vi_out) abort ();
  d = vi_out [0].depth;
  XFree ((char *) vi_out);
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function: