devdraw: x11 working again
Need to think a bit more about locking, but overall it's a working devdraw. Multiclient mode may not be working but nothing is using it yet.
This commit is contained in:
Russ Cox
Russ Cox
parent
892b3c4687
commit
50923426bf
14 changed files with 1845 additions and 2341 deletions
|
|
@ -144,9 +144,11 @@ addflush(Client *c, Rectangle r)
|
||||||
// Unlock drawlk because rpc_flush may want to run on gfx thread,
|
// Unlock drawlk because rpc_flush may want to run on gfx thread,
|
||||||
// and gfx thread might be blocked on drawlk trying to install a new screen
|
// and gfx thread might be blocked on drawlk trying to install a new screen
|
||||||
// during a resize.
|
// during a resize.
|
||||||
|
rpc_gfxdrawunlock();
|
||||||
qunlock(&c->drawlk);
|
qunlock(&c->drawlk);
|
||||||
rpc_flush(c, fr);
|
rpc_flush(c, fr);
|
||||||
qlock(&c->drawlk);
|
qlock(&c->drawlk);
|
||||||
|
rpc_gfxdrawlock();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -187,9 +189,11 @@ drawflush(Client *c)
|
||||||
// Unlock drawlk because rpc_flush may want to run on gfx thread,
|
// Unlock drawlk because rpc_flush may want to run on gfx thread,
|
||||||
// and gfx thread might be blocked on drawlk trying to install a new screen
|
// and gfx thread might be blocked on drawlk trying to install a new screen
|
||||||
// during a resize.
|
// during a resize.
|
||||||
|
rpc_gfxdrawunlock();
|
||||||
qunlock(&c->drawlk);
|
qunlock(&c->drawlk);
|
||||||
rpc_flush(c, r);
|
rpc_flush(c, r);
|
||||||
qlock(&c->drawlk);
|
qlock(&c->drawlk);
|
||||||
|
rpc_gfxdrawlock();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -656,6 +660,7 @@ draw_datawrite(Client *client, void *v, int n)
|
||||||
Refx *refx;
|
Refx *refx;
|
||||||
|
|
||||||
qlock(&client->drawlk);
|
qlock(&client->drawlk);
|
||||||
|
rpc_gfxdrawlock();
|
||||||
a = v;
|
a = v;
|
||||||
m = 0;
|
m = 0;
|
||||||
oldn = n;
|
oldn = n;
|
||||||
|
|
@ -1428,6 +1433,7 @@ draw_datawrite(Client *client, void *v, int n)
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
rpc_gfxdrawunlock();
|
||||||
qunlock(&client->drawlk);
|
qunlock(&client->drawlk);
|
||||||
return oldn - n;
|
return oldn - n;
|
||||||
|
|
||||||
|
|
@ -1498,6 +1504,7 @@ Ebadarg:
|
||||||
|
|
||||||
error:
|
error:
|
||||||
werrstr("%s", err);
|
werrstr("%s", err);
|
||||||
|
rpc_gfxdrawunlock();
|
||||||
qunlock(&client->drawlk);
|
qunlock(&client->drawlk);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -204,14 +204,19 @@ void rpc_setmouse(Client*, Point);
|
||||||
void rpc_shutdown(void);
|
void rpc_shutdown(void);
|
||||||
void rpc_topwin(Client*);
|
void rpc_topwin(Client*);
|
||||||
void rpc_main(void);
|
void rpc_main(void);
|
||||||
|
void rpc_bouncemouse(Client*, Mouse);
|
||||||
// TODO: rpc_flush is called from draw_datawrite,
|
|
||||||
// which holds c->drawlk. Is this OK?
|
|
||||||
void rpc_flush(Client*, Rectangle);
|
void rpc_flush(Client*, Rectangle);
|
||||||
|
|
||||||
|
// rpc_gfxdrawlock and rpc_gfxdrawunlock
|
||||||
|
// are called around drawing operations to lock and unlock
|
||||||
|
// access to the graphics display, for systems where the
|
||||||
|
// individual memdraw operations use the graphics display (X11, not macOS).
|
||||||
|
void rpc_gfxdrawlock(void);
|
||||||
|
void rpc_gfxdrawunlock(void);
|
||||||
|
|
||||||
// draw* routines are called on the RPC thread,
|
// draw* routines are called on the RPC thread,
|
||||||
// invoked by the RPC server to do pixel pushing.
|
// invoked by the RPC server to do pixel pushing.
|
||||||
// c->drawlk is held on entry.
|
// No locks are held on entry.
|
||||||
int draw_dataread(Client*, void*, int);
|
int draw_dataread(Client*, void*, int);
|
||||||
int draw_datawrite(Client*, void*, int);
|
int draw_datawrite(Client*, void*, int);
|
||||||
void draw_initdisplaymemimage(Client*, Memimage*);
|
void draw_initdisplaymemimage(Client*, Memimage*);
|
||||||
|
|
|
||||||
|
|
@ -1063,6 +1063,26 @@ rpc_putsnarf(char *s)
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// rpc_bouncemouse is for sending a mouse event
|
||||||
|
// back to the X11 window manager rio(1).
|
||||||
|
// Does not apply here.
|
||||||
|
void
|
||||||
|
rpc_bouncemouse(Client *c, Mouse m)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// We don't use the graphics thread state during memimagedraw,
|
||||||
|
// so rpc_gfxdrawlock and rpc_gfxdrawunlock are no-ops.
|
||||||
|
void
|
||||||
|
rpc_gfxdrawlock(void)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
rpc_gfxdrawunlock(void)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
setprocname(const char *s)
|
setprocname(const char *s)
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -28,9 +28,6 @@ HFILES=\
|
||||||
$O.drawclient: drawclient.$O
|
$O.drawclient: drawclient.$O
|
||||||
$LD -o $target $prereq
|
$LD -o $target $prereq
|
||||||
|
|
||||||
$O.snarf: x11-alloc.$O x11-cload.$O x11-draw.$O x11-fill.$O x11-get.$O x11-init.$O x11-itrans.$O x11-keysym2ucs.$O x11-load.$O x11-pixelbits.$O x11-unload.$O x11-wsys.$O snarf.$O latin1.$O devdraw.$O
|
|
||||||
$LD -o $target $prereq
|
|
||||||
|
|
||||||
$O.mklatinkbd: mklatinkbd.$O
|
$O.mklatinkbd: mklatinkbd.$O
|
||||||
$LD -o $target $prereq
|
$LD -o $target $prereq
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,109 +0,0 @@
|
||||||
#include <u.h>
|
|
||||||
#include <sys/select.h>
|
|
||||||
#include <errno.h>
|
|
||||||
#include "x11-inc.h"
|
|
||||||
#include <libc.h>
|
|
||||||
#include <draw.h>
|
|
||||||
#include <memdraw.h>
|
|
||||||
#include <memlayer.h>
|
|
||||||
#include <keyboard.h>
|
|
||||||
#include <mouse.h>
|
|
||||||
#include <cursor.h>
|
|
||||||
#include <drawfcall.h>
|
|
||||||
#include "x11-memdraw.h"
|
|
||||||
#include "devdraw.h"
|
|
||||||
|
|
||||||
#undef time
|
|
||||||
|
|
||||||
#define MouseMask (\
|
|
||||||
ButtonPressMask|\
|
|
||||||
ButtonReleaseMask|\
|
|
||||||
PointerMotionMask|\
|
|
||||||
Button1MotionMask|\
|
|
||||||
Button2MotionMask|\
|
|
||||||
Button3MotionMask)
|
|
||||||
|
|
||||||
#define Mask MouseMask|ExposureMask|StructureNotifyMask|KeyPressMask|EnterWindowMask|LeaveWindowMask
|
|
||||||
|
|
||||||
void runxevent(XEvent*);
|
|
||||||
|
|
||||||
void
|
|
||||||
usage(void)
|
|
||||||
{
|
|
||||||
fprint(2, "usage: snarf [-a] [-o | text]\n");
|
|
||||||
exits("usage");
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
main(int argc, char **argv)
|
|
||||||
{
|
|
||||||
int apple;
|
|
||||||
int out;
|
|
||||||
|
|
||||||
apple = 0;
|
|
||||||
out = 0;
|
|
||||||
|
|
||||||
ARGBEGIN{
|
|
||||||
case 'a':
|
|
||||||
apple = 1;
|
|
||||||
break;
|
|
||||||
case 'o':
|
|
||||||
out = 1;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
usage();
|
|
||||||
}ARGEND
|
|
||||||
|
|
||||||
if(out && argc != 0)
|
|
||||||
usage();
|
|
||||||
if(!out && argc != 1)
|
|
||||||
usage();
|
|
||||||
|
|
||||||
_x.fd = -1;
|
|
||||||
|
|
||||||
memimageinit();
|
|
||||||
_xattach("snarf", "20x20");
|
|
||||||
|
|
||||||
XSelectInput(_x.display, _x.drawable, Mask);
|
|
||||||
XFlush(_x.display);
|
|
||||||
|
|
||||||
if(out){
|
|
||||||
char *s;
|
|
||||||
if(apple)
|
|
||||||
s = _applegetsnarf();
|
|
||||||
else
|
|
||||||
s = _xgetsnarf();
|
|
||||||
write(1, s, strlen(s));
|
|
||||||
write(1, "\n", 1);
|
|
||||||
exits(0);
|
|
||||||
}else{
|
|
||||||
_xputsnarf(argv[0]);
|
|
||||||
for(;;){
|
|
||||||
XEvent event;
|
|
||||||
XNextEvent(_x.display, &event);
|
|
||||||
runxevent(&event);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Handle an incoming X event.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
runxevent(XEvent *xev)
|
|
||||||
{
|
|
||||||
switch(xev->type){
|
|
||||||
case Expose:
|
|
||||||
_xexpose(xev);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case DestroyNotify:
|
|
||||||
if(_xdestroy(xev))
|
|
||||||
exits(0);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case SelectionRequest:
|
|
||||||
_xselect(xev);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -258,7 +258,7 @@ runmsg(Client *c, Wsysmsg *m)
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case Tbouncemouse:
|
case Tbouncemouse:
|
||||||
// _xbouncemouse(&m->mouse);
|
rpc_bouncemouse(c, m->mouse);
|
||||||
replymsg(c, m);
|
replymsg(c, m);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -21,7 +21,7 @@ _xallocmemimage(Rectangle r, u32int chan, int pixmap)
|
||||||
m = _allocmemimage(r, chan);
|
m = _allocmemimage(r, chan);
|
||||||
if(chan != GREY1 && chan != _x.chan)
|
if(chan != GREY1 && chan != _x.chan)
|
||||||
return m;
|
return m;
|
||||||
if(_x.display == 0)
|
if(_x.display == 0 || _x.windows == nil)
|
||||||
return m;
|
return m;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
|
@ -49,7 +49,7 @@ _xallocmemimage(Rectangle r, u32int chan, int pixmap)
|
||||||
if(pixmap != PMundef)
|
if(pixmap != PMundef)
|
||||||
xm->pixmap = pixmap;
|
xm->pixmap = pixmap;
|
||||||
else
|
else
|
||||||
xm->pixmap = XCreatePixmap(_x.display, _x.drawable, Dx(r), Dy(r), d);
|
xm->pixmap = XCreatePixmap(_x.display, _x.windows->drawable, Dx(r), Dy(r), d);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* We want to align pixels on word boundaries.
|
* We want to align pixels on word boundaries.
|
||||||
|
|
|
||||||
|
|
@ -31,5 +31,3 @@
|
||||||
#undef Screen
|
#undef Screen
|
||||||
#undef Visual
|
#undef Visual
|
||||||
#undef Window
|
#undef Window
|
||||||
|
|
||||||
void sendalt(void);
|
|
||||||
|
|
|
||||||
|
|
@ -1,738 +0,0 @@
|
||||||
/*
|
|
||||||
* Some of the stuff in this file is not X-dependent and should be elsewhere.
|
|
||||||
*/
|
|
||||||
#include <u.h>
|
|
||||||
#include "x11-inc.h"
|
|
||||||
#include <libc.h>
|
|
||||||
#include <draw.h>
|
|
||||||
#include <memdraw.h>
|
|
||||||
#include <memlayer.h>
|
|
||||||
#include <keyboard.h>
|
|
||||||
#include <mouse.h>
|
|
||||||
#include <cursor.h>
|
|
||||||
#include "x11-memdraw.h"
|
|
||||||
#include "devdraw.h"
|
|
||||||
|
|
||||||
static void plan9cmap(void);
|
|
||||||
static int setupcmap(XWindow);
|
|
||||||
static XGC xgc(XDrawable, int, int);
|
|
||||||
|
|
||||||
Xprivate _x;
|
|
||||||
|
|
||||||
static int
|
|
||||||
xerror(XDisplay *d, XErrorEvent *e)
|
|
||||||
{
|
|
||||||
char buf[200];
|
|
||||||
|
|
||||||
if(e->request_code == 42) /* XSetInputFocus */
|
|
||||||
return 0;
|
|
||||||
if(e->request_code == 18) /* XChangeProperty */
|
|
||||||
return 0;
|
|
||||||
/*
|
|
||||||
* BadDrawable happens in apps that get resized a LOT,
|
|
||||||
* e.g. when KDE is configured to resize continuously
|
|
||||||
* during a window drag.
|
|
||||||
*/
|
|
||||||
if(e->error_code == 9) /* BadDrawable */
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
fprint(2, "X error: error_code=%d, request_code=%d, minor=%d disp=%p\n",
|
|
||||||
e->error_code, e->request_code, e->minor_code, d);
|
|
||||||
XGetErrorText(d, e->error_code, buf, sizeof buf);
|
|
||||||
fprint(2, "%s\n", buf);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
xioerror(XDisplay *d)
|
|
||||||
{
|
|
||||||
/*print("X I/O error\n"); */
|
|
||||||
exit(0);
|
|
||||||
/*sysfatal("X I/O error\n");*/
|
|
||||||
abort();
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
Memimage*
|
|
||||||
_xattach(char *label, char *winsize)
|
|
||||||
{
|
|
||||||
char *argv[2], *disp;
|
|
||||||
int i, havemin, height, mask, n, width, x, xrootid, y;
|
|
||||||
Rectangle r;
|
|
||||||
XClassHint classhint;
|
|
||||||
XDrawable pmid;
|
|
||||||
XPixmapFormatValues *pfmt;
|
|
||||||
XScreen *xscreen;
|
|
||||||
XSetWindowAttributes attr;
|
|
||||||
XSizeHints normalhint;
|
|
||||||
XTextProperty name;
|
|
||||||
XVisualInfo xvi;
|
|
||||||
XWindow xrootwin;
|
|
||||||
XWindowAttributes wattr;
|
|
||||||
XWMHints hint;
|
|
||||||
Atom atoms[2];
|
|
||||||
|
|
||||||
/*
|
|
||||||
if(XInitThreads() == 0){
|
|
||||||
fprint(2, "XInitThreads failed\n");
|
|
||||||
abort();
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Connect to X server.
|
|
||||||
*/
|
|
||||||
_x.display = XOpenDisplay(NULL);
|
|
||||||
if(_x.display == nil){
|
|
||||||
disp = getenv("DISPLAY");
|
|
||||||
werrstr("XOpenDisplay %s: %r", disp ? disp : ":0");
|
|
||||||
free(disp);
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
_x.fd = ConnectionNumber(_x.display);
|
|
||||||
XSetErrorHandler(xerror);
|
|
||||||
XSetIOErrorHandler(xioerror);
|
|
||||||
xrootid = DefaultScreen(_x.display);
|
|
||||||
xrootwin = DefaultRootWindow(_x.display);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Figure out underlying screen format.
|
|
||||||
*/
|
|
||||||
if(XMatchVisualInfo(_x.display, xrootid, 24, TrueColor, &xvi)
|
|
||||||
|| XMatchVisualInfo(_x.display, xrootid, 24, DirectColor, &xvi)){
|
|
||||||
_x.vis = xvi.visual;
|
|
||||||
_x.depth = 24;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
if(XMatchVisualInfo(_x.display, xrootid, 16, TrueColor, &xvi)
|
|
||||||
|| XMatchVisualInfo(_x.display, xrootid, 16, DirectColor, &xvi)){
|
|
||||||
_x.vis = xvi.visual;
|
|
||||||
_x.depth = 16;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
if(XMatchVisualInfo(_x.display, xrootid, 15, TrueColor, &xvi)
|
|
||||||
|| XMatchVisualInfo(_x.display, xrootid, 15, DirectColor, &xvi)){
|
|
||||||
_x.vis = xvi.visual;
|
|
||||||
_x.depth = 15;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
if(XMatchVisualInfo(_x.display, xrootid, 8, PseudoColor, &xvi)
|
|
||||||
|| XMatchVisualInfo(_x.display, xrootid, 8, StaticColor, &xvi)){
|
|
||||||
if(_x.depth > 8){
|
|
||||||
werrstr("can't deal with colormapped depth %d screens",
|
|
||||||
_x.depth);
|
|
||||||
goto err0;
|
|
||||||
}
|
|
||||||
_x.vis = xvi.visual;
|
|
||||||
_x.depth = 8;
|
|
||||||
}
|
|
||||||
else{
|
|
||||||
_x.depth = DefaultDepth(_x.display, xrootid);
|
|
||||||
if(_x.depth != 8){
|
|
||||||
werrstr("can't understand depth %d screen", _x.depth);
|
|
||||||
goto err0;
|
|
||||||
}
|
|
||||||
_x.vis = DefaultVisual(_x.display, xrootid);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(DefaultDepth(_x.display, xrootid) == _x.depth)
|
|
||||||
_x.usetable = 1;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* _x.depth is only the number of significant pixel bits,
|
|
||||||
* not the total number of pixel bits. We need to walk the
|
|
||||||
* display list to find how many actual bits are used
|
|
||||||
* per pixel.
|
|
||||||
*/
|
|
||||||
_x.chan = 0;
|
|
||||||
pfmt = XListPixmapFormats(_x.display, &n);
|
|
||||||
for(i=0; i<n; i++){
|
|
||||||
if(pfmt[i].depth == _x.depth){
|
|
||||||
switch(pfmt[i].bits_per_pixel){
|
|
||||||
case 1: /* untested */
|
|
||||||
_x.chan = GREY1;
|
|
||||||
break;
|
|
||||||
case 2: /* untested */
|
|
||||||
_x.chan = GREY2;
|
|
||||||
break;
|
|
||||||
case 4: /* untested */
|
|
||||||
_x.chan = GREY4;
|
|
||||||
break;
|
|
||||||
case 8:
|
|
||||||
_x.chan = CMAP8;
|
|
||||||
break;
|
|
||||||
case 15:
|
|
||||||
_x.chan = RGB15;
|
|
||||||
break;
|
|
||||||
case 16: /* how to tell RGB15? */
|
|
||||||
_x.chan = RGB16;
|
|
||||||
break;
|
|
||||||
case 24: /* untested (impossible?) */
|
|
||||||
_x.chan = RGB24;
|
|
||||||
break;
|
|
||||||
case 32:
|
|
||||||
_x.chan = XRGB32;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
XFree(pfmt);
|
|
||||||
if(_x.chan == 0){
|
|
||||||
werrstr("could not determine screen pixel format");
|
|
||||||
goto err0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Set up color map if necessary.
|
|
||||||
*/
|
|
||||||
xscreen = DefaultScreenOfDisplay(_x.display);
|
|
||||||
_x.cmap = DefaultColormapOfScreen(xscreen);
|
|
||||||
if(_x.vis->class != StaticColor){
|
|
||||||
plan9cmap();
|
|
||||||
setupcmap(xrootwin);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We get to choose the initial rectangle size.
|
|
||||||
* This is arbitrary. In theory we should read the
|
|
||||||
* command line and allow the traditional X options.
|
|
||||||
*/
|
|
||||||
mask = 0;
|
|
||||||
x = 0;
|
|
||||||
y = 0;
|
|
||||||
if(winsize && winsize[0]){
|
|
||||||
if(parsewinsize(winsize, &r, &havemin) < 0)
|
|
||||||
sysfatal("%r");
|
|
||||||
}else{
|
|
||||||
/*
|
|
||||||
* Parse the various X resources. Thanks to Peter Canning.
|
|
||||||
*/
|
|
||||||
char *screen_resources, *display_resources, *geom,
|
|
||||||
*geomrestype, *home, *file, *dpitype;
|
|
||||||
XrmDatabase database;
|
|
||||||
XrmValue geomres, dpires;
|
|
||||||
|
|
||||||
database = XrmGetDatabase(_x.display);
|
|
||||||
screen_resources = XScreenResourceString(xscreen);
|
|
||||||
if(screen_resources != nil){
|
|
||||||
XrmCombineDatabase(XrmGetStringDatabase(screen_resources), &database, False);
|
|
||||||
XFree(screen_resources);
|
|
||||||
}
|
|
||||||
|
|
||||||
display_resources = XResourceManagerString(_x.display);
|
|
||||||
if(display_resources == nil){
|
|
||||||
home = getenv("HOME");
|
|
||||||
if(home!=nil && (file=smprint("%s/.Xdefaults", home)) != nil){
|
|
||||||
XrmCombineFileDatabase(file, &database, False);
|
|
||||||
free(file);
|
|
||||||
}
|
|
||||||
free(home);
|
|
||||||
}else
|
|
||||||
XrmCombineDatabase(XrmGetStringDatabase(display_resources), &database, False);
|
|
||||||
|
|
||||||
if (XrmGetResource(database, "Xft.dpi", "String", &dpitype, &dpires) == True) {
|
|
||||||
if (dpires.addr) {
|
|
||||||
client0->displaydpi = atoi(dpires.addr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
geom = smprint("%s.geometry", label);
|
|
||||||
if(geom && XrmGetResource(database, geom, nil, &geomrestype, &geomres))
|
|
||||||
mask = XParseGeometry(geomres.addr, &x, &y, (uint*)&width, (uint*)&height);
|
|
||||||
XrmDestroyDatabase(database);
|
|
||||||
free(geom);
|
|
||||||
|
|
||||||
if((mask & WidthValue) && (mask & HeightValue)){
|
|
||||||
r = Rect(0, 0, width, height);
|
|
||||||
}else{
|
|
||||||
r = Rect(0, 0, WidthOfScreen(xscreen)*3/4,
|
|
||||||
HeightOfScreen(xscreen)*3/4);
|
|
||||||
if(Dx(r) > Dy(r)*3/2)
|
|
||||||
r.max.x = r.min.x + Dy(r)*3/2;
|
|
||||||
if(Dy(r) > Dx(r)*3/2)
|
|
||||||
r.max.y = r.min.y + Dx(r)*3/2;
|
|
||||||
}
|
|
||||||
if(mask & XNegative){
|
|
||||||
x += WidthOfScreen(xscreen);
|
|
||||||
}
|
|
||||||
if(mask & YNegative){
|
|
||||||
y += HeightOfScreen(xscreen);
|
|
||||||
}
|
|
||||||
havemin = 0;
|
|
||||||
}
|
|
||||||
screenrect = Rect(0, 0, WidthOfScreen(xscreen), HeightOfScreen(xscreen));
|
|
||||||
windowrect = r;
|
|
||||||
|
|
||||||
memset(&attr, 0, sizeof attr);
|
|
||||||
attr.colormap = _x.cmap;
|
|
||||||
attr.background_pixel = ~0;
|
|
||||||
attr.border_pixel = 0;
|
|
||||||
_x.drawable = XCreateWindow(
|
|
||||||
_x.display, /* display */
|
|
||||||
xrootwin, /* parent */
|
|
||||||
x, /* x */
|
|
||||||
y, /* y */
|
|
||||||
Dx(r), /* width */
|
|
||||||
Dy(r), /* height */
|
|
||||||
0, /* border width */
|
|
||||||
_x.depth, /* depth */
|
|
||||||
InputOutput, /* class */
|
|
||||||
_x.vis, /* visual */
|
|
||||||
/* valuemask */
|
|
||||||
CWBackPixel|CWBorderPixel|CWColormap,
|
|
||||||
&attr /* attributes (the above aren't?!) */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Label and other properties required by ICCCCM.
|
|
||||||
*/
|
|
||||||
memset(&name, 0, sizeof name);
|
|
||||||
if(label == nil)
|
|
||||||
label = "pjw-face-here";
|
|
||||||
name.value = (uchar*)label;
|
|
||||||
name.encoding = XA_STRING;
|
|
||||||
name.format = 8;
|
|
||||||
name.nitems = strlen((char*)name.value);
|
|
||||||
|
|
||||||
memset(&normalhint, 0, sizeof normalhint);
|
|
||||||
normalhint.flags = PSize|PMaxSize;
|
|
||||||
if(winsize && winsize[0]){
|
|
||||||
normalhint.flags &= ~PSize;
|
|
||||||
normalhint.flags |= USSize;
|
|
||||||
normalhint.width = Dx(r);
|
|
||||||
normalhint.height = Dy(r);
|
|
||||||
}else{
|
|
||||||
if((mask & WidthValue) && (mask & HeightValue)){
|
|
||||||
normalhint.flags &= ~PSize;
|
|
||||||
normalhint.flags |= USSize;
|
|
||||||
normalhint.width = width;
|
|
||||||
normalhint.height = height;
|
|
||||||
}
|
|
||||||
if((mask & WidthValue) && (mask & HeightValue)){
|
|
||||||
normalhint.flags |= USPosition;
|
|
||||||
normalhint.x = x;
|
|
||||||
normalhint.y = y;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
normalhint.max_width = WidthOfScreen(xscreen);
|
|
||||||
normalhint.max_height = HeightOfScreen(xscreen);
|
|
||||||
|
|
||||||
memset(&hint, 0, sizeof hint);
|
|
||||||
hint.flags = InputHint|StateHint;
|
|
||||||
hint.input = 1;
|
|
||||||
hint.initial_state = NormalState;
|
|
||||||
|
|
||||||
memset(&classhint, 0, sizeof classhint);
|
|
||||||
classhint.res_name = label;
|
|
||||||
classhint.res_class = label;
|
|
||||||
|
|
||||||
argv[0] = label;
|
|
||||||
argv[1] = nil;
|
|
||||||
|
|
||||||
XSetWMProperties(
|
|
||||||
_x.display, /* display */
|
|
||||||
_x.drawable, /* window */
|
|
||||||
&name, /* XA_WM_NAME property */
|
|
||||||
&name, /* XA_WM_ICON_NAME property */
|
|
||||||
argv, /* XA_WM_COMMAND */
|
|
||||||
1, /* argc */
|
|
||||||
&normalhint, /* XA_WM_NORMAL_HINTS */
|
|
||||||
&hint, /* XA_WM_HINTS */
|
|
||||||
&classhint /* XA_WM_CLASSHINTS */
|
|
||||||
);
|
|
||||||
XFlush(_x.display);
|
|
||||||
|
|
||||||
if(havemin){
|
|
||||||
XWindowChanges ch;
|
|
||||||
|
|
||||||
memset(&ch, 0, sizeof ch);
|
|
||||||
ch.x = r.min.x;
|
|
||||||
ch.y = r.min.y;
|
|
||||||
XConfigureWindow(_x.display, _x.drawable, CWX|CWY, &ch);
|
|
||||||
/*
|
|
||||||
* Must pretend origin is 0,0 for X.
|
|
||||||
*/
|
|
||||||
r = Rect(0,0,Dx(r),Dy(r));
|
|
||||||
}
|
|
||||||
/*
|
|
||||||
* Look up clipboard atom.
|
|
||||||
*/
|
|
||||||
_x.clipboard = XInternAtom(_x.display, "CLIPBOARD", False);
|
|
||||||
_x.utf8string = XInternAtom(_x.display, "UTF8_STRING", False);
|
|
||||||
_x.targets = XInternAtom(_x.display, "TARGETS", False);
|
|
||||||
_x.text = XInternAtom(_x.display, "TEXT", False);
|
|
||||||
_x.compoundtext = XInternAtom(_x.display, "COMPOUND_TEXT", False);
|
|
||||||
_x.takefocus = XInternAtom(_x.display, "WM_TAKE_FOCUS", False);
|
|
||||||
_x.losefocus = XInternAtom(_x.display, "_9WM_LOSE_FOCUS", False);
|
|
||||||
_x.wmprotos = XInternAtom(_x.display, "WM_PROTOCOLS", False);
|
|
||||||
|
|
||||||
atoms[0] = _x.takefocus;
|
|
||||||
atoms[1] = _x.losefocus;
|
|
||||||
XChangeProperty(_x.display, _x.drawable, _x.wmprotos, XA_ATOM, 32,
|
|
||||||
PropModeReplace, (uchar*)atoms, 2);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put the window on the screen, check to see what size we actually got.
|
|
||||||
*/
|
|
||||||
XMapWindow(_x.display, _x.drawable);
|
|
||||||
XSync(_x.display, False);
|
|
||||||
|
|
||||||
if(!XGetWindowAttributes(_x.display, _x.drawable, &wattr))
|
|
||||||
fprint(2, "XGetWindowAttributes failed\n");
|
|
||||||
else if(wattr.width && wattr.height){
|
|
||||||
if(wattr.width != Dx(r) || wattr.height != Dy(r)){
|
|
||||||
r.max.x = wattr.width;
|
|
||||||
r.max.y = wattr.height;
|
|
||||||
}
|
|
||||||
}else
|
|
||||||
fprint(2, "XGetWindowAttributes: bad attrs\n");
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Allocate our local backing store.
|
|
||||||
*/
|
|
||||||
_x.screenr = r;
|
|
||||||
_x.screenpm = XCreatePixmap(_x.display, _x.drawable, Dx(r), Dy(r), _x.depth);
|
|
||||||
_x.nextscreenpm = _x.screenpm;
|
|
||||||
_x.screenimage = _xallocmemimage(r, _x.chan, _x.screenpm);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Allocate some useful graphics contexts for the future.
|
|
||||||
*/
|
|
||||||
_x.gcfill = xgc(_x.screenpm, FillSolid, -1);
|
|
||||||
_x.gccopy = xgc(_x.screenpm, -1, -1);
|
|
||||||
_x.gcsimplesrc = xgc(_x.screenpm, FillStippled, -1);
|
|
||||||
_x.gczero = xgc(_x.screenpm, -1, -1);
|
|
||||||
_x.gcreplsrc = xgc(_x.screenpm, FillTiled, -1);
|
|
||||||
|
|
||||||
pmid = XCreatePixmap(_x.display, _x.drawable, 1, 1, 1);
|
|
||||||
_x.gcfill0 = xgc(pmid, FillSolid, 0);
|
|
||||||
_x.gccopy0 = xgc(pmid, -1, -1);
|
|
||||||
_x.gcsimplesrc0 = xgc(pmid, FillStippled, -1);
|
|
||||||
_x.gczero0 = xgc(pmid, -1, -1);
|
|
||||||
_x.gcreplsrc0 = xgc(pmid, FillTiled, -1);
|
|
||||||
XFreePixmap(_x.display, pmid);
|
|
||||||
|
|
||||||
return _x.screenimage;
|
|
||||||
|
|
||||||
err0:
|
|
||||||
/*
|
|
||||||
* Should do a better job of cleaning up here.
|
|
||||||
*/
|
|
||||||
XCloseDisplay(_x.display);
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xsetlabel(char *label)
|
|
||||||
{
|
|
||||||
XTextProperty name;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Label and other properties required by ICCCCM.
|
|
||||||
*/
|
|
||||||
memset(&name, 0, sizeof name);
|
|
||||||
if(label == nil)
|
|
||||||
label = "pjw-face-here";
|
|
||||||
name.value = (uchar*)label;
|
|
||||||
name.encoding = XA_STRING;
|
|
||||||
name.format = 8;
|
|
||||||
name.nitems = strlen((char*)name.value);
|
|
||||||
|
|
||||||
XSetWMProperties(
|
|
||||||
_x.display, /* display */
|
|
||||||
_x.drawable, /* window */
|
|
||||||
&name, /* XA_WM_NAME property */
|
|
||||||
&name, /* XA_WM_ICON_NAME property */
|
|
||||||
nil, /* XA_WM_COMMAND */
|
|
||||||
0, /* argc */
|
|
||||||
nil, /* XA_WM_NORMAL_HINTS */
|
|
||||||
nil, /* XA_WM_HINTS */
|
|
||||||
nil /* XA_WM_CLASSHINTS */
|
|
||||||
);
|
|
||||||
XFlush(_x.display);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Create a GC with a particular fill style and XXX.
|
|
||||||
* Disable generation of GraphicsExpose/NoExpose events in the GC.
|
|
||||||
*/
|
|
||||||
static XGC
|
|
||||||
xgc(XDrawable d, int fillstyle, int foreground)
|
|
||||||
{
|
|
||||||
XGC gc;
|
|
||||||
XGCValues v;
|
|
||||||
|
|
||||||
memset(&v, 0, sizeof v);
|
|
||||||
v.function = GXcopy;
|
|
||||||
v.graphics_exposures = False;
|
|
||||||
gc = XCreateGC(_x.display, d, GCFunction|GCGraphicsExposures, &v);
|
|
||||||
if(fillstyle != -1)
|
|
||||||
XSetFillStyle(_x.display, gc, fillstyle);
|
|
||||||
if(foreground != -1)
|
|
||||||
XSetForeground(_x.display, gc, 0);
|
|
||||||
return gc;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize map with the Plan 9 rgbv color map.
|
|
||||||
*/
|
|
||||||
static void
|
|
||||||
plan9cmap(void)
|
|
||||||
{
|
|
||||||
int r, g, b, cr, cg, cb, v, num, den, idx, v7, idx7;
|
|
||||||
static int once;
|
|
||||||
|
|
||||||
if(once)
|
|
||||||
return;
|
|
||||||
once = 1;
|
|
||||||
|
|
||||||
for(r=0; r!=4; r++)
|
|
||||||
for(g = 0; g != 4; g++)
|
|
||||||
for(b = 0; b!=4; b++)
|
|
||||||
for(v = 0; v!=4; v++){
|
|
||||||
den=r;
|
|
||||||
if(g > den)
|
|
||||||
den=g;
|
|
||||||
if(b > den)
|
|
||||||
den=b;
|
|
||||||
/* divide check -- pick grey shades */
|
|
||||||
if(den==0)
|
|
||||||
cr=cg=cb=v*17;
|
|
||||||
else {
|
|
||||||
num=17*(4*den+v);
|
|
||||||
cr=r*num/den;
|
|
||||||
cg=g*num/den;
|
|
||||||
cb=b*num/den;
|
|
||||||
}
|
|
||||||
idx = r*64 + v*16 + ((g*4 + b + v - r) & 15);
|
|
||||||
_x.map[idx].red = cr*0x0101;
|
|
||||||
_x.map[idx].green = cg*0x0101;
|
|
||||||
_x.map[idx].blue = cb*0x0101;
|
|
||||||
_x.map[idx].pixel = idx;
|
|
||||||
_x.map[idx].flags = DoRed|DoGreen|DoBlue;
|
|
||||||
|
|
||||||
v7 = v >> 1;
|
|
||||||
idx7 = r*32 + v7*16 + g*4 + b;
|
|
||||||
if((v & 1) == v7){
|
|
||||||
_x.map7to8[idx7][0] = idx;
|
|
||||||
if(den == 0) { /* divide check -- pick grey shades */
|
|
||||||
cr = ((255.0/7.0)*v7)+0.5;
|
|
||||||
cg = cr;
|
|
||||||
cb = cr;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
num=17*15*(4*den+v7*2)/14;
|
|
||||||
cr=r*num/den;
|
|
||||||
cg=g*num/den;
|
|
||||||
cb=b*num/den;
|
|
||||||
}
|
|
||||||
_x.map7[idx7].red = cr*0x0101;
|
|
||||||
_x.map7[idx7].green = cg*0x0101;
|
|
||||||
_x.map7[idx7].blue = cb*0x0101;
|
|
||||||
_x.map7[idx7].pixel = idx7;
|
|
||||||
_x.map7[idx7].flags = DoRed|DoGreen|DoBlue;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
_x.map7to8[idx7][1] = idx;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize and install the rgbv color map as a private color map
|
|
||||||
* for this application. It gets the best colors when it has the
|
|
||||||
* cursor focus.
|
|
||||||
*
|
|
||||||
* We always choose the best depth possible, but that might not
|
|
||||||
* be the default depth. On such "suboptimal" systems, we have to allocate an
|
|
||||||
* empty color map anyway, according to Axel Belinfante.
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
setupcmap(XWindow w)
|
|
||||||
{
|
|
||||||
char buf[30];
|
|
||||||
int i;
|
|
||||||
u32int p, pp;
|
|
||||||
XColor c;
|
|
||||||
|
|
||||||
if(_x.depth <= 1)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
if(_x.depth >= 24) {
|
|
||||||
if(_x.usetable == 0)
|
|
||||||
_x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocNone);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The pixel value returned from XGetPixel needs to
|
|
||||||
* be converted to RGB so we can call rgb2cmap()
|
|
||||||
* to translate between 24 bit X and our color. Unfortunately,
|
|
||||||
* the return value appears to be display server endian
|
|
||||||
* dependant. Therefore, we run some heuristics to later
|
|
||||||
* determine how to mask the int value correctly.
|
|
||||||
* Yeah, I know we can look at _x.vis->byte_order but
|
|
||||||
* some displays say MSB even though they run on LSB.
|
|
||||||
* Besides, this is more anal.
|
|
||||||
*/
|
|
||||||
c = _x.map[19]; /* known to have different R, G, B values */
|
|
||||||
if(!XAllocColor(_x.display, _x.cmap, &c)){
|
|
||||||
werrstr("XAllocColor: %r");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
p = c.pixel;
|
|
||||||
pp = rgb2cmap((p>>16)&0xff,(p>>8)&0xff,p&0xff);
|
|
||||||
if(pp != _x.map[19].pixel) {
|
|
||||||
/* check if endian is other way */
|
|
||||||
pp = rgb2cmap(p&0xff,(p>>8)&0xff,(p>>16)&0xff);
|
|
||||||
if(pp != _x.map[19].pixel){
|
|
||||||
werrstr("cannot detect X server byte order");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
switch(_x.chan){
|
|
||||||
case RGB24:
|
|
||||||
_x.chan = BGR24;
|
|
||||||
break;
|
|
||||||
case XRGB32:
|
|
||||||
_x.chan = XBGR32;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
werrstr("cannot byteswap channel %s",
|
|
||||||
chantostr(buf, _x.chan));
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}else if(_x.vis->class == TrueColor || _x.vis->class == DirectColor){
|
|
||||||
/*
|
|
||||||
* Do nothing. We have no way to express a
|
|
||||||
* mixed-endian 16-bit screen, so pretend they don't exist.
|
|
||||||
*/
|
|
||||||
if(_x.usetable == 0)
|
|
||||||
_x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocNone);
|
|
||||||
}else if(_x.vis->class == PseudoColor){
|
|
||||||
if(_x.usetable == 0){
|
|
||||||
_x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocAll);
|
|
||||||
XStoreColors(_x.display, _x.cmap, _x.map, 256);
|
|
||||||
for(i = 0; i < 256; i++){
|
|
||||||
_x.tox11[i] = i;
|
|
||||||
_x.toplan9[i] = i;
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
for(i = 0; i < 128; i++){
|
|
||||||
c = _x.map7[i];
|
|
||||||
if(!XAllocColor(_x.display, _x.cmap, &c)){
|
|
||||||
werrstr("can't allocate colors in 7-bit map");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
_x.tox11[_x.map7to8[i][0]] = c.pixel;
|
|
||||||
_x.tox11[_x.map7to8[i][1]] = c.pixel;
|
|
||||||
_x.toplan9[c.pixel] = _x.map7to8[i][0];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
werrstr("unsupported visual class %d", _x.vis->class);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
_flushmemscreen(Rectangle r)
|
|
||||||
{
|
|
||||||
if(_x.nextscreenpm != _x.screenpm){
|
|
||||||
qlock(&_x.screenlock);
|
|
||||||
XSync(_x.display, False);
|
|
||||||
XFreePixmap(_x.display, _x.screenpm);
|
|
||||||
_x.screenpm = _x.nextscreenpm;
|
|
||||||
qunlock(&_x.screenlock);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(r.min.x >= r.max.x || r.min.y >= r.max.y)
|
|
||||||
return;
|
|
||||||
XCopyArea(_x.display, _x.screenpm, _x.drawable, _x.gccopy, r.min.x, r.min.y,
|
|
||||||
Dx(r), Dy(r), r.min.x, r.min.y);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
_xexpose(XEvent *e)
|
|
||||||
{
|
|
||||||
XExposeEvent *xe;
|
|
||||||
Rectangle r;
|
|
||||||
|
|
||||||
qlock(&_x.screenlock);
|
|
||||||
if(_x.screenpm != _x.nextscreenpm){
|
|
||||||
qunlock(&_x.screenlock);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
xe = (XExposeEvent*)e;
|
|
||||||
r.min.x = xe->x;
|
|
||||||
r.min.y = xe->y;
|
|
||||||
r.max.x = xe->x+xe->width;
|
|
||||||
r.max.y = xe->y+xe->height;
|
|
||||||
XCopyArea(_x.display, _x.screenpm, _x.drawable, _x.gccopy, r.min.x, r.min.y,
|
|
||||||
Dx(r), Dy(r), r.min.x, r.min.y);
|
|
||||||
XSync(_x.display, False);
|
|
||||||
qunlock(&_x.screenlock);
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xdestroy(XEvent *e)
|
|
||||||
{
|
|
||||||
XDestroyWindowEvent *xe;
|
|
||||||
|
|
||||||
xe = (XDestroyWindowEvent*)e;
|
|
||||||
if(xe->window == _x.drawable){
|
|
||||||
_x.destroyed = 1;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xconfigure(XEvent *e)
|
|
||||||
{
|
|
||||||
Rectangle r;
|
|
||||||
XConfigureEvent *xe = (XConfigureEvent*)e;
|
|
||||||
|
|
||||||
if(!fullscreen){
|
|
||||||
int rx, ry;
|
|
||||||
XWindow w;
|
|
||||||
if(XTranslateCoordinates(_x.display, _x.drawable, DefaultRootWindow(_x.display), 0, 0, &rx, &ry, &w))
|
|
||||||
windowrect = Rect(rx, ry, rx+xe->width, ry+xe->height);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(xe->width == Dx(_x.screenr) && xe->height == Dy(_x.screenr))
|
|
||||||
return 0;
|
|
||||||
r = Rect(0, 0, xe->width, xe->height);
|
|
||||||
|
|
||||||
qlock(&_x.screenlock);
|
|
||||||
if(_x.screenpm != _x.nextscreenpm){
|
|
||||||
XCopyArea(_x.display, _x.screenpm, _x.drawable, _x.gccopy, r.min.x, r.min.y,
|
|
||||||
Dx(r), Dy(r), r.min.x, r.min.y);
|
|
||||||
XSync(_x.display, False);
|
|
||||||
}
|
|
||||||
qunlock(&_x.screenlock);
|
|
||||||
_x.newscreenr = r;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xreplacescreenimage(void)
|
|
||||||
{
|
|
||||||
Memimage *m;
|
|
||||||
XDrawable pixmap;
|
|
||||||
Rectangle r;
|
|
||||||
|
|
||||||
r = _x.newscreenr;
|
|
||||||
|
|
||||||
pixmap = XCreatePixmap(_x.display, _x.drawable, Dx(r), Dy(r), _x.depth);
|
|
||||||
m = _xallocmemimage(r, _x.chan, pixmap);
|
|
||||||
if(_x.nextscreenpm != _x.screenpm)
|
|
||||||
XFreePixmap(_x.display, _x.nextscreenpm);
|
|
||||||
_x.nextscreenpm = pixmap;
|
|
||||||
_x.screenr = r;
|
|
||||||
gfx_replacescreenimage(m);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
@ -1,741 +0,0 @@
|
||||||
/* input event and data structure translation */
|
|
||||||
|
|
||||||
#include <u.h>
|
|
||||||
#include "x11-inc.h"
|
|
||||||
#ifdef __APPLE__
|
|
||||||
#define APPLESNARF
|
|
||||||
#define Boolean AppleBoolean
|
|
||||||
#define Rect AppleRect
|
|
||||||
#define EventMask AppleEventMask
|
|
||||||
#define Point ApplePoint
|
|
||||||
#define Cursor AppleCursor
|
|
||||||
#include <Carbon/Carbon.h>
|
|
||||||
AUTOFRAMEWORK(Carbon)
|
|
||||||
#undef Boolean
|
|
||||||
#undef Rect
|
|
||||||
#undef EventMask
|
|
||||||
#undef Point
|
|
||||||
#undef Cursor
|
|
||||||
#endif
|
|
||||||
#include <libc.h>
|
|
||||||
#include <draw.h>
|
|
||||||
#include <memdraw.h>
|
|
||||||
#include <mouse.h>
|
|
||||||
#include <cursor.h>
|
|
||||||
#include <keyboard.h>
|
|
||||||
#include "x11-memdraw.h"
|
|
||||||
#include "x11-keysym2ucs.h"
|
|
||||||
#undef time
|
|
||||||
|
|
||||||
static KeySym
|
|
||||||
__xtoplan9kbd(XEvent *e)
|
|
||||||
{
|
|
||||||
KeySym k;
|
|
||||||
|
|
||||||
if(e->xany.type != KeyPress)
|
|
||||||
return -1;
|
|
||||||
needstack(64*1024); /* X has some *huge* buffers in openobject */
|
|
||||||
/* and they're even bigger on SuSE */
|
|
||||||
XLookupString((XKeyEvent*)e,NULL,0,&k,NULL);
|
|
||||||
if(k == NoSymbol)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
if(k&0xFF00){
|
|
||||||
switch(k){
|
|
||||||
case XK_BackSpace:
|
|
||||||
case XK_Tab:
|
|
||||||
case XK_Escape:
|
|
||||||
case XK_Delete:
|
|
||||||
case XK_KP_0:
|
|
||||||
case XK_KP_1:
|
|
||||||
case XK_KP_2:
|
|
||||||
case XK_KP_3:
|
|
||||||
case XK_KP_4:
|
|
||||||
case XK_KP_5:
|
|
||||||
case XK_KP_6:
|
|
||||||
case XK_KP_7:
|
|
||||||
case XK_KP_8:
|
|
||||||
case XK_KP_9:
|
|
||||||
case XK_KP_Divide:
|
|
||||||
case XK_KP_Multiply:
|
|
||||||
case XK_KP_Subtract:
|
|
||||||
case XK_KP_Add:
|
|
||||||
case XK_KP_Decimal:
|
|
||||||
k &= 0x7F;
|
|
||||||
break;
|
|
||||||
case XK_Linefeed:
|
|
||||||
k = '\r';
|
|
||||||
break;
|
|
||||||
case XK_KP_Space:
|
|
||||||
k = ' ';
|
|
||||||
break;
|
|
||||||
case XK_Home:
|
|
||||||
case XK_KP_Home:
|
|
||||||
k = Khome;
|
|
||||||
break;
|
|
||||||
case XK_Left:
|
|
||||||
case XK_KP_Left:
|
|
||||||
k = Kleft;
|
|
||||||
break;
|
|
||||||
case XK_Up:
|
|
||||||
case XK_KP_Up:
|
|
||||||
k = Kup;
|
|
||||||
break;
|
|
||||||
case XK_Down:
|
|
||||||
case XK_KP_Down:
|
|
||||||
k = Kdown;
|
|
||||||
break;
|
|
||||||
case XK_Right:
|
|
||||||
case XK_KP_Right:
|
|
||||||
k = Kright;
|
|
||||||
break;
|
|
||||||
case XK_Page_Down:
|
|
||||||
case XK_KP_Page_Down:
|
|
||||||
k = Kpgdown;
|
|
||||||
break;
|
|
||||||
case XK_End:
|
|
||||||
case XK_KP_End:
|
|
||||||
k = Kend;
|
|
||||||
break;
|
|
||||||
case XK_Page_Up:
|
|
||||||
case XK_KP_Page_Up:
|
|
||||||
k = Kpgup;
|
|
||||||
break;
|
|
||||||
case XK_Insert:
|
|
||||||
case XK_KP_Insert:
|
|
||||||
k = Kins;
|
|
||||||
break;
|
|
||||||
case XK_KP_Enter:
|
|
||||||
case XK_Return:
|
|
||||||
k = '\n';
|
|
||||||
break;
|
|
||||||
case XK_Alt_L:
|
|
||||||
case XK_Meta_L: /* Shift Alt on PCs */
|
|
||||||
case XK_Alt_R:
|
|
||||||
case XK_Meta_R: /* Shift Alt on PCs */
|
|
||||||
case XK_Multi_key:
|
|
||||||
return -1;
|
|
||||||
default: /* not ISO-1 or tty control */
|
|
||||||
if(k>0xff) {
|
|
||||||
k = _p9keysym2ucs(k);
|
|
||||||
if(k==-1) return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Compensate for servers that call a minus a hyphen */
|
|
||||||
if(k == XK_hyphen)
|
|
||||||
k = XK_minus;
|
|
||||||
/* Do control mapping ourselves if translator doesn't */
|
|
||||||
if(e->xkey.state&ControlMask)
|
|
||||||
k &= 0x9f;
|
|
||||||
if(k == NoSymbol) {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return k+0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int alting;
|
|
||||||
|
|
||||||
void
|
|
||||||
abortcompose(void)
|
|
||||||
{
|
|
||||||
alting = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static Rune* sendrune(Rune);
|
|
||||||
|
|
||||||
extern int latin1(Rune*, int);
|
|
||||||
static Rune*
|
|
||||||
xtoplan9latin1(XEvent *e)
|
|
||||||
{
|
|
||||||
Rune r;
|
|
||||||
|
|
||||||
r = __xtoplan9kbd(e);
|
|
||||||
if(r == -1)
|
|
||||||
return nil;
|
|
||||||
return sendrune(r);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
sendalt(void)
|
|
||||||
{
|
|
||||||
sendrune(Kalt);
|
|
||||||
}
|
|
||||||
|
|
||||||
static Rune*
|
|
||||||
sendrune(Rune r)
|
|
||||||
{
|
|
||||||
static Rune k[10];
|
|
||||||
static int nk;
|
|
||||||
int n;
|
|
||||||
|
|
||||||
if(alting){
|
|
||||||
/*
|
|
||||||
* Kludge for Mac's X11 3-button emulation.
|
|
||||||
* It treats Command+Button as button 3, but also
|
|
||||||
* ends up sending XK_Meta_L twice.
|
|
||||||
*/
|
|
||||||
if(r == Kalt){
|
|
||||||
alting = 0;
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
k[nk++] = r;
|
|
||||||
n = latin1(k, nk);
|
|
||||||
if(n > 0){
|
|
||||||
alting = 0;
|
|
||||||
k[0] = n;
|
|
||||||
k[1] = 0;
|
|
||||||
return k;
|
|
||||||
}
|
|
||||||
if(n == -1){
|
|
||||||
alting = 0;
|
|
||||||
k[nk] = 0;
|
|
||||||
return k;
|
|
||||||
}
|
|
||||||
/* n < -1, need more input */
|
|
||||||
return nil;
|
|
||||||
}else if(r == Kalt){
|
|
||||||
alting = 1;
|
|
||||||
nk = 0;
|
|
||||||
return nil;
|
|
||||||
}else{
|
|
||||||
k[0] = r;
|
|
||||||
k[1] = 0;
|
|
||||||
return k;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xtoplan9kbd(XEvent *e)
|
|
||||||
{
|
|
||||||
static Rune *r;
|
|
||||||
|
|
||||||
if(e == (XEvent*)-1){
|
|
||||||
assert(r);
|
|
||||||
r--;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if(e)
|
|
||||||
r = xtoplan9latin1(e);
|
|
||||||
if(r && *r)
|
|
||||||
return *r++;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xtoplan9mouse(XEvent *e, Mouse *m)
|
|
||||||
{
|
|
||||||
int s;
|
|
||||||
XButtonEvent *be;
|
|
||||||
XMotionEvent *me;
|
|
||||||
|
|
||||||
if(_x.putsnarf != _x.assertsnarf){
|
|
||||||
_x.assertsnarf = _x.putsnarf;
|
|
||||||
XSetSelectionOwner(_x.display, XA_PRIMARY, _x.drawable, CurrentTime);
|
|
||||||
if(_x.clipboard != None)
|
|
||||||
XSetSelectionOwner(_x.display, _x.clipboard, _x.drawable, CurrentTime);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
switch(e->type){
|
|
||||||
case ButtonPress:
|
|
||||||
be = (XButtonEvent*)e;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Fake message, just sent to make us announce snarf.
|
|
||||||
* Apparently state and button are 16 and 8 bits on
|
|
||||||
* the wire, since they are truncated by the time they
|
|
||||||
* get to us.
|
|
||||||
*/
|
|
||||||
if(be->send_event
|
|
||||||
&& (~be->state&0xFFFF)==0
|
|
||||||
&& (~be->button&0xFF)==0)
|
|
||||||
return -1;
|
|
||||||
/* BUG? on mac need to inherit these from elsewhere? */
|
|
||||||
m->xy.x = be->x;
|
|
||||||
m->xy.y = be->y;
|
|
||||||
s = be->state;
|
|
||||||
m->msec = be->time;
|
|
||||||
switch(be->button){
|
|
||||||
case 1:
|
|
||||||
s |= Button1Mask;
|
|
||||||
break;
|
|
||||||
case 2:
|
|
||||||
s |= Button2Mask;
|
|
||||||
break;
|
|
||||||
case 3:
|
|
||||||
s |= Button3Mask;
|
|
||||||
break;
|
|
||||||
case 4:
|
|
||||||
s |= Button4Mask;
|
|
||||||
break;
|
|
||||||
case 5:
|
|
||||||
s |= Button5Mask;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ButtonRelease:
|
|
||||||
be = (XButtonEvent*)e;
|
|
||||||
m->xy.x = be->x;
|
|
||||||
m->xy.y = be->y;
|
|
||||||
s = be->state;
|
|
||||||
m->msec = be->time;
|
|
||||||
switch(be->button){
|
|
||||||
case 1:
|
|
||||||
s &= ~Button1Mask;
|
|
||||||
break;
|
|
||||||
case 2:
|
|
||||||
s &= ~Button2Mask;
|
|
||||||
break;
|
|
||||||
case 3:
|
|
||||||
s &= ~Button3Mask;
|
|
||||||
break;
|
|
||||||
case 4:
|
|
||||||
s &= ~Button4Mask;
|
|
||||||
break;
|
|
||||||
case 5:
|
|
||||||
s &= ~Button5Mask;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case MotionNotify:
|
|
||||||
me = (XMotionEvent*)e;
|
|
||||||
s = me->state;
|
|
||||||
m->xy.x = me->x;
|
|
||||||
m->xy.y = me->y;
|
|
||||||
m->msec = me->time;
|
|
||||||
return 0; // do not set buttons
|
|
||||||
|
|
||||||
default:
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
m->buttons = 0;
|
|
||||||
if(s & Button1Mask)
|
|
||||||
m->buttons |= 1;
|
|
||||||
if(s & Button2Mask)
|
|
||||||
m->buttons |= 2;
|
|
||||||
if(s & Button3Mask)
|
|
||||||
m->buttons |= 4;
|
|
||||||
if(s & Button4Mask)
|
|
||||||
m->buttons |= 8;
|
|
||||||
if(s & Button5Mask)
|
|
||||||
m->buttons |= 16;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
_xmoveto(Point p)
|
|
||||||
{
|
|
||||||
XWarpPointer(_x.display, None, _x.drawable, 0, 0, 0, 0, p.x, p.y);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
revbyte(int b)
|
|
||||||
{
|
|
||||||
int r;
|
|
||||||
|
|
||||||
r = 0;
|
|
||||||
r |= (b&0x01) << 7;
|
|
||||||
r |= (b&0x02) << 5;
|
|
||||||
r |= (b&0x04) << 3;
|
|
||||||
r |= (b&0x08) << 1;
|
|
||||||
r |= (b&0x10) >> 1;
|
|
||||||
r |= (b&0x20) >> 3;
|
|
||||||
r |= (b&0x40) >> 5;
|
|
||||||
r |= (b&0x80) >> 7;
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
xcursorarrow(void)
|
|
||||||
{
|
|
||||||
if(_x.cursor != 0){
|
|
||||||
XFreeCursor(_x.display, _x.cursor);
|
|
||||||
_x.cursor = 0;
|
|
||||||
}
|
|
||||||
XUndefineCursor(_x.display, _x.drawable);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void
|
|
||||||
_xsetcursor(Cursor *c)
|
|
||||||
{
|
|
||||||
XColor fg, bg;
|
|
||||||
XCursor xc;
|
|
||||||
Pixmap xsrc, xmask;
|
|
||||||
int i;
|
|
||||||
uchar src[2*16], mask[2*16];
|
|
||||||
|
|
||||||
if(c == nil){
|
|
||||||
xcursorarrow();
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
for(i=0; i<2*16; i++){
|
|
||||||
src[i] = revbyte(c->set[i]);
|
|
||||||
mask[i] = revbyte(c->set[i] | c->clr[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
fg = _x.map[0];
|
|
||||||
bg = _x.map[255];
|
|
||||||
xsrc = XCreateBitmapFromData(_x.display, _x.drawable, (char*)src, 16, 16);
|
|
||||||
xmask = XCreateBitmapFromData(_x.display, _x.drawable, (char*)mask, 16, 16);
|
|
||||||
xc = XCreatePixmapCursor(_x.display, xsrc, xmask, &fg, &bg, -c->offset.x, -c->offset.y);
|
|
||||||
if(xc != 0) {
|
|
||||||
XDefineCursor(_x.display, _x.drawable, xc);
|
|
||||||
if(_x.cursor != 0)
|
|
||||||
XFreeCursor(_x.display, _x.cursor);
|
|
||||||
_x.cursor = xc;
|
|
||||||
}
|
|
||||||
XFreePixmap(_x.display, xsrc);
|
|
||||||
XFreePixmap(_x.display, xmask);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
struct {
|
|
||||||
QLock lk;
|
|
||||||
char buf[SnarfSize];
|
|
||||||
#ifdef APPLESNARF
|
|
||||||
Rune rbuf[SnarfSize];
|
|
||||||
PasteboardRef apple;
|
|
||||||
#endif
|
|
||||||
} clip;
|
|
||||||
|
|
||||||
static uchar*
|
|
||||||
_xgetsnarffrom(XWindow w, Atom clipboard, Atom target, int timeout0, int timeout)
|
|
||||||
{
|
|
||||||
Atom prop, type;
|
|
||||||
ulong len, lastlen, dummy;
|
|
||||||
int fmt, i;
|
|
||||||
uchar *data, *xdata;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We should be waiting for SelectionNotify here, but it might never
|
|
||||||
* come, and we have no way to time out. Instead, we will clear
|
|
||||||
* local property #1, request our buddy to fill it in for us, and poll
|
|
||||||
* until he's done or we get tired of waiting.
|
|
||||||
*/
|
|
||||||
prop = 1;
|
|
||||||
XChangeProperty(_x.display, _x.drawable, prop, target, 8, PropModeReplace, (uchar*)"", 0);
|
|
||||||
XConvertSelection(_x.display, clipboard, target, prop, _x.drawable, CurrentTime);
|
|
||||||
XFlush(_x.display);
|
|
||||||
lastlen = 0;
|
|
||||||
timeout0 = (timeout0 + 9)/10;
|
|
||||||
timeout = (timeout + 9)/10;
|
|
||||||
for(i=0; i<timeout0 || (lastlen!=0 && i<timeout); i++){
|
|
||||||
usleep(10*1000);
|
|
||||||
XGetWindowProperty(_x.display, _x.drawable, prop, 0, 0, 0, AnyPropertyType,
|
|
||||||
&type, &fmt, &dummy, &len, &xdata);
|
|
||||||
if(lastlen == len && len > 0){
|
|
||||||
XFree(xdata);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
lastlen = len;
|
|
||||||
XFree(xdata);
|
|
||||||
}
|
|
||||||
if(len == 0)
|
|
||||||
return nil;
|
|
||||||
|
|
||||||
/* get the property */
|
|
||||||
xdata = nil;
|
|
||||||
XGetWindowProperty(_x.display, _x.drawable, prop, 0, SnarfSize/sizeof(ulong), 0,
|
|
||||||
AnyPropertyType, &type, &fmt, &len, &dummy, &xdata);
|
|
||||||
if((type != target && type != XA_STRING && type != _x.utf8string) || len == 0){
|
|
||||||
if(xdata)
|
|
||||||
XFree(xdata);
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
if(xdata){
|
|
||||||
data = (uchar*)strdup((char*)xdata);
|
|
||||||
XFree(xdata);
|
|
||||||
return data;
|
|
||||||
}
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
|
|
||||||
char*
|
|
||||||
_xgetsnarf(void)
|
|
||||||
{
|
|
||||||
uchar *data;
|
|
||||||
Atom clipboard;
|
|
||||||
XWindow w;
|
|
||||||
|
|
||||||
qlock(&clip.lk);
|
|
||||||
/*
|
|
||||||
* Have we snarfed recently and the X server hasn't caught up?
|
|
||||||
*/
|
|
||||||
if(_x.putsnarf != _x.assertsnarf)
|
|
||||||
goto mine;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Is there a primary selection (highlighted text in an xterm)?
|
|
||||||
*/
|
|
||||||
clipboard = XA_PRIMARY;
|
|
||||||
w = XGetSelectionOwner(_x.display, XA_PRIMARY);
|
|
||||||
if(w == _x.drawable){
|
|
||||||
mine:
|
|
||||||
data = (uchar*)strdup(clip.buf);
|
|
||||||
goto out;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If not, is there a clipboard selection?
|
|
||||||
*/
|
|
||||||
if(w == None && _x.clipboard != None){
|
|
||||||
clipboard = _x.clipboard;
|
|
||||||
w = XGetSelectionOwner(_x.display, _x.clipboard);
|
|
||||||
if(w == _x.drawable)
|
|
||||||
goto mine;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If not, give up.
|
|
||||||
*/
|
|
||||||
if(w == None){
|
|
||||||
data = nil;
|
|
||||||
goto out;
|
|
||||||
}
|
|
||||||
|
|
||||||
if((data = _xgetsnarffrom(w, clipboard, _x.utf8string, 10, 100)) == nil)
|
|
||||||
if((data = _xgetsnarffrom(w, clipboard, XA_STRING, 10, 100)) == nil){
|
|
||||||
/* nothing left to do */
|
|
||||||
}
|
|
||||||
|
|
||||||
out:
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return (char*)data;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
__xputsnarf(char *data)
|
|
||||||
{
|
|
||||||
XButtonEvent e;
|
|
||||||
|
|
||||||
if(strlen(data) >= SnarfSize)
|
|
||||||
return;
|
|
||||||
qlock(&clip.lk);
|
|
||||||
strcpy(clip.buf, data);
|
|
||||||
/* leave note for mouse proc to assert selection ownership */
|
|
||||||
_x.putsnarf++;
|
|
||||||
|
|
||||||
/* send mouse a fake event so snarf is announced */
|
|
||||||
memset(&e, 0, sizeof e);
|
|
||||||
e.type = ButtonPress;
|
|
||||||
e.window = _x.drawable;
|
|
||||||
e.state = ~0;
|
|
||||||
e.button = ~0;
|
|
||||||
XSendEvent(_x.display, _x.drawable, True, ButtonPressMask, (XEvent*)&e);
|
|
||||||
XFlush(_x.display);
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
_xselect(XEvent *e)
|
|
||||||
{
|
|
||||||
char *name;
|
|
||||||
XEvent r;
|
|
||||||
XSelectionRequestEvent *xe;
|
|
||||||
Atom a[4];
|
|
||||||
|
|
||||||
memset(&r, 0, sizeof r);
|
|
||||||
xe = (XSelectionRequestEvent*)e;
|
|
||||||
if(0) fprint(2, "xselect target=%d requestor=%d property=%d selection=%d (sizeof atom=%d)\n",
|
|
||||||
xe->target, xe->requestor, xe->property, xe->selection, sizeof a[0]);
|
|
||||||
r.xselection.property = xe->property;
|
|
||||||
if(xe->target == _x.targets){
|
|
||||||
a[0] = _x.utf8string;
|
|
||||||
a[1] = XA_STRING;
|
|
||||||
a[2] = _x.text;
|
|
||||||
a[3] = _x.compoundtext;
|
|
||||||
XChangeProperty(_x.display, xe->requestor, xe->property, XA_ATOM,
|
|
||||||
32, PropModeReplace, (uchar*)a, nelem(a));
|
|
||||||
}else if(xe->target == XA_STRING
|
|
||||||
|| xe->target == _x.utf8string
|
|
||||||
|| xe->target == _x.text
|
|
||||||
|| xe->target == _x.compoundtext
|
|
||||||
|| ((name = XGetAtomName(_x.display, xe->target)) && strcmp(name, "text/plain;charset=UTF-8") == 0)){
|
|
||||||
/* text/plain;charset=UTF-8 seems nonstandard but is used by Synergy */
|
|
||||||
/* if the target is STRING we're supposed to reply with Latin1 XXX */
|
|
||||||
qlock(&clip.lk);
|
|
||||||
XChangeProperty(_x.display, xe->requestor, xe->property, xe->target,
|
|
||||||
8, PropModeReplace, (uchar*)clip.buf, strlen(clip.buf));
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
}else{
|
|
||||||
if(strcmp(name, "TIMESTAMP") != 0)
|
|
||||||
fprint(2, "%s: cannot handle selection request for '%s' (%d)\n", argv0, name, (int)xe->target);
|
|
||||||
r.xselection.property = None;
|
|
||||||
}
|
|
||||||
|
|
||||||
r.xselection.display = xe->display;
|
|
||||||
/* r.xselection.property filled above */
|
|
||||||
r.xselection.target = xe->target;
|
|
||||||
r.xselection.type = SelectionNotify;
|
|
||||||
r.xselection.requestor = xe->requestor;
|
|
||||||
r.xselection.time = xe->time;
|
|
||||||
r.xselection.send_event = True;
|
|
||||||
r.xselection.selection = xe->selection;
|
|
||||||
XSendEvent(_x.display, xe->requestor, False, 0, &r);
|
|
||||||
XFlush(_x.display);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef APPLESNARF
|
|
||||||
char*
|
|
||||||
_applegetsnarf(void)
|
|
||||||
{
|
|
||||||
char *s, *t;
|
|
||||||
CFArrayRef flavors;
|
|
||||||
CFDataRef data;
|
|
||||||
CFIndex nflavor, ndata, j;
|
|
||||||
CFStringRef type;
|
|
||||||
ItemCount nitem;
|
|
||||||
PasteboardItemID id;
|
|
||||||
PasteboardSyncFlags flags;
|
|
||||||
UInt32 i;
|
|
||||||
|
|
||||||
/* fprint(2, "applegetsnarf\n"); */
|
|
||||||
qlock(&clip.lk);
|
|
||||||
if(clip.apple == nil){
|
|
||||||
if(PasteboardCreate(kPasteboardClipboard, &clip.apple) != noErr){
|
|
||||||
fprint(2, "apple pasteboard create failed\n");
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
flags = PasteboardSynchronize(clip.apple);
|
|
||||||
if(flags&kPasteboardClientIsOwner){
|
|
||||||
s = strdup(clip.buf);
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
if(PasteboardGetItemCount(clip.apple, &nitem) != noErr){
|
|
||||||
fprint(2, "apple pasteboard get item count failed\n");
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
for(i=1; i<=nitem; i++){
|
|
||||||
if(PasteboardGetItemIdentifier(clip.apple, i, &id) != noErr)
|
|
||||||
continue;
|
|
||||||
if(PasteboardCopyItemFlavors(clip.apple, id, &flavors) != noErr)
|
|
||||||
continue;
|
|
||||||
nflavor = CFArrayGetCount(flavors);
|
|
||||||
for(j=0; j<nflavor; j++){
|
|
||||||
type = (CFStringRef)CFArrayGetValueAtIndex(flavors, j);
|
|
||||||
if(!UTTypeConformsTo(type, CFSTR("public.utf16-plain-text")))
|
|
||||||
continue;
|
|
||||||
if(PasteboardCopyItemFlavorData(clip.apple, id, type, &data) != noErr)
|
|
||||||
continue;
|
|
||||||
ndata = CFDataGetLength(data);
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
s = smprint("%.*S", ndata/2, (Rune*)CFDataGetBytePtr(data));
|
|
||||||
CFRelease(flavors);
|
|
||||||
CFRelease(data);
|
|
||||||
for(t=s; *t; t++)
|
|
||||||
if(*t == '\r')
|
|
||||||
*t = '\n';
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
CFRelease(flavors);
|
|
||||||
}
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return nil;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
_appleputsnarf(char *s)
|
|
||||||
{
|
|
||||||
CFDataRef cfdata;
|
|
||||||
PasteboardSyncFlags flags;
|
|
||||||
|
|
||||||
/* fprint(2, "appleputsnarf\n"); */
|
|
||||||
|
|
||||||
if(strlen(s) >= SnarfSize)
|
|
||||||
return;
|
|
||||||
qlock(&clip.lk);
|
|
||||||
strcpy(clip.buf, s);
|
|
||||||
runesnprint(clip.rbuf, nelem(clip.rbuf), "%s", s);
|
|
||||||
if(clip.apple == nil){
|
|
||||||
if(PasteboardCreate(kPasteboardClipboard, &clip.apple) != noErr){
|
|
||||||
fprint(2, "apple pasteboard create failed\n");
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(PasteboardClear(clip.apple) != noErr){
|
|
||||||
fprint(2, "apple pasteboard clear failed\n");
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
flags = PasteboardSynchronize(clip.apple);
|
|
||||||
if((flags&kPasteboardModified) || !(flags&kPasteboardClientIsOwner)){
|
|
||||||
fprint(2, "apple pasteboard cannot assert ownership\n");
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
cfdata = CFDataCreate(kCFAllocatorDefault,
|
|
||||||
(uchar*)clip.rbuf, runestrlen(clip.rbuf)*2);
|
|
||||||
if(cfdata == nil){
|
|
||||||
fprint(2, "apple pasteboard cfdatacreate failed\n");
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if(PasteboardPutItemFlavor(clip.apple, (PasteboardItemID)1,
|
|
||||||
CFSTR("public.utf16-plain-text"), cfdata, 0) != noErr){
|
|
||||||
fprint(2, "apple pasteboard putitem failed\n");
|
|
||||||
CFRelease(cfdata);
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
/* CFRelease(cfdata); ??? */
|
|
||||||
qunlock(&clip.lk);
|
|
||||||
}
|
|
||||||
#endif /* APPLESNARF */
|
|
||||||
|
|
||||||
void
|
|
||||||
_xputsnarf(char *data)
|
|
||||||
{
|
|
||||||
#ifdef APPLESNARF
|
|
||||||
_appleputsnarf(data);
|
|
||||||
#endif
|
|
||||||
__xputsnarf(data);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Send the mouse event back to the window manager.
|
|
||||||
* So that 9term can tell rio to pop up its button3 menu.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
_xbouncemouse(Mouse *m)
|
|
||||||
{
|
|
||||||
XButtonEvent e;
|
|
||||||
XWindow dw;
|
|
||||||
|
|
||||||
e.type = ButtonPress;
|
|
||||||
e.state = 0;
|
|
||||||
e.button = 0;
|
|
||||||
if(m->buttons&1)
|
|
||||||
e.button = 1;
|
|
||||||
else if(m->buttons&2)
|
|
||||||
e.button = 2;
|
|
||||||
else if(m->buttons&4)
|
|
||||||
e.button = 3;
|
|
||||||
e.same_screen = 1;
|
|
||||||
XTranslateCoordinates(_x.display, _x.drawable,
|
|
||||||
DefaultRootWindow(_x.display),
|
|
||||||
m->xy.x, m->xy.y, &e.x_root, &e.y_root, &dw);
|
|
||||||
e.root = DefaultRootWindow(_x.display);
|
|
||||||
e.window = e.root;
|
|
||||||
e.subwindow = None;
|
|
||||||
e.x = e.x_root;
|
|
||||||
e.y = e.y_root;
|
|
||||||
#undef time
|
|
||||||
e.time = CurrentTime;
|
|
||||||
XUngrabPointer(_x.display, m->msec);
|
|
||||||
XSendEvent(_x.display, e.root, True, ButtonPressMask, (XEvent*)&e);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
@ -4,6 +4,7 @@
|
||||||
|
|
||||||
typedef struct Xmem Xmem;
|
typedef struct Xmem Xmem;
|
||||||
typedef struct Xprivate Xprivate;
|
typedef struct Xprivate Xprivate;
|
||||||
|
typedef struct Xwin Xwin;
|
||||||
|
|
||||||
enum
|
enum
|
||||||
{
|
{
|
||||||
|
|
@ -26,7 +27,6 @@ struct Xprivate {
|
||||||
XDisplay *display;
|
XDisplay *display;
|
||||||
int fd; /* of display */
|
int fd; /* of display */
|
||||||
int depth; /* of screen */
|
int depth; /* of screen */
|
||||||
XDrawable drawable;
|
|
||||||
XColor map[256];
|
XColor map[256];
|
||||||
XColor map7[128];
|
XColor map7[128];
|
||||||
uchar map7to8[128][2];
|
uchar map7to8[128][2];
|
||||||
|
|
@ -50,12 +50,6 @@ struct Xprivate {
|
||||||
u32int gczeropixmap;
|
u32int gczeropixmap;
|
||||||
XGC gczero0;
|
XGC gczero0;
|
||||||
u32int gczero0pixmap;
|
u32int gczero0pixmap;
|
||||||
Rectangle newscreenr;
|
|
||||||
Memimage* screenimage;
|
|
||||||
QLock screenlock;
|
|
||||||
XDrawable screenpm;
|
|
||||||
XDrawable nextscreenpm;
|
|
||||||
Rectangle screenr;
|
|
||||||
int toplan9[256];
|
int toplan9[256];
|
||||||
int tox11[256];
|
int tox11[256];
|
||||||
int usetable;
|
int usetable;
|
||||||
|
|
@ -70,9 +64,35 @@ struct Xprivate {
|
||||||
Atom wmprotos;
|
Atom wmprotos;
|
||||||
uint putsnarf;
|
uint putsnarf;
|
||||||
uint assertsnarf;
|
uint assertsnarf;
|
||||||
int destroyed;
|
int kbuttons;
|
||||||
|
int kstate;
|
||||||
|
int altdown;
|
||||||
|
|
||||||
|
Xwin* windows;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
struct Client;
|
||||||
|
|
||||||
|
struct Xwin
|
||||||
|
{
|
||||||
|
XDrawable drawable;
|
||||||
|
struct Client* client;
|
||||||
|
|
||||||
|
Rectangle newscreenr;
|
||||||
|
Memimage* screenimage;
|
||||||
|
XDrawable screenpm;
|
||||||
|
XDrawable nextscreenpm;
|
||||||
|
Rectangle screenr;
|
||||||
|
Rectangle screenrect;
|
||||||
|
Rectangle windowrect;
|
||||||
|
int fullscreen;
|
||||||
|
int destroyed;
|
||||||
|
|
||||||
|
Xwin* next;
|
||||||
|
};
|
||||||
|
|
||||||
|
void xlock(void);
|
||||||
|
void xunlock(void);
|
||||||
extern Xprivate _x;
|
extern Xprivate _x;
|
||||||
|
|
||||||
extern Memimage *_xallocmemimage(Rectangle, u32int, int);
|
extern Memimage *_xallocmemimage(Rectangle, u32int, int);
|
||||||
|
|
@ -83,35 +103,3 @@ extern void _xfreexdata(Memimage*);
|
||||||
extern XImage *_xgetxdata(Memimage*, Rectangle);
|
extern XImage *_xgetxdata(Memimage*, Rectangle);
|
||||||
extern void _xputxdata(Memimage*, Rectangle);
|
extern void _xputxdata(Memimage*, Rectangle);
|
||||||
|
|
||||||
struct Mouse;
|
|
||||||
extern int _xtoplan9mouse(XEvent*, struct Mouse*);
|
|
||||||
extern int _xtoplan9kbd(XEvent*);
|
|
||||||
extern void _xexpose(XEvent*);
|
|
||||||
extern int _xselect(XEvent*);
|
|
||||||
extern int _xconfigure(XEvent*);
|
|
||||||
extern int _xdestroy(XEvent*);
|
|
||||||
extern void _flushmemscreen(Rectangle);
|
|
||||||
extern void _xmoveto(Point);
|
|
||||||
struct Cursor;
|
|
||||||
extern void _xsetcursor(struct Cursor*);
|
|
||||||
extern void _xbouncemouse(Mouse*);
|
|
||||||
extern int _xsetlabel(char*);
|
|
||||||
extern Memimage* _xattach(char*, char*);
|
|
||||||
extern char* _xgetsnarf(void);
|
|
||||||
extern void _xputsnarf(char *data);
|
|
||||||
extern void _xtopwindow(void);
|
|
||||||
extern void _xresizewindow(Rectangle);
|
|
||||||
extern void _xmovewindow(Rectangle);
|
|
||||||
extern int _xreplacescreenimage(void);
|
|
||||||
|
|
||||||
#define MouseMask (\
|
|
||||||
ButtonPressMask|\
|
|
||||||
ButtonReleaseMask|\
|
|
||||||
PointerMotionMask|\
|
|
||||||
Button1MotionMask|\
|
|
||||||
Button2MotionMask|\
|
|
||||||
Button3MotionMask)
|
|
||||||
|
|
||||||
extern Rectangle screenrect;
|
|
||||||
extern Rectangle windowrect;
|
|
||||||
extern int fullscreen;
|
|
||||||
|
|
|
||||||
1759
src/cmd/devdraw/x11-screen.c
Normal file
1759
src/cmd/devdraw/x11-screen.c
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -1,637 +0,0 @@
|
||||||
/*
|
|
||||||
* Window system protocol server.
|
|
||||||
* Use select and a single proc and single stack
|
|
||||||
* to avoid aggravating the X11 library, which is
|
|
||||||
* subtle and quick to anger.
|
|
||||||
*/
|
|
||||||
|
|
||||||
// #define SHOWEVENT
|
|
||||||
|
|
||||||
#include <u.h>
|
|
||||||
#include <sys/select.h>
|
|
||||||
#include <errno.h>
|
|
||||||
#ifdef SHOWEVENT
|
|
||||||
#include <stdio.h>
|
|
||||||
#endif
|
|
||||||
#include "x11-inc.h"
|
|
||||||
|
|
||||||
#include <libc.h>
|
|
||||||
#include <draw.h>
|
|
||||||
#include <memdraw.h>
|
|
||||||
#include <memlayer.h>
|
|
||||||
#include <keyboard.h>
|
|
||||||
#include <mouse.h>
|
|
||||||
#include <cursor.h>
|
|
||||||
#include <drawfcall.h>
|
|
||||||
#include "x11-memdraw.h"
|
|
||||||
#include "devdraw.h"
|
|
||||||
|
|
||||||
#undef time
|
|
||||||
|
|
||||||
#define MouseMask (\
|
|
||||||
ButtonPressMask|\
|
|
||||||
ButtonReleaseMask|\
|
|
||||||
PointerMotionMask|\
|
|
||||||
Button1MotionMask|\
|
|
||||||
Button2MotionMask|\
|
|
||||||
Button3MotionMask)
|
|
||||||
|
|
||||||
#define Mask MouseMask|ExposureMask|StructureNotifyMask|KeyPressMask|KeyReleaseMask|EnterWindowMask|LeaveWindowMask|FocusChangeMask
|
|
||||||
|
|
||||||
typedef struct Kbdbuf Kbdbuf;
|
|
||||||
typedef struct Mousebuf Mousebuf;
|
|
||||||
typedef struct Fdbuf Fdbuf;
|
|
||||||
typedef struct Tagbuf Tagbuf;
|
|
||||||
|
|
||||||
struct Kbdbuf
|
|
||||||
{
|
|
||||||
Rune r[32];
|
|
||||||
int ri;
|
|
||||||
int wi;
|
|
||||||
int stall;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Mousebuf
|
|
||||||
{
|
|
||||||
Mouse m[32];
|
|
||||||
int ri;
|
|
||||||
int wi;
|
|
||||||
int stall;
|
|
||||||
int resized;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Tagbuf
|
|
||||||
{
|
|
||||||
int t[32];
|
|
||||||
int ri;
|
|
||||||
int wi;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Fdbuf
|
|
||||||
{
|
|
||||||
uchar buf[2*MAXWMSG];
|
|
||||||
uchar *rp;
|
|
||||||
uchar *wp;
|
|
||||||
uchar *ep;
|
|
||||||
};
|
|
||||||
|
|
||||||
Kbdbuf kbd;
|
|
||||||
Mousebuf mouse;
|
|
||||||
Fdbuf fdin;
|
|
||||||
Fdbuf fdout;
|
|
||||||
Tagbuf kbdtags;
|
|
||||||
Tagbuf mousetags;
|
|
||||||
|
|
||||||
void fdslide(Fdbuf*);
|
|
||||||
void runmsg(Wsysmsg*);
|
|
||||||
void replymsg(Wsysmsg*);
|
|
||||||
void runxevent(XEvent*);
|
|
||||||
void matchkbd(void);
|
|
||||||
void matchmouse(void);
|
|
||||||
int fdnoblock(int);
|
|
||||||
|
|
||||||
int chatty;
|
|
||||||
int drawsleep;
|
|
||||||
int fullscreen;
|
|
||||||
|
|
||||||
Rectangle windowrect;
|
|
||||||
Rectangle screenrect;
|
|
||||||
|
|
||||||
void
|
|
||||||
usage(void)
|
|
||||||
{
|
|
||||||
fprint(2, "usage: devdraw (don't run directly)\n");
|
|
||||||
exits("usage");
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
bell(void *v, char *msg)
|
|
||||||
{
|
|
||||||
if(strcmp(msg, "alarm") == 0)
|
|
||||||
drawsleep = drawsleep ? 0 : 1000;
|
|
||||||
noted(NCONT);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
main(int argc, char **argv)
|
|
||||||
{
|
|
||||||
int n, top, firstx;
|
|
||||||
fd_set rd, wr, xx;
|
|
||||||
Wsysmsg m;
|
|
||||||
XEvent event;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Move the protocol off stdin/stdout so that
|
|
||||||
* any inadvertent prints don't screw things up.
|
|
||||||
*/
|
|
||||||
dup(0, 3);
|
|
||||||
dup(1, 4);
|
|
||||||
close(0);
|
|
||||||
close(1);
|
|
||||||
open("/dev/null", OREAD);
|
|
||||||
open("/dev/null", OWRITE);
|
|
||||||
|
|
||||||
/* reopens stdout if debugging */
|
|
||||||
runxevent(0);
|
|
||||||
|
|
||||||
fmtinstall('W', drawfcallfmt);
|
|
||||||
|
|
||||||
ARGBEGIN{
|
|
||||||
case 'D':
|
|
||||||
chatty++;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
usage();
|
|
||||||
}ARGEND
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Ignore arguments. They're only for good ps -a listings.
|
|
||||||
*/
|
|
||||||
|
|
||||||
notify(bell);
|
|
||||||
|
|
||||||
fdin.rp = fdin.wp = fdin.buf;
|
|
||||||
fdin.ep = fdin.buf+sizeof fdin.buf;
|
|
||||||
|
|
||||||
fdout.rp = fdout.wp = fdout.buf;
|
|
||||||
fdout.ep = fdout.buf+sizeof fdout.buf;
|
|
||||||
|
|
||||||
fdnoblock(3);
|
|
||||||
fdnoblock(4);
|
|
||||||
|
|
||||||
firstx = 1;
|
|
||||||
_x.fd = -1;
|
|
||||||
for(;;){
|
|
||||||
/* set up file descriptors */
|
|
||||||
FD_ZERO(&rd);
|
|
||||||
FD_ZERO(&wr);
|
|
||||||
FD_ZERO(&xx);
|
|
||||||
/*
|
|
||||||
* Don't read unless there's room *and* we haven't
|
|
||||||
* already filled the output buffer too much.
|
|
||||||
*/
|
|
||||||
if(fdout.wp < fdout.buf+MAXWMSG && fdin.wp < fdin.ep)
|
|
||||||
FD_SET(3, &rd);
|
|
||||||
if(fdout.wp > fdout.rp)
|
|
||||||
FD_SET(4, &wr);
|
|
||||||
FD_SET(3, &xx);
|
|
||||||
FD_SET(4, &xx);
|
|
||||||
top = 4;
|
|
||||||
if(_x.fd >= 0){
|
|
||||||
if(firstx){
|
|
||||||
firstx = 0;
|
|
||||||
XSelectInput(_x.display, _x.drawable, Mask);
|
|
||||||
}
|
|
||||||
FD_SET(_x.fd, &rd);
|
|
||||||
FD_SET(_x.fd, &xx);
|
|
||||||
XFlush(_x.display);
|
|
||||||
if(_x.fd > top)
|
|
||||||
top = _x.fd;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(chatty)
|
|
||||||
fprint(2, "select %d...\n", top+1);
|
|
||||||
/* wait for something to happen */
|
|
||||||
again:
|
|
||||||
if(select(top+1, &rd, &wr, &xx, NULL) < 0){
|
|
||||||
if(errno == EINTR)
|
|
||||||
goto again;
|
|
||||||
if(chatty)
|
|
||||||
fprint(2, "select failure\n");
|
|
||||||
exits(0);
|
|
||||||
}
|
|
||||||
if(chatty)
|
|
||||||
fprint(2, "got select...\n");
|
|
||||||
|
|
||||||
{
|
|
||||||
/* read what we can */
|
|
||||||
n = 1;
|
|
||||||
while(fdin.wp < fdin.ep && (n = read(3, fdin.wp, fdin.ep-fdin.wp)) > 0)
|
|
||||||
fdin.wp += n;
|
|
||||||
if(n == 0){
|
|
||||||
if(chatty)
|
|
||||||
fprint(2, "eof\n");
|
|
||||||
exits(0);
|
|
||||||
}
|
|
||||||
if(n < 0 && errno != EAGAIN)
|
|
||||||
sysfatal("reading wsys msg: %r");
|
|
||||||
|
|
||||||
/* pick off messages one by one */
|
|
||||||
while((n = convM2W(fdin.rp, fdin.wp-fdin.rp, &m)) > 0){
|
|
||||||
/* fprint(2, "<- %W\n", &m); */
|
|
||||||
runmsg(&m);
|
|
||||||
fdin.rp += n;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* slide data to beginning of buf */
|
|
||||||
fdslide(&fdin);
|
|
||||||
}
|
|
||||||
{
|
|
||||||
/* write what we can */
|
|
||||||
n = 1;
|
|
||||||
while(fdout.rp < fdout.wp && (n = write(4, fdout.rp, fdout.wp-fdout.rp)) > 0)
|
|
||||||
fdout.rp += n;
|
|
||||||
if(n == 0)
|
|
||||||
sysfatal("short write writing wsys");
|
|
||||||
if(n < 0 && errno != EAGAIN)
|
|
||||||
sysfatal("writing wsys msg: %r");
|
|
||||||
|
|
||||||
/* slide data to beginning of buf */
|
|
||||||
fdslide(&fdout);
|
|
||||||
}
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* Read an X message if we can.
|
|
||||||
* (XPending actually calls select to make sure
|
|
||||||
* the display's fd is readable and then reads
|
|
||||||
* in any waiting data before declaring whether
|
|
||||||
* there are events on the queue.)
|
|
||||||
*/
|
|
||||||
while(XPending(_x.display)){
|
|
||||||
XNextEvent(_x.display, &event);
|
|
||||||
runxevent(&event);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
fdnoblock(int fd)
|
|
||||||
{
|
|
||||||
return fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
fdslide(Fdbuf *fb)
|
|
||||||
{
|
|
||||||
int n;
|
|
||||||
|
|
||||||
n = fb->wp - fb->rp;
|
|
||||||
if(n > 0)
|
|
||||||
memmove(fb->buf, fb->rp, n);
|
|
||||||
fb->rp = fb->buf;
|
|
||||||
fb->wp = fb->rp+n;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
replyerror(Wsysmsg *m)
|
|
||||||
{
|
|
||||||
char err[256];
|
|
||||||
|
|
||||||
rerrstr(err, sizeof err);
|
|
||||||
m->type = Rerror;
|
|
||||||
m->error = err;
|
|
||||||
replymsg(m);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Handle a single wsysmsg.
|
|
||||||
* Might queue for later (kbd, mouse read)
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
runmsg(Wsysmsg *m)
|
|
||||||
{
|
|
||||||
uchar buf[65536];
|
|
||||||
int n;
|
|
||||||
Memimage *i;
|
|
||||||
|
|
||||||
switch(m->type){
|
|
||||||
case Tinit:
|
|
||||||
memimageinit();
|
|
||||||
i = _xattach(m->label, m->winsize);
|
|
||||||
_initdisplaymemimage(i);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Trdmouse:
|
|
||||||
mousetags.t[mousetags.wi++] = m->tag;
|
|
||||||
if(mousetags.wi == nelem(mousetags.t))
|
|
||||||
mousetags.wi = 0;
|
|
||||||
if(mousetags.wi == mousetags.ri)
|
|
||||||
sysfatal("too many queued mouse reads");
|
|
||||||
/* fprint(2, "mouse unstall\n"); */
|
|
||||||
mouse.stall = 0;
|
|
||||||
matchmouse();
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Trdkbd:
|
|
||||||
kbdtags.t[kbdtags.wi++] = m->tag;
|
|
||||||
if(kbdtags.wi == nelem(kbdtags.t))
|
|
||||||
kbdtags.wi = 0;
|
|
||||||
if(kbdtags.wi == kbdtags.ri)
|
|
||||||
sysfatal("too many queued keyboard reads");
|
|
||||||
kbd.stall = 0;
|
|
||||||
matchkbd();
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Tmoveto:
|
|
||||||
_xmoveto(m->mouse.xy);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Tcursor:
|
|
||||||
case Tcursor2:
|
|
||||||
if(m->arrowcursor)
|
|
||||||
_xsetcursor(nil);
|
|
||||||
else
|
|
||||||
_xsetcursor(&m->cursor);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Tbouncemouse:
|
|
||||||
_xbouncemouse(&m->mouse);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Tlabel:
|
|
||||||
_xsetlabel(m->label);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Trdsnarf:
|
|
||||||
m->snarf = _xgetsnarf();
|
|
||||||
replymsg(m);
|
|
||||||
free(m->snarf);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Twrsnarf:
|
|
||||||
_xputsnarf(m->snarf);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Trddraw:
|
|
||||||
n = m->count;
|
|
||||||
if(n > sizeof buf)
|
|
||||||
n = sizeof buf;
|
|
||||||
n = draw_dataread(buf, n);
|
|
||||||
if(n < 0)
|
|
||||||
replyerror(m);
|
|
||||||
else{
|
|
||||||
m->count = n;
|
|
||||||
m->data = buf;
|
|
||||||
replymsg(m);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Twrdraw:
|
|
||||||
if(draw_datawrite(m->data, m->count) < 0)
|
|
||||||
replyerror(m);
|
|
||||||
else
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Ttop:
|
|
||||||
_xtopwindow();
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case Tresize:
|
|
||||||
_xresizewindow(m->rect);
|
|
||||||
replymsg(m);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Reply to m.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
replymsg(Wsysmsg *m)
|
|
||||||
{
|
|
||||||
int n;
|
|
||||||
|
|
||||||
/* T -> R msg */
|
|
||||||
if(m->type%2 == 0)
|
|
||||||
m->type++;
|
|
||||||
|
|
||||||
/* fprint(2, "-> %W\n", m); */
|
|
||||||
/* copy to output buffer */
|
|
||||||
n = sizeW2M(m);
|
|
||||||
if(fdout.wp+n > fdout.ep)
|
|
||||||
sysfatal("out of space for reply message");
|
|
||||||
convW2M(m, fdout.wp, n);
|
|
||||||
fdout.wp += n;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Match queued kbd reads with queued kbd characters.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
matchkbd(void)
|
|
||||||
{
|
|
||||||
Wsysmsg m;
|
|
||||||
|
|
||||||
if(kbd.stall)
|
|
||||||
return;
|
|
||||||
while(kbd.ri != kbd.wi && kbdtags.ri != kbdtags.wi){
|
|
||||||
m.type = Rrdkbd;
|
|
||||||
m.tag = kbdtags.t[kbdtags.ri++];
|
|
||||||
if(kbdtags.ri == nelem(kbdtags.t))
|
|
||||||
kbdtags.ri = 0;
|
|
||||||
m.rune = kbd.r[kbd.ri++];
|
|
||||||
if(kbd.ri == nelem(kbd.r))
|
|
||||||
kbd.ri = 0;
|
|
||||||
replymsg(&m);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Match queued mouse reads with queued mouse events.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
matchmouse(void)
|
|
||||||
{
|
|
||||||
Wsysmsg m;
|
|
||||||
|
|
||||||
while(mouse.ri != mouse.wi && mousetags.ri != mousetags.wi){
|
|
||||||
m.type = Rrdmouse;
|
|
||||||
m.tag = mousetags.t[mousetags.ri++];
|
|
||||||
if(mousetags.ri == nelem(mousetags.t))
|
|
||||||
mousetags.ri = 0;
|
|
||||||
m.mouse = mouse.m[mouse.ri];
|
|
||||||
m.resized = mouse.resized;
|
|
||||||
/*
|
|
||||||
if(m.resized)
|
|
||||||
fprint(2, "sending resize\n");
|
|
||||||
*/
|
|
||||||
mouse.resized = 0;
|
|
||||||
mouse.ri++;
|
|
||||||
if(mouse.ri == nelem(mouse.m))
|
|
||||||
mouse.ri = 0;
|
|
||||||
replymsg(&m);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static int kbuttons;
|
|
||||||
static int altdown;
|
|
||||||
static int kstate;
|
|
||||||
|
|
||||||
static void
|
|
||||||
sendmouse(Mouse m)
|
|
||||||
{
|
|
||||||
m.buttons |= kbuttons;
|
|
||||||
mouse.m[mouse.wi] = m;
|
|
||||||
mouse.wi++;
|
|
||||||
if(mouse.wi == nelem(mouse.m))
|
|
||||||
mouse.wi = 0;
|
|
||||||
if(mouse.wi == mouse.ri){
|
|
||||||
mouse.stall = 1;
|
|
||||||
mouse.ri = 0;
|
|
||||||
mouse.wi = 1;
|
|
||||||
mouse.m[0] = m;
|
|
||||||
/* fprint(2, "mouse stall\n"); */
|
|
||||||
}
|
|
||||||
matchmouse();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Handle an incoming X event.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
runxevent(XEvent *xev)
|
|
||||||
{
|
|
||||||
int c;
|
|
||||||
KeySym k;
|
|
||||||
static Mouse m;
|
|
||||||
XButtonEvent *be;
|
|
||||||
XKeyEvent *ke;
|
|
||||||
|
|
||||||
#ifdef SHOWEVENT
|
|
||||||
static int first = 1;
|
|
||||||
if(first){
|
|
||||||
dup(create("/tmp/devdraw.out", OWRITE, 0666), 1);
|
|
||||||
setbuf(stdout, 0);
|
|
||||||
first = 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if(xev == 0)
|
|
||||||
return;
|
|
||||||
|
|
||||||
#ifdef SHOWEVENT
|
|
||||||
print("\n");
|
|
||||||
ShowEvent(xev);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
switch(xev->type){
|
|
||||||
case Expose:
|
|
||||||
_xexpose(xev);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case DestroyNotify:
|
|
||||||
if(_xdestroy(xev))
|
|
||||||
exits(0);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case ConfigureNotify:
|
|
||||||
if(_xconfigure(xev)){
|
|
||||||
mouse.resized = 1;
|
|
||||||
_xreplacescreenimage();
|
|
||||||
sendmouse(m);
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
|
|
||||||
case ButtonPress:
|
|
||||||
be = (XButtonEvent*)xev;
|
|
||||||
if(be->button == 1) {
|
|
||||||
if(kstate & ControlMask)
|
|
||||||
be->button = 2;
|
|
||||||
else if(kstate & Mod1Mask)
|
|
||||||
be->button = 3;
|
|
||||||
}
|
|
||||||
// fall through
|
|
||||||
case ButtonRelease:
|
|
||||||
altdown = 0;
|
|
||||||
// fall through
|
|
||||||
case MotionNotify:
|
|
||||||
if(mouse.stall)
|
|
||||||
return;
|
|
||||||
if(_xtoplan9mouse(xev, &m) < 0)
|
|
||||||
return;
|
|
||||||
sendmouse(m);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case KeyRelease:
|
|
||||||
case KeyPress:
|
|
||||||
ke = (XKeyEvent*)xev;
|
|
||||||
XLookupString(ke, NULL, 0, &k, NULL);
|
|
||||||
c = ke->state;
|
|
||||||
switch(k) {
|
|
||||||
case XK_Alt_L:
|
|
||||||
case XK_Meta_L: /* Shift Alt on PCs */
|
|
||||||
case XK_Alt_R:
|
|
||||||
case XK_Meta_R: /* Shift Alt on PCs */
|
|
||||||
case XK_Multi_key:
|
|
||||||
if(xev->type == KeyPress)
|
|
||||||
altdown = 1;
|
|
||||||
else if(altdown) {
|
|
||||||
altdown = 0;
|
|
||||||
sendalt();
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
switch(k) {
|
|
||||||
case XK_Control_L:
|
|
||||||
if(xev->type == KeyPress)
|
|
||||||
c |= ControlMask;
|
|
||||||
else
|
|
||||||
c &= ~ControlMask;
|
|
||||||
goto kbutton;
|
|
||||||
case XK_Alt_L:
|
|
||||||
case XK_Shift_L:
|
|
||||||
if(xev->type == KeyPress)
|
|
||||||
c |= Mod1Mask;
|
|
||||||
else
|
|
||||||
c &= ~Mod1Mask;
|
|
||||||
kbutton:
|
|
||||||
kstate = c;
|
|
||||||
if(m.buttons || kbuttons) {
|
|
||||||
altdown = 0; // used alt
|
|
||||||
kbuttons = 0;
|
|
||||||
if(c & ControlMask)
|
|
||||||
kbuttons |= 2;
|
|
||||||
if(c & Mod1Mask)
|
|
||||||
kbuttons |= 4;
|
|
||||||
sendmouse(m);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(xev->type != KeyPress)
|
|
||||||
break;
|
|
||||||
if(k == XK_F11){
|
|
||||||
fullscreen = !fullscreen;
|
|
||||||
_xmovewindow(fullscreen ? screenrect : windowrect);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if(kbd.stall)
|
|
||||||
return;
|
|
||||||
if((c = _xtoplan9kbd(xev)) < 0)
|
|
||||||
return;
|
|
||||||
kbd.r[kbd.wi++] = c;
|
|
||||||
if(kbd.wi == nelem(kbd.r))
|
|
||||||
kbd.wi = 0;
|
|
||||||
if(kbd.ri == kbd.wi)
|
|
||||||
kbd.stall = 1;
|
|
||||||
matchkbd();
|
|
||||||
break;
|
|
||||||
|
|
||||||
case FocusOut:
|
|
||||||
/*
|
|
||||||
* Some key combinations (e.g. Alt-Tab) can cause us
|
|
||||||
* to see the key down event without the key up event,
|
|
||||||
* so clear out the keyboard state when we lose the focus.
|
|
||||||
*/
|
|
||||||
kstate = 0;
|
|
||||||
altdown = 0;
|
|
||||||
abortcompose();
|
|
||||||
break;
|
|
||||||
|
|
||||||
case SelectionRequest:
|
|
||||||
_xselect(xev);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,45 +0,0 @@
|
||||||
#include <u.h>
|
|
||||||
#include "x11-inc.h"
|
|
||||||
#include <libc.h>
|
|
||||||
#include <draw.h>
|
|
||||||
#include <memdraw.h>
|
|
||||||
#include "x11-memdraw.h"
|
|
||||||
|
|
||||||
void
|
|
||||||
_xtopwindow(void)
|
|
||||||
{
|
|
||||||
XMapRaised(_x.display, _x.drawable);
|
|
||||||
XSetInputFocus(_x.display, _x.drawable, RevertToPointerRoot,
|
|
||||||
CurrentTime);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
_xresizewindow(Rectangle r)
|
|
||||||
{
|
|
||||||
XWindowChanges e;
|
|
||||||
int value_mask;
|
|
||||||
|
|
||||||
memset(&e, 0, sizeof e);
|
|
||||||
value_mask = CWX|CWY|CWWidth|CWHeight;
|
|
||||||
e.width = Dx(r);
|
|
||||||
e.height = Dy(r);
|
|
||||||
XConfigureWindow(_x.display, _x.drawable, value_mask, &e);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
_xmovewindow(Rectangle r)
|
|
||||||
{
|
|
||||||
XWindowChanges e;
|
|
||||||
int value_mask;
|
|
||||||
|
|
||||||
memset(&e, 0, sizeof e);
|
|
||||||
value_mask = CWX|CWY|CWWidth|CWHeight;
|
|
||||||
e.x = r.min.x;
|
|
||||||
e.y = r.min.y;
|
|
||||||
e.width = Dx(r);
|
|
||||||
e.height = Dy(r);
|
|
||||||
XConfigureWindow(_x.display, _x.drawable, value_mask, &e);
|
|
||||||
XFlush(_x.display);
|
|
||||||
}
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue