Drawing.h File Reference

#include <X11/Xlib.h>
#include <X11/Xfuncproto.h>
#include <stdio.h>

Include dependency graph for Drawing.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef unsigned long	Pixel
Functions
_XFUNCPROTOBEGIN void	XmuDrawRoundedRectangle (Display *dpy, Drawable draw, GC gc, int x, int y, int w, int h, int ew, int eh)
void	XmuFillRoundedRectangle (Display *dpy, Drawable draw, GC gc, int x, int y, int w, int h, int ew, int eh)
void	XmuDrawLogo (Display *dpy, Drawable drawable, GC gcFore, GC gcBack, int x, int y, unsigned int width, unsigned int height)
Pixmap	XmuCreatePixmapFromBitmap (Display *dpy, Drawable d, Pixmap bitmap, unsigned int width, unsigned int height, unsigned int depth, unsigned long fore, unsigned long back)
Pixmap	XmuCreateStippledPixmap (Screen *screen, Pixel fore, Pixel back, unsigned int depth)
void	XmuReleaseStippledPixmap (Screen *screen, Pixmap pixmap)
Pixmap	XmuLocateBitmapFile (Screen *screen, _Xconst char *name, char *srcname_return, int srcnamelen, int *width_return, int *height_return, int *xhot_return, int *yhot_return)
Pixmap	XmuLocatePixmapFile (Screen *screen, _Xconst char *name, unsigned long fore, unsigned long back, unsigned int depth, char *srcname_return, int srcnamelen, int *width_return, int *height_return, int *xhot_return, int *yhot_return)
int	XmuReadBitmapData (FILE *fstream, unsigned int *width_return, unsigned int *height_return, unsigned char **datap_return, int *xhot_return, int *yhot_return)
int	XmuReadBitmapDataFromFile (_Xconst char *filename, unsigned int *width_return, unsigned int *height_return, unsigned char **datap_return, int *xhot_return, int *yhot_return)

---

Typedef Documentation

typedef unsigned long Pixel

Definition at line 43 of file Drawing.h.

---

Function Documentation

Pixmap XmuCreatePixmapFromBitmap	(	Display *	dpy,
		Drawable	d,
		Pixmap	bitmap,
		unsigned int	width,
		unsigned int	height,
		unsigned int	depth,
		unsigned long	fore,
		unsigned long	back
	)

Definition at line 46 of file CrPixFBit.c.

References gc.

{
    Pixmap pixmap;

    pixmap = XCreatePixmap (dpy, d, width, height, depth);
    if (pixmap != None) {
        GC gc;
        XGCValues xgcv;

        xgcv.foreground = fore;
        xgcv.background = back;
        xgcv.graphics_exposures = False;

        gc = XCreateGC (dpy, d,
                        (GCForeground | GCBackground | GCGraphicsExposures),
                        &xgcv);
        if (gc) {
            XCopyPlane (dpy, bitmap, pixmap, gc, 0, 0, width, height, 0, 0, 1);
            XFreeGC (dpy, gc);
        } else {
            XFreePixmap (dpy, pixmap);
            pixmap = None;
        }
    }
    return pixmap;
}

Pixmap XmuCreateStippledPixmap	(	Screen *	screen,
		Pixel	fore,
		Pixel	back,
		unsigned int	depth
	)

Definition at line 72 of file GrayPixmap.c.

References _PixmapCache::background, _PixmapCache::depth, display, _PixmapCache::foreground, _PixmapCache::next, _PixmapCache::pixmap, pixmap_height, pixmap_width, pixmapCache, _PixmapCache::ref_count, and _PixmapCache::screen.

Referenced by ChangeSensitive(), CreateGC(), CreateGCs(), GetGCs(), GetgrayGC(), Realize(), and reset_shadow_gc().

{
    register Display *display = DisplayOfScreen(screen);
    CacheEntry *cachePtr;
    Pixmap stippled_pixmap;
    static unsigned char pixmap_bits[] = {
        0x02, 0x01,
    };

/*
 *      Creates a stippled pixmap of depth DefaultDepth(screen)
 *      caches these so that multiple requests share the pixmap
 */

#define pixmap_width 2
#define pixmap_height 2

    /* see if we already have a pixmap suitable for this screen */
    for (cachePtr = pixmapCache; cachePtr; cachePtr = cachePtr->next) {
        if (cachePtr->screen == screen && cachePtr->foreground == fore &&
            cachePtr->background == back && cachePtr->depth == depth)
            return( cachePtr->ref_count++, cachePtr->pixmap );
    }

    stippled_pixmap = XCreatePixmapFromBitmapData (display,
                        RootWindowOfScreen(screen), (char *)pixmap_bits, 
                        pixmap_width, pixmap_height, fore, back, depth);

    /* and insert it at the head of the cache */
    cachePtr = XtNew(CacheEntry);
    cachePtr->screen = screen;
    cachePtr->foreground = fore;
    cachePtr->background = back;
    cachePtr->depth = depth;
    cachePtr->pixmap = stippled_pixmap;
    cachePtr->ref_count = 1;
    cachePtr->next = pixmapCache;
    pixmapCache = cachePtr;

    return( stippled_pixmap );
}

Here is the caller graph for this function:

void XmuDrawLogo	(	Display *	dpy,
		Drawable	drawable,
		GC	gcFore,
		GC	gcBack,
		int	x,
		int	y,
		unsigned int	width,
		unsigned int	height
	)

Definition at line 43 of file DrawLogo.c.

References CoordModeOrigin, and size.

{
    unsigned int size;
    int thin, gap, d31;
    XPoint poly[4];

    XFillRectangle(dpy, drawable, gcBack, x, y, width, height);

    /* for now, do a centered even-sized square, at least for now */
    size = width;
    if (height < width)
         size = height;
    size &= ~1;
    x += (width - size) >> 1;
    y += (height - size) >> 1;

/*    
 * Draw what will be the thin strokes.
 *
 *           ----- 
 *          /    /
 *         /    /
 *        /    /
 *       /    /
 *      /____/
 *           d
 *
 * Point d is 9/44 (~1/5) of the way across.
 */

    thin = (size / 11);
    if (thin < 1) thin = 1;
    gap = (thin+3) / 4;
    d31 = thin + thin + gap;
    poly[0].x = x + size;              poly[0].y = y;
    poly[1].x = x + size-d31;          poly[1].y = y;
    poly[2].x = x + 0;                 poly[2].y = y + size;
    poly[3].x = x + d31;               poly[3].y = y + size;
    XFillPolygon(dpy, drawable, gcFore, poly, 4, Convex, CoordModeOrigin);

/*    
 * Erase area not needed for lower thin stroke.
 *
 *           ------ 
 *          /     /
 *         /  __ /
 *        /  /  /
 *       /  /  /
 *      /__/__/
 */

    poly[0].x = x + d31/2;                       poly[0].y = y + size;
    poly[1].x = x + size / 2;                    poly[1].y = y + size/2;
    poly[2].x = x + (size/2)+(d31-(d31/2));      poly[2].y = y + size/2;
    poly[3].x = x + d31;                         poly[3].y = y + size;
    XFillPolygon(dpy, drawable, gcBack, poly, 4, Convex, CoordModeOrigin);

/*    
 * Erase area not needed for upper thin stroke.
 *
 *           ------ 
 *          /  /  /
 *         /--/  /
 *        /     /
 *       /     /
 *      /_____/
 */

    poly[0].x = x + size - d31/2;                poly[0].y = y;
    poly[1].x = x + size / 2;                    poly[1].y = y + size/2;
    poly[2].x = x + (size/2)-(d31-(d31/2));      poly[2].y = y + size/2;
    poly[3].x = x + size - d31;                  poly[3].y = y;
    XFillPolygon(dpy, drawable, gcBack, poly, 4, Convex, CoordModeOrigin);

/*
 * Draw thick stroke.
 * Point b is 1/4 of the way across.
 *
 *      b
 * -----
 * \    \
 *  \    \
 *   \    \
 *    \    \
 *     \____\
 */

    poly[0].x = x;                     poly[0].y = y;
    poly[1].x = x + size/4;            poly[1].y = y;
    poly[2].x = x + size;              poly[2].y = y + size;
    poly[3].x = x + size - size/4;     poly[3].y = y + size;
    XFillPolygon(dpy, drawable, gcFore, poly, 4, Convex, CoordModeOrigin);

/*    
 * Erase to create gap.
 *
 *          /
 *         /
 *        /
 *       /
 *      /
 */

    poly[0].x = x + size- thin;        poly[0].y = y;
    poly[1].x = x + size-( thin+gap);  poly[1].y = y;
    poly[2].x = x + thin;              poly[2].y = y + size;
    poly[3].x = x + thin + gap;        poly[3].y = y + size;
    XFillPolygon(dpy, drawable, gcBack, poly, 4, Convex, CoordModeOrigin);
}

_XFUNCPROTOBEGIN void XmuDrawRoundedRectangle	(	Display *	dpy,
		Drawable	draw,
		GC	gc,
		int	x,
		int	y,
		int	w,
		int	h,
		int	ew,
		int	eh
	)

Definition at line 42 of file DrRndRect.c.

{
        XArc    arcs[8];
  int ew2, eh2;

  if ((ew2 = (ew << 1)) > w)
    ew2 = ew = 0;
  if ((eh2 = (eh << 1)) > h)
    eh2 = eh = 0;

        arcs[0].x = x;
        arcs[0].y = y;
  arcs[0].width = ew2;
  arcs[0].height = eh2;
  arcs[0].angle1 = 180 * 64;
  arcs[0].angle2 = -90 * 64;

        arcs[1].x = x + ew;
        arcs[1].y = y;
  arcs[1].width = w - ew2;
        arcs[1].height = 0;
  arcs[1].angle1 = 180 * 64;
  arcs[1].angle2 = -180 * 64;

  arcs[2].x = x + w - ew2;
        arcs[2].y = y;
  arcs[2].width = ew2;
  arcs[2].height = eh2;
  arcs[2].angle1 = 90 * 64;
  arcs[2].angle2 = -90 * 64;

        arcs[3].x = x + w;
        arcs[3].y = y + eh;
        arcs[3].width = 0;
  arcs[3].height = h - eh2;
        arcs[3].angle1 = 90 * 64;
  arcs[3].angle2 = -180 * 64;

  arcs[4].x = x + w - ew2;
  arcs[4].y = y + h - eh2;
  arcs[4].width = ew2;
  arcs[4].height = eh2;
        arcs[4].angle1 = 0;
  arcs[4].angle2 = -90 * 64;

        arcs[5].x = x + ew;
        arcs[5].y = y + h;
  arcs[5].width = w - ew2;
        arcs[5].height = 0;
        arcs[5].angle1 = 0;
  arcs[5].angle2 = -180 * 64;

        arcs[6].x = x;
  arcs[6].y = y + h - eh2;
  arcs[6].width = ew2;
  arcs[6].height = eh2;
  arcs[6].angle1 = 270 * 64;
  arcs[6].angle2 = -90 * 64;

        arcs[7].x = x;
        arcs[7].y = y + eh;
        arcs[7].width = 0;
  arcs[7].height = h - eh2;
  arcs[7].angle1 = 270 * 64;
  arcs[7].angle2 = -180 * 64;

  XDrawArcs(dpy, draw, gc, arcs, 8);
}

void XmuFillRoundedRectangle	(	Display *	dpy,
		Drawable	draw,
		GC	gc,
		int	x,
		int	y,
		int	w,
		int	h,
		int	ew,
		int	eh
	)

Definition at line 113 of file DrRndRect.c.

Referenced by ShapeEllipseOrRoundedRectangle().

{
        XArc    arcs[4];
        XRectangle rects[3];
        XGCValues vals;
  int ew2, eh2;

        XGetGCValues(dpy, gc, GCArcMode, &vals);
        if (vals.arc_mode != ArcPieSlice)
            XSetArcMode(dpy, gc, ArcPieSlice);

  if ((ew2 = (ew << 1)) > w)
    ew2 = ew = 0;
  if ((eh2 = (eh << 1)) > h)
    eh2 = eh = 0;

        arcs[0].x = x;
        arcs[0].y = y;
  arcs[0].width = ew2;
  arcs[0].height = eh2;
  arcs[0].angle1 = 180 * 64;
  arcs[0].angle2 = -90 * 64;

  arcs[1].x = x + w - ew2 - 1;
        arcs[1].y = y;
  arcs[1].width = ew2;
  arcs[1].height = eh2;
  arcs[1].angle1 = 90 * 64;
  arcs[1].angle2 = -90 * 64;

  arcs[2].x = x + w - ew2 - 1;
  arcs[2].y = y + h - eh2 - 1;
  arcs[2].width = ew2;
  arcs[2].height = eh2;
        arcs[2].angle1 = 0;
  arcs[2].angle2 = -90 * 64;

        arcs[3].x = x;
  arcs[3].y = y + h - eh2 - 1;
  arcs[3].width = ew2;
  arcs[3].height = eh2;
  arcs[3].angle1 = 270 * 64;
  arcs[3].angle2 = -90 * 64;

  XFillArcs(dpy, draw, gc, arcs, 4);

        rects[0].x = x + ew;
        rects[0].y = y;
  rects[0].width = w - ew2;
        rects[0].height = h;

        rects[1].x = x;
        rects[1].y = y + eh;
        rects[1].width = ew;
  rects[1].height = h - eh2;

        rects[2].x = x + w - ew;
        rects[2].y = y + eh;
        rects[2].width = ew;
  rects[2].height = h - eh2;

  XFillRectangles(dpy, draw, gc, rects, 3);

        if (vals.arc_mode != ArcPieSlice)
            XSetArcMode(dpy, gc, vals.arc_mode);
}

Here is the caller graph for this function:

Pixmap XmuLocateBitmapFile	(	Screen *	screen,
		_Xconst char *	name,
		char *	srcname_return,
		int	srcnamelen,
		int *	width_return,
		int *	height_return,
		int *	xhot_return,
		int *	yhot_return
	)

Definition at line 77 of file LocBitmap.c.

References XmuLocatePixmapFile().

Referenced by XmuCvtStringToBitmap().

{
    return XmuLocatePixmapFile (screen, name, 
                                (unsigned long) 1, (unsigned long) 0,
                                (unsigned int) 1, srcname, srcnamelen,
                                widthp, heightp, xhotp, yhotp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Pixmap XmuLocatePixmapFile	(	Screen *	screen,
		_Xconst char *	name,
		unsigned long	fore,
		unsigned long	back,
		unsigned int	depth,
		char *	srcname_return,
		int	srcnamelen,
		int *	width_return,
		int *	height_return,
		int *	xhot_return,
		int *	yhot_return
	)

Definition at line 92 of file LocBitmap.c.

References _XmuCCLookupDisplay(), BITMAPDIR, _XmuCvtCache::bitmapFilePath, data, dpy, filename, height, i, int, NULL, PATH_MAX, root, split_path_string(), _XmuCvtCache::string_to_bitmap, value, void(), width, XmuReadBitmapDataFromFile(), and XmuSnprintf().

Referenced by XmuLocateBitmapFile().

{

#ifndef BITMAPDIR
#define BITMAPDIR "/usr/include/X11/bitmaps"
#endif

    Display *dpy = DisplayOfScreen (screen);
    Window root = RootWindowOfScreen (screen);
    Bool try_plain_name = True;
    XmuCvtCache *cache = _XmuCCLookupDisplay (dpy);
    char **file_paths = (char **) NULL;
    char filename[PATH_MAX];
#if 0
    char* bitmapdir = BITMAPDIR;
#endif
    unsigned int width, height;
    int xhot, yhot;
    int i;

    /*
     * look in cache for bitmap path
     */
    if (cache) {
        if (!cache->string_to_bitmap.bitmapFilePath) {
            XrmName xrm_name[2];
            XrmClass xrm_class[2];
            XrmRepresentation rep_type;
            XrmValue value;

            xrm_name[0] = XrmPermStringToQuark ("bitmapFilePath");
            xrm_name[1] = NULLQUARK;
            xrm_class[0] = XrmPermStringToQuark ("BitmapFilePath");
            xrm_class[1] = NULLQUARK;
            if (!XrmGetDatabase(dpy)) {
                /* what a hack; need to initialize it */
                (void) XGetDefault (dpy, "", "");
            }
            if (XrmQGetResource (XrmGetDatabase(dpy), xrm_name, xrm_class, 
                                 &rep_type, &value) &&
                rep_type == XrmPermStringToQuark("String")) {
                cache->string_to_bitmap.bitmapFilePath = 
                  split_path_string (value.addr);
            }
        }
        file_paths = cache->string_to_bitmap.bitmapFilePath;
    }

    /*
     * Search order:
     *    1.  name if it begins with / or ./
     *    2.  "each prefix in file_paths"/name
     *    3.  BITMAPDIR/name
     *    4.  name if didn't begin with / or .
     */

    for (i = 1; i <= 4; i++) {
        char *fn = filename;
        Pixmap pixmap;
        unsigned char *data;

        switch (i) {
          case 1:
#ifndef __UNIXOS2__
            if (!(name[0] == '/' || ((name[0] == '.') && name[1] == '/')))
#else
            if (!(name[0] == '/' || (name[0] == '.' && name[1] == '/') ||
                  (isalpha(name[0]) && name[1] == ':')))
#endif
              continue;
            fn = (char *) name;
            try_plain_name = False;
            break;
          case 2:
            if (file_paths && *file_paths) {
                XmuSnprintf(filename, sizeof(filename),
                            "%s/%s", *file_paths, name);
                file_paths++;
                i--;
                break;
            }
            continue;
          case 3:
            XmuSnprintf(filename, sizeof(filename), "%s/%s", BITMAPDIR, name);
            break;
          case 4:
            if (!try_plain_name) continue;
            fn = (char *) name;
            break;
        }

        data = NULL;
        pixmap = None;
#ifdef __UNIXOS2__
        fn = (char*)__XOS2RedirRoot(fn);
#endif
        if (XmuReadBitmapDataFromFile (fn, &width, &height, &data,
                                       &xhot, &yhot) == BitmapSuccess) {
            pixmap = XCreatePixmapFromBitmapData (dpy, root, (char *) data,
                                                  width, height,
                                                  fore, back, depth);
            XFree ((char *)data);
        }

        if (pixmap) {
            if (widthp) *widthp = (int)width;
            if (heightp) *heightp = (int)height;
            if (xhotp) *xhotp = xhot;
            if (yhotp) *yhotp = yhot;
            if (srcname && srcnamelen > 0) {
                strncpy (srcname, fn, srcnamelen - 1);
                srcname[srcnamelen - 1] = '\0';
            }
            return pixmap;
        }
    }

    return None;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int XmuReadBitmapData	(	FILE *	fstream,
		unsigned int *	width_return,
		unsigned int *	height_return,
		unsigned char **	datap_return,
		int *	xhot_return,
		int *	yhot_return
	)

Definition at line 146 of file RdBitF.c.

References data, initHexTable(), initialized, int, line, MAX_SIZE, NextInt(), NULL, RETURN, size, type, value, and Xmalloc.

Referenced by XmuReadBitmapDataFromFile().

{
    unsigned char *data = NULL;         /* working variable */
    char line[MAX_SIZE];                /* input line from file */
    int size;                           /* number of bytes of data */
    char name_and_type[MAX_SIZE];       /* an input line */
    char *type;                         /* for parsing */
    int value;                          /* from an input line */
    int version10p;                     /* boolean, old format */
    int padding;                        /* to handle alignment */
    int bytes_per_line;                 /* per scanline of data */
    unsigned int ww = 0;                /* width */
    unsigned int hh = 0;                /* height */
    int hx = -1;                        /* x hotspot */
    int hy = -1;                        /* y hotspot */

#undef  Xmalloc /* see MALLOC_0_RETURNS_NULL in Xlibint.h */
#define Xmalloc(size) malloc(size)

    /* first time initialization */
    if (initialized == False) initHexTable();

    /* error cleanup and return macro   */
#define RETURN(code) { if (data) free (data); return code; }

    while (fgets(line, MAX_SIZE, fstream)) {
        if (strlen(line) == MAX_SIZE-1) {
            RETURN (BitmapFileInvalid);
        }
        if (sscanf(line,"#define %s %d",name_and_type,&value) == 2) {
            if (!(type = strrchr(name_and_type, '_')))
              type = name_and_type;
            else
              type++;

            if (!strcmp("width", type))
              ww = (unsigned int) value;
            if (!strcmp("height", type))
              hh = (unsigned int) value;
            if (!strcmp("hot", type)) {
                if (type-- == name_and_type || type-- == name_and_type)
                  continue;
                if (!strcmp("x_hot", type))
                  hx = value;
                if (!strcmp("y_hot", type))
                  hy = value;
            }
            continue;
        }
    
        if (sscanf(line, "static short %s = {", name_and_type) == 1)
          version10p = 1;
        else if (sscanf(line,"static unsigned char %s = {",name_and_type) == 1)
          version10p = 0;
        else if (sscanf(line, "static char %s = {", name_and_type) == 1)
          version10p = 0;
        else
          continue;

        if (!(type = strrchr(name_and_type, '_')))
          type = name_and_type;
        else
          type++;

        if (strcmp("bits[]", type))
          continue;
    
        if (!ww || !hh)
          RETURN (BitmapFileInvalid);

        if ((ww % 16) && ((ww % 16) < 9) && version10p)
          padding = 1;
        else
          padding = 0;

        bytes_per_line = (ww+7)/8 + padding;

        size = bytes_per_line * hh;
        data = (unsigned char *) Xmalloc ((unsigned int) size);
        if (!data) 
          RETURN (BitmapNoMemory);

        if (version10p) {
            unsigned char *ptr;
            int bytes;

            for (bytes=0, ptr=data; bytes<size; (bytes += 2)) {
                if ((value = NextInt(fstream)) < 0)
                  RETURN (BitmapFileInvalid);
                *(ptr++) = value;
                if (!padding || ((bytes+2) % bytes_per_line))
                  *(ptr++) = value >> 8;
            }
        } else {
            unsigned char *ptr;
            int bytes;

            for (bytes=0, ptr=data; bytes<size; bytes++, ptr++) {
                if ((value = NextInt(fstream)) < 0) 
                  RETURN (BitmapFileInvalid);
                *ptr=value;
            }
        }
        break;
    }                                   /* end while */

    if (data == NULL) {
        RETURN (BitmapFileInvalid);
    }

    *datap = data;
    data = NULL;
    *width = ww;
    *height = hh;
    if (x_hot) *x_hot = hx;
    if (y_hot) *y_hot = hy;

    RETURN (BitmapSuccess);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int XmuReadBitmapDataFromFile	(	_Xconst char *	filename,
		unsigned int *	width_return,
		unsigned int *	height_return,
		unsigned char **	datap_return,
		int *	xhot_return,
		int *	yhot_return
	)

Definition at line 382 of file RdBitF.c.

References fopen_file, NULL, and XmuReadBitmapData().

Referenced by XmuCvtStringToBitmap(), and XmuLocatePixmapFile().

{
    FILE *fstream;
    int status;

#ifdef __UNIXOS2__
    filename = __XOS2RedirRoot(filename);
#endif
    if ((fstream = fopen_file (filename, "r")) == NULL) {
        return BitmapOpenFailed;
    }
    status = XmuReadBitmapData(fstream, width, height, datap, x_hot, y_hot);
    fclose (fstream);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void XmuReleaseStippledPixmap	(	Screen *	screen,
		Pixmap	pixmap
	)

Definition at line 120 of file GrayPixmap.c.

References display, _PixmapCache::next, _PixmapCache::pixmap, pixmapCache, _PixmapCache::ref_count, and _PixmapCache::screen.

Referenced by Destroy(), and SetValues().

{
    register Display *display = DisplayOfScreen(screen);
    CacheEntry *cachePtr, **prevP;
    for (prevP = &pixmapCache, cachePtr = pixmapCache; cachePtr;) {
        if (cachePtr->screen == screen && cachePtr->pixmap == pixmap) {
            if (--cachePtr->ref_count == 0) {
                XFreePixmap( display, pixmap );
                *prevP = cachePtr->next;
                XtFree( (char*)cachePtr );
                break;
            }
        }
        prevP = &cachePtr->next;
        cachePtr = *prevP;
    }
}

Here is the caller graph for this function:

---