util/wmagnify.c

   1 /*
   2  * magnify - a X utility for magnifying screen image
   3  *
   4  * 2000/5/21  Alfredo K. Kojima
   5  *
   6  * This program is in the Public Domain.
   7  */
   8
   9 #include <X11/Xproto.h>
  10
  11 #include <WINGs/WINGs.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14
  15 /*
  16  * TODO:
  17  * - lens that shows where it's magnifying
  18  *
  19  *
  20  */
  21
  22 int refreshrate = 200;
  23
  24
  25 typedef struct {
  26     Drawable d;
  27     XRectangle *rects;
  28     int rectP;
  29     unsigned long lastpixel;
  30     unsigned long *buffer;
  31     int width, height;
  32     int rwidth, rheight;               /* size of window in real pixels */
  33     int magfactor;
  34     int refreshrate;
  35
  36     WMWindow *win;
  37     WMLabel *label;
  38     WMPixmap *pixmap;
  39
  40     WMWindow *dlg;
  41
  42     WMSlider *speed;
  43     WMSlider *magnify;
  44     WMButton *okB;
  45     WMButton *cancelB;
  46     WMButton *newB;
  47
  48     int x, y;
  49     Bool frozen;
  50     Bool firstDraw;
  51     Bool markPointerHotspot;
  52
  53     WMHandlerID tid;
  54 } BufferData;
  55
  56
  57
  58 static BufferData *newWindow(int magfactor);
  59
  60
  61 int windowCount = 0;
  62
  63 int rectBufferSize = 32;
  64 Display *dpy, *vdpy;
  65 WMScreen *scr;
  66 unsigned int black;
  67 WMColor *cursorColor1;
  68 WMColor *cursorColor2;
  69
  70 #ifndef __GNUC__
  71 #define inline
  72 #endif
  73
  74
  75 static BufferData*
  76 makeBufferData(WMWindow *win, WMLabel *label, int width, int height,
  77                int magfactor)
  78 {
  79     BufferData *data;
  80
  81     data = wmalloc(sizeof(BufferData));
  82
  83     data->rwidth = width;
  84     data->rheight = height;
  85
  86     data->refreshrate = refreshrate;
  87
  88     data->firstDraw = True;
  89
  90     data->magfactor = magfactor;
  91
  92     data->rects = wmalloc(sizeof(XRectangle)*rectBufferSize);
  93     data->rectP = 0;
  94
  95     data->win = win;
  96     data->label = label;
  97
  98     data->pixmap = WMCreatePixmap(scr, width, height,
  99                                   WMScreenDepth(scr), False);
 100     WMSetLabelImage(data->label, data->pixmap);
 101
 102     data->d = WMGetPixmapXID(data->pixmap);
 103
 104     data->frozen = False;
 105
 106     width /= magfactor;
 107     height /= magfactor;
 108     data->buffer = wmalloc(sizeof(unsigned long)*width*height);
 109     memset(data->buffer, 0, width*height*sizeof(unsigned long));
 110     data->width = width;
 111     data->height = height;
 112
 113     return data;
 114 }
 115
 116
 117 static void
 118 resizeBufferData(BufferData *data, int width, int height, int magfactor)
 119 {
 120     int w = width/magfactor;
 121     int h = height/magfactor;
 122
 123     data->rwidth = width;
 124     data->rheight = height;
 125     data->firstDraw = True;
 126     data->magfactor = magfactor;
 127     data->buffer = wrealloc(data->buffer, sizeof(unsigned long)*w*h);
 128     data->width = w;
 129     data->height = h;
 130     memset(data->buffer, 0, w*h*sizeof(unsigned long));
 131
 132     WMResizeWidget(data->label, width, height);
 133
 134     WMReleasePixmap(data->pixmap);
 135     data->pixmap = WMCreatePixmap(scr, width, height, WMScreenDepth(scr),
 136                                   False);
 137     WMSetLabelImage(data->label, data->pixmap);
 138
 139     data->d = WMGetPixmapXID(data->pixmap);
 140 }
 141
 142
 143 static int
 144 drawpoint(BufferData *data, unsigned long pixel, int x, int y)
 145 {
 146     static GC gc = NULL;
 147     Bool flush = (x < 0);
 148
 149     if (!flush) {
 150         if (data->buffer[x+data->width*y] == pixel && !data->firstDraw)
 151             return 0;
 152
 153         data->buffer[x+data->width*y] = pixel;
 154     }
 155     if (gc == NULL) {
 156         gc = XCreateGC(dpy, DefaultRootWindow(dpy), 0, NULL);
 157     }
 158
 159     if (!flush && data->lastpixel == pixel && data->rectP < rectBufferSize) {
 160         data->rects[data->rectP].x = x*data->magfactor;
 161         data->rects[data->rectP].y = y*data->magfactor;
 162         data->rects[data->rectP].width = data->magfactor;
 163         data->rects[data->rectP].height = data->magfactor;
 164         data->rectP++;
 165
 166         return 0;
 167     }
 168     XSetForeground(dpy, gc, data->lastpixel);
 169     XFillRectangles(dpy, data->d, gc, data->rects, data->rectP);
 170     data->rectP = 0;
 171     data->rects[data->rectP].x = x*data->magfactor;
 172     data->rects[data->rectP].y = y*data->magfactor;
 173     data->rects[data->rectP].width = data->magfactor;
 174     data->rects[data->rectP].height = data->magfactor;
 175     data->rectP++;
 176
 177     data->lastpixel = pixel;
 178
 179     return 1;
 180 }
 181
 182
 183 static inline unsigned long
 184 getpix(XImage *image, int x, int y, int xoffs, int yoffs)
 185 {
 186     if (x < xoffs || y < yoffs
 187         || x >= xoffs + image->width || y >= yoffs + image->height) {
 188         return black;
 189     }
 190     return XGetPixel(image, x-xoffs, y-yoffs);
 191 }
 192
 193
 194 static void
 195 updateImage(BufferData *data, int rx, int ry)
 196 {
 197     int gx, gy, gw, gh;
 198     int x, y;
 199     int xoffs, yoffs;
 200     int changedPixels = 0;
 201     XImage *image;
 202
 203     gw = data->width;
 204     gh = data->height;
 205
 206     gx = rx - gw/2;
 207     gy = ry - gh/2;
 208
 209     xoffs = yoffs = 0;
 210     if (gx < 0) {
 211         xoffs = abs(gx);
 212         gw += gx;
 213         gx = 0;
 214     }
 215     if (gx + gw >= WidthOfScreen(DefaultScreenOfDisplay(vdpy))) {
 216         gw = WidthOfScreen(DefaultScreenOfDisplay(vdpy)) - gx;
 217     }
 218     if (gy < 0) {
 219         yoffs = abs(gy);
 220         gh += gy;
 221         gy = 0;
 222     }
 223     if (gy + gh >= HeightOfScreen(DefaultScreenOfDisplay(vdpy))) {
 224         gh = HeightOfScreen(DefaultScreenOfDisplay(vdpy)) - gy;
 225     }
 226
 227     image = XGetImage(vdpy, DefaultRootWindow(vdpy), gx, gy, gw, gh,
 228                       AllPlanes, ZPixmap);
 229
 230
 231     for (y = 0; y < data->height; y++) {
 232         for (x = 0; x < data->width; x++) {
 233             unsigned long pixel;
 234
 235             pixel = getpix(image, x-xoffs, y-yoffs, xoffs, yoffs);
 236
 237             if (drawpoint(data, pixel, x, y))
 238                 changedPixels++;
 239         }
 240     }
 241     /* flush the point cache */
 242     drawpoint(data, 0, -1, -1);
 243
 244     XDestroyImage(image);
 245
 246     if (data->markPointerHotspot && !data->frozen) {
 247         XRectangle rects[4];
 248
 249         rects[0].x = (data->width/2 - 3)*data->magfactor;
 250         rects[0].y = (data->height/2)*data->magfactor;
 251         rects[0].width = 2*data->magfactor;
 252         rects[0].height = data->magfactor;
 253
 254         rects[1].x = (data->width/2 + 2)*data->magfactor;
 255         rects[1].y = (data->height/2)*data->magfactor;
 256         rects[1].width = 2*data->magfactor;
 257         rects[1].height = data->magfactor;
 258
 259         XFillRectangles(dpy, data->d, WMColorGC(cursorColor1), rects, 2);
 260
 261         rects[2].y = (data->height/2 - 3)*data->magfactor;
 262         rects[2].x = (data->width/2)*data->magfactor;
 263         rects[2].height = 2*data->magfactor;
 264         rects[2].width = data->magfactor;
 265
 266         rects[3].y = (data->height/2 + 2)*data->magfactor;
 267         rects[3].x = (data->width/2)*data->magfactor;
 268         rects[3].height = 2*data->magfactor;
 269         rects[3].width = data->magfactor;
 270
 271         XFillRectangles(dpy, data->d, WMColorGC(cursorColor2), rects + 2, 2);
 272     }
 273
 274     if (changedPixels > 0) {
 275         WMRedisplayWidget(data->label);
 276     }
 277
 278     data->firstDraw = False;
 279 }
 280
 281
 282 static void
 283 update(void *d)
 284 {
 285     BufferData *data = (BufferData*)d;
 286     Window win;
 287     int rx, ry;
 288     int bla;
 289     unsigned ubla;
 290
 291
 292     if (data->frozen) {
 293         rx = data->x;
 294         ry = data->y;
 295     } else {
 296         XQueryPointer(dpy, DefaultRootWindow(dpy), &win, &win, &rx, &ry,
 297                       &bla, &bla, &ubla);
 298     }
 299     updateImage(data, rx, ry);
 300
 301     data->tid = WMAddTimerHandler(data->refreshrate, update, data);
 302 }
 303
 304
 305 void resizedWindow(void *d, WMNotification *notif)
 306 {
 307     BufferData *data = (BufferData*)d;
 308     WMView *view = (WMView*)WMGetNotificationObject(notif);
 309     WMSize size;
 310
 311     size = WMGetViewSize(view);
 312
 313     resizeBufferData(data, size.width, size.height, data->magfactor);
 314 }
 315
 316
 317
 318 void closeWindow(WMWidget *w, void *d)
 319 {
 320     BufferData *data = (BufferData*)d;
 321
 322     windowCount--;
 323     if (windowCount == 0) {
 324         exit(0);
 325     } else {
 326         WMDeleteTimerHandler(data->tid);
 327         WMDestroyWidget(w);
 328         wfree(data->buffer);
 329         wfree(data->rects);
 330         WMReleasePixmap(data->pixmap);
 331         wfree(data);
 332     }
 333 }
 334
 335
 336 #if 0
 337 static void
 338 clickHandler(XEvent *event, void *d)
 339 {
 340     BufferData *data = (BufferData*)d;
 341
 342     data->win = WMCreateWindow(scr, "setup");
 343     WMSetWindowTitle(data->win, "Magnify Options");
 344
 345     data->speed = WMCreateSlider(data->win);
 346
 347     data->magnify = WMCreateSlider(data->win);
 348
 349
 350
 351 }
 352 #endif
 353
 354
 355 static void
 356 keyHandler(XEvent *event, void *d)
 357 {
 358     BufferData *data = (BufferData*)d;
 359     char buf[32];
 360     KeySym ks;
 361     WMView *view = WMWidgetView(data->win);
 362     WMSize size;
 363
 364     size = WMGetViewSize(view);
 365
 366     if (XLookupString(&event->xkey, buf, 31, &ks, NULL) > 0) {
 367         switch (buf[0]) {
 368          case 'n':
 369             newWindow(data->magfactor);
 370             break;
 371          case 'm':
 372             data->markPointerHotspot = !data->markPointerHotspot;
 373             break;
 374          case 'f':
 375          case ' ':
 376             data->frozen = !data->frozen;
 377             if (data->frozen) {
 378                 data->x = event->xkey.x_root;
 379                 data->y = event->xkey.y_root;
 380                 sprintf(buf, "[Magnify %ix]", data->magfactor);
 381             } else {
 382                 sprintf(buf, "Magnify %ix", data->magfactor);
 383             }
 384             WMSetWindowTitle(data->win, buf);
 385             break;
 386          case '1':
 387          case '2':
 388          case '3':
 389          case '4':
 390          case '5':
 391          case '6':
 392          case '7':
 393          case '8':
 394          case '9':
 395             resizeBufferData(data, size.width, size.height, buf[0]-'0');
 396             if (data->frozen) {
 397                 sprintf(buf, "[Magnify %ix]", data->magfactor);
 398             } else {
 399                 sprintf(buf, "Magnify %ix", data->magfactor);
 400             }
 401             WMSetWindowTitle(data->win, buf);
 402             break;
 403         }
 404     }
 405 }
 406
 407
 408 static BufferData*
 409 newWindow(int magfactor)
 410 {
 411     WMWindow *win;
 412     WMLabel *label;
 413     BufferData *data;
 414     char buf[32];
 415
 416     windowCount++;
 417
 418     win = WMCreateWindow(scr, "magnify");
 419     WMResizeWidget(win, 300, 200);
 420     sprintf(buf, "Magnify %ix", magfactor);
 421     WMSetWindowTitle(win, buf);
 422     WMSetViewNotifySizeChanges(WMWidgetView(win), True);
 423
 424     label = WMCreateLabel(win);
 425     WMResizeWidget(label, 300, 200);
 426     WMMoveWidget(label, 0, 0);
 427     WMSetLabelRelief(label, WRSunken);
 428     WMSetLabelImagePosition(label, WIPImageOnly);
 429
 430     data = makeBufferData(win, label, 300, 200, magfactor);
 431
 432     WMCreateEventHandler(WMWidgetView(win), KeyReleaseMask,
 433                          keyHandler, data);
 434
 435     WMAddNotificationObserver(resizedWindow, data,
 436                               WMViewSizeDidChangeNotification,
 437                               WMWidgetView(win));
 438
 439     WMRealizeWidget(win);
 440
 441     WMMapSubwidgets(win);
 442     WMMapWidget(win);
 443
 444     WMSetWindowCloseAction(win, closeWindow, data);
 445     data->tid = WMAddTimerHandler(refreshrate, update, data);
 446
 447     return data;
 448 }
 449
 450
 451 int main(int argc, char **argv)
 452 {
 453     BufferData *data;
 454     int i;
 455     char *display = "";
 456     char *vdisplay = NULL;
 457     int magfactor = 2;
 458 #if 0
 459     WMButton *radio, *tradio;
 460 #endif
 461     WMInitializeApplication("Magnify", &argc, argv);
 462
 463
 464     for (i = 1; i < argc; i++) {
 465         if (strcmp(argv[i], "-display")==0) {
 466             i++;
 467             if (i >= argc)
 468                 goto help;
 469             display = argv[i];
 470         } else if (strcmp(argv[i], "-vdisplay")==0) {
 471             i++;
 472             if (i >= argc)
 473                 goto help;
 474             vdisplay = argv[i];
 475         } else if (strcmp(argv[i], "-m")==0) {
 476             i++;
 477             if (i >= argc)
 478                 goto help;
 479             magfactor = atoi(argv[i]);
 480             if (magfactor < 1 || magfactor > 32) {
 481                 printf("%s:invalid magnification factor ``%s''\n", argv[0],
 482                        argv[i]);
 483                 exit(1);
 484             }
 485         } else if (strcmp(argv[i], "-r")==0) {
 486             i++;
 487             if (i >= argc)
 488                 goto help;
 489             refreshrate = atoi(argv[i]);
 490             if (refreshrate < 1) {
 491                 printf("%s:invalid refresh rate ``%s''\n", argv[0], argv[i]);
 492                 exit(1);
 493             }
 494         } else if (strcmp(argv[i], "-h")==0
 495                    || strcmp(argv[i], "--help")==0) {
 496         help:
 497
 498             printf("Syntax: %s [options]\n",
 499                    argv[0]);
 500             puts("Options:");
 501             puts("  -display <display>  display that should be used");
 502             puts("  -m <number>         change magnification factor (default 2)");
 503             puts("  -r <number>         change refresh delay, in milliseconds (default 200)");
 504             puts("Keys:");
 505             puts("  1,2,3,4,5,6,7,8,9   change the magnification factor");
 506             puts("  <space>, f          freeze the 'camera', making it magnify only the current\n"
 507                  "                      position");
 508             puts("  n                   create a new window");
 509             puts("  m                   show/hide the pointer hotspot mark");
 510             exit(0);
 511         }
 512     }
 513
 514     dpy = XOpenDisplay(display);
 515     if (!dpy) {
 516         puts("couldnt open display");
 517         exit(1);
 518     }
 519
 520     if (vdisplay) {
 521         vdpy = XOpenDisplay(vdisplay);
 522         if (!vdpy) {
 523             puts("couldnt open display to be viewed");
 524             exit(1);
 525         }
 526     } else {
 527         vdpy = dpy;
 528     }
 529
 530     /* calculate how many rectangles we can send in a trip to the server */
 531     rectBufferSize = XMaxRequestSize(dpy) - 128;
 532     rectBufferSize /= sizeof(XRectangle);
 533     if (rectBufferSize < 1)
 534         rectBufferSize = 1;
 535
 536     black = BlackPixel(dpy, DefaultScreen(dpy));
 537
 538     scr = WMCreateScreen(dpy, 0);
 539
 540     cursorColor1 = WMCreateNamedColor(scr, "#ff0000", False);
 541     cursorColor2 = WMCreateNamedColor(scr, "#00ff00", False);
 542
 543     data = newWindow(magfactor);
 544
 545     WMScreenMainLoop(scr);
 546
 547     return 0;
 548 }
 549