ref: ab24e5e186af64aa39cdfa03a87e7ce2eec6ad4b
dir: /emu/port/win-x11-old.c/
#include "dat.h"
#include "fns.h"
#include "cursor.h"
#include "keyboard.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#define ABS(x) ((x) < 0 ? -(x) : (x))
/*
* alias defs for image types to overcome name conflicts
*/
typedef struct ICursor ICursor;
typedef struct IPoint IPoint;
typedef struct IRectangle IRectangle;
typedef struct CRemapTbl CRemapTbl;
struct ICursor
{
int w;
int h;
int hotx;
int hoty;
char *src;
char *mask;
};
struct IPoint
{
int x;
int y;
};
struct IRectangle
{
IPoint min;
IPoint max;
};
struct CRemapTbl
{
ulong inferno[256]; /* The corresponding inferno colormap vals */
ulong openslot[256];
Bool cellused[256];
int cnt;
int opencnt;
};
enum
{
DblTime = 300 /* double click time in msec */
};
XColor map[256]; /* Inferno colormap array */
XColor map7[128]; /* Inferno colormap array */
uchar map7to8[128][2];
Colormap xcmap; /* Default shared colormap */
int infernotox11[256]; /* Values for mapping between */
int x11toinferno[256]; /* X11 and inferno */
int x24bitswap = 0; /* swap endian for 24bit RGB */
static int triedscreen;
static XModifierKeymap *modmap;
static int keypermod;
static Drawable xdrawable;
static Atom wm_take_focus;
static void xexpose(XEvent*);
static void xmouse(XEvent*);
static void xkeyboard(XEvent*);
static void xmapping(XEvent*);
static void xproc(void*);
static void xinitscreen(int, int);
static void initmap(Window);
static GC creategc(Drawable);
static CRemapTbl crtbl;
static void graphicscmap(XColor*);
int xscreendepth;
Drawable xscreenid;
Display* xdisplay;
Display* xkmcon;
Visual *xvis;
GC xgcfill, xgccopy, xgcsimplesrc, xgczero, xgcreplsrc;
GC xgcfill0, xgccopy0, xgcsimplesrc0, xgczero0, xgcreplsrc0;
char *gkscanid = "emu_x11";
ulong*
attachscreen(IRectangle *r, int *ld, int *width, int *softscreen)
{
extern ulong* makememones();
r->min.x = 0;
r->min.y = 0;
r->max.x = Xsize;
r->max.y = Ysize;
*ld = 3;
*width = Xsize/4;
*softscreen = 1;
if(!triedscreen){
triedscreen = 1;
xinitscreen(Xsize, Ysize);
if(kproc("xproc", xproc, nil, 0) < 0) {
fprint(2, "emu: win-x11 can't make X proc\n");
return 0;
}
}
return makememones();
}
void
flushmemscreen(IRectangle r)
{
if(r.min.x > r.max.x)
return;
XCopyArea(xdisplay, xscreenid, xdrawable, xgccopy,
r.min.x, r.min.y,
r.max.x-r.min.x, r.max.y-r.min.y, r.min.x, r.min.y);
XFlush(xdisplay);
}
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
gotcursor(ICursor c)
{
Cursor xc;
XColor fg, bg;
Pixmap xsrc, xmask;
static Cursor xcursor;
if(c.src == nil){
if(xcursor != 0) {
XFreeCursor(xdisplay, xcursor);
xcursor = 0;
}
XUndefineCursor(xdisplay, xdrawable);
XFlush(xdisplay);
return;
}
xsrc = XCreateBitmapFromData(xdisplay, xdrawable, c.src, c.w, c.h);
xmask = XCreateBitmapFromData(xdisplay, xdrawable, c.mask, c.w, c.h);
fg = map[255];
bg = map[0];
fg.pixel = infernotox11[255];
bg.pixel = infernotox11[0];
xc = XCreatePixmapCursor(xdisplay, xsrc, xmask, &fg, &bg, -c.hotx, -c.hoty);
if(xc != 0) {
XDefineCursor(xdisplay, xdrawable, xc);
if(xcursor != 0)
XFreeCursor(xdisplay, xcursor);
xcursor = xc;
}
XFreePixmap(xdisplay, xsrc);
XFreePixmap(xdisplay, xmask);
XFlush(xdisplay);
free(c.src);
}
void
setcursor(IPoint p)
{
XWarpPointer(xdisplay, None, xdrawable, 0, 0, 0, 0, p.x, p.y);
XFlush(xdisplay);
}
void
drawcursor(Drawcursor* c)
{
ICursor ic;
IRectangle ir;
uchar *bs, *bc;
int i, h, j, bpl;
char *src, *mask, *csrc, *cmask;
/* Set the default system cursor */
src = nil;
mask = nil;
if(c->data != nil){
h = (c->maxy-c->miny)/2;
ir.min.x = c->minx;
ir.min.y = c->miny;
ir.max.x = c->maxx;
ir.max.y = c->maxy;
/* passing IRectangle to Rectangle is safe */
bpl = bytesperline(ir, 1);
i = h*bpl;
src = malloc(2*i);
if(src == nil)
return;
mask = src + i;
csrc = src;
cmask = mask;
bc = c->data;
bs = c->data + h*bpl;
for(i = 0; i < h; i++){
for(j = 0; j < bpl; j++) {
*csrc++ = revbyte(bs[j]);
*cmask++ = revbyte(bs[j] | bc[j]);
}
bs += bpl;
bc += bpl;
}
}
ic.w = 8*bpl;
ic.h = h;
ic.hotx = c->hotx;
ic.hoty = c->hoty;
ic.src = src;
ic.mask = mask;
gotcursor(ic);
}
static void
xproc(void *arg)
{
ulong mask;
XEvent event;
closepgrp(up->env->pgrp);
closefgrp(up->env->fgrp);
closeegrp(up->env->egrp);
closesigs(up->env->sigs);
mask = KeyPressMask|
KeyReleaseMask|
ButtonPressMask|
ButtonReleaseMask|
PointerMotionMask|
Button1MotionMask|
Button2MotionMask|
Button3MotionMask|
ExposureMask;
XSelectInput(xkmcon, xdrawable, mask);
for(;;) {
XWindowEvent(xkmcon, xdrawable, mask, &event);
switch(event.type) {
case KeyPress:
case KeyRelease:
xkeyboard(&event);
break;
case ButtonPress:
case ButtonRelease:
case MotionNotify:
xmouse(&event);
break;
case Expose:
xexpose(&event);
break;
case MappingNotify:
xmapping(&event);
break;
default:
break;
}
}
}
static int
shutup(Display *d, XErrorEvent *e)
{
char buf[200];
print("X error: error code=%d, request_code=%d, minor=%d\n", e->error_code, e->request_code, e->minor_code);
XGetErrorText(d, e->error_code, buf, sizeof(buf));
print("%s\n", buf);
USED(d);
USED(e);
return 0;
}
static void
xinitscreen(int xsize, int ysize)
{
int i, pmid;
char *argv[2];
char *disp_val;
Window rootwin;
XWMHints hints;
Screen *screen;
XVisualInfo xvi;
int rootscreennum;
XTextProperty name;
XClassHint classhints;
XSizeHints normalhints;
XSetWindowAttributes attrs;
xscreenid = 0;
xdrawable = 0;
xdisplay = XOpenDisplay(NULL);
if(xdisplay == 0){
disp_val = getenv("DISPLAY");
if(disp_val == 0)
disp_val = "not set";
fprint(2, "emu: win-x11 open %r, DISPLAY is %s\n", disp_val);
cleanexit(0);
}
rootscreennum = DefaultScreen(xdisplay);
rootwin = DefaultRootWindow(xdisplay);
xscreendepth = DefaultDepth(xdisplay, rootscreennum);
if(XMatchVisualInfo(xdisplay, rootscreennum, 24, TrueColor, &xvi)
|| XMatchVisualInfo(xdisplay, rootscreennum, 24, DirectColor, &xvi)){
xvis = xvi.visual;
xscreendepth = 24;
xtblbit = 1;
}
else if(XMatchVisualInfo(xdisplay, rootscreennum, 8, PseudoColor, &xvi)
|| XMatchVisualInfo(xdisplay, rootscreennum, 8, StaticColor, &xvi)){
if(xscreendepth > 8) {
fprint(2, "emu: win-x11 can't deal with depth %d screens\n", xscreendepth);
cleanexit(0);
}
xvis = xvi.visual;
xscreendepth = 8;
}
else{
if(xscreendepth != 8){
fprint(2, "emu: win-x11 can't deal with depth %d screens\n", xscreendepth);
cleanexit(0);
}
xvis = DefaultVisual(xdisplay, rootscreennum);
}
screen = DefaultScreenOfDisplay(xdisplay);
xcmap = DefaultColormapOfScreen(screen);
if(xvis->class != StaticColor){
graphicscmap(map);
initmap(rootwin);
}
if(modmap = XGetModifierMapping(xdisplay))
keypermod = modmap->max_keypermod;
attrs.colormap = xcmap;
attrs.background_pixel = 0;
attrs.border_pixel = 0;
/* attrs.override_redirect = 1;*/ /* WM leave me alone! |CWOverrideRedirect */
xdrawable = XCreateWindow(xdisplay, rootwin, 0, 0, xsize, ysize, 0, xscreendepth, InputOutput, xvis, CWBackPixel|CWBorderPixel|CWColormap, &attrs);
/*
* set up property as required by ICCCM
*/
name.value = "inferno";
name.encoding = XA_STRING;
name.format = 8;
name.nitems = strlen(name.value);
normalhints.flags = USSize|PMaxSize;
normalhints.max_width = normalhints.width = xsize;
normalhints.max_height = normalhints.height = ysize;
hints.flags = InputHint|StateHint;
hints.input = 1;
hints.initial_state = NormalState;
classhints.res_name = "inferno";
classhints.res_class = "Inferno";
argv[0] = "inferno";
argv[1] = nil;
XSetWMProperties(xdisplay, xdrawable,
&name, /* XA_WM_NAME property for ICCCM */
&name, /* XA_WM_ICON_NAME */
argv, /* XA_WM_COMMAND */
1, /* argc */
&normalhints, /* XA_WM_NORMAL_HINTS */
&hints, /* XA_WM_HINTS */
&classhints); /* XA_WM_CLASS */
/*
* put the window on the screen
*/
XMapWindow(xdisplay, xdrawable);
xscreenid = XCreatePixmap(xdisplay, xdrawable, xsize, ysize, xscreendepth);
XFlush(xdisplay);
xgcfill = creategc(xscreenid);
XSetFillStyle(xdisplay, xgcfill, FillSolid);
xgccopy = creategc(xscreenid);
xgcsimplesrc = creategc(xscreenid);
XSetFillStyle(xdisplay, xgcsimplesrc, FillStippled);
xgczero = creategc(xscreenid);
xgcreplsrc = creategc(xscreenid);
XSetFillStyle(xdisplay, xgcreplsrc, FillTiled);
pmid = XCreatePixmap(xdisplay, xdrawable, 1, 1, 1);
xgcfill0 = creategc(pmid);
XSetFillStyle(xdisplay, xgcfill0, FillSolid);
xgccopy0 = creategc(pmid);
xgcsimplesrc0 = creategc(pmid);
XSetFillStyle(xdisplay, xgcsimplesrc0, FillStippled);
xgczero0 = creategc(pmid);
xgcreplsrc0 = creategc(pmid);
XSetFillStyle(xdisplay, xgcreplsrc0, FillTiled);
XFreePixmap(xdisplay, pmid);
XSetForeground(xdisplay, xgccopy, infernotox11[0]);
XFillRectangle(xdisplay, xscreenid, xgccopy, 0, 0, xsize, ysize);
xkmcon = XOpenDisplay(NULL);
if(xkmcon == 0){
disp_val = getenv("DISPLAY");
if(disp_val == 0)
disp_val = "not set";
fprint(2, "emu: win-x11 open %r, DISPLAY is %s\n", disp_val);
cleanexit(0);
}
}
static void
graphicscmap(XColor *map)
{
int r, g, b, cr, cg, cb, v, num, den, idx, v7, idx7;
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);
idx = 255 - idx;
map[idx].red = cr*0x0101;
map[idx].green = cg*0x0101;
map[idx].blue = cb*0x0101;
map[idx].pixel = idx;
map[idx].flags = DoRed|DoGreen|DoBlue;
v7 = v >> 1;
idx7 = r*32 + v7*16 + g*4 + b;
if((v & 1) == v7){
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;
}
map7[idx7].red = cr*0x0101;
map7[idx7].green = cg*0x0101;
map7[idx7].blue = cb*0x0101;
map7[idx7].pixel = idx7;
map7[idx7].flags = DoRed|DoGreen|DoBlue;
}
else
map7to8[idx7][1] = idx;
}
}
}
}
}
/*
* Initialize and install the Inferno colormap as a private colormap for this
* application. Inferno gets the best colors here when it has the cursor focus.
*/
static void
initmap(Window w)
{
XColor c;
XColor xcol;
ulong v;
int i, pix, ncmaps;
if(xscreendepth <= 1)
return;
if(xvis->class == TrueColor || xvis->class == DirectColor) {
int color_order_init = 0;
uint pp, p;
for(i = 0; i < 256; i++) {
c = map[i];
/* find out index into colormap for our RGB */
if(!XAllocColor(xdisplay, xcmap, &c)) {
fprint(2, "emu: win-x11 can't alloc color\n");
cleanexit(0);
}
/* 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 xvis->byte_order but
* some displays say MSB even though they run on LSB.
* Besides, this is more anal.
*/
p = c.pixel;
pp = rgb2cmap((p>>16)&0xff,(p>>8)&0xff,p&0xff);
if(!color_order_init && (pp!=map[i].pixel)) {
/* check if endian is other way */
pp = rgb2cmap(p&0xff,(p>>8)&0xff,(p>>16)&0xff);
if(pp!=map[i].pixel) {
fprint(2, "emu: win-x11 can't convert 24bit colors\n");
cleanexit(0);
}
color_order_init = 1;
x24bitswap = 1;
}
if(color_order_init) {
pp = rgb2cmap(p&0xff,(p>>8)&0xff,(p>>16)&0xff);
if(pp!=map[i].pixel) {
fprint(2, "emu: win-x11 can't convert 24bit colors\n");
cleanexit(0);
}
/* no x11toinferno; later use rgb2cmap() */
infernotox11[map[i].pixel] = c.pixel;
}
else if(pp!=map[i].pixel) {
fprint(2, "emu: win-x11 can't convert 24bit colors\n");
cleanexit(0);
}
else {
/* no x11toinferno; later use rgb2cmap() */
infernotox11[map[i].pixel] = c.pixel;
}
}
}
else if(xvis->class == PseudoColor) {
if(xtblbit == 0){
xcmap = XCreateColormap(xdisplay, w, xvis, AllocAll);
XStoreColors(xdisplay, xcmap, map, 256);
for(i = 0; i < 256; i++) {
infernotox11[i] = i;
x11toinferno[i] = i;
}
}
else {
for(i = 0; i < 128; i++) {
c = map7[i];
if(!XAllocColor(xdisplay, xcmap, &c)) {
fprint(2, "emu: win-x11 can't alloc colors in default map, don't use -7\n");
cleanexit(0);
}
infernotox11[map7to8[i][0]] = c.pixel;
infernotox11[map7to8[i][1]] = c.pixel;
x11toinferno[c.pixel] = map7to8[i][0];
}
}
}
else {
xtblbit = 0;
fprint(2, "emu: win-x11 unsupported visual class %d\n", xvis->class);
}
return;
}
static void
xmapping(XEvent *e)
{
XMappingEvent *xe;
if(e->type != MappingNotify)
return;
xe = (XMappingEvent*)e;
if(modmap)
XFreeModifiermap(modmap);
modmap = XGetModifierMapping(xe->display);
if(modmap)
keypermod = modmap->max_keypermod;
}
/*
* Disable generation of GraphicsExpose/NoExpose events in the GC.
*/
static GC
creategc(Drawable d)
{
XGCValues gcv;
gcv.function = GXcopy;
gcv.graphics_exposures = False;
return XCreateGC(xdisplay, d, GCFunction|GCGraphicsExposures, &gcv);
}
static void
xexpose(XEvent *e)
{
IRectangle r;
XExposeEvent *xe;
if(e->type != Expose)
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;
drawqlock();
flushmemscreen(r);
drawqunlock();
}
static void
xkeyboard(XEvent *e)
{
int ind, n;
KeySym k;
Rune r;
unsigned int md;
char buf[1];
if(gkscanq) {
uchar ch = (KeyCode)e->xkey.keycode;
if(e->xany.type == KeyRelease)
ch |= 0x80;
qproduce(gkscanq, &ch, 1);
return;
}
/*
* I tried using XtGetActionKeysym, but it didn't seem to
* do case conversion properly
* (at least, with Xterminal servers and R4 intrinsics)
*/
if(e->xany.type != KeyPress)
return;
md = e->xkey.state;
ind = 0;
if(md & ShiftMask)
ind = 1;
k = XKeycodeToKeysym(e->xany.display, (KeyCode)e->xkey.keycode, ind);
/* May have to try unshifted version */
if(k == NoSymbol && ind == 1)
k = XKeycodeToKeysym(e->xany.display, (KeyCode)e->xkey.keycode, 0);
if(k == XK_Multi_key || k == NoSymbol)
return;
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_Enter:
case XK_Return:
k = '\n';
break;
case XK_Alt_L:
case XK_Alt_R:
case XK_Meta_L:
case XK_Meta_R:
k = Latin;
break;
case XK_Left:
case XK_KP_Left:
k = Left;
break;
case XK_Down:
case XK_KP_Down:
k = Down;
break;
case XK_Right:
case XK_KP_Right:
k = Right;
break;
case XK_Up:
case XK_KP_Up:
k = Up;
break;
case XK_Home:
case XK_KP_Home:
k = Home;
break;
case XK_End:
case XK_KP_End:
k = End;
break;
case XK_Page_Up:
case XK_KP_Page_Up:
k = Pgup;
break;
case XK_Page_Down:
case XK_KP_Page_Down:
k = Pgdown;
break;
default: /* not ISO-1 or tty control */
return;
}
}
/* 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(md & ControlMask)
k &= 0x9f;
if(k == '\t' && ind)
k = BackTab;
if(md & Mod1Mask)
k = APP|(k&0xff);
if(k == NoSymbol)
return;
gkbdputc(gkbdq, k);
}
static void
xmouse(XEvent *e)
{
int s, dbl;
XButtonEvent *be;
XMotionEvent *me;
XEvent motion;
Pointer m;
static ulong lastb, lastt;
dbl = 0;
switch(e->type){
case ButtonPress:
be = (XButtonEvent *)e;
m.x = be->x;
m.y = be->y;
s = be->state;
if(be->button == lastb && be->time - lastt < DblTime)
dbl = 1;
lastb = be->button;
lastt = be->time;
switch(be->button){
case 1:
s |= Button1Mask;
break;
case 2:
s |= Button2Mask;
break;
case 3:
s |= Button3Mask;
break;
}
break;
case ButtonRelease:
be = (XButtonEvent *)e;
m.x = be->x;
m.y = be->y;
s = be->state;
switch(be->button){
case 1:
s &= ~Button1Mask;
break;
case 2:
s &= ~Button2Mask;
break;
case 3:
s &= ~Button3Mask;
break;
}
break;
case MotionNotify:
me = (XMotionEvent *) e;
/* remove excess MotionNotify events from queue and keep last one */
while(XCheckTypedWindowEvent(xkmcon, xdrawable, MotionNotify, &motion) == True)
me = (XMotionEvent *) &motion;
s = me->state;
m.x = me->x;
m.y = me->y;
break;
default:
return;
}
m.b = 0;
if(s & Button1Mask)
m.b |= 1;
if(s & Button2Mask)
m.b |= 2;
if(s & Button3Mask)
m.b |= 4;
if(dbl)
m.b |= 1<<4;
m.modify = 1;
mouseproduce(m);
}