wmaker/util/wmagnify.c

/*
 * magnify - a X utility for magnifying screen image
 * 
 * 2000/5/21  Alfredo K. Kojima
 * 
 * This program is in the Public Domain.
 */

#include <X11/Xproto.h>

#include <WINGs/WINGs.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

/*
 * TODO:
 * - lens that shows where it's magnifying
 * 
 * 
 */

int refreshrate = 200;


typedef struct {
    Drawable d;
    XRectangle *rects;
    int rectP;
    unsigned long lastpixel;
    unsigned long *buffer;
    int width, height;
    int rwidth, rheight; 	       /* size of window in real pixels */
    int magfactor;
    int refreshrate;

    WMWindow *win;
    WMLabel *label;
    WMPixmap *pixmap;

    WMWindow *dlg;

    WMSlider *speed;
    WMSlider *magnify;
    WMButton *okB;
    WMButton *cancelB;
    WMButton *newB;

    int x, y;
    Bool frozen;
    Bool firstDraw;
    Bool markPointerHotspot;

    WMHandlerID tid;
} BufferData;



static BufferData *newWindow(int magfactor);


int windowCount = 0;

int rectBufferSize = 32;
Display *dpy, *vdpy;
WMScreen *scr;
unsigned int black;
WMColor *cursorColor1;
WMColor *cursorColor2;

#ifndef __GNUC__
#define inline
#endif


static BufferData*
makeBufferData(WMWindow *win, WMLabel *label, int width, int height,
	       int magfactor)
{
    BufferData *data;
    
    data = wmalloc(sizeof(BufferData));

    data->rwidth = width;
    data->rheight = height;
    
    data->refreshrate = refreshrate;
    
    data->firstDraw = True;

    data->magfactor = magfactor;
    
    data->rects = wmalloc(sizeof(XRectangle)*rectBufferSize);
    data->rectP = 0;
    
    data->win = win;
    data->label = label;

    data->pixmap = WMCreatePixmap(scr, width, height,
				  WMScreenDepth(scr), False);
    WMSetLabelImage(data->label, data->pixmap);

    data->d = WMGetPixmapXID(data->pixmap);
    
    data->frozen = False;

    width /= magfactor;
    height /= magfactor;
    data->buffer = wmalloc(sizeof(unsigned long)*width*height);
    memset(data->buffer, 0, width*height*sizeof(unsigned long));
    data->width = width;
    data->height = height;

    return data;
}


static void
resizeBufferData(BufferData *data, int width, int height, int magfactor)
{
    int w = width/magfactor;
    int h = height/magfactor;

    data->rwidth = width;
    data->rheight = height;
    data->firstDraw = True;
    data->magfactor = magfactor;
    data->buffer = wrealloc(data->buffer, sizeof(unsigned long)*w*h);
    data->width = w;
    data->height = h;
    memset(data->buffer, 0, w*h*sizeof(unsigned long));

    WMResizeWidget(data->label, width, height);

    WMReleasePixmap(data->pixmap);
    data->pixmap = WMCreatePixmap(scr, width, height, WMScreenDepth(scr), 
				  False);
    WMSetLabelImage(data->label, data->pixmap);
    
    data->d = WMGetPixmapXID(data->pixmap);
}


static int
drawpoint(BufferData *data, unsigned long pixel, int x, int y)
{
    static GC gc = NULL;
    Bool flush = (x < 0);

    if (!flush) {
	if (data->buffer[x+data->width*y] == pixel && !data->firstDraw)
	    return 0;
    
	data->buffer[x+data->width*y] = pixel;
    }
    if (gc == NULL) {
	gc = XCreateGC(dpy, DefaultRootWindow(dpy), 0, NULL);
    }
    
    if (!flush && data->lastpixel == pixel && data->rectP < rectBufferSize) {
	data->rects[data->rectP].x = x*data->magfactor;
	data->rects[data->rectP].y = y*data->magfactor;
	data->rects[data->rectP].width = data->magfactor;
	data->rects[data->rectP].height = data->magfactor;
	data->rectP++;

	return 0;
    }
    XSetForeground(dpy, gc, data->lastpixel);
    XFillRectangles(dpy, data->d, gc, data->rects, data->rectP);
    data->rectP = 0;
    data->rects[data->rectP].x = x*data->magfactor;
    data->rects[data->rectP].y = y*data->magfactor;
    data->rects[data->rectP].width = data->magfactor;
    data->rects[data->rectP].height = data->magfactor;
    data->rectP++;
   
    data->lastpixel = pixel;

    return 1;
}


static inline unsigned long
getpix(XImage *image, int x, int y, int xoffs, int yoffs)
{
    if (x < xoffs || y < yoffs
	|| x >= xoffs + image->width || y >= yoffs + image->height) {
	return black;
    }
    return XGetPixel(image, x-xoffs, y-yoffs);
}


static void
updateImage(BufferData *data, int rx, int ry)
{
    int gx, gy, gw, gh;
    int x, y;
    int xoffs, yoffs;
    int changedPixels = 0;
    XImage *image;

    gw = data->width;
    gh = data->height;
    
    gx = rx - gw/2;
    gy = ry - gh/2;
    
    xoffs = yoffs = 0;
    if (gx < 0) {
	xoffs = abs(gx);
	gw += gx;
	gx = 0;
    }
    if (gx + gw >= WidthOfScreen(DefaultScreenOfDisplay(vdpy))) {
	gw = WidthOfScreen(DefaultScreenOfDisplay(vdpy)) - gx;
    }
    if (gy < 0) {
	yoffs = abs(gy);
	gh += gy;
	gy = 0;
    }
    if (gy + gh >= HeightOfScreen(DefaultScreenOfDisplay(vdpy))) {
	gh = HeightOfScreen(DefaultScreenOfDisplay(vdpy)) - gy;
    }

    image = XGetImage(vdpy, DefaultRootWindow(vdpy), gx, gy, gw, gh,
		      AllPlanes, ZPixmap);


    for (y = 0; y < data->height; y++) {
	for (x = 0; x < data->width; x++) {
	    unsigned long pixel;

	    pixel = getpix(image, x, y, xoffs, yoffs);

	    if (drawpoint(data, pixel, x, y))
		changedPixels++;
	}
    }
    /* flush the point cache */
    drawpoint(data, 0, -1, -1);

    XDestroyImage(image);
    
    if (data->markPointerHotspot && !data->frozen) {
	XRectangle rects[4];

	rects[0].x = (data->width/2 - 3)*data->magfactor;
	rects[0].y = (data->height/2)*data->magfactor;
	rects[0].width = 2*data->magfactor;
	rects[0].height = data->magfactor;

	rects[1].x = (data->width/2 + 2)*data->magfactor;
	rects[1].y = (data->height/2)*data->magfactor;
	rects[1].width = 2*data->magfactor;
	rects[1].height = data->magfactor;

	XFillRectangles(dpy, data->d, WMColorGC(cursorColor1), rects, 2);

	rects[2].y = (data->height/2 - 3)*data->magfactor;
	rects[2].x = (data->width/2)*data->magfactor;
	rects[2].height = 2*data->magfactor;
	rects[2].width = data->magfactor;

	rects[3].y = (data->height/2 + 2)*data->magfactor;
	rects[3].x = (data->width/2)*data->magfactor;
	rects[3].height = 2*data->magfactor;
	rects[3].width = data->magfactor;

	XFillRectangles(dpy, data->d, WMColorGC(cursorColor2), rects + 2, 2);
    }

    if (changedPixels > 0) {
	WMRedisplayWidget(data->label);
    }
    
    data->firstDraw = False;
}


static void
update(void *d)
{
    BufferData *data = (BufferData*)d;
    Window win;
    int rx, ry;
    int bla;
    unsigned ubla;
    

    if (data->frozen) {
	rx = data->x;
	ry = data->y;
    } else {
	XQueryPointer(dpy, DefaultRootWindow(dpy), &win, &win, &rx, &ry, 
		      &bla, &bla, &ubla);
    }
    updateImage(data, rx, ry);

    data->tid = WMAddTimerHandler(data->refreshrate, update, data);
}


void resizedWindow(void *d, WMNotification *notif)
{
    BufferData *data = (BufferData*)d;
    WMView *view = (WMView*)WMGetNotificationObject(notif);
    WMSize size;

    size = WMGetViewSize(view);
    
    resizeBufferData(data, size.width, size.height, data->magfactor);
}



void closeWindow(WMWidget *w, void *d)
{
    BufferData *data = (BufferData*)d;

    windowCount--;
    if (windowCount == 0) {
	exit(0);
    } else {
	WMDeleteTimerHandler(data->tid);
	WMDestroyWidget(w);
	wfree(data->buffer);
	wfree(data->rects);
	WMReleasePixmap(data->pixmap);
	wfree(data);
    }
}


#if 0
static void
clickHandler(XEvent *event, void *d)
{
    BufferData *data = (BufferData*)d;
    
    data->win = WMCreateWindow(scr, "setup");
    WMSetWindowTitle(data->win, "Magnify Options");
    
    data->speed = WMCreateSlider(data->win);
    
    data->magnify = WMCreateSlider(data->win);
    
    

}
#endif


static void
keyHandler(XEvent *event, void *d)
{
    BufferData *data = (BufferData*)d;
    char buf[32];
    KeySym ks;
    WMView *view = WMWidgetView(data->win);
    WMSize size;

    size = WMGetViewSize(view);

    if (XLookupString(&event->xkey, buf, 31, &ks, NULL) > 0) {
	switch (buf[0]) {
	 case 'n':
	    newWindow(data->magfactor);
	    break;
	 case 'm':
	    data->markPointerHotspot = !data->markPointerHotspot;
	    break;
	 case 'f':
	 case ' ':
	    data->frozen = !data->frozen;
	    if (data->frozen) {
		data->x = event->xkey.x_root;
		data->y = event->xkey.y_root;
		sprintf(buf, "[Magnify %ix]", data->magfactor);
	    } else {
		sprintf(buf, "Magnify %ix", data->magfactor);
	    }
	    WMSetWindowTitle(data->win, buf);
	    break;
	 case '1':
	 case '2':
	 case '3':
	 case '4':
	 case '5':
	 case '6':
	 case '7':
	 case '8':
	 case '9':
	    resizeBufferData(data, size.width, size.height, buf[0]-'0');
	    if (data->frozen) {
		sprintf(buf, "[Magnify %ix]", data->magfactor);
	    } else {
		sprintf(buf, "Magnify %ix", data->magfactor);
	    }
	    WMSetWindowTitle(data->win, buf);
	    break;
	}
    }
}


static BufferData*
newWindow(int magfactor)
{
    WMWindow *win;
    WMLabel *label;
    BufferData *data;
    char buf[32];

    windowCount++;
    
    win = WMCreateWindow(scr, "magnify");
    WMResizeWidget(win, 300, 200);
    sprintf(buf, "Magnify %ix", magfactor);
    WMSetWindowTitle(win, buf);
    WMSetViewNotifySizeChanges(WMWidgetView(win), True);

    label = WMCreateLabel(win);
    WMResizeWidget(label, 300, 200);
    WMMoveWidget(label, 0, 0);
    WMSetLabelRelief(label, WRSunken);
    WMSetLabelImagePosition(label, WIPImageOnly);
    
    data = makeBufferData(win, label, 300, 200, magfactor);

    WMCreateEventHandler(WMWidgetView(win), KeyReleaseMask,
			 keyHandler, data);
    
    WMAddNotificationObserver(resizedWindow, data,
			      WMViewSizeDidChangeNotification,
			      WMWidgetView(win));

    WMRealizeWidget(win);

    WMMapSubwidgets(win);
    WMMapWidget(win);

    WMSetWindowCloseAction(win, closeWindow, data);
    data->tid = WMAddTimerHandler(refreshrate, update, data);

    return data;
}


int main(int argc, char **argv)
{
    BufferData *data;
    int i;
    char *display = "";
    char *vdisplay = NULL;
    int magfactor = 2;
#if 0
    WMButton *radio, *tradio;
#endif
    WMInitializeApplication("Magnify", &argc, argv);
    
    
    for (i = 1; i < argc; i++) {
	if (strcmp(argv[i], "-display")==0) {
	    i++;
	    if (i >= argc)
		goto help;
	    display = argv[i];
	} else if (strcmp(argv[i], "-vdisplay")==0) {
	    i++;
	    if (i >= argc)
		goto help;
	    vdisplay = argv[i];
	} else if (strcmp(argv[i], "-m")==0) {
	    i++;
	    if (i >= argc)
		goto help;
	    magfactor = atoi(argv[i]);
	    if (magfactor < 1 || magfactor > 32) {
		printf("%s:invalid magnification factor ``%s''\n", argv[0],
		       argv[i]);
		exit(1);
	    }
	} else if (strcmp(argv[i], "-r")==0) {
	    i++;
	    if (i >= argc)
		goto help;
	    refreshrate = atoi(argv[i]);
	    if (refreshrate < 1) {
		printf("%s:invalid refresh rate ``%s''\n", argv[0], argv[i]);
		exit(1);
	    }
	} else if (strcmp(argv[i], "-h")==0 
		   || strcmp(argv[i], "--help")==0) {
	help:

	    printf("Syntax: %s [options]\n",
		   argv[0]);
	    puts("Options:");
	    puts("  -display <display>	display that should be used");
	    puts("  -m <number>		change magnification factor (default 2)");
	    puts("  -r <number>		change refresh delay, in milliseconds (default 200)");
	    puts("Keys:");
	    puts("  1,2,3,4,5,6,7,8,9	change the magnification factor");
	    puts("  <space>, f		freeze the 'camera', making it magnify only the current\n"
		 "			position");
	    puts("  n			create a new window");
	    puts("  m			show/hide the pointer hotspot mark");
	    exit(0);
	}
    }

    dpy = XOpenDisplay(display);
    if (!dpy) {
	puts("couldnt open display");
	exit(1);
    }

    if (vdisplay) {
        vdpy = XOpenDisplay(vdisplay);
    	if (!vdpy) {
	    puts("couldnt open display to be viewed");
	    exit(1);
    	}
    } else {
	vdpy = dpy;
    }

    /* calculate how many rectangles we can send in a trip to the server */
    rectBufferSize = XMaxRequestSize(dpy) - 128;
    rectBufferSize /= sizeof(XRectangle);
    if (rectBufferSize < 1)
	rectBufferSize = 1;

    black = BlackPixel(dpy, DefaultScreen(dpy));

    scr = WMCreateScreen(dpy, 0);

    cursorColor1 = WMCreateNamedColor(scr, "#ff0000", False);
    cursorColor2 = WMCreateNamedColor(scr, "#00ff00", False);
    
    data = newWindow(magfactor);

    WMScreenMainLoop(scr);

    return 0;
}