lib/gfxwindow_unix.c

   1 /* gfxwindow.h
   2
   3    Simple GUI abstraction- Unix implementation
   4
   5    Part of the swftools package.
   6
   7    Copyright (c) 2005 Matthias Kramm <kramm@quiss.org>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <pthread.h>
  26 #include <memory.h>
  27 #include <unistd.h>
  28 #include <sys/ipc.h>
  29 #include <sys/shm.h>
  30 #include <X11/Xlib.h>
  31 #include <X11/Xutil.h>
  32 #include <X11/Xresource.h>
  33 #include <X11/xpm.h>
  34 #include <X11/Xthreads.h>
  35 #include <X11/Xatom.h>
  36 #include <X11/extensions/XShm.h>
  37 #include "gfxwindow.h"
  38 #include "types.h"
  39
  40 #define USE_SHM 1
  41 #define USE_PIXMAP 1 // use pixmap instead of ximage for off-screen rendering
  42
  43 #define initMutex(mutex) {pthread_mutex_init(mutex, 0);}
  44 #define destroyMutex(mutex) {pthread_mutex_destroy((mutex));}
  45 #define lockMutex(mutex) pthread_mutex_lock(mutex)
  46 #define unlockMutex(mutex) pthread_mutex_unlock(mutex)
  47
  48 typedef struct _queue
  49 {
  50     char* data;
  51     int readpos;
  52     int writepos;
  53     int number;
  54     int size;
  55     int nmemb;
  56     pthread_mutex_t mutex;
  57 } queue_t;
  58
  59
  60 queue_t* queue_init(int size, int nmemb)
  61 {
  62     queue_t* queue = malloc(sizeof(queue_t));
  63     queue->data = (char*)malloc(size * nmemb);
  64     queue->size = size;
  65     queue->nmemb = nmemb;
  66     queue->readpos = 0;
  67     queue->writepos = 0;
  68     queue->number = 0;
  69     initMutex(&queue->mutex);
  70     return queue;
  71 }
  72
  73 void queue_destroy(queue_t*queue)
  74 {
  75     free(queue->data);queue->data = 0;
  76     destroyMutex(&queue->mutex);
  77     memset(queue, 0, sizeof(queue_t));
  78 }
  79
  80 int queue_put(queue_t*queue, void*data)
  81 {
  82     int tmp = queue->writepos+1;
  83     tmp%=queue->nmemb;
  84
  85     lockMutex(&queue->mutex);
  86     if(tmp==queue->readpos) {
  87         unlockMutex(&queue->mutex);
  88         return 0;
  89     }
  90     memcpy(&queue->data[queue->writepos*queue->size], data, queue->size);
  91     queue->writepos = tmp;
  92     queue->number++;
  93     unlockMutex(&queue->mutex);
  94     return 1;
  95 }
  96
  97 int queue_get(queue_t*queue, void*data)
  98 {
  99     lockMutex(&queue->mutex);
 100     if(queue->writepos == queue->readpos) {
 101         unlockMutex(&queue->mutex);
 102         return 0;
 103     }
 104     memcpy(data, &queue->data[queue->readpos*queue->size], queue->size);
 105     queue->readpos++;
 106     queue->readpos %= queue->nmemb;
 107     queue->number--;
 108     unlockMutex(&queue->mutex);
 109     return 1;
 110 }
 111
 112 void queue_flush(queue_t*queue)
 113 {
 114     lockMutex(&queue->mutex);
 115     queue->number = 0;
 116     queue->readpos = 0;
 117     queue->writepos = 0;
 118     unlockMutex(&queue->mutex);
 119 }
 120
 121 int queue_num(queue_t*queue)
 122 {
 123     return queue->number;
 124 }
 125
 126 static int initializexwindows();
 127
 128 struct _QXWindow;
 129 struct X
 130 {
 131     char isnative24;
 132     char isnative16;
 133     char isnative8;
 134     int bpp;
 135     int bypp;
 136     Atom atom_wm;
 137     Atom atom_wmdelete;
 138
 139     int rootsizex;
 140     int rootsizey;
 141
 142     Display *d;
 143     Window root;
 144     int s;
 145     Visual*v;
 146
 147     char running;
 148     pthread_t eventhandler;
 149     pthread_mutex_t xmutex;
 150
 151     struct _QXWindow*windowring;
 152
 153     int stopall;
 154     Colormap cmap;
 155     U32 white;
 156     U32 black;
 157 };
 158 static struct X X;
 159
 160 static int initialized = 0;
 161
 162 void destroyX() {
 163     X.stopall=1;
 164     if(X.running)
 165       pthread_cancel(X.eventhandler);
 166     if(X.d)
 167       XCloseDisplay(X.d);
 168     pthread_mutex_destroy(&X.xmutex);
 169 }
 170
 171 typedef struct _QXWindow {
 172     struct _QXWindow*next;
 173     struct _QXWindow*prev;
 174
 175     XWMHints *xwmh;
 176     XClassHint *xch;
 177
 178     GC gc;
 179     //XFontStruct *xfs;
 180
 181     XSetWindowAttributes xswa;
 182     XWindowAttributes xwa;
 183
 184 #ifdef USE_PIXMAP
 185     Pixmap offscreen_pixmap;
 186 #else
 187     XImage* offscreen_ximage;
 188 #endif
 189
 190     U8*currentscr;
 191
 192     int x,y;
 193     int lenx,leny;
 194     int bpp;
 195     int bypp;
 196     Window mywin;
 197     XGCValues xgcv;
 198     XSizeHints *xsh;
 199
 200     pthread_mutex_t wmutex;
 201
 202     queue_t* queue;
 203 } QXWindow;
 204
 205 static int lastbit(U32 bits)
 206 {
 207     int t;
 208     for(t=0;t<32;t++)
 209     {
 210         if(bits&1) break;
 211         bits>>=1;
 212     }
 213     return t;
 214 }
 215
 216 static int firstbit(U32 bits)
 217 {
 218     int t,s=-1;
 219     for(t=0;t<32;t++)
 220     {
 221         if(bits&1) s=t;
 222         bits>>=1;
 223     }
 224     return s;
 225 }
 226
 227 static U32 shiftl(U32 bits,int shift)
 228 {
 229     if(shift>0) return bits<<shift;
 230     else        return bits>>-shift;
 231 }
 232
 233 static U32 getColorFromRGB(U8 r,U8 g,U8 b)
 234 {
 235     U32 ret=0;
 236     ret|=shiftl(r,(firstbit(X.v->red_mask)-7))&X.v->red_mask;
 237     ret|=shiftl(g,(firstbit(X.v->green_mask)-7))&X.v->green_mask;
 238     ret|=shiftl(b,(firstbit(X.v->blue_mask)-7))&X.v->blue_mask;
 239     return ret;
 240 }
 241
 242 static void whatever()
 243 {
 244             XrmValue xrmvalue;
 245             XrmDatabase rdb;
 246             return;
 247 }
 248
 249 static void*eventloop(void*);
 250 static int debug;
 251 static int initializexwindows()
 252 {
 253     if(initialized)
 254         return 1;
 255     X.windowring=0;
 256     X.d=0;
 257     X.running=0;
 258     pthread_mutex_init(&X.xmutex, 0);
 259
 260     //whatever();
 261     /* open display, and show some information */
 262     X.d=XOpenDisplay(0);//getenv("DISPLAY"));
 263     if(!X.d) {return 0;}
 264 /*    printf("Xprotocol V%d.%d Vendor:%s Name:%s Defaults:%s",X.d->proto_major_version,
 265                                X.d->proto_minor_version,
 266                                X.d->vendor,X.d->display_name,X.d->defaults);
 267     int t;
 268     printf("Formats:\n");
 269     for(t=0;t<X.d->nformats;t++) {
 270         ScreenFormat*sf=&X.d->pixmap_formats[t];
 271         printf("%d:depth:%d, bpp:%d, scanline:%d\n",sf->depth,sf->bits_per_pixel,sf->scanline_pad);
 272     }
 273     printf("Screens:\n");
 274     for(t=0;t<X.d->nscreens;t++) {
 275         Screen*s=&X.d->screens[t];
 276         printf("%d*%d, bpp:%d\n",s->width,s->height,s->root_depth);
 277     }*/
 278
 279     /* open screen */
 280     X.s=DefaultScreen(X.d);
 281     if(debug) printf("Display:\n");
 282     int xbig=DisplayWidth(X.d, X.s);
 283     int ybig=DisplayHeight(X.d, X.s);
 284     X.rootsizex=xbig;
 285     X.rootsizey=ybig;
 286     int bppbig=X.bpp=DisplayPlanes(X.d, X.s);
 287     if(X.bpp==24) X.bypp=4; //Can this be 3, also?
 288     if(X.bpp==16) X.bypp=2;
 289     if(X.bpp==8) X.bypp=1;
 290     if(debug) printf("%d*%d:%d/%d/%d\n",xbig,ybig,bppbig, X.bpp, X.bypp);
 291     if(debug) printf("%d screens, vendor:%s, Ver:%d.%d(%d), at %s\n",
 292     ScreenCount(X.d),
 293     ServerVendor(X.d),
 294     ProtocolVersion(X.d),
 295     ProtocolRevision(X.d),
 296     VendorRelease(X.d),
 297     DisplayString(X.d));
 298
 299     /* open visual */
 300     X.v=XDefaultVisualOfScreen(DefaultScreenOfDisplay(X.d));
 301
 302     X.isnative24 = (bppbig==24 && X.v->red_mask==0xff0000 &&
 303                       X.v->green_mask==0x00ff00 &&
 304                       X.v->blue_mask==0x0000ff);
 305     X.isnative16 = (bppbig==16 && X.v->red_mask==0xf800 &&
 306                       X.v->green_mask==0x07e0 &&
 307                       X.v->blue_mask==0x1f);
 308     X.isnative8 = (bppbig==8);
 309     if(debug) printf("8bpp:%d 16bpp:%d 24(32)bpp:%d\n",X.isnative8,X.isnative16,X.isnative24);
 310
 311     X.root=DefaultRootWindow(X.d);
 312     if(!X.root) {return 0;}
 313
 314     X.atom_wm = XInternAtom( X.d, "WM_PROTOCOLS", False );
 315     X.atom_wmdelete = XInternAtom( X.d, "WM_DELETE_WINDOW", False );
 316
 317     X.cmap=DefaultColormap(X.d,X.s);
 318     X.white=WhitePixel(X.d,X.s);
 319     X.black=BlackPixel(X.d,X.s);
 320
 321     /* start event handler thread */
 322     X.running = 1;
 323     pthread_create(&X.eventhandler,0,eventloop,0);
 324
 325     X.stopall=0;
 326
 327     initialized=1;
 328     return 1;
 329 }
 330
 331 //needed to set the border attribute
 332 #define MWM_HINTS_FUNCTIONS     (1L << 0)
 333 #define MWM_HINTS_DECORATIONS   (1L << 1)
 334 #define MWM_HINTS_INPUT_MODE    (1L << 2)
 335 #define MWM_HINTS_STATUS        (1L << 3)
 336
 337 #define MWM_FUNC_ALL            (1L << 0)
 338 #define MWM_FUNC_RESIZE         (1L << 1)
 339 #define MWM_FUNC_MOVE           (1L << 2)
 340 #define MWM_FUNC_MINIMIZE       (1L << 3)
 341 #define MWM_FUNC_MAXIMIZE       (1L << 4)
 342 #define MWM_FUNC_CLOSE          (1L << 5)
 343
 344 #define MWM_DECOR_ALL           (1L << 0)
 345 #define MWM_DECOR_BORDER        (1L << 1)
 346 #define MWM_DECOR_RESIZEH       (1L << 2)
 347 #define MWM_DECOR_TITLE         (1L << 3)
 348 #define MWM_DECOR_MENU          (1L << 4)
 349 #define MWM_DECOR_MINIMIZE      (1L << 5)
 350 #define MWM_DECOR_MAXIMIZE      (1L << 6)
 351
 352 #define MWM_INPUT_MODELESS 0
 353 #define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
 354 #define MWM_INPUT_SYSTEM_MODAL 2
 355 #define MWM_INPUT_FULL_APPLICATION_MODAL 3
 356 #define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
 357
 358 typedef struct _mwmhints {
 359   unsigned int flags;
 360   unsigned int functions;
 361   unsigned int decorations;
 362   int input_mode;
 363   unsigned int status;
 364 } MWMHints;
 365
 366 static QXWindow* openwindow(int posx,int posy,int w,int h,char*winName)
 367 {
 368     int noborder = 0;
 369     XTextProperty iname;
 370     XTextProperty wname;
 371
 372     pthread_mutex_lock(&X.xmutex);
 373
 374     if(!initialized) {
 375         fprintf(stderr, "Error: XWindows not yet initialized!\n");
 376         pthread_mutex_unlock(&X.xmutex);
 377         return 0;
 378     }
 379
 380     QXWindow*qx= malloc(sizeof(QXWindow));
 381     if(!X.windowring) {
 382         qx->next=qx;
 383         qx->prev=qx;
 384         X.windowring=qx;
 385     } else {
 386         qx->next=X.windowring;
 387         qx->prev=X.windowring->prev;
 388         qx->prev->next=qx;
 389         X.windowring->prev=qx;
 390         X.windowring=qx;
 391     }
 392
 393     char*iconName=winName;
 394     qx->x = posx;
 395     qx->y = posy;
 396     qx->lenx=w;
 397     qx->leny=h;
 398
 399     qx->mywin=0;
 400     qx->mywin=XCreateSimpleWindow(X.d,X.root,posx,posy,qx->lenx,qx->leny,0,X.white,X.black);
 401
 402     if(!qx->mywin) {
 403         printf("Error: Couldn't create SimpleWindow\n");
 404         pthread_mutex_unlock(&X.xmutex);
 405         return 0;
 406     }
 407     qx->xwmh=XAllocWMHints();
 408     qx->xsh=XAllocSizeHints();
 409     qx->xch=XAllocClassHint();
 410
 411     qx->xsh->flags=(PPosition|PSize|PMinSize|PMaxSize);
 412     qx->xsh->height=qx->xsh->min_height=qx->xsh->max_height=h;
 413     qx->xsh->width =qx->xsh->min_width =qx->xsh->max_width =w;
 414     qx->xsh->x=0;
 415     qx->xsh->y=0;
 416
 417     if(!XStringListToTextProperty(&winName, 1, &wname)) {
 418         printf("Error: XStringToTextProperty failed\n");
 419         pthread_mutex_unlock(&X.xmutex);
 420         return 0;
 421     }
 422     if(!XStringListToTextProperty(&iconName, 1, &iname)) {
 423         printf("Error: XStringToTextProperty failed\n");
 424         pthread_mutex_unlock(&X.xmutex);
 425         return 0;
 426     }
 427
 428     XSetWMProperties(X.d,qx->mywin,&wname,&iname,0,0,qx->xsh,qx->xwmh,qx->xch);
 429
 430     qx->xgcv.foreground=X.white;
 431     qx->xgcv.background=X.black;
 432     //qx->gc=XDefaultGC(X.d,qx->mywin);
 433     qx->gc=XCreateGC(X.d,qx->mywin,GCForeground|GCBackground,&qx->xgcv);
 434
 435     XGetWindowAttributes(X.d,qx->mywin,&qx->xwa);
 436
 437     // enable events for close window
 438     XChangeProperty(X.d, qx->mywin, X.atom_wm, XA_ATOM, 32, PropModeReplace, (unsigned char *)(&X.atom_wmdelete), 1 );
 439
 440     // no border
 441     // (This code comes from the project xine (xine.sourceforge.net)
 442     //  I wonder if this works with all windowmanagers, though)
 443     if(noborder>0)
 444     {
 445         Atom atomprop = XInternAtom(X.d, "_MOTIF_WM_HINTS", True);
 446         if(atomprop)
 447         {
 448             MWMHints mwmhints;
 449             mwmhints.flags = MWM_HINTS_DECORATIONS;
 450             if(noborder==1) mwmhints.decorations = 2;
 451             if(noborder>1) mwmhints.decorations = 0;
 452             XChangeProperty(X.d, qx->mywin, atomprop, atomprop, 32,
 453                             PropModeReplace, (unsigned char *) &mwmhints, 5);
 454             XSetTransientForHint (X.d, qx->mywin, X.root);
 455         }
 456     }
 457
 458     qx->bpp=qx->xwa.depth;
 459     if(qx->bpp==24) qx->bypp=4; //Can this be 3, also?
 460     if(qx->bpp==16) qx->bypp=2;
 461     if(qx->bpp==8) qx->bypp=1;
 462
 463 #ifdef USE_SHM
 464     XShmSegmentInfo segInfo;
 465     int bpl = qx->lenx*qx->bypp;
 466     segInfo.readOnly = 0;
 467     segInfo.shmid = shmget(IPC_PRIVATE,qx->leny*bpl,IPC_CREAT|0777);
 468     struct shmid_ds buf;
 469     if (segInfo.shmid <0) {
 470         perror("shmget");
 471         fprintf(stderr,"Size = %d x %d\n", qx->lenx, qx->leny);
 472     }
 473     segInfo.shmaddr = (char*)shmat (segInfo.shmid, 0, 0);
 474     if ((long)segInfo.shmaddr == -1) {
 475         perror("shmat");
 476     }
 477     XShmAttach(X.d, &segInfo);
 478     if (shmctl(segInfo.shmid, IPC_RMID, &buf) < 0)
 479         perror("shmctl");
 480
 481     qx->currentscr = (U8*)segInfo.shmaddr;
 482
 483 # ifdef USE_PIXMAP
 484     qx->offscreen_pixmap = XShmCreatePixmap(X.d,qx->mywin,segInfo.shmaddr,&segInfo,qx->lenx,qx->leny,DefaultDepth(X.d, DefaultScreen(X.d)));
 485 # else
 486     qx->offscreen_ximage = XShmCreateImage(X.d,X.v,24,ZPixmap,(char*)segInfo.shmaddr, &segInfo, qx->lenx,qx->leny);
 487     XInitImage(qx->offscreen_ximage);
 488 # endif
 489
 490 #else
 491
 492     qx->currentscr = malloc(qx->lenx*qx->leny*4);
 493 # ifdef USE_PIXMAP
 494     qx->offscreen_pixmap = XCreatePixmapFromBitmapData(X.d,qx->mywin,qx->currentscr,qx->lenx,qx->leny,0,0,DefaultDepth(X.d,X.s));
 495 # else
 496     qx->offscreen_ximage = XCreateImage(X.d,X.v,24,ZPixmap,0,(char*)qx->currentscr,qx->lenx,qx->leny,8,qx->lenx*4);
 497     XInitImage(qx->offscreen_ximage);
 498 # endif
 499
 500 #endif
 501     XSync(X.d, False);
 502
 503     /* get the image data for the area this window will be/is placed on */
 504     /*{
 505         Window tmpwin;
 506         XImage*background;
 507         int x,y;
 508         XTranslateCoordinates(X.d,qx->mywin,X.root,0,0,&x,&y,&tmpwin);
 509         qx->background = XGetImage(X.d, DefaultRootWindow(X.d), x, y, qx->lenx, qx->leny, AllPlanes, ZPixmap);
 510         printf("%d %d\n",x,y);
 511     }*/
 512
 513     XMapRaised(X.d,qx->mywin);
 514     XFlush(X.d);
 515
 516     qx->xswa.event_mask=(qx->xwa.your_event_mask|=
 517             ButtonPressMask|
 518             ButtonReleaseMask|
 519             //ExposureMask|
 520             KeyPressMask|
 521             MotionNotify|
 522             EnterWindowMask|
 523             LeaveWindowMask|
 524             PointerMotionMask
 525         );
 526     XChangeWindowAttributes(X.d,qx->mywin,CWEventMask,&qx->xswa);
 527
 528     qx->queue = queue_init(sizeof(gfxevent_t), 256);
 529
 530     pthread_mutex_unlock(&X.xmutex);
 531
 532     pthread_mutex_init(&qx->wmutex, 0);
 533     return qx;
 534 }
 535
 536 static void closeWindow(QXWindow*qx)
 537 {
 538     if(qx->mywin) {
 539         pthread_mutex_lock(&X.xmutex);
 540         XDestroyWindow(X.d,qx->mywin);
 541         pthread_mutex_unlock(&X.xmutex);
 542         qx->mywin = 0;
 543     }
 544 }
 545
 546 static void processEvent(gfxevent_t*event)
 547 {
 548     fd_set fdset;
 549     struct timeval de;
 550     int status;
 551
 552     XEvent xe;
 553
 554     FD_ZERO(&fdset);
 555     FD_SET(ConnectionNumber(X.d),&fdset);
 556     de.tv_sec = 0;
 557     de.tv_usec = 5000; // 1/200 s
 558
 559     pthread_mutex_lock(&X.xmutex);
 560     FD_ZERO(&fdset);
 561     FD_SET(ConnectionNumber(X.d),&fdset);
 562     de.tv_sec = de.tv_usec = 0;
 563     if(!select(ConnectionNumber(X.d)+1, &fdset, 0, 0, &de)) {
 564         pthread_mutex_unlock(&X.xmutex);
 565         usleep(1000);
 566         return;
 567     }
 568     XNextEvent(X.d,&xe);
 569     pthread_mutex_unlock(&X.xmutex);
 570
 571     /* 1: find out which windows the message is for */
 572     Window w = 0;
 573     switch(xe.type)
 574     {
 575         case ClientMessage: w = xe.xclient.window;break;
 576         case Expose:        w = xe.xexpose.window;break;
 577         case NoExpose:      w = xe.xexpose.window;break;
 578         case ButtonPress:   w = xe.xbutton.window;break;
 579         case ButtonRelease: w = xe.xbutton.window;break;
 580         case KeyPress:      w = xe.xkey.window;   break;
 581         case KeyRelease:    w = xe.xkey.window;   break;
 582         case MotionNotify:  w = xe.xmotion.window;break;
 583         case EnterNotify:   w = xe.xmotion.window;break;
 584         case LeaveNotify:   w = xe.xmotion.window;break;
 585         default:
 586         /* this usually happens for unknown events which
 587            we don't care about */
 588             return;
 589     }
 590
 591     QXWindow*qx=X.windowring;
 592     QXWindow*win=0;
 593     event->internal = 0;
 594     do {
 595         if(w == qx->mywin) {
 596             win = qx;
 597         }
 598     }
 599     while(qx!=X.windowring);
 600
 601     if(!win) {
 602         /* Not one of our windows. This may be a bug */
 603         return;
 604     }
 605     event->internal = win;
 606
 607     /* 2: Go for the event construction */
 608
 609     switch(xe.type)
 610     {
 611         case ButtonPress:
 612             event->type = GFXEVENT_MOUSEPRESS;
 613             event->button = xe.xbutton.button;
 614         break;
 615         case ButtonRelease:
 616             event->type = GFXEVENT_MOUSERELEASE;
 617             event->button = xe.xbutton.button;
 618         break;
 619         case KeyPress:
 620             event->type = GFXEVENT_KEYPRESS;
 621             event->key = xe.xkey.keycode;
 622         break;
 623         case KeyRelease:
 624             event->type = GFXEVENT_KEYRELEASE;
 625             event->key = xe.xkey.keycode;
 626         break;
 627         case MotionNotify:
 628             event->type = GFXEVENT_MOUSEMOVE;
 629             pthread_mutex_lock(&qx->wmutex);
 630             event->x = xe.xmotion.x_root - win->x;
 631             event->y = xe.xmotion.y_root - win->y;
 632             if(!queue_put(win->queue, event)) {
 633                 printf("Queue overflow for window %08x!\n", win);
 634             }
 635             pthread_mutex_unlock(&qx->wmutex);
 636         break;
 637         case EnterNotify:
 638             event->type = GFXEVENT_MOUSEENTER;
 639             pthread_mutex_lock(&qx->wmutex);
 640             event->x = xe.xmotion.x_root - win->x;
 641             event->y = xe.xmotion.y_root - win->y;
 642             pthread_mutex_unlock(&qx->wmutex);
 643         break;
 644         case LeaveNotify:
 645             event->type = GFXEVENT_MOUSELEAVE;
 646             pthread_mutex_lock(&qx->wmutex);
 647             event->x = xe.xmotion.x - win->x;
 648             event->y = xe.xmotion.y - win->y;
 649             pthread_mutex_unlock(&qx->wmutex);
 650         break;
 651         case ClientMessage:
 652             if ((xe.xclient.message_type == X.atom_wm ) &&
 653                 ((unsigned)xe.xclient.data.l[0] == X.atom_wmdelete) ) {
 654                 pthread_mutex_lock(&qx->wmutex);
 655                 closeWindow(win);
 656                 event->type = GFXEVENT_DESTROY;
 657                 pthread_mutex_unlock(&qx->wmutex);
 658             }
 659         break;
 660     }
 661 }
 662
 663 static void*eventloop(void*r)
 664 {
 665     //while(!XEventsQueued(X.d,QueuedAfterReading))
 666     while(X.running)
 667     {
 668         gfxevent_t event;
 669         event.type = GFXEVENT_NOTHING;
 670         event.key = event.x = event.y = event.button = -1;
 671         processEvent(&event);
 672         if(event.type != GFXEVENT_NOTHING && event.type != GFXEVENT_MOUSEMOVE) {
 673             QXWindow*win = (QXWindow*)event.internal;
 674             pthread_mutex_lock(&win->wmutex);
 675             if(!queue_put(win->queue,&event)) {
 676                 fprintf(stderr, "Queue overflow for window %08x!\n", win);
 677             }
 678             pthread_mutex_unlock(&win->wmutex);
 679         }
 680     }
 681     return 0;
 682 }
 683
 684 typedef struct _internal {
 685     GC gc;
 686     char*name;
 687     QXWindow*qx;
 688     int lenx, leny;
 689     int tmplenx, tmpleny;
 690     void*currentscr2;
 691 } internal_t;
 692
 693 static void gfxwindow_on(gfxwindow_t*win)
 694 {
 695     internal_t*i = (internal_t*)win->internal;
 696
 697     i->qx=openwindow(64, 64, win->width, win->height, i->name);
 698     if(!i->qx)
 699         return;
 700     i->currentscr2=0;
 701     if(i->qx->bypp != 4) {
 702         fprintf(stderr, "Warning: Not a native 32 bit screen, using second buffer\n");
 703         i->currentscr2 = malloc(win->width*win->height*4);
 704         win->currentscr = (unsigned char*)i->currentscr2;
 705     } else {
 706         win->currentscr = i->qx->currentscr;
 707     }
 708     win->lastscr = 0;
 709 }
 710
 711 static void gfxwindow_off(gfxwindow_t*win)
 712 {
 713     internal_t*i = (internal_t*)win->internal;
 714     if(i->currentscr2)
 715         free(i->currentscr2);
 716     closeWindow(i->qx);
 717 }
 718
 719 static void gfxwindow_flippage(gfxwindow_t*win)
 720 {
 721     internal_t*i = (internal_t*)win->internal;
 722     pthread_mutex_lock(&X.xmutex);
 723
 724     if(i->currentscr2) {
 725         if(i->qx->bypp==2 && X.isnative16) {
 726             int t;
 727             int l = win->width*win->height;
 728             unsigned char*dest = i->qx->currentscr;
 729             unsigned char*src = (unsigned char*)i->currentscr2;
 730             do {
 731                 dest[1] = (src[2]&0xf8)|(src[1]>>5);
 732                 dest[0] = ((src[1]<<5)&0xe0)|(src[0]>>3);
 733                 dest+=2;
 734                 src+=4;
 735             } while(--l);
 736         } else {
 737             memcpy(i->qx->currentscr, i->currentscr2, i->lenx*i->leny*i->qx->bypp);
 738         }
 739     }
 740
 741     XSetFunction(X.d,i->qx->gc,GXcopy);
 742 #ifdef USE_PIXMAP
 743 # ifndef USE_SHM
 744     if(i->qx->offscreen_pixmap) {
 745         XFreePixmap(X.d,i->qx->offscreen_pixmap);i->qx->offscreen_pixmap = 0;
 746     }
 747     i->qx->offscreen_pixmap = XCreatePixmapFromBitmapData(X.d,i->qx->mywin,i->qx->currentscr,i->qx->lenx,i->qx->leny,X.white,X.black,DefaultDepth(X.d,X.s));
 748 # endif
 749     XCopyArea(X.d,i->qx->offscreen_pixmap,i->qx->mywin,i->qx->gc, 0, 0, i->qx->lenx,i->qx->leny, 0, 0);
 750     XFlush(X.d);
 751 #else
 752     XPutImage(X.d,i->qx->mywin,i->qx->gc,i->qx->offscreen_ximage,0,0,0,0,i->qx->lenx,i->qx->leny);
 753 #endif
 754     pthread_mutex_unlock(&X.xmutex);
 755 }
 756
 757 void gfxwindow_setcolor(gfxwindow_t*win, U32 c)
 758 {
 759     internal_t*i = (internal_t*)win->internal;
 760     pthread_mutex_lock(&X.xmutex);
 761     i->qx->xgcv.foreground=getColorFromRGB((U8)(c>>16),(U8)(c>>8),(U8)c);
 762     i->gc=XCreateGC(X.d,i->qx->mywin,GCForeground|GCBackground,&i->qx->xgcv);
 763     pthread_mutex_unlock(&X.xmutex);
 764 }
 765 void gfxwindow_putpixel(gfxwindow_t*win, int x, int y, unsigned char c)
 766 {
 767     internal_t*i = (internal_t*)win->internal;
 768     if(((U32)x)<(U32)win->width && ((U32)y)<(U32)win->height)
 769         *(U32*)&win->currentscr[y*win->width*i->qx->bypp+x*i->qx->bypp]=c;
 770 }
 771 static gfxevent_t gfxwindow_getEvent(gfxwindow_t*win)
 772 {
 773     internal_t*i = (internal_t*)win->internal;
 774     gfxevent_t event;
 775     pthread_mutex_lock(&i->qx->wmutex);
 776     if(!i->qx->queue || !queue_get(i->qx->queue,&event)) {
 777         event.type = GFXEVENT_NOTHING;
 778     } else if(event.type == GFXEVENT_DESTROY) {
 779         queue_destroy(i->qx->queue);i->qx->queue=0;
 780     }
 781     pthread_mutex_unlock(&i->qx->wmutex);
 782     return event;
 783 }
 784
 785 static void gfxwindow_move(gfxwindow_t*win, int x,int y)
 786 {
 787     internal_t*i = (internal_t*)win->internal;
 788     pthread_mutex_lock(&i->qx->wmutex);
 789     pthread_mutex_lock(&X.xmutex);
 790     XWindowAttributes a;
 791     i->qx->x += x;
 792     i->qx->y += y;
 793     XMoveResizeWindow(X.d, i->qx->mywin, i->qx->x, i->qx->y, i->tmplenx, i->tmpleny);
 794
 795     queue_t* queue2 = queue_init(sizeof(gfxevent_t), 256);
 796     gfxevent_t event;
 797     /* HACK: now that we have moved the window, all mouse move events
 798        are outdated- remove them*/
 799     while(queue_get(i->qx->queue, &event)) {
 800         if(event.type!=GFXEVENT_MOUSEMOVE)
 801             queue_put(queue2, &event);
 802     }
 803     queue_destroy(i->qx->queue);
 804     i->qx->queue = queue2;
 805
 806     pthread_mutex_unlock(&X.xmutex);
 807     pthread_mutex_unlock(&i->qx->wmutex);
 808 }
 809
 810 static void gfxwindow_resize(gfxwindow_t*win, int x,int y)
 811 {
 812     internal_t*i = (internal_t*)win->internal;
 813     if(x>win->width || y>win->height) {
 814         fprintf(stderr, "resize: can only make windows smaller\n");
 815         return;
 816     }
 817     if(x<1) x=1;
 818     if(y<1) y=1;
 819     pthread_mutex_lock(&i->qx->wmutex);
 820     i->tmplenx=x;
 821     i->tmpleny=y;
 822     pthread_mutex_lock(&X.xmutex);
 823     XMoveResizeWindow(X.d, i->qx->mywin, i->qx->x, i->qx->y, i->tmplenx, i->tmpleny);
 824     pthread_mutex_unlock(&X.xmutex);
 825     pthread_mutex_unlock(&i->qx->wmutex);
 826 }
 827 static void gfxwindow_destroy(gfxwindow_t*win)
 828 {
 829     internal_t*i = (internal_t*)win->internal;
 830     gfxwindow_off(win);
 831     pthread_mutex_destroy(&i->qx->wmutex);
 832 }
 833
 834 gfxwindow_t* gfxwindow_new(int width, int height)
 835 {
 836     gfxwindow_t*w = (gfxwindow_t*)malloc(sizeof(gfxwindow_t));
 837     if(!initializexwindows()) {
 838         fprintf(stderr, "Warning: Couldn't initialize X-Windows\n");
 839     }
 840     internal_t*i = malloc(sizeof(internal_t));
 841     w->internal = i;
 842     w->move = gfxwindow_move;
 843     w->resize = gfxwindow_resize;
 844     w->flippage = gfxwindow_flippage;
 845     w->getEvent = gfxwindow_getEvent;
 846     w->width = width;
 847     w->height = height;
 848     w->destroy = gfxwindow_destroy;
 849
 850     i->lenx = i->tmplenx = width;
 851     i->leny = i->tmpleny = height;
 852     i->name = "";
 853
 854     gfxwindow_on(w);
 855     return w;
 856 };
 857