-
deuce authoredcols, rows, charwidth, charheight, scaling, vmultiplier. Only the drivers are allowed to update them, so the drivers don't need to use locks for them. The drivers have their own internal copies, so we don't need vstatlock in the drivers except when updating these values.
deuce authoredcols, rows, charwidth, charheight, scaling, vmultiplier. Only the drivers are allowed to update them, so the drivers don't need to use locks for them. The drivers have their own internal copies, so we don't need vstatlock in the drivers except when updating these values.
x_events.c 28.76 KiB
/*
* This file contains ONLY the functions that are called from the
* event thread.
*/
#include <unistd.h>
#include <stdbool.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <threadwrap.h>
#include <genwrap.h>
#include <dirwrap.h>
#include "vidmodes.h"
#include "ciolib.h"
#define BITMAP_CIOLIB_DRIVER
#include "bitmap_con.h"
#include "link_list.h"
#include "x_events.h"
#include "x_cio.h"
/*
* Exported variables
*/
int local_pipe[2]; /* Used for passing local events */
int key_pipe[2]; /* Used for passing keyboard events */
struct x11 x11;
char *copybuf;
pthread_mutex_t copybuf_mutex;
char *pastebuf;
sem_t pastebuf_set;
sem_t pastebuf_used;
sem_t init_complete;
sem_t mode_set;
int x11_window_xpos;
int x11_window_ypos;
int x11_window_width;
int x11_window_height;
int x11_initialized=0;
sem_t event_thread_complete;
int terminate = 0;
/*
* Local variables
*/
/* Sets the atom to be used for copy/paste operations */
#define CONSOLE_CLIPBOARD XA_PRIMARY
static Atom WM_DELETE_WINDOW=0;
static Display *dpy=NULL;
static Window win;
static Visual visual;
static unsigned int depth=0;
static int xfd;
static unsigned long black;
static unsigned long white;
static int bitmap_width=0;
static int bitmap_height=0;static int old_scaling = 0;
struct video_stats x_cvstat;
/* Array of Graphics Contexts */
static GC *gca = NULL;
/* Array of pixel values to match all possible colours */
static unsigned long *pixel = NULL;
size_t pixelsz = 0;
static WORD Ascii2Scan[] = {
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0x000e, 0x000f, 0xffff, 0xffff, 0xffff, 0x001c, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0x0001, 0xffff, 0xffff, 0xffff, 0xffff,
0x0039, 0x0102, 0x0128, 0x0104, 0x0105, 0x0106, 0x0108, 0x0028,
0x010a, 0x010b, 0x0109, 0x010d, 0x0033, 0x000c, 0x0034, 0x0035,
0x000b, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
0x0009, 0x000a, 0x0127, 0x0027, 0x0133, 0x000d, 0x0134, 0x0135,
0x0103, 0x011e, 0x0130, 0x012e, 0x0120, 0x0112, 0x0121, 0x0122,
0x0123, 0x0117, 0x0124, 0x0125, 0x0126, 0x0132, 0x0131, 0x0118,
0x0119, 0x0110, 0x0113, 0x011f, 0x0114, 0x0116, 0x012f, 0x0111,
0x012d, 0x0115, 0x012c, 0x001a, 0x002b, 0x001b, 0x0107, 0x010c,
0x0029, 0x001e, 0x0030, 0x002e, 0x0020, 0x0012, 0x0021, 0x0022,
0x0023, 0x0017, 0x0024, 0x0025, 0x0026, 0x0032, 0x0031, 0x0018,
0x0019, 0x0010, 0x0013, 0x001f, 0x0014, 0x0016, 0x002f, 0x0011,
0x002d, 0x0015, 0x002c, 0x011a, 0x012b, 0x011b, 0x0129, 0xffff,
};
static struct {
WORD base;
WORD shift;
WORD ctrl;
WORD alt;
} ScanCodes[] = {
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 0 */
{ 0x011b, 0x011b, 0x011b, 0xffff }, /* key 1 - Escape key */
{ 0x0231, 0x0221, 0xffff, 0x7800 }, /* key 2 - '1' */
{ 0x0332, 0x0340, 0x0300, 0x7900 }, /* key 3 - '2' - special handling */
{ 0x0433, 0x0423, 0xffff, 0x7a00 }, /* key 4 - '3' */
{ 0x0534, 0x0524, 0xffff, 0x7b00 }, /* key 5 - '4' */
{ 0x0635, 0x0625, 0xffff, 0x7c00 }, /* key 6 - '5' */
{ 0x0736, 0x075e, 0x071e, 0x7d00 }, /* key 7 - '6' */
{ 0x0837, 0x0826, 0xffff, 0x7e00 }, /* key 8 - '7' */
{ 0x0938, 0x092a, 0xffff, 0x7f00 }, /* key 9 - '8' */
{ 0x0a39, 0x0a28, 0xffff, 0x8000 }, /* key 10 - '9' */
{ 0x0b30, 0x0b29, 0xffff, 0x8100 }, /* key 11 - '0' */
{ 0x0c2d, 0x0c5f, 0x0c1f, 0x8200 }, /* key 12 - '-' */
{ 0x0d3d, 0x0d2b, 0xffff, 0x8300 }, /* key 13 - '=' */
{ 0x0e08, 0x0e08, 0x0e7f, 0xffff }, /* key 14 - backspace */
{ 0x0f09, 0x0f00, 0xffff, 0xffff }, /* key 15 - tab */
{ 0x1071, 0x1051, 0x1011, 0x1000 }, /* key 16 - 'Q' */
{ 0x1177, 0x1157, 0x1117, 0x1100 }, /* key 17 - 'W' */
{ 0x1265, 0x1245, 0x1205, 0x1200 }, /* key 18 - 'E' */
{ 0x1372, 0x1352, 0x1312, 0x1300 }, /* key 19 - 'R' */
{ 0x1474, 0x1454, 0x1414, 0x1400 }, /* key 20 - 'T' */
{ 0x1579, 0x1559, 0x1519, 0x1500 }, /* key 21 - 'Y' */
{ 0x1675, 0x1655, 0x1615, 0x1600 }, /* key 22 - 'U' */
{ 0x1769, 0x1749, 0x1709, 0x1700 }, /* key 23 - 'I' */
{ 0x186f, 0x184f, 0x180f, 0x1800 }, /* key 24 - 'O' */
{ 0x1970, 0x1950, 0x1910, 0x1900 }, /* key 25 - 'P' */
{ 0x1a5b, 0x1a7b, 0x1a1b, 0xffff }, /* key 26 - '[' */
{ 0x1b5d, 0x1b7d, 0x1b1d, 0xffff }, /* key 27 - ']' */
{ 0x1c0d, 0x1c0d, 0x1c0a, 0xffff }, /* key 28 - CR */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 29 - control */
{ 0x1e61, 0x1e41, 0x1e01, 0x1e00 }, /* key 30 - 'A' */
{ 0x1f73, 0x1f53, 0x1f13, 0x1f00 }, /* key 31 - 'S' */
{ 0x2064, 0x2044, 0x2004, 0x2000 }, /* key 32 - 'D' */
{ 0x2166, 0x2146, 0x2106, 0x2100 }, /* key 33 - 'F' */
{ 0x2267, 0x2247, 0x2207, 0x2200 }, /* key 34 - 'G' */ { 0x2368, 0x2348, 0x2308, 0x2300 }, /* key 35 - 'H' */
{ 0x246a, 0x244a, 0x240a, 0x2400 }, /* key 36 - 'J' */
{ 0x256b, 0x254b, 0x250b, 0x2500 }, /* key 37 - 'K' */
{ 0x266c, 0x264c, 0x260c, 0x2600 }, /* key 38 - 'L' */
{ 0x273b, 0x273a, 0xffff, 0xffff }, /* key 39 - ';' */
{ 0x2827, 0x2822, 0xffff, 0xffff }, /* key 40 - ''' */
{ 0x2960, 0x297e, 0xffff, 0xffff }, /* key 41 - '`' */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 42 - left shift */
{ 0x2b5c, 0x2b7c, 0x2b1c, 0xffff }, /* key 43 - '' */
{ 0x2c7a, 0x2c5a, 0x2c1a, 0x2c00 }, /* key 44 - 'Z' */
{ 0x2d78, 0x2d58, 0x2d18, 0x2d00 }, /* key 45 - 'X' */
{ 0x2e63, 0x2e43, 0x2e03, 0x2e00 }, /* key 46 - 'C' */
{ 0x2f76, 0x2f56, 0x2f16, 0x2f00 }, /* key 47 - 'V' */
{ 0x3062, 0x3042, 0x3002, 0x3000 }, /* key 48 - 'B' */
{ 0x316e, 0x314e, 0x310e, 0x3100 }, /* key 49 - 'N' */
{ 0x326d, 0x324d, 0x320d, 0x3200 }, /* key 50 - 'M' */
{ 0x332c, 0x333c, 0xffff, 0xffff }, /* key 51 - ',' */
{ 0x342e, 0x343e, 0xffff, 0xffff }, /* key 52 - '.' */
{ 0x352f, 0x353f, 0xffff, 0xffff }, /* key 53 - '/' */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 54 - right shift - */
{ 0x372a, 0xffff, 0x3772, 0xffff }, /* key 55 - prt-scr - */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 56 - Alt - */
{ 0x3920, 0x3920, 0x3920, 0x3920 }, /* key 57 - space bar */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 58 - caps-lock - */
{ 0x3b00, 0x5400, 0x5e00, 0x6800 }, /* key 59 - F1 */
{ 0x3c00, 0x5500, 0x5f00, 0x6900 }, /* key 60 - F2 */
{ 0x3d00, 0x5600, 0x6000, 0x6a00 }, /* key 61 - F3 */
{ 0x3e00, 0x5700, 0x6100, 0x6b00 }, /* key 62 - F4 */
{ 0x3f00, 0x5800, 0x6200, 0x6c00 }, /* key 63 - F5 */
{ 0x4000, 0x5900, 0x6300, 0x6d00 }, /* key 64 - F6 */
{ 0x4100, 0x5a00, 0x6400, 0x6e00 }, /* key 65 - F7 */
{ 0x4200, 0x5b00, 0x6500, 0x6f00 }, /* key 66 - F8 */
{ 0x4300, 0x5c00, 0x6600, 0x7000 }, /* key 67 - F9 */
{ 0x4400, 0x5d00, 0x6700, 0x7100 }, /* key 68 - F10 */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 69 - num-lock - */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 70 - scroll-lock - */
{ 0x4700, 0x4737, 0x7700, 0xffff }, /* key 71 - home */
{ 0x4800, 0x4838, 0x8d00, 0x9800 }, /* key 72 - cursor up */
{ 0x4900, 0x4939, 0x8400, 0xffff }, /* key 73 - page up */
{ 0x4a2d, 0x4a2d, 0xffff, 0xffff }, /* key 74 - minus sign */
{ 0x4b00, 0x4b34, 0x7300, 0xffff }, /* key 75 - cursor left */
{ 0xffff, 0x4c35, 0xffff, 0xffff }, /* key 76 - center key */
{ 0x4d00, 0x4d36, 0x7400, 0xffff }, /* key 77 - cursor right */
{ 0x4e2b, 0x4e2b, 0xffff, 0xffff }, /* key 78 - plus sign */
{ 0x4f00, 0x4f31, 0x7500, 0xffff }, /* key 79 - end */
{ 0x5000, 0x5032, 0x9100, 0xa000 }, /* key 80 - cursor down */
{ 0x5100, 0x5133, 0x7600, 0xffff }, /* key 81 - page down */
{ 0x5200, 0x5230, 0xffff, 0xffff }, /* key 82 - insert */
{ 0x5300, 0x532e, 0xffff, 0xffff }, /* key 83 - delete */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 84 - sys key */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 85 */
{ 0xffff, 0xffff, 0xffff, 0xffff }, /* key 86 */
{ 0x8500, 0x5787, 0x8900, 0x8b00 }, /* key 87 - F11 */
{ 0x8600, 0x5888, 0x8a00, 0x8c00 }, /* key 88 - F12 */
};
/* Get a connection to the X server and create the window. */
static int init_window()
{
XGCValues gcv;
XColor color;
int i;
XWindowAttributes attr;
XWMHints *wmhints;
dpy = x11.XOpenDisplay(NULL);
if (dpy == NULL) {
return(-1);
}
xfd = ConnectionNumber(dpy);
/* Allocate black and white */
black=BlackPixel(dpy, DefaultScreen(dpy));
white=WhitePixel(dpy, DefaultScreen(dpy));
/* Create window, but defer setting a size and GC. */
win = x11.XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0,
640*x_cvstat.scaling, 400*x_cvstat.scaling*x_cvstat.vmultiplier, 2, black, black);
wmhints=x11.XAllocWMHints();
if(wmhints) {
wmhints->initial_state=NormalState;
wmhints->flags = (StateHint | IconPixmapHint | IconMaskHint | InputHint);
wmhints->input = True;
x11.XSetWMProperties(dpy, win, NULL, NULL, 0, 0, NULL, wmhints, NULL);
}
WM_DELETE_WINDOW = x11.XInternAtom(dpy, "WM_DELETE_WINDOW", False);
gcv.function = GXcopy;
gcv.foreground = white;
gcv.background = black;
gcv.graphics_exposures = False;
if (pixelsz < sizeof(dac_default)/sizeof(struct dac_colors)) {
unsigned long *newpixel;
GC *newgca;
size_t newpixelsz = sizeof(dac_default)/sizeof(struct dac_colors);
newpixel = realloc(pixel, sizeof(pixel[0])*newpixelsz);
if (newpixel == NULL)
return -1;
pixel = newpixel;
pixelsz = newpixelsz;
newgca = realloc(gca, sizeof(gca[0])*newpixelsz);
if (newgca == NULL)
return -1;
gca = newgca;
}
/* Get the pixel and GC values */
for(i=0; i<sizeof(dac_default)/sizeof(struct dac_colors); i++) {
color.red=dac_default[i].red << 8 | dac_default[i].red;
color.green=dac_default[i].green << 8 | dac_default[i].green;
color.blue=dac_default[i].blue << 8 | dac_default[i].blue;
if(x11.XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &color))
pixel[i]=color.pixel;
gcv.foreground=color.pixel;
gca[i]=x11.XCreateGC(dpy, win, GCFunction | GCForeground | GCBackground | GCGraphicsExposures, &gcv);
}
x11.XSelectInput(dpy, win, KeyReleaseMask | KeyPressMask |
ExposureMask | ButtonPressMask
| ButtonReleaseMask | PointerMotionMask | StructureNotifyMask);
x11.XGetWindowAttributes(dpy,win,&attr);
memcpy(&visual,attr.visual,sizeof(visual));
x11.XStoreName(dpy, win, "SyncConsole");
depth = DefaultDepth(dpy, DefaultScreen(dpy));
x11.XSetWMProtocols(dpy, win, &WM_DELETE_WINDOW, 1);
return(0);
}
/*
* Actually maps (shows) the window
*/
static void map_window()
{
XSizeHints *sh;
sh = x11.XAllocSizeHints();
if (sh == NULL) {
fprintf(stderr, "Could not get XSizeHints structure");
exit(1);
}
sh->base_width = bitmap_width*x_cvstat.scaling;
sh->base_height = bitmap_height*x_cvstat.scaling*x_cvstat.vmultiplier;
sh->min_width = sh->width_inc = sh->min_aspect.x = sh->max_aspect.x = bitmap_width;
sh->min_height = sh->height_inc = sh->min_aspect.y = sh->max_aspect.y = bitmap_height;
sh->flags = USSize | PMinSize | PSize | PResizeInc | PAspect;
x11.XSetWMNormalHints(dpy, win, sh);
x11.XMapWindow(dpy, win);
x11.XFree(sh);
bitmap_drv_request_pixels();
return;
}
/* Resize the window. This function is called after a mode change. */
static void resize_window()
{
x11.XResizeWindow(dpy, win, bitmap_width*x_cvstat.scaling, bitmap_height*x_cvstat.scaling*x_cvstat.vmultiplier);
return;
}
static int init_mode(int mode)
{
int oldcols;
int oldwidth=bitmap_width;
int oldheight=bitmap_height;
oldcols=x_cvstat.cols;
pthread_mutex_lock(&vstatlock);
bitmap_drv_init_mode(mode, &bitmap_width, &bitmap_height);
x_cvstat = vstat;
pthread_mutex_unlock(&vstatlock);
/* Deal with 40 col doubling */
if(oldcols != x_cvstat.cols) {
if(oldcols == 40)
x_cvstat.scaling /= 2;
if(x_cvstat.cols == 40)
x_cvstat.scaling *= 2;
}
if(x_cvstat.scaling < 1)
x_setscaling(1);
map_window();
/* Resize window if necessary. */
if((!(bitmap_width == 0 && bitmap_height == 0)) && (oldwidth != bitmap_width || oldheight != bitmap_height))
resize_window();
bitmap_drv_request_pixels();
sem_post(&mode_set);
return(0);
}
static int video_init()
{
/* If we are running under X, get a connection to the X server and create
an empty window of size (1, 1). It makes a couple of init functions a
lot easier. */ if(x_cvstat.scaling<1)
x_setscaling(1);
if(x_cvstat.vmultiplier<1)
x_cvstat.vmultiplier=1;
if(init_window())
return(-1);
bitmap_drv_init(x11_drawrect, x11_flush);
/* Initialize mode 3 (text, 80x25, 16 colors) */
if(init_mode(3)) {
return(-1);
}
sem_wait(&mode_set);
return(0);
}
static void local_draw_rect(struct update_rect *rect)
{
int x,y,xscale,yscale;
XImage *xim;
#if 0 /* Draw solid colour rectangles... */
int rectw, recth, rectc, y2;
for(y=0; y<rect->height; y++) {
for(x=0; x<rect->width; x++) {
rectc=rect->data[y*rect->width+x];
/* Already displayed? */
if(rectc == 255)
continue;
rectw=1;
recth=1;
/* Grow as wide as we can */
while(x+rectw < rect->width && rect->data[y*rect->width+x+rectw]==rectc)
rectw++;
/* Now grow as tall as we can */
while(y+recth < rect->height && memcmp(rect->data+(y*rect->width+x), rect->data+((y+recth)*rect->width+x), rectw)==0)
recth++;
/* Mark pixels as drawn */
for(y2=0; y2<recth; y2++)
memset(rect->data+((y+y2)*rect->width+x),255,rectw);
/* Draw it */
x11.XFillRectangle(dpy, win, gca[rectc], (rect->x+x)*x_cvstat.scaling, (rect->y+y)*x_cvstat.scaling*x_cvstat.vmultiplier, rectw*x_cvstat.scaling, recth*x_cvstat.scaling*x_cvstat.vmultiplier);
}
}
#else
#if 1 /* XImage */
xim=x11.XCreateImage(dpy,&visual,depth,ZPixmap,0,NULL,rect->width*x_cvstat.scaling,rect->height*x_cvstat.scaling*x_cvstat.vmultiplier,32,0);
xim->data=(char *)malloc(xim->bytes_per_line*rect->height*x_cvstat.scaling*x_cvstat.vmultiplier);
for(y=0;y<rect->height;y++) {
for(x=0; x<rect->width; x++) {
for(yscale=0; yscale<x_cvstat.scaling*x_cvstat.vmultiplier; yscale++) {
for(xscale=0; xscale<x_cvstat.scaling; xscale++) {
#ifdef XPutPixel
XPutPixel(xim,x*x_cvstat.scaling+xscale,y*x_cvstat.scaling*x_cvstat.vmultiplier+yscale,pixel[rect->data[y*rect->width+x]]);
#else
x11.XPutPixel(xim,x*x_cvstat.scaling+xscale,y*x_cvstat.scaling*x_cvstat.vmultiplier+yscale,pixel[rect->data[y*rect->width+x]]);
#endif
}
}
} }
x11.XPutImage(dpy,win,gca[0],xim,0,0,rect->x*x_cvstat.scaling,rect->y*x_cvstat.scaling*x_cvstat.vmultiplier,rect->width*x_cvstat.scaling,rect->height*x_cvstat.scaling*x_cvstat.vmultiplier);
#ifdef XDestroyImage
XDestroyImage(xim);
#else
x11.XDestroyImage(xim);
#endif
#else /* XFillRectangle */
for(y=0;y<rect->height;y++) {
for(x=0; x<rect->width; x++) {
x11.XFillRectangle(dpy, win, gca[rect->data[y*rect->width+x]], (rect->x+x)*x_cvstat.scaling, (rect->y+y)*x_cvstat.scaling*x_cvstat.vmultiplier, x_cvstat.scaling, x_cvstat.scaling*x_cvstat.vmultiplier);
}
}
#endif
#endif
free(rect->data);
}
static void handle_resize_event(int width, int height)
{
int newFSH=1;
int newFSW=1;
// No change
if((width == x_cvstat.charwidth * x_cvstat.cols * x_cvstat.scaling)
&& (height == x_cvstat.charheight * x_cvstat.rows * x_cvstat.scaling*x_cvstat.vmultiplier))
return;
newFSH=width/bitmap_width;
newFSW=height/bitmap_height;
if(newFSW<1)
newFSW=1;
if(newFSH<1)
newFSH=1;
if(newFSH<newFSW)
x_setscaling(newFSH);
else
x_setscaling(newFSW);
old_scaling = x_cvstat.scaling;
if(x_cvstat.scaling > 16)
x_setscaling(16);
/*
* We only need to resize if the width/height are not even multiples
* Otherwise, we can simply resend everything
*/
if((width % (x_cvstat.charwidth * x_cvstat.cols) != 0)
|| (height % (x_cvstat.charheight * x_cvstat.rows) != 0)) {
resize_window();
}
bitmap_drv_request_pixels();
}
static void expose_rect(int x, int y, int width, int height)
{
int sx,sy,ex,ey;
sx=x/x_cvstat.scaling;
sy=y/(x_cvstat.scaling*x_cvstat.vmultiplier);
ex=x+width-1;
ey=y+height-1;
if((ex+1)%x_cvstat.scaling) {
ex += x_cvstat.scaling-(ex%x_cvstat.scaling);
}
if((ey+1)%(x_cvstat.scaling*x_cvstat.vmultiplier)) {
ey += x_cvstat.scaling*x_cvstat.vmultiplier-(ey%(x_cvstat.scaling*x_cvstat.vmultiplier));
}
ex=ex/x_cvstat.scaling; ey=ey/(x_cvstat.scaling*x_cvstat.vmultiplier);
bitmap_drv_request_some_pixels(sx, sy, ex-sx+1, ey-sy+1);
}
static int x11_event(XEvent *ev)
{
switch (ev->type) {
case ClientMessage:
if (ev->xclient.format == 32 && ev->xclient.data.l[0] == WM_DELETE_WINDOW) {
uint16_t key=CIO_KEY_QUIT;
write(key_pipe[1], &key, 2);
}
break;
/* Graphics related events */
case ConfigureNotify:
x11_window_xpos=ev->xconfigure.x;
x11_window_ypos=ev->xconfigure.y;
x11_window_width=ev->xconfigure.width;
x11_window_height=ev->xconfigure.height;
handle_resize_event(ev->xconfigure.width, ev->xconfigure.height);
break;
case NoExpose:
break;
case GraphicsExpose:
expose_rect(ev->xgraphicsexpose.x, ev->xgraphicsexpose.y, ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
break;
case Expose:
expose_rect(ev->xexpose.x, ev->xexpose.y, ev->xexpose.width, ev->xexpose.height);
break;
/* Copy/Paste events */
case SelectionClear:
{
XSelectionClearEvent *req;
req=&(ev->xselectionclear);
pthread_mutex_lock(©buf_mutex);
if(req->selection==CONSOLE_CLIPBOARD)
FREE_AND_NULL(copybuf);
pthread_mutex_unlock(©buf_mutex);
}
break;
case SelectionNotify:
{
int format;
unsigned long len, bytes_left, dummy;
Atom type;
if(ev->xselection.selection != CONSOLE_CLIPBOARD)
break;
if(ev->xselection.requestor!=win)
break;
if(ev->xselection.property) {
x11.XGetWindowProperty(dpy, win, ev->xselection.property, 0, 0, 0, AnyPropertyType, &type, &format, &len, &bytes_left, (unsigned char **)(&pastebuf));
if(bytes_left > 0 && format==8)
x11.XGetWindowProperty(dpy, win, ev->xselection.property,0,bytes_left,0,AnyPropertyType,&type,&format,&len,&dummy,(unsigned char **)&pastebuf);
else
pastebuf=NULL;
}
else
pastebuf=NULL;
/* Set paste buffer */
sem_post(&pastebuf_set);
sem_wait(&pastebuf_used);
x11.XFree(pastebuf);
pastebuf=NULL;
}
break; case SelectionRequest:
{
XSelectionRequestEvent *req;
XEvent respond;
req=&(ev->xselectionrequest);
pthread_mutex_lock(©buf_mutex);
if(copybuf==NULL) {
respond.xselection.property=None;
}
else {
if(req->target==XA_STRING) {
x11.XChangeProperty(dpy, req->requestor, req->property, XA_STRING, 8, PropModeReplace, (unsigned char *)copybuf, strlen(copybuf));
respond.xselection.property=req->property;
}
else
respond.xselection.property=None;
}
respond.xselection.type=SelectionNotify;
respond.xselection.display=req->display;
respond.xselection.requestor=req->requestor;
respond.xselection.selection=req->selection;
respond.xselection.target=req->target;
respond.xselection.time=req->time;
x11.XSendEvent(dpy,req->requestor,0,0,&respond);
pthread_mutex_unlock(©buf_mutex);
}
break;
/* Mouse Events */
case MotionNotify:
{
XMotionEvent *me = (XMotionEvent *)ev;
me->x/=x_cvstat.scaling;
me->x/=x_cvstat.charwidth;
me->y/=x_cvstat.scaling;
me->y/=x_cvstat.vmultiplier;
me->y/=x_cvstat.charheight;
me->x++;
me->y++;
if(me->x<1)
me->x=1;
if(me->y<1)
me->y=1;
if(me->x>x_cvstat.cols)
me->x=x_cvstat.cols;
if(me->y>x_cvstat.rows+1)
me->y=x_cvstat.rows+1;
ciomouse_gotevent(CIOLIB_MOUSE_MOVE,me->x,me->y);
}
break;
case ButtonRelease:
{
XButtonEvent *be = (XButtonEvent *)ev;
be->x/=x_cvstat.scaling;
be->x/=x_cvstat.charwidth;
be->y/=x_cvstat.scaling;
be->y/=x_cvstat.vmultiplier;
be->y/=x_cvstat.charheight;
be->x++;
be->y++;
if(be->x<1)
be->x=1;
if(be->y<1)
be->y=1;
if(be->x>x_cvstat.cols)
be->x=x_cvstat.cols;
if(be->y>x_cvstat.rows+1) be->y=x_cvstat.rows+1;
if (be->button <= 3) {
ciomouse_gotevent(CIOLIB_BUTTON_RELEASE(be->button),be->x,be->y);
}
}
break;
case ButtonPress:
{
XButtonEvent *be = (XButtonEvent *)ev;
be->x/=x_cvstat.scaling;
be->x/=x_cvstat.charwidth;
be->y/=x_cvstat.scaling;
be->y/=x_cvstat.vmultiplier;
be->y/=x_cvstat.charheight;
be->x++;
be->y++;
if(be->x<1)
be->x=1;
if(be->y<1)
be->y=1;
if(be->x>x_cvstat.cols)
be->x=x_cvstat.cols;
if(be->y>x_cvstat.rows+1)
be->y=x_cvstat.rows+1;
if (be->button <= 3) {
ciomouse_gotevent(CIOLIB_BUTTON_PRESS(be->button),be->x,be->y);
}
}
break;
/* Keyboard Events */
case KeyPress:
{
static char buf[128];
KeySym ks;
int nlock = 0;
WORD scan = 0xffff;
x11.XLookupString((XKeyEvent *)ev, buf, sizeof(buf), &ks, 0);
switch (ks) {
case XK_Escape:
scan = 1;
goto docode;
case XK_Tab:
case XK_ISO_Left_Tab:
scan = 15;
goto docode;
case XK_Return:
case XK_KP_Enter:
scan = 28;
goto docode;
case XK_Print:
scan = 55;
goto docode;
case XK_F1:
case XK_F2:
case XK_F3:
case XK_F4:
case XK_F5:
case XK_F6:
case XK_F7:
case XK_F8:
case XK_F9: case XK_F10:
scan = ks - XK_F1 + 59;
goto docode;
case XK_KP_7:
nlock = 1;
case XK_Home:
case XK_KP_Home:
scan = 71;
goto docode;
case XK_KP_8:
nlock = 1;
case XK_Up:
case XK_KP_Up:
scan = 72;
goto docode;
case XK_KP_9:
nlock = 1;
case XK_Prior:
case XK_KP_Prior:
scan = 73;
goto docode;
case XK_KP_Subtract:
scan = 74;
goto docode;
case XK_KP_4:
nlock = 1;
case XK_Left:
case XK_KP_Left:
scan = 75;
goto docode;
case XK_KP_5:
nlock = 1;
case XK_Begin:
case XK_KP_Begin:
scan = 76;
goto docode;
case XK_KP_6:
nlock = 1;
case XK_Right:
case XK_KP_Right:
scan = 77;
goto docode;
case XK_KP_Add:
scan = 78;
goto docode;
case XK_KP_1:
nlock = 1;
case XK_End:
case XK_KP_End:
scan = 79;
goto docode;
case XK_KP_2:
nlock = 1;
case XK_Down:
case XK_KP_Down:
scan = 80;
goto docode;
case XK_KP_3:
nlock = 1; case XK_Next:
case XK_KP_Next:
scan = 81;
goto docode;
case XK_KP_0:
nlock = 1;
case XK_Insert:
case XK_KP_Insert:
scan = 82;
goto docode;
case XK_KP_Decimal:
nlock = 1;
scan = 83;
goto docode;
case XK_Delete:
case XK_KP_Delete:
/* scan = flipdelete ? 14 : 83; */
scan = 83;
goto docode;
case XK_BackSpace:
/* scan = flipdelete ? 83 : 14; */
scan = 14;
goto docode;
case XK_F11:
scan = 87;
goto docode;
case XK_F12:
scan = 88;
goto docode;
case XK_KP_Divide:
scan = Ascii2Scan['/'];
goto docode;
case XK_KP_Multiply:
scan = Ascii2Scan['*'];
goto docode;
default:
if (ks < ' ' || ks > '~')
break;
scan = Ascii2Scan[ks];
docode:
if (nlock)
scan |= 0x100;
if ((scan & ~0x100) > 88) {
scan = 0xffff;
break;
}
if (ev->xkey.state & Mod1Mask) {
scan = ScanCodes[scan & 0xff].alt;
} else if ((ev->xkey.state & ShiftMask) || (scan & 0x100)) {
scan = ScanCodes[scan & 0xff].shift;
} else if (ev->xkey.state & ControlMask) {
scan = ScanCodes[scan & 0xff].ctrl;
} else
scan = ScanCodes[scan & 0xff].base;
break;
}
if (scan != 0xffff) {
uint16_t key=scan; write(key_pipe[1], &key, (scan&0xff)?1:2);
}
return(1);
}
default:
break;
}
return(0);
}
void check_scaling(void)
{
if (old_scaling != x_cvstat.scaling) {
resize_window();
old_scaling = x_cvstat.scaling;
}
}
static void x11_terminate_event_thread(void)
{
terminate = 1;
sem_wait(&event_thread_complete);
}
static void local_set_palette(struct x11_palette_entry *p)
{
unsigned long *newpixel;
static GC *newgca;
size_t i;
size_t newpixelsz;
XGCValues gcv;
XColor color;
gcv.function = GXcopy;
gcv.foreground = white;
gcv.background = black;
gcv.graphics_exposures = False;
newpixelsz = p->index + 1;
if (pixelsz < newpixelsz) {
newpixel = realloc(pixel, sizeof(pixel[0])*newpixelsz);
if (newpixel == NULL)
// TODO: Handle failure!
return;
pixel = newpixel;
newgca = realloc(gca, sizeof(gca[0])*newpixelsz);
if (newgca == NULL)
// TODO: Handle failure!
return;
gca = newgca;
/* Set all empty colours to black. */
for (i = pixelsz; i < (newpixelsz-1); i++) {
color.red=0;
color.green=0;
color.blue=0;
if(x11.XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &color))
pixel[i]=color.pixel;
gcv.foreground=color.pixel;
gca[i]=x11.XCreateGC(dpy, win, GCFunction | GCForeground | GCBackground | GCGraphicsExposures, &gcv);
}
pixelsz = newpixelsz;
}
else {
/* Free old colour first */
x11.XFreeColors(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &pixel[p->index], 1, 0);
}
/* Now set new colour */
color.red=p->r;
color.green=p->g;
color.blue=p->b; if(x11.XAllocColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), &color))
pixel[p->index]=color.pixel;
gcv.foreground=color.pixel;
gca[p->index]=x11.XCreateGC(dpy, win, GCFunction | GCForeground | GCBackground | GCGraphicsExposures, &gcv);
expose_rect(0, 0, x11_window_width, x11_window_height);
}
static void readev(struct x11_local_event *lev)
{
fd_set rfd;
int ret;
int rcvd = 0;
char *buf = (char *)lev;
FD_ZERO(&rfd);
FD_SET(local_pipe[0], &rfd);
while (rcvd < sizeof(*lev)) {
select(local_pipe[0]+1, &rfd, NULL, NULL, NULL);
ret = read(local_pipe[0], buf+rcvd, sizeof(*lev) - rcvd);
if (ret > 0)
rcvd += ret;
}
}
void x11_event_thread(void *args)
{
int x;
int high_fd;
fd_set fdset;
XEvent ev;
static struct timeval tv;
SetThreadName("X11 Events");
if(video_init()) {
sem_post(&init_complete);
return;
}
x11_initialized=1;
sem_init(&event_thread_complete, 0, 0);
atexit(x11_terminate_event_thread);
sem_post(&init_complete);
if(local_pipe[0] > xfd)
high_fd=local_pipe[0];
else
high_fd=xfd;
for (;!terminate;) {
check_scaling();
tv.tv_sec=0;
tv.tv_usec=54925; /* was 54925 (was also 10) */
/*
* Handle any events just sitting around...
*/
while (QLength(dpy) > 0) {
x11.XNextEvent(dpy, &ev);
x11_event(&ev);
}
FD_ZERO(&fdset);
FD_SET(xfd, &fdset);
FD_SET(local_pipe[0], &fdset);
x = select(high_fd+1, &fdset, 0, 0, &tv);
switch (x) {
case -1: /*
* Errno might be wrong, so we just select again.
* This could cause a problem is something really
* was wrong with select....
*/
/* perror("select"); */
break;
case 0:
/* Timeout */
break;
default:
if (FD_ISSET(xfd, &fdset)) {
x11.XNextEvent(dpy, &ev);
x11_event(&ev);
}
while(FD_ISSET(local_pipe[0], &fdset)) {
struct x11_local_event lev;
readev(&lev);
switch(lev.type) {
case X11_LOCAL_SETMODE:
init_mode(lev.data.mode);
break;
case X11_LOCAL_SETNAME:
x11.XSetIconName(dpy, win, lev.data.name);
x11.XFlush(dpy);
break;
case X11_LOCAL_SETTITLE:
x11.XStoreName(dpy, win, lev.data.title);
x11.XFlush(dpy);
break;
case X11_LOCAL_COPY:
x11.XSetSelectionOwner(dpy, CONSOLE_CLIPBOARD, win, CurrentTime);
break;
case X11_LOCAL_PASTE:
{
Window sowner=None;
sowner=x11.XGetSelectionOwner(dpy, CONSOLE_CLIPBOARD);
if(sowner==win) {
/* Get your own primary selection */
if(copybuf==NULL)
pastebuf=NULL;
else
pastebuf=strdup(copybuf);
/* Set paste buffer */
sem_post(&pastebuf_set);
sem_wait(&pastebuf_used);
FREE_AND_NULL(pastebuf);
}
else if(sowner!=None) {
x11.XConvertSelection(dpy, CONSOLE_CLIPBOARD, XA_STRING, XA_STRING, win, CurrentTime);
}
else {
/* Set paste buffer */
pastebuf=NULL;
sem_post(&pastebuf_set);
sem_wait(&pastebuf_used);
}
}
break;
case X11_LOCAL_DRAWRECT:
local_draw_rect(&lev.data.rect);
break;
case X11_LOCAL_FLUSH:
x11.XFlush(dpy);
break;
case X11_LOCAL_BEEP:
x11.XBell(dpy, 100); break;
case X11_LOCAL_SETPALETTE:
local_set_palette(&lev.data.palette);
break;
}
tv.tv_sec=0;
tv.tv_usec=0;
FD_ZERO(&fdset);
FD_SET(local_pipe[0], &fdset);
if(select(local_pipe[0]+1, &fdset, 0, 0, &tv)!=1)
FD_ZERO(&fdset);
}
}
}
x11.XCloseDisplay(dpy);
sem_post(&event_thread_complete);
}