xlib_rgb_init ()

void
xlib_rgb_init (Display *display,
               Screen *screen);

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.

xlib_rgb_init_with_depth ()

void
xlib_rgb_init_with_depth (Display *display,
                          Screen *screen,
                          int prefDepth);

Initializes the XlibRGB machinery with a particular depth you specify, instead of automatically picking the best depth in the display. This function or xlib_rgb_init() must be called before using any of the other functions in XlibRGB.

xlib_rgb_xpixel_from_rgb ()

unsigned long
xlib_rgb_xpixel_from_rgb (guint32 rgb);

Converts an RGB triplet into the closest color that XlibRGB visual can handle.

xlib_rgb_gc_set_foreground ()

void
xlib_rgb_gc_set_foreground (GC gc,
                            guint32 rgb);

This is a convenience function to set the foreground of a GC from an RGB triplet. It calls xlib_rgb_xpixel_from_rgb() internally and uses the returned pixel value to set the GC's foreground.

xlib_rgb_gc_set_background ()

void
xlib_rgb_gc_set_background (GC gc,
                            guint32 rgb);

This is a convenience function to set the background of a GC from an RGB triplet. It calls xlib_rgb_xpixel_from_rgb() internally and uses the returned pixel value to set the GC's background.

xlib_draw_rgb_image ()

void
xlib_draw_rgb_image (Drawable drawable,
                     GC gc,
                     int x,
                     int y,
                     int width,
                     int height,
                     XlibRgbDither dith,
                     unsigned char *rgb_buf,
                     int rowstride);

Renders an RGB buffer to a drawable. Pixels are specified as RGB triplets with 8 bits per channel. An image will thus look like an RGBRGBRGBRGB sequence of 8-bit values. This function does not let you specify dither offsets; applications that need to render partial regions of a buffer to build the final image should use xlib_draw_rgb_image_dithalign() instead.

xlib_draw_rgb_image_dithalign ()

void
xlib_draw_rgb_image_dithalign (Drawable drawable,
                               GC gc,
                               int x,
                               int y,
                               int width,
                               int height,
                               XlibRgbDither dith,
                               unsigned char *rgb_buf,
                               int rowstride,
                               int xdith,
                               int ydith);

Renders an RGB buffer to a drawable. Pixels are specified as RGB triplets with 8 bits per channel. An image will thus look like an RGBRGBRGBRGB sequence of 8-bit values. This function lets you specify a pair of dither offsets. It should be used when you need to render regions of an RGB buffer separately to form the final image; the dither offsets let you align the dither mask appropriately.

xlib_draw_rgb_32_image ()

void
xlib_draw_rgb_32_image (Drawable drawable,
                        GC gc,
                        int x,
                        int y,
                        int width,
                        int height,
                        XlibRgbDither dith,
                        unsigned char *buf,
                        int rowstride);

This function is analogous to xlib_draw_rgb_image(), but it lets you use 32-bit RGB buffers with pixels specified as 0xRRGGBB00. The least-significant 8 bits are actually discarded. This function can lead to faster results than xlib_draw_rgb_image() since the pixels are aligned on 32-bit boundaries.

xlib_draw_gray_image ()

void
xlib_draw_gray_image (Drawable drawable,
                      GC gc,
                      int x,
                      int y,
                      int width,
                      int height,
                      XlibRgbDither dith,
                      unsigned char *buf,
                      int rowstride);

Renders a grayscale buffer to a drawable. Pixels are specified as 8-bit intensity values. An image will thus look as a GGGGGG sequence of 8-bit values.

xlib_rgb_cmap_new ()

XlibRgbCmap *
xlib_rgb_cmap_new (guint32 *colors,
                   int n_colors);

FIXME

xlib_rgb_cmap_free ()

void
xlib_rgb_cmap_free (XlibRgbCmap *cmap);

Frees an XlibRGB colormap.

xlib_draw_indexed_image ()

void
xlib_draw_indexed_image (Drawable drawable,
                         GC gc,
                         int x,
                         int y,
                         int width,
                         int height,
                         XlibRgbDither dith,
                         unsigned char *buf,
                         int rowstride,
                         XlibRgbCmap *cmap);

FIXME

xlib_rgb_ditherable ()

Bool
xlib_rgb_ditherable (void);

Queries whether XlibRGB supports dithering for its chosen visual.

xlib_rgb_set_verbose ()

void
xlib_rgb_set_verbose (Bool verbose);

Enables/disables debug spew.

xlib_rgb_set_install ()

void
xlib_rgb_set_install (Bool install);

Sets whether we install an RGB colormap.

xlib_rgb_set_min_colors ()

void
xlib_rgb_set_min_colors (int min_colors);

Sets the minimum number of colors in the color cube.

xlib_rgb_get_cmap ()

Colormap
xlib_rgb_get_cmap (void);

Queries the X colormap that XlibRGB is using.

xlib_rgb_get_visual ()

Visual *
xlib_rgb_get_visual (void);

Queries the visual that XlibRGB is using.

xlib_rgb_get_visual_info ()

XVisualInfo *
xlib_rgb_get_visual_info (void);

Queries the visual info structure for the visual that XlibRGB is using.

xlib_rgb_get_depth ()

int
xlib_rgb_get_depth (void);

Queries the depth of the visual that XlibRGB is using.

xlib_rgb_get_display ()

Display *
xlib_rgb_get_display (void);

Queries the X display that XlibRGB is using.

xlib_rgb_get_screen ()

Screen *
xlib_rgb_get_screen (void);

Queries the screen that XlibRGB is using.

struct XlibRgbCmap

struct XlibRgbCmap {
  unsigned int colors[256];
  unsigned char lut[256]; /* for 8-bit modes */
};

FIXME: Describe this.

enum XlibRgbDither

These values are used to specify which dithering method should be used. <symbol>XLIB_RGB_DITHER_NONE</symbol> will use no dithering and simply map the colors in an RGB buffer to the closest colors that the display can provide. <symbol>XLIB_RGB_DITHER_NORMAL</symbol> will provide dithering only on pseudocolor displays. <symbol>XLIB_RGB_DITHER_MAX</symbol> will provide dithering on pseudocolor and 16-bit truecolor or &ldquo;high color&rdquo; displays.