/*-

 * xcolor.c - X11 client to display all colors in current colormap.

 *

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 *

 * Author: Patrick J. Naughton

 * [email protected]

 */

#include <stdio.h>

#include <math.h>

#include <X11/X.h>

#include <X11/Xos.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/keysym.h>

#define DEFX 256

#define DEFY 256

#define DEFW 128

#define DEFH 128

#define ICON_WIDTH 48

#define ICON_HEIGHT 48

Display    *dsp = NULL;		/* current display (must be inited) */

int         screen;

Visual	    *visual;

Window      win;		/* window used to cover screen */

Window	    icon;

GC	    gc;			/* graphics context */

int         height = 0,

            width = 0;

Colormap    cmap;

char       *pname;

Atom	    ATOM_WM_PROTOCOLS;

Atom	    ATOM_WM_DELETE_WINDOW;

int    	    cmap_size;

void

error(s1, s2)

    char       *s1,

               *s2;

{

    fprintf(stderr, s1, pname, s2);

    exit(1);

}

dumpCmap()

{

    register int i;

    XColor      color[256];

    for (i = 0; i < 256; i++)

	color[i].pixel = i;

    XQueryColors(dsp, DefaultColormap(dsp, screen), color, 256);

    for (i = 0; i < 256; i++) {

	printf("/name%02x	%3d %3d %3d RGBcolor def\n",

	      i, color[i].red >> 8, color[i].green >> 8, color[i].blue >> 8);

    }

}

redisplay_indexed(window)

    Window window;

{

    int		 max;

    register int i,

                 j;

    register float fw;

    register float fh;

    switch (cmap_size) {

        case   2:   max = 2;   break;

        case  16:   max = 4;   break; 

        case 256:   max = 16;  break;

        default:    max = (int)sqrt((double)cmap_size);

    }

    if (window == win) {

	fw = (float) width / (float)max;

	fh = (float) height / (float)max;

    } else {

	fw = (float) ICON_WIDTH / (float)max;

	fh = (float) ICON_HEIGHT / (float)max;

    }

    for (i = 0; i < max; i++) {

	register int y = (int) (i * fh);

	register int h = (i + 1) * fh - y;

	for (j = 0; j < max; j++) {

	    register int x = (int) (j * fw);

	    register int w = (j + 1) * fw - x;

	    XSetForeground(dsp, gc, i * max + j);

	    XFillRectangle(dsp, window, gc, x, y, w, h);

	}

    }

}

redisplay_direct(window)

    Window window;

{

    register int i,

                j, k;

    register float fw;

    register float fh;

    static int roffset, goffset, boffset;

    static int got_offsets = 0;

    if (window == win) {

	fw = (float) width / 16.0;

	fh = (float) height / (3 * 16.0);

    } else {

	fw = (float) ICON_WIDTH / 16.0;

	fh = (float) ICON_HEIGHT / (3 * 16.0);

    }

    if (!got_offsets) {

	got_offsets = 1;

	roffset = ffs(visual->red_mask)-1;

	goffset = ffs(visual->green_mask)-1;

	boffset = ffs(visual->blue_mask)-1;

    }

    /* red channel */

    k = 0;

    for (i = 0; i < 16; i++, k++) {

	register int y = (int) (k * fh);

	register int h = (k + 1) * fh - y;

	for (j = 0; j < 16; j++) {

	    register int x = (int) (j * fw);

	    register int w = (j + 1) * fw - x;

	    XSetForeground(dsp, gc, (i * 16 + j)<<roffset);

	    XFillRectangle(dsp, window, gc, x, y, w, h);

	}

    }

    /* green channel */

    for (i = 0; i < 16; i++, k++) {

	register int y = (int) (k * fh);

	register int h = (k + 1) * fh - y;

	for (j = 0; j < 16; j++) {

	    register int x = (int) (j * fw);

	    register int w = (j + 1) * fw - x;

	    XSetForeground(dsp, gc, (i * 16 + j)<<goffset);

	    XFillRectangle(dsp, window, gc, x, y, w, h);

	}

    }

    /* blue channel */

    for (i = 0; i < 16; i++, k++) {

	register int y = (int) (k * fh);

	register int h = (k + 1) * fh - y;

	for (j = 0; j < 16; j++) {

	    register int x = (int) (j * fw);

	    register int w = (j + 1) * fw - x;

	    XSetForeground(dsp, gc, (i * 16 + j)<<boffset);

	    XFillRectangle(dsp, window, gc, x, y, w, h);

	}

    }

}

redisplay (w)

    Window w;

{

    if (visual->class == TrueColor || visual->class == DirectColor)

	    redisplay_direct(w);

    else

	    redisplay_indexed(w);

}

HandleEvents()

{

    XEvent      event;

    XConfigureEvent *xce = (XConfigureEvent *) & event;

    XKeyEvent  *xke = (XKeyEvent *) & event;

    while (1) {

	XNextEvent(dsp, &event);

	switch (event.type) {

	case Expose:

	    redisplay(event.xexpose.window);

	    continue;

	case GraphicsExpose:

	case NoExpose:

	case MapNotify:

	case UnmapNotify:

	    continue;

	case ConfigureNotify:

	    if ((height == xce->height) && (width == xce->width))

		continue;

	    height = xce->height;

	    width = xce->width;

	    redisplay(event.xconfigure.window);

	    continue;

	case KeyPress:

	    switch (XLookupKeysym(xke, 0)) {

	    case XK_Escape:

		return;

	    default:

		continue;

	    }

	case ClientMessage:

	    if (event.xclient.message_type == ATOM_WM_PROTOCOLS &&

		event.xclient.format == 32 &&

		event.xclient.data.l[0] == ATOM_WM_DELETE_WINDOW)

	    {

		return;

	    }

	    continue;

	}

    }

}

main(argc, argv)

    int         argc;

    char       *argv[];

{

    XSetWindowAttributes xswa;

    XGCValues   xgcv;

    XSizeHints  size_hints;

    XWMHints	wmhints;

    int         i;

    int         geomStat;

    char       *geom = NULL;

    char       *displayName = NULL;

    Status      stat;

    int         dump = 0;

    int		nobw = 0;

    int		half = 0;

    int		install = 1;

    int		mask;

    int		useiconwin = 0;

    if (getenv("_SYNC")) { 

	extern int _Xdebug;

	_Xdebug = 1;

    }

    pname = argv[0];

    for (i = 1; i < argc; i++) {

	if (!strcmp(argv[i], "-geometry"))

	    geom = argv[++i];

	else if (!strcmp(argv[i], "-display"))

	    displayName = argv[++i];

	else if (!strcmp(argv[i], "-dump"))

	    dump = 1;

	else if (!strcmp(argv[i], "-nobw"))

	    nobw = 1;

	else if (!strcmp(argv[i], "-half"))

	    half = 1;

	else if (!strcmp(argv[i], "-noinst"))

	    install = 0;

	else if (!strcmp(argv[i], "-iconwin"))

	    useiconwin = 1;

	else

	    error("usage:  %s [-display dpystr] [-geometry geomstr]\n\

\t[-dump] [-nobw] [-half] [-noinst] [-iconwin]\n", NULL);

    }

    /* SUNSOFT_BUYBACK

    if (!(dsp = XOpenDisplay(displayName)))

	error("%s: unable to open display, %s.\n", displayName);

    **********/

    if (!(dsp = XOpenDisplay(displayName))) {

	if (displayName)

	    error("%s: unable to open display, %s.\n", displayName);

        else

	    error("unable to open display\n");

    }

    screen = DefaultScreen(dsp);

    visual = DefaultVisualOfScreen(DefaultScreenOfDisplay(dsp));

    cmap_size = visual->map_entries;

    ATOM_WM_PROTOCOLS = XInternAtom(dsp, "WM_PROTOCOLS", False);

    ATOM_WM_DELETE_WINDOW = XInternAtom(dsp, "WM_DELETE_WINDOW", False);

    if (dump)

	dumpCmap();

    if (install)  {

	    stat = XCreateHSBColormap(dsp, screen, &cmap, half 

					? (cmap_size>>1) : cmap_size,

				      0.0, 1.0, 1.0,

				      1.0, 1.0, 1.0, !nobw, &visual);

	    if (stat != Success)

		error("%s: unable create colormap (%d).\n", stat);

    }

    size_hints.x = DEFX;

    size_hints.y = DEFY;

    size_hints.width = DEFW;

    size_hints.height = DEFH;

    size_hints.flags = 0;

    if (geom) {

	geomStat = XParseGeometry(geom, &(size_hints.x),

				  &(size_hints.y),

				  (unsigned int *) &(size_hints.width),

				  (unsigned int *) &(size_hints.height));

	if (geomStat & (XValue | YValue)) {

	    size_hints.flags |= USPosition;

	}

	if (geomStat & (WidthValue | HeightValue)) {

	    size_hints.flags |= USSize;

	}

    }

    width = size_hints.width;

    height = size_hints.height;

    xswa.event_mask = ExposureMask | KeyPressMask | StructureNotifyMask;

    mask = CWEventMask;

    if (install) {

	    xswa.colormap = cmap;

	    mask |= CWColormap;

    }

    win = XCreateWindow(

			dsp,

			DefaultRootWindow(dsp),

			size_hints.x,

			size_hints.y,

			size_hints.width,

			size_hints.height,

			1,	/* borderwidth */

			DefaultDepth(dsp, screen),	/* depth */

			InputOutput,	/* class */

			visual,	/* visual */

			mask,	/* window attribute mask */

			&xswa	/* the attributes */

	);

    XSetStandardProperties(dsp, win, " XColor ", " XCOLOR ",

			   NULL, argv, argc, &size_hints);

    wmhints.flags = InputHint;

    wmhints.input = True;

    if (useiconwin) {

	xswa.event_mask = ExposureMask;

	mask = CWEventMask;

	if (install) {

	    xswa.colormap = cmap;

	    mask |= CWColormap;

	}

	icon = XCreateWindow(dsp, DefaultRootWindow(dsp),

	    0, 0, ICON_WIDTH, ICON_HEIGHT, 0, DefaultDepth(dsp, screen),

	    InputOutput, visual, mask, &xswa);

	wmhints.flags |= IconWindowHint;

	wmhints.icon_window = icon;

	if (install) {

	    Window cmapwins[2];

	    cmapwins[0] = icon;

	    cmapwins[1] = win;

	    XSetWMColormapWindows(dsp, win, cmapwins, 2);

	}

    }

    XSetWMHints(dsp, win, &wmhints);

    XSetWMProtocols(dsp, win, &ATOM_WM_DELETE_WINDOW, 1);

    xgcv.foreground = BlackPixel(dsp, screen);

    xgcv.background = WhitePixel(dsp, screen);

    gc = XCreateGC(dsp, win, GCForeground | GCBackground, &xgcv);

    XMapWindow(dsp, win);

    HandleEvents();

    XUnmapWindow(dsp, win);

    XDestroyWindow(dsp, win);

    XFlush(dsp);

    XCloseDisplay(dsp);

    exit(0);

}