-
Deucе authoredOn expose, always redraw the entire screen. The calculations were wrong and with fractional scaling, some of them will always be wrong. Don't clear the screen when xim is resized.
Deucе authoredOn expose, always redraw the entire screen. The calculations were wrong and with fractional scaling, some of them will always be wrong. Don't clear the screen when xim is resized.
x_events.c 59.08 KiB
/*
* This file contains ONLY the functions that are called from the
* event thread.
*/
#include <math.h>
#include <unistd.h>
#include <stdbool.h>
#include <fcntl.h>
#include <limits.h>
#include <locale.h>
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <X11/cursorfont.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 "scale.h"
#include "x_events.h"
#include "x_cio.h"
#include "utf8_codepages.h"
static bool send_fullscreen(bool set);
static void resize_window();
/*
* 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_initialized=0;
static sem_t event_thread_complete;
static int terminate = 0;
Atom copybuf_format;
static Atom pastebuf_format;
bool xrender_found;
bool xinerama_found;
bool xrandr_found;
bool x_internal_scaling = true;
/*
* Local variables
*/
enum UsedAtom {
// UTF8_STRING: https://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text
ATOM_UTF8_STRING,
// ICCM: https://x.org/releases/X11R7.6/doc/xorg-docs/specs/ICCCM/icccm.html
ATOM_CLIPBOARD,
ATOM_TARGETS,
ATOM_WM_CLASS,
ATOM_WM_DELETE_WINDOW,
// EWMH: https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.html
ATOM__NET_FRAME_EXTENTS,
ATOM__NET_SUPPORTED,
ATOM__NET_SUPPORTING_WM_CHECK,
ATOM__NET_WM_DESKTOP,
ATOM__NET_WM_ICON,
ATOM__NET_WM_ICON_NAME,
ATOM__NET_WM_NAME,
ATOM__NET_WM_PID,
ATOM__NET_WM_PING,
ATOM__NET_WM_STATE,
ATOM__NET_WM_STATE_FULLSCREEN,
ATOM__NET_WM_STATE_MAXIMIZED_VERT,
ATOM__NET_WM_STATE_MAXIMIZED_HORZ,
ATOM__NET_WM_WINDOW_TYPE,
ATOM__NET_WM_WINDOW_TYPE_NORMAL,
ATOM__NET_WORKAREA,
ATOMCOUNT
};
enum AtomStandard {
UTF8_ATOM,
ICCM_ATOM,
EWMH_ATOM
};
static uint32_t supported_standards;
#define XA_UTF8_STRING (0x10000000UL)
static struct AtomDef {
const char * const name;
const enum AtomStandard standard;
Atom req_type;
const int format;
Atom atom;
bool supported;
} SupportedAtoms[ATOMCOUNT] = {
// UTF8_STRING: https://www.pps.jussieu.fr/~jch/software/UTF8_STRING/UTF8_STRING.text
{"UTF8_STRING", UTF8_ATOM, None, 0, None, false},
// ICCM: https://x.org/releases/X11R7.6/doc/xorg-docs/specs/ICCCM/icccm.html
{"CLIPBOARD", ICCM_ATOM, XA_ATOM, 32, None, false},
{"TARGETS", ICCM_ATOM, XA_ATOM, 32, None, false},
{"WM_CLASS", ICCM_ATOM, XA_STRING, 8, None, false},
{"WM_DELETE_WINDOW", ICCM_ATOM, None, 0, None, false},
// EWMH: https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.html
{"_NET_FRAME_EXTENTS", EWMH_ATOM, XA_CARDINAL, 32, None, false},
{"_NET_SUPPORTED", EWMH_ATOM, XA_ATOM, 32, None, false},
{"_NET_SUPPORTING_WM_CHECK", EWMH_ATOM, XA_WINDOW, 32, None, false},
{"_NET_WM_DESKTOP", EWMH_ATOM, XA_CARDINAL, 32, None, false},
{"_NET_WM_ICON", EWMH_ATOM, XA_CARDINAL, 32, None, false},
{"_NET_WM_ICON_NAME", EWMH_ATOM, XA_UTF8_STRING, 8, None, false},
{"_NET_WM_NAME", EWMH_ATOM, XA_UTF8_STRING, 8, None, false},
{"_NET_WM_PID", EWMH_ATOM, XA_CARDINAL, 32, None, false},
{"_NET_WM_PING", EWMH_ATOM, None, 0, None, false},
{"_NET_WM_STATE", EWMH_ATOM, XA_ATOM, 32, None, false},
{"_NET_WM_STATE_FULLSCREEN", EWMH_ATOM, None, 0, None, false},
{"_NET_WM_STATE_MAXIMIZED_VERT", EWMH_ATOM, None, 0, None, false},
{"_NET_WM_STATE_MAXIMIZED_HORZ", EWMH_ATOM, None, 0, None, false},
{"_NET_WM_WINDOW_TYPE", EWMH_ATOM, XA_ATOM, 32, None, false},
{"_NET_WM_WINDOW_TYPE_NORMAL", EWMH_ATOM, None, 0, None, false},
{"_NET_WORKAREA", EWMH_ATOM, XA_CARDINAL, 4, None, false},};
#define A(name) SupportedAtoms[ATOM_ ## name].atom
/* Sets the atom to be used for copy/paste operations */
static const long _NET_WM_STATE_REMOVE = 0;
static const long _NET_WM_STATE_ADD = 1;
static Display *dpy=NULL;
static Window win;
static Cursor curs = None;
static Visual *visual;
static Colormap wincmap;
static Pixmap icn;
static Pixmap icn_mask;
static bool VisualIsRGB8 = false;
static XImage *xim;
static XIM im;
static XIC ic;
static unsigned int depth=0;
static int xfd;
static unsigned long black;
static unsigned long white;
struct video_stats x_cvstat;
static unsigned long base_pixel;
static int r_shift;
static int g_shift;
static int b_shift;
static struct graphics_buffer *last = NULL;
#ifdef WITH_XRENDER
static XRenderPictFormat *xrender_pf = NULL;
static Pixmap xrender_pm = None;
static Picture xrender_src_pict = None;
static Picture xrender_dst_pict = None;
#endif
static bool fullscreen;
static Window parent;
static Window root;
static char *wm_wm_name;
static Atom copy_paste_selection = XA_PRIMARY;
static bool map_pending = true;
static int pending_width, pending_height, pending_xpos, pending_ypos;
/* Array of Graphics Contexts */
static GC gc;
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 */
{ CIO_KEY_IC, CIO_KEY_SHIFT_IC, CIO_KEY_CTRL_IC, CIO_KEY_ALT_IC}, /* key 82 - insert */
{ CIO_KEY_DC, CIO_KEY_SHIFT_DC, CIO_KEY_CTRL_DC, CIO_KEY_ALT_IC}, /* 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 */
};
static struct AtomDef *
get_atom_def(Atom atom)
{
enum UsedAtom a;
for (a = 0; a < ATOMCOUNT; a++) {
if (SupportedAtoms[a].atom == atom)
return &SupportedAtoms[a];
}
return NULL;
}
static void
initialize_atoms(void)
{
enum UsedAtom a;
Atom atr;
int afr;
unsigned long nir;
unsigned long bytes_left = 4;
unsigned char *prop = NULL;
Window w;
Atom atom;
struct AtomDef *ad;
long offset;
supported_standards |= (1 << UTF8_ATOM);
supported_standards |= (1 << ICCM_ATOM);
for (a = 0; a < ATOMCOUNT; a++) {
SupportedAtoms[a].atom = x11.XInternAtom(dpy, (char *)SupportedAtoms[a].name, False);
}
if (A(UTF8_STRING) == None)
supported_standards &= ~(1 << UTF8_ATOM);
if (supported_standards & (1 << UTF8_ATOM)) {
if (x11.XGetWindowProperty(dpy, root, A(_NET_SUPPORTING_WM_CHECK), 0, 1, False, XA_WINDOW, &atr, &afr, &nir, &bytes_left, &prop) == Success) {
if (atr == XA_WINDOW) {
if (nir == 1) {
w = *(Window *)prop;
x11.XFree(prop);
prop = NULL;
if (x11.XGetWindowProperty(dpy, w, A(_NET_SUPPORTING_WM_CHECK), 0, 1, False, AnyPropertyType, &atr, &afr, &nir, &bytes_left, &prop) == Success) {
if (atr == XA_WINDOW) {
if (nir == 1) {
if (w == *(Window *)prop) { supported_standards |= (1 << EWMH_ATOM);
}
}
}
}
if (prop != NULL)
x11.XFree(prop);
if (x11.XGetWindowProperty(dpy, w, A(_NET_WM_NAME), 0, 0, False, AnyPropertyType, &atr, &afr, &nir, &bytes_left, &prop) == Success) {
if (prop != NULL)
x11.XFree(prop);
if (afr == 8) {
if (wm_wm_name != NULL)
free(wm_wm_name);
wm_wm_name = malloc(bytes_left + 1);
if (x11.XGetWindowProperty(dpy, w, A(_NET_WM_NAME), 0, bytes_left, False, AnyPropertyType, &atr, &afr, &nir, &bytes_left, &prop) == Success) {
if (afr == 8) {
memcpy(wm_wm_name, prop, nir);
wm_wm_name[nir] = 0;
}
}
}
}
}
}
if (prop != NULL)
x11.XFree(prop);
}
}
if (!(supported_standards & (1 << EWMH_ATOM))) {
for (a = 0; a < ATOMCOUNT; a++) {
if (SupportedAtoms[a].standard == EWMH_ATOM)
SupportedAtoms[a].atom = None;
}
}
else {
for (offset = 0, bytes_left = 1; bytes_left; offset += nir) {
if (x11.XGetWindowProperty(dpy, root, A(_NET_SUPPORTED), offset, 1, False, XA_ATOM, &atr, &afr, &nir, &bytes_left, &prop) != Success)
break;
if (atr != XA_ATOM) {
x11.XFree(prop);
break;
}
atom = *(Atom *)prop;
x11.XFree(prop);
if (atom != None) {
ad = get_atom_def(atom);
if (ad != NULL)
ad->supported = true;
}
}
for (a = 0; a < ATOMCOUNT; a++) {
if (SupportedAtoms[a].atom != None) {
if (SupportedAtoms[a].standard != EWMH_ATOM)
SupportedAtoms[a].supported = true;
if (!SupportedAtoms[a].supported) {
SupportedAtoms[a].atom = None;
}
}
}
}
for (a = 0; a < ATOMCOUNT; a++) {
if (SupportedAtoms[a].req_type == XA_UTF8_STRING) {
if (A(UTF8_STRING) == None) {
SupportedAtoms[a].supported = false;
SupportedAtoms[a].atom = None;
}
else {
SupportedAtoms[a].req_type = A(UTF8_STRING); }
}
}
/*
* ChromeOS doesn't do anything reasonable with PRIMARY...
* Hack in use of CLIPBOARD instead.
*/
if (wm_wm_name != NULL && strcmp(wm_wm_name, "Sommelier") == 0) {
if (A(CLIPBOARD) != None)
copy_paste_selection = A(CLIPBOARD);
}
}
static bool
set_win_property(enum UsedAtom atom, Atom type, int format, int action, const void *value, int count)
{
struct AtomDef *ad = &SupportedAtoms[atom];
if (ad->atom == None)
return false;
if (!(supported_standards & (1 << ad->standard)))
return false;
return (x11.XChangeProperty(dpy, win, ad->atom, type, format, action, (unsigned char *)value, count) != 0);
}
static bool
fullscreen_geometry(int *x_org, int *y_org, int *width, int *height)
{
Window root;
Window cr;
uint64_t dummy;
unsigned int rw, rh;
int wx, wy;
#if defined(WITH_XRANDR) || defined(WITH_XINERAMA)
int cx, cy;
#endif
#ifdef WITH_XRANDR
static XRRScreenResources *xrrsr = NULL;
XRRCrtcInfo *xrrci = NULL;
int searched = 0;
bool found;
#endif
#ifdef WITH_XINERAMA
int i;
int nscrn;
XineramaScreenInfo *xsi;
#endif
if (win == 0)
return false;
if (x11.XGetGeometry(dpy, win, (void *)&root, &wx, &wy, &rw, &rh, (void *)&dummy, (void *)&dummy) == 0)
return false;
#if defined(WITH_XRANDR) || defined(WITH_XINERAMA)
x11.XTranslateCoordinates(dpy, win, root, wx, wy, &cx, &cy, &cr);
cx += rw / 2;
cy += rh / 2;
#endif
#ifdef WITH_XRANDR
// We likely don't actually need Ximerama... this is always better and almost certainly present
if (xrandr_found) {
searched = 0;
found = false;
while (searched < 10 && found == false) {
searched++;
if (xrrsr == NULL)
xrrsr = x11.XRRGetScreenResources(dpy, root); if (xrrsr == NULL)
break;
for (i = 0; i < xrrsr->ncrtc; i++) {
if (xrrci != NULL)
x11.XRRFreeCrtcInfo(xrrci);
xrrci = x11.XRRGetCrtcInfo(dpy, xrrsr, xrrsr->crtcs[i]);
if (xrrci == NULL) {
x11.XRRFreeScreenResources(xrrsr);
xrrsr = NULL;
break;
}
if (cx >= xrrci->x && cx < xrrci->x + xrrci->width
&& cy >= xrrci->y && cy < xrrci->y + xrrci->height) {
found = true;
break;
}
}
}
if (xrrsr != NULL && !found) {
if (xrrci != NULL)
x11.XRRFreeCrtcInfo(xrrci);
xrrci = x11.XRRGetCrtcInfo(dpy, xrrsr, xrrsr->crtcs[0]);
if (xrrci != NULL)
found = true;
}
if (found) {
if (x_org)
*x_org = xrrci->x;
if (y_org)
*y_org = xrrci->y;
if (width)
*width = xrrci->width;
if (height)
*height = xrrci->height;
if (xrrci != NULL)
x11.XRRFreeCrtcInfo(xrrci);
return true;
}
if (xrrci != NULL)
x11.XRRFreeCrtcInfo(xrrci);
}
#endif
#ifdef WITH_XINERAMA
if (xinerama_found) {
// NOTE: Xinerama is limited to a short for the entire screen dimensions.
if ((xsi = x11.XineramaQueryScreens(dpy, &nscrn)) != NULL && nscrn != 0) {
for (i = 0; i < nscrn; i++) {
if (cx >= xsi[i].x_org && cx < xsi[i].x_org + xsi[i].width
&& cy >= xsi[i].y_org && cy < xsi[i].y_org + xsi[i].height) {
break;
}
}
if (i == nscrn)
i = 0;
if (x_org)
*x_org = xsi[i].x_org;
if (y_org)
*y_org = xsi[i].y_org;
if (width)
*width = xsi[i].width;
if (height)
*height = xsi[i].height;
x11.XFree(xsi);
return true;
}
}
#endif
if (x_org)
*x_org = 0;
if (y_org) *y_org = 0;
if (width)
*width = rw;
if (height)
*height = rh;
return true;
}
static bool
x11_get_maxsize(int *w, int *h)
{
int i;
long offset;
int maxw = 0, maxh = 0;
Atom atr;
int afr;
long *ret;
unsigned long nir;
unsigned long bytes_left;
unsigned char *prop;
long desktop = -1;
if (dpy == NULL)
return false;
if (fullscreen) {
// TODO: We may not need this if we can wait for ConfigurNotify on fullscreen...
return fullscreen_geometry(NULL, NULL, w, h);
}
else {
// First, try to get _NET_WORKAREA...
if (A(_NET_WM_DESKTOP) != None && win != 0) {
if (x11.XGetWindowProperty(dpy, win, A(_NET_WM_DESKTOP), 0, 1, False, XA_CARDINAL, &atr, &afr, &nir, &bytes_left, &prop) == Success) {
if (atr == XA_CARDINAL && afr == 32 && nir > 0) {
desktop = *(long *)prop;
}
x11.XFree(prop);
}
}
if (A(_NET_WORKAREA) != None) {
for (i = 0, offset = 0, bytes_left = 1; bytes_left; i++, offset += nir) {
if (x11.XGetWindowProperty(dpy, root, A(_NET_WORKAREA), offset, 4, False, XA_CARDINAL, &atr, &afr, &nir, &bytes_left, &prop) != Success)
break;
if (atr != XA_CARDINAL) {
x11.XFree(prop);
break;
}
ret = (long *)prop;
if (desktop == -1) {
if (nir >= 3) {
if (ret[2] > maxw)
maxw = ret[2];
}
if (nir >= 4) {
if (ret[3] > maxh)
maxh = ret[3];
}
}
else if (desktop == i) {
if (nir >= 3)
maxw = ret[2];
if (nir >= 4)
maxh = ret[3];
x11.XFree(prop);
break;
}
x11.XFree(prop);
}
}
if (maxw > 0 && maxh > 0) {
if (A(_NET_FRAME_EXTENTS) != None && win != 0) { if (x11.XGetWindowProperty(dpy, win, A(_NET_FRAME_EXTENTS), 0, 4, False, XA_CARDINAL, &atr, &afr, &nir, &bytes_left, &prop) == Success) {
if (atr == XA_CARDINAL && afr == 32 && nir == 4) {
ret = (long *)prop;
maxw -= ret[0] + ret[1];
maxh -= ret[2] + ret[3];
}
x11.XFree(prop);
}
}
}
}
// Couldn't get work area, get size of screen instead. :(
if (maxw == 0 || maxh == 0) {
// We could just use root window size here...
fullscreen_geometry(NULL, NULL, &maxw, &maxh);
}
if (maxw != 0 && maxh != 0) {
*w = maxw;
*h = maxh;
return true;
}
return false;
}
static void
resize_pictures(void)
{
#ifdef WITH_XRENDER
int iw, ih;
if (xrender_found) {
if (xrender_pf == NULL)
xrender_pf = x11.XRenderFindStandardFormat(dpy, PictStandardRGB24);
if (xrender_pf == NULL)
xrender_pf = x11.XRenderFindVisualFormat(dpy, visual);
if (xrender_pf == NULL)
xrender_pf = x11.XRenderFindVisualFormat(dpy, DefaultVisual(dpy, DefaultScreen(dpy)));
if (xrender_pm != None)
x11.XFreePixmap(dpy, xrender_pm);
xrender_pm = x11.XCreatePixmap(dpy, win, x_cvstat.scrnwidth, x_cvstat.scrnheight, depth);
if (xrender_src_pict != None)
x11.XRenderFreePicture(dpy, xrender_src_pict);
if (xrender_dst_pict != None)
x11.XRenderFreePicture(dpy, xrender_dst_pict);
XRenderPictureAttributes pa;
xrender_src_pict = x11.XRenderCreatePicture(dpy, xrender_pm, xrender_pf, 0, &pa);
xrender_dst_pict = x11.XRenderCreatePicture(dpy, win, xrender_pf, 0, &pa);
x11.XRenderSetPictureFilter(dpy, xrender_src_pict, "best", NULL, 0);
pthread_mutex_lock(&vstatlock);
bitmap_get_scaled_win_size(vstat.scaling, &iw, &ih, 0, 0);
pthread_mutex_unlock(&vstatlock);
XTransform transform_matrix = {{
{XDoubleToFixed((double)vstat.scrnwidth / iw), XDoubleToFixed(0), XDoubleToFixed(0)},
{XDoubleToFixed(0), XDoubleToFixed((double)vstat.scrnheight / ih), XDoubleToFixed(0)},
{XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1.0)}
}};
x11.XRenderSetPictureTransform(dpy, xrender_src_pict, &transform_matrix);
}
#endif
}
static void resize_xim(void)
{
int width, height;
resize_pictures(); if (x_internal_scaling) {
pthread_mutex_lock(&vstatlock);
bitmap_get_scaled_win_size(x_cvstat.scaling, &width, &height, 0, 0);
pthread_mutex_unlock(&vstatlock);
}
else {
width = x_cvstat.scrnwidth;
height = x_cvstat.scrnheight;
}
if (xim) {
if (width == xim->width
&& height == xim->height) {
if (last) {
release_buffer(last);
last = NULL;
}
return;
}
#ifdef XDestroyImage
XDestroyImage(xim);
#else
x11.XDestroyImage(xim);
#endif
}
if (last) {
release_buffer(last);
last = NULL;
}
xim = x11.XCreateImage(dpy, visual, depth, ZPixmap, 0, NULL, width, height, 32, 0);
xim->data=(char *)calloc(1, xim->bytes_per_line*xim->height);
}
/* Swiped from FreeBSD libc */
static int
my_fls(unsigned long mask)
{
int bit;
if (mask == 0)
return (0);
for (bit = 1; mask != 1; bit++)
mask = mask >> 1;
return (bit);
}
/*
* 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);
}
if (x11_get_maxsize(&sh->max_width,&sh->max_height)) {
pthread_mutex_lock(&vstatlock);
if (!fullscreen)
bitmap_get_scaled_win_size(bitmap_double_mult_inside(sh->max_width, sh->max_height), &sh->max_width, &sh->max_height, sh->max_width, sh->max_height);
}
else {
pthread_mutex_lock(&vstatlock);
bitmap_get_scaled_win_size(7.0, &sh->max_width, &sh->max_height, 0, 0);
}
bitmap_get_scaled_win_size(x_cvstat.scaling, &sh->base_width, &sh->base_height, 0, 0); sh->width = sh->base_width;
sh->height = sh->base_height;
bitmap_get_scaled_win_size(1.0, &sh->min_width, &sh->min_height, 0, 0);
pthread_mutex_unlock(&vstatlock);
if (x_cvstat.aspect_width != 0 && x_cvstat.aspect_height != 0) {
sh->min_aspect.x = sh->max_aspect.x = x_cvstat.aspect_width;
sh->min_aspect.y = sh->max_aspect.y = x_cvstat.aspect_height;
}
else {
sh->min_aspect.x = sh->max_aspect.x = sh->min_width;
sh->min_aspect.y = sh->max_aspect.y = sh->min_height;
}
sh->flags = PMinSize | PSize | PAspect | PMaxSize | PBaseSize;
x11.XSetWMNormalHints(dpy, win, sh);
pthread_mutex_lock(&vstatlock);
vstat.scaling = x_cvstat.scaling;
pthread_mutex_unlock(&vstatlock);
if (map_pending)
x11.XMapWindow(dpy, win);
x11.XFree(sh);
return;
}
static void
set_icon(const void *data, size_t width, XWMHints *hints)
{
const uint32_t *idata = data;
Pixmap opm = icn;
Pixmap opmm = icn_mask;
XGCValues gcv = {
.function = GXcopy,
.foreground = black | 0xff000000,
.background = white
};
int x,y,i;
GC igc, imgc;
bool fail = false;
unsigned short tmp;
XColor fg;
bool sethints = (hints == NULL);
unsigned long lasti = ULONG_MAX, lastim = ULONG_MAX;
// This is literally the wost possible way to create a pixmap. :)
/*
* This whole mess was added to get the icon working on ChromeOS...
* as it happens, ChromeOS doesn't actually use the X11 icons at
* all for anything ever. Instead it does some weird hackery in
* the icon theme and pulls the icon files out to the host.
* Leaving this here though since it is marginally "better" aside
* from the insane method to create a Pixmap.
*/
icn = x11.XCreatePixmap(dpy, root, width, width, depth);
igc = x11.XCreateGC(dpy, icn, GCFunction | GCForeground | GCBackground | GCGraphicsExposures, &gcv);
icn_mask = x11.XCreatePixmap(dpy, root, width, width, 1);
imgc = x11.XCreateGC(dpy, icn_mask, GCFunction | GCForeground | GCBackground | GCGraphicsExposures, &gcv);
fail = (!icn) || (!icn_mask);
if (!fail) {
for (x = 0, i = 0; x < width; x++) {
for (y = 0; y < width; y++) {
if (idata[i] & 0xff000000) {
if (VisualIsRGB8)
fg.pixel = idata[i] & 0xffffff;
else {
tmp = (idata[i] & 0xff);
fg.red = tmp << 8 | tmp; tmp = (idata[i] & 0xff00) >> 8;
fg.green = tmp << 8 | tmp;
tmp = (idata[i] & 0xff0000) >> 16;
fg.blue = tmp << 8 | tmp;
fg.flags = DoRed | DoGreen | DoBlue;
if (x11.XAllocColor(dpy, wincmap, &fg) == 0)
fail = true;
}
if (fail)
break;
if (lasti != fg.pixel) {
x11.XSetForeground(dpy, igc, fg.pixel);
lasti = fg.pixel;
}
x11.XDrawPoint(dpy, icn, igc, y, x);
if (lastim != white) {
x11.XSetForeground(dpy, imgc, white);
lastim = white;
}
x11.XDrawPoint(dpy, icn_mask, imgc, y, x);
}
else {
if (lastim != black) {
x11.XSetForeground(dpy, imgc, black);
lastim = black;
}
x11.XDrawPoint(dpy, icn_mask, imgc, y, x);
}
i++;
}
if (fail)
break;
}
}
if (!fail) {
if (!hints)
hints = x11.XGetWMHints(dpy, win);
if (!hints)
hints = x11.XAllocWMHints();
if (hints) {
hints->flags |= IconPixmapHint | IconMaskHint;
hints->icon_pixmap = icn;
hints->icon_mask = icn_mask;
if (sethints) {
x11.XSetWMHints(dpy, win, hints);
x11.XFree(hints);
}
if (opm)
x11.XFreePixmap(dpy, opm);
if (opmm)
x11.XFreePixmap(dpy, opmm);
}
}
x11.XFreeGC(dpy, igc);
x11.XFreeGC(dpy, imgc);
}
/* Get a connection to the X server and create the window. */
static int init_window()
{
XGCValues gcv;
XWMHints *wmhints;
XClassHint *classhints;
int w, h;
int mw, mh;
int screen;
int major, minor;
unsigned long pid_l;
Atom a;
dpy = x11.XOpenDisplay(NULL);
if (dpy == NULL) {
return(-1);
}
root = DefaultRootWindow(dpy);
x11.XSynchronize(dpy, False);
#ifdef WITH_XRENDER
if (xrender_found && x11.XRenderQueryVersion(dpy, &major, &minor) == 0)
xrender_found = false;
#endif
#ifdef WITH_XINERAMA
if (xinerama_found && x11.XineramaQueryVersion(dpy, &major, &minor) == 0)
xinerama_found = false;
#endif
#ifdef WITH_XRANDR
if (xrandr_found && x11.XRRQueryVersion(dpy, &major, &minor) == 0)
xrandr_found = false;
#endif
xfd = ConnectionNumber(dpy);
initialize_atoms();
screen = DefaultScreen(dpy);
#ifdef DefaultVisual
visual = DefaultVisual(dpy, screen);
#else
visual = x11.DefaultVisual(dpy, screen);
#endif
#ifdef DefaultDepth
depth = DefaultDepth(dpy, screen);
#else
depth = x11.DefaultDepth(dpy, screen);
#endif
base_pixel = ULONG_MAX;
base_pixel &= ~visual->red_mask;
base_pixel &= ~visual->green_mask;
base_pixel &= ~visual->blue_mask;
r_shift = my_fls(visual->red_mask)-16;
g_shift = my_fls(visual->green_mask)-16;
b_shift = my_fls(visual->blue_mask)-16;
if (visual->red_mask == 0xff0000 && visual->green_mask == 0xff00 && visual->blue_mask == 0xff)
VisualIsRGB8 = true;
/* Allocate black and white */
black=BlackPixel(dpy, DefaultScreen(dpy));
white=WhitePixel(dpy, DefaultScreen(dpy));
/* Create window, but defer setting a size and GC. */
XSetWindowAttributes wa = {0};
parent = root;
wincmap = x11.XCreateColormap(dpy, root, visual, AllocNone);
x11.XInstallColormap(dpy, wincmap);
wa.colormap = wincmap;
wa.background_pixel = black;
wa.border_pixel = black;
x11_get_maxsize(&mw, &mh);
pthread_mutex_lock(&vstatlock);
bitmap_get_scaled_win_size(x_cvstat.scaling, &w, &h, mw, mh);
vstat.winwidth = x_cvstat.winwidth = w;
vstat.winheight = x_cvstat.winheight = h;
vstat.scaling = x_cvstat.scaling;
pthread_mutex_unlock(&vstatlock);
win = x11.XCreateWindow(dpy, parent, 0, 0,
w, h, 2, depth, InputOutput, visual, CWColormap | CWBorderPixel | CWBackPixel, &wa);
classhints=x11.XAllocClassHint();
if (classhints) {
classhints->res_name = (char *)ciolib_initial_program_name;
classhints->res_class = (char *)ciolib_initial_program_class; }
wmhints=x11.XAllocWMHints();
if(wmhints) {
wmhints->flags = 0;
wmhints->initial_state=NormalState;
wmhints->flags |= (StateHint | InputHint);
wmhints->input = True;
set_icon(ciolib_initial_icon, ciolib_initial_icon_width, wmhints);
x11.XSetWMProperties(dpy, win, NULL, NULL, 0, 0, NULL, wmhints, classhints);
x11.XFree(wmhints);
}
set_win_property(ATOM__NET_WM_ICON, XA_CARDINAL, 32, PropModeReplace, ciolib_initial_icon, ciolib_initial_icon_width * ciolib_initial_icon_width);
pid_l = getpid();
set_win_property(ATOM__NET_WM_PID, XA_CARDINAL, 32, PropModeReplace, &pid_l, 1);
a = A(_NET_WM_WINDOW_TYPE_NORMAL);
if (a != None)
set_win_property(ATOM__NET_WM_WINDOW_TYPE, XA_ATOM, 32, PropModeReplace, &a, 1);
a = A(_NET_WM_STATE_FULLSCREEN);
if (a != None)
set_win_property(ATOM__NET_WM_STATE, XA_ATOM, 32, PropModeReplace, &a, 1);
im = x11.XOpenIM(dpy, NULL, "CIOLIB", "CIOLIB");
if (im != NULL) {
ic = x11.XCreateIC(im, XNClientWindow, win, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, NULL);
if (ic)
x11.XSetICFocus(ic);
}
if (classhints)
x11.XFree(classhints);
gcv.function = GXcopy;
gcv.foreground = black | 0xff000000;
gcv.background = white;
gcv.graphics_exposures = False;
gc=x11.XCreateGC(dpy, win, GCFunction | GCForeground | GCBackground | GCGraphicsExposures, &gcv);
x11.XSelectInput(dpy, win, KeyReleaseMask | KeyPressMask |
ExposureMask | ButtonPressMask
| ButtonReleaseMask | PointerMotionMask | StructureNotifyMask);
x11.XStoreName(dpy, win, "SyncConsole");
Atom protos[2];
int i = 0;
if (A(WM_DELETE_WINDOW) != None)
protos[i++] = A(WM_DELETE_WINDOW);
if (A(_NET_WM_PING) != None)
protos[i++] = A(_NET_WM_PING);
if (i)
x11.XSetWMProtocols(dpy, win, protos, i);
return(0);
}
static bool
send_fullscreen(bool set)
{
static bool last = false;
XEvent ev = {0};
bool ret = false;
if (A(_NET_WM_STATE) != None && A(_NET_WM_STATE_FULLSCREEN) != None) {
if (last != set) {
ev.xclient.type = ClientMessage;
ev.xclient.serial = 0; // Populated by XSendEvent
ev.xclient.send_event = True; // Populated by XSendEvent
ev.xclient.display = dpy;
ev.xclient.window = win;
ev.xclient.message_type = A(_NET_WM_STATE); ev.xclient.format = 32;
memset(&ev.xclient.data.l, 0, sizeof(ev.xclient.data.l));
ev.xclient.data.l[0] = set ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
ev.xclient.data.l[1] = A(_NET_WM_STATE_FULLSCREEN);
ev.xclient.data.l[3] = 1;
ret = x11.XSendEvent(dpy, root, False, SubstructureNotifyMask | SubstructureRedirectMask, &ev) != 0;
if (ret) {
x11.XFlush(dpy);
last = set;
}
}
else
ret = true;
}
return ret;
}
/* Resize the window. This function is called after a mode change. */
// It's also called after scaling is changed!
static void resize_window()
{
int width;
int height;
int max_width, max_height;
bool resize;
double new_scaling;
pthread_mutex_lock(&vstatlock);
if (fullscreen && send_fullscreen(true)) {
cio_api.mode = CIOLIB_MODE_X_FULLSCREEN;
}
else {
send_fullscreen(false);
fullscreen = false;
cio_api.mode = CIOLIB_MODE_X;
new_scaling = x_cvstat.scaling;
bitmap_get_scaled_win_size(new_scaling, &width, &height, 0, 0);
// TODO: If we're in fullscreen mode, we don't get the decoration sizes...
if (x11_get_maxsize(&max_width, &max_height)) {
if (width > max_width || height > max_height) {
new_scaling = bitmap_double_mult_inside(max_width, max_height);
bitmap_get_scaled_win_size(new_scaling, &width, &height, 0, 0);
}
}
new_scaling = bitmap_double_mult_inside(width, height);
if (width == vstat.winwidth && height == vstat.winheight) {
if (new_scaling != vstat.scaling) {
vstat.scaling = x_cvstat.scaling = new_scaling;
pthread_mutex_unlock(&vstatlock);
resize_xim();
}
else
pthread_mutex_unlock(&vstatlock);
return;
}
resize = new_scaling != vstat.scaling;
x_cvstat.scaling = vstat.scaling;
if (resize)
x11.XResizeWindow(dpy, win, width, height);
}
pthread_mutex_unlock(&vstatlock);
return;
}
static void init_mode_internal(int mode)
{
int mw, mh;
int ow, oh;
double os;
x11_get_maxsize(&mw, &mh);
pthread_mutex_lock(&vstatlock);
if (last) {
release_buffer(last);
last = NULL;
}
ow = vstat.winwidth;
oh = vstat.winheight;
os = vstat.scaling;
bitmap_drv_init_mode(mode, NULL, NULL, mw, mh);
x_cvstat = vstat;
x_cvstat.scaling = bitmap_double_mult_inside(vstat.winwidth, vstat.winheight);
vstat.winwidth = ow;
vstat.winheight = oh;
vstat.scaling = os;
pthread_mutex_unlock(&vstatlock);
resize_window();
pthread_mutex_lock(&vstatlock);
x_cvstat = vstat;
pthread_mutex_unlock(&vstatlock);
resize_xim();
map_window();
}
static void check_scaling(void)
{
pthread_mutex_lock(&vstatlock);
pthread_mutex_lock(&scalinglock);
if (newscaling != 0) {
x_cvstat.scaling = newscaling;
newscaling = 0.0;
pthread_mutex_unlock(&scalinglock);
pthread_mutex_unlock(&vstatlock);
resize_window();
}
else {
pthread_mutex_unlock(&scalinglock);
pthread_mutex_unlock(&vstatlock);
}
}
static int init_mode(int mode)
{
init_mode_internal(mode);
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. */
pthread_mutex_lock(&vstatlock);
x_internal_scaling = (ciolib_initial_scaling_type == CIOLIB_SCALING_INTERNAL);
if (ciolib_initial_scaling != 0.0)
x_cvstat.scaling = vstat.scaling = ciolib_initial_scaling;
if (x_cvstat.scaling < 1.0 || vstat.scaling < 1.0)
x_cvstat.scaling = vstat.scaling = 1.0;
/* Initialize mode 3 (text, 80x25, 16 colors) */
if(load_vmode(&vstat, ciolib_initial_mode)) {
pthread_mutex_unlock(&vstatlock);
return(-1);
}
x_cvstat = vstat;
pthread_mutex_unlock(&vstatlock); if(init_window())
return(-1);
bitmap_drv_init(x11_drawrect, x11_flush);
pthread_mutex_lock(&vstatlock);
bitmap_drv_init_mode(vstat.mode, NULL, NULL, 0, 0);
x_cvstat = vstat;
pthread_mutex_unlock(&vstatlock);
return(0);
}
static void
local_draw_rect(struct rectlist *rect)
{
int x, y, xoff = 0, yoff = 0;
unsigned int r, g, b;
unsigned long pixel;
int cleft;
int cright = -100;
int ctop;
int cbottom = -1;
int idx;
uint32_t last_pixel = 0x55555555;
struct graphics_buffer *source;
int w, h;
int dw, dh;
uint32_t *source_data;
bool internal_scaling = x_internal_scaling;
if (x_cvstat.scrnwidth != rect->rect.width || x_cvstat.scrnheight != rect->rect.height || xim == NULL) {
bitmap_drv_free_rect(rect);
return;
}
// Scale...
pthread_mutex_lock(&vstatlock);
if (x_cvstat.winwidth != vstat.winwidth || x_cvstat.winheight != vstat.winheight) {
bitmap_drv_free_rect(rect);
pthread_mutex_unlock(&vstatlock);
return;
}
bitmap_get_scaled_win_size(vstat.scaling, &w, &h, vstat.winwidth, vstat.winheight);
pthread_mutex_unlock(&vstatlock);
if (w < rect->rect.width || h < rect->rect.height) {
bitmap_drv_free_rect(rect);
return;
}
if (internal_scaling) {
source = do_scale(rect, w, h);
bitmap_drv_free_rect(rect);
if (source == NULL)
return;
cleft = source->w;
ctop = source->h;
source_data = source->data;
dw = source->w;
dh = source->h;
}
else {
source = NULL;
cleft = w;
ctop = h;
source_data = rect->data;
dw = rect->rect.width;
dh = rect->rect.height;
}
pthread_mutex_lock(&vstatlock);
w = vstat.winwidth;
h = vstat.winheight; pthread_mutex_unlock(&vstatlock);
xoff = (w - cleft) / 2;
if (xoff < 0)
xoff = 0;
yoff = (h - ctop) / 2;
if (yoff < 0)
yoff = 0;
if (last && (last->w != dw || last->h != dh)) {
release_buffer(last);
last = NULL;
}
/* TODO: Translate into local colour depth */
idx = 0;
for (y = 0; y < dh; y++) {
for (x = 0; x < dw; x++) {
if (last) {
if (last->data[idx] != source_data[idx]) {
if (x < cleft)
cleft = x;
if (x > cright)
cright = x;
if (y < ctop)
ctop = y;
if (y > cbottom)
cbottom = y;
}
else {
idx++;
continue;
}
}
if (VisualIsRGB8) {
pixel = source_data[idx];
((uint32_t*)xim->data)[idx] = pixel;
}
else {
if (last_pixel != source_data[idx]) {
last_pixel = source_data[idx];
r = source_data[idx] >> 16 & 0xff;
g = source_data[idx] >> 8 & 0xff;
b = source_data[idx] & 0xff;
r = (r<<8)|r;
g = (g<<8)|g;
b = (b<<8)|b;
pixel = base_pixel;
if (r_shift >= 0)
pixel |= (r << r_shift) & visual->red_mask;
else
pixel |= (r >> (0-r_shift)) & visual->red_mask;
if (g_shift >= 0)
pixel |= (g << g_shift) & visual->green_mask;
else
pixel |= (g >> (0-g_shift)) & visual->green_mask;
if (b_shift >= 0)
pixel |= (b << b_shift) & visual->blue_mask;
else
pixel |= (b >> (0-b_shift)) & visual->blue_mask;
}
#ifdef XPutPixel
XPutPixel(xim, x, y, pixel);
#else
x11.XPutPixel(xim, x, y, pixel);
#endif
}
idx++;
}
if (internal_scaling) { /* This line was changed */
// TODO: Previously this did one update per display line...
if (last && cright >= 0 && (cbottom != y || y == source->h - 1)) {
x11.XPutImage(dpy, win, gc, xim, cleft, ctop
, cleft + xoff, ctop + yoff
, (cright - cleft + 1), (cbottom - ctop + 1));
cleft = source->w;
cright = cbottom = -100;
ctop = source->h;
}
}
}
if (!internal_scaling)
bitmap_drv_free_rect(rect);
// TODO: We really only need to do this once after changing resolution...
if (xoff > 0 || yoff > 0) {
if (yoff != 0) {
x11.XFillRectangle(dpy, win, gc, 0, 0, w, yoff);
}
if (xoff != 0) {
x11.XFillRectangle(dpy, win, gc, 0, yoff, xoff, yoff + ctop);
}
// These clean up odd-numbered widths,
x11.XFillRectangle(dpy, win, gc, xoff + cleft, yoff, w, yoff + ctop);
x11.XFillRectangle(dpy, win, gc, 0, yoff + ctop, w, h);
}
if (internal_scaling || xrender_found == false) {
if (last == NULL)
x11.XPutImage(dpy, win, gc, xim, 0, 0, xoff, yoff, cleft, ctop);
else {
release_buffer(last);
last = NULL;
}
}
else {
if (last != NULL) {
release_buffer(last);
last = NULL;
}
#ifdef WITH_XRENDER
x11.XPutImage(dpy, xrender_pm, gc, xim, 0, 0, 0, 0, dw, dh);
x11.XRenderComposite(dpy, PictOpSrc, xrender_src_pict, 0, xrender_dst_pict,
0, 0, 0, 0, xoff, yoff,
cleft, ctop);
#else
fprintf(stderr, "External scaling enabled without XRender support compiled in!\n");
#endif
}
last = source;
}
static void handle_resize_event(int width, int height, bool map)
{
pthread_mutex_lock(&vstatlock);
if (fullscreen && !map) {
if ((width != x_cvstat.winwidth || height != x_cvstat.winheight)) {
fullscreen = false;
cio_api.mode = CIOLIB_MODE_X;
}
}
x_cvstat.winwidth = vstat.winwidth = width;
x_cvstat.winheight = vstat.winheight = height;
vstat.scaling = bitmap_double_mult_inside(width, height);
if (vstat.scaling > 16)
vstat.scaling = 16;
x_cvstat.scaling = vstat.scaling;
pthread_mutex_unlock(&vstatlock);
resize_xim();
bitmap_drv_request_pixels();}
static void expose_rect(int x, int y, int width, int height)
{
int xoff=0, yoff=0;
int w, h;
int sw, sh;
double s;
if (xim == NULL) {
fprintf(stderr, "Exposing NULL xim!\n");
return;
}
pthread_mutex_lock(&vstatlock);
w = vstat.winwidth;
h = vstat.winheight;
s = vstat.scaling;
bitmap_get_scaled_win_size(s, &sw, &sh, 0, 0);
pthread_mutex_unlock(&vstatlock);
xoff = (w - sw) / 2;
if (xoff < 0)
xoff = 0;
yoff = (h - sh) / 2;
if (yoff < 0)
yoff = 0;
x11.XFillRectangle(dpy, win, gc, 0, 0, w, yoff);
x11.XFillRectangle(dpy, win, gc, 0, yoff, xoff, yoff + sh);
x11.XFillRectangle(dpy, win, gc, xoff + sw, yoff, w, yoff + sh);
x11.XFillRectangle(dpy, win, gc, 0, yoff + sh, w, h);
/* Since we're exposing, we *have* to redraw */
if (last) {
release_buffer(last);
last = NULL;
}
bitmap_drv_request_pixels();
}
static bool
xlat_mouse_xy(int *x, int *y)
{
int xoff, yoff;
pthread_mutex_lock(&vstatlock);
xoff = (vstat.winwidth - xim->width) / 2;
if (xoff < 0)
xoff = 0;
yoff = (vstat.winheight - xim->height) / 2;
if (yoff < 0)
yoff = 0;
pthread_mutex_unlock(&vstatlock);
if (*x < xoff)
return false;
if (*y < yoff)
return false;
*x -= xoff;
*y -= yoff;
if (*x >= xim->width)
return false;
if (*y >= xim->height)
return false;
*x *= x_cvstat.scrnwidth;
*y *= x_cvstat.scrnheight;
*x /= xim->width;
*y /= xim->height;
return true;
}
bool
is_maximized(void)
{
bool is = false;
Atom atr;
int afr;
Atom *ret;
unsigned long nir;
unsigned long bytes_left = 4;
unsigned char *prop;
size_t offset;
if (A(_NET_WM_STATE) != None) {
for (offset = 0; bytes_left; offset += nir) {
if (x11.XGetWindowProperty(dpy, win, A(_NET_WM_STATE), offset, 1, False, XA_ATOM, &atr, &afr, &nir, &bytes_left, &prop) != Success)
break;
if (atr != XA_ATOM) {
x11.XFree(prop);
break;
}
ret = (Atom *)prop;
if (*ret == A(_NET_WM_STATE_MAXIMIZED_VERT) || *ret == A(_NET_WM_STATE_MAXIMIZED_HORZ))
is = true;
x11.XFree(prop);
if (is)
break;
}
}
return is;
}
static void
handle_configuration(int x, int y, int w, int h, bool map)
{
bool resize = false;
if ((x11_window_xpos != x || x11_window_ypos != y)) {
x11_window_xpos = x;
x11_window_ypos = y;
}
pthread_mutex_lock(&vstatlock);
if (w != vstat.winwidth || h != vstat.winheight)
resize = true;
pthread_mutex_unlock(&vstatlock);
if (resize)
handle_resize_event(w, h, map);
}
static int x11_event(XEvent *ev)
{
if (x11.XFilterEvent(ev, win))
return 0;
switch (ev->type) {
case ReparentNotify:
parent = ev->xreparent.parent;
break;
case ClientMessage:
if (ev->xclient.format == 32 && ev->xclient.data.l[0] == A(WM_DELETE_WINDOW) && A(WM_DELETE_WINDOW) != None) {
uint16_t key=CIO_KEY_QUIT;
write(key_pipe[1], &key, 2);
}
else if(ev->xclient.format == 32 && ev->xclient.data.l[0] == A(_NET_WM_PING) && A(_NET_WM_PING) != None) {
ev->xclient.window = root;
x11.XSendEvent(dpy, ev->xclient.window, False, SubstructureNotifyMask | SubstructureRedirectMask, ev);
}
break;
case PropertyNotify:
if (A(_NET_FRAME_EXTENTS) != None) {
if (ev->xproperty.atom != A(_NET_FRAME_EXTENTS))
break; map_window();
}
break;
/* Graphics related events */
case ConfigureNotify: {
int ax, ay;
Window cr;
// TODO: Maybe we care about parent events?
if (ev->xconfigure.window == win) {
// TODO: Verify this hack...
if (ev->xconfigure.above != None)
x11.XTranslateCoordinates(dpy, ev->xconfigure.window, root, ev->xconfigure.x, ev->xconfigure.y, &ax, &ay, &cr);
else {
ax = ev->xconfigure.x;
ay = ev->xconfigure.y;
}
if (map_pending) {
pending_xpos = ax;
pending_ypos = ay;
pending_width = ev->xconfigure.width;
pending_height = ev->xconfigure.height;
}
else {
handle_configuration(ax, ay, ev->xconfigure.width, ev->xconfigure.height, false);
}
}
break;
}
case MapNotify:
if (map_pending) {
map_pending = false;
handle_configuration(pending_xpos, pending_ypos, pending_width, pending_height, true);
}
break;
case NoExpose:
break;
case GraphicsExpose:
expose_rect(ev->xgraphicsexpose.x, ev->xgraphicsexpose.y, ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
break;
case Expose:
if (ev->xexpose.count == 0)
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==copy_paste_selection)
FREE_AND_NULL(copybuf);
pthread_mutex_unlock(©buf_mutex);
}
break;
case SelectionNotify:
{
int format;
unsigned long len, bytes_left, dummy;
if(ev->xselection.selection != copy_paste_selection)
break;
if(ev->xselection.requestor!=win)
break;
if(ev->xselection.property) {
x11.XGetWindowProperty(dpy, win, ev->xselection.property, 0, 0, True, AnyPropertyType, &pastebuf_format, &format, &len, &bytes_left, (unsigned char **)(&pastebuf));
if(bytes_left > 0 && format==8) {
x11.XGetWindowProperty(dpy, win, ev->xselection.property, 0, bytes_left, True, AnyPropertyType, &pastebuf_format, &format, &len, &dummy, (unsigned char **)&pastebuf); if (A(UTF8_STRING) && pastebuf_format == A(UTF8_STRING)) {
char *opb = pastebuf;
pastebuf = (char *)utf8_to_cp(CIOLIB_ISO_8859_1, (uint8_t *)pastebuf, '?', strlen(pastebuf), NULL);
if (pastebuf == NULL)
pastebuf = opb;
else
x11.XFree(opb);
}
}
else
pastebuf=NULL;
}
else
pastebuf=NULL;
/* Set paste buffer */
sem_post(&pastebuf_set);
sem_wait(&pastebuf_used);
if (A(UTF8_STRING) && pastebuf_format == A(UTF8_STRING))
free(pastebuf);
else
x11.XFree(pastebuf);
pastebuf=NULL;
}
break;
case SelectionRequest:
{
XSelectionRequestEvent *req;
XEvent respond;
Atom supported[3];
int count = 0;
req=&(ev->xselectionrequest);
pthread_mutex_lock(©buf_mutex);
respond.xselection.property=None;
if(copybuf!=NULL) {
if(req->target==XA_STRING) {
char *cpstr = utf8_to_cp(CIOLIB_ISO_8859_1, (uint8_t *)copybuf, '?', strlen(copybuf), NULL);
if (cpstr != NULL) {
x11.XChangeProperty(dpy, req->requestor, req->property, XA_STRING, 8, PropModeReplace, (uint8_t *)cpstr, strlen((char *)cpstr));
respond.xselection.property=req->property;
free(cpstr);
}
}
else if(req->target == A(UTF8_STRING)) {
x11.XChangeProperty(dpy, req->requestor, req->property, A(UTF8_STRING), 8, PropModeReplace, (uint8_t *)copybuf, strlen((char *)copybuf));
respond.xselection.property=req->property;
}
else if(req->target == A(TARGETS)) {
supported[count++] = A(TARGETS);
supported[count++] = XA_STRING;
if (A(UTF8_STRING))
supported[count++] = A(UTF8_STRING);
x11.XChangeProperty(dpy, req->requestor, req->property, XA_ATOM, 32, PropModeReplace, (unsigned char *)supported, count);
respond.xselection.property=req->property;
}
}
respond.xselection.requestor=req->requestor;
respond.xselection.selection=req->selection;
respond.xselection.time=req->time;
respond.xselection.target=req->target;
respond.xselection.type=SelectionNotify;
respond.xselection.display=req->display;
x11.XSendEvent(dpy,req->requestor,0,0,&respond);
x11.XFlush(dpy);
pthread_mutex_unlock(©buf_mutex);
}
break;
/* Mouse Events */ case MotionNotify:
{
XMotionEvent *me = (XMotionEvent *)ev;
if (!xlat_mouse_xy(&me->x, &me->y))
break;
int x_res = me->x;
int y_res = me->y;
me->x /= x_cvstat.charwidth;
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, x_res, y_res);
}
break;
case ButtonRelease:
{
XButtonEvent *be = (XButtonEvent *)ev;
if (!xlat_mouse_xy(&be->x, &be->y))
break;
int x_res = be->x;
int y_res = be->y;
be->x/=x_cvstat.charwidth;
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, x_res, y_res);
}
}
break;
case ButtonPress:
{
XButtonEvent *be = (XButtonEvent *)ev;
if (!xlat_mouse_xy(&be->x, &be->y))
break;
int x_res = be->x;
int y_res = be->y;
be->x/=x_cvstat.charwidth;
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 <= 5) {
ciomouse_gotevent(CIOLIB_BUTTON_PRESS(be->button),be->x,be->y, x_res, y_res); }
}
break;
/* Keyboard Events */
case KeyPress:
{
static char buf[128];
static wchar_t wbuf[128];
KeySym ks;
int nlock = 0;
WORD scan = 0xffff;
Status lus = 0;
int cnt;
int i;
uint8_t ch;
if (ic)
cnt = x11.XwcLookupString(ic, (XKeyPressedEvent *)ev, wbuf, sizeof(wbuf)/sizeof(wbuf[0]), &ks, &lus);
else {
cnt = x11.XLookupString((XKeyEvent *)ev, buf, sizeof(buf), &ks, NULL);
lus = XLookupKeySym;
}
switch(lus) {
case XLookupNone:
ks = 0xffff;
break;
case XLookupBoth:
case XLookupChars:
if (lus == XLookupChars || ((ev->xkey.state & (Mod1Mask | ControlMask)) == 0)) {
for (i = 0; i < cnt; i++) {
if (wbuf[i] < 128)
ch = cpchar_from_unicode_cpoint(getcodepage(), wbuf[i], wbuf[i]);
else
ch = cpchar_from_unicode_cpoint(getcodepage(), wbuf[i], 0);
if (ch) {
write(key_pipe[1], &ch, 1);
}
}
break;
}
// Fallthrough
case XLookupKeySym:
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:
if (ev->xkey.state & Mod1Mask) {
// ALT-Enter, toggle full-screen
fullscreen = !fullscreen;
resize_window();
}
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:
if (ev->xkey.state & Mod1Mask && !is_maximized()) {
double fval;
double ival;
fval = modf(x_cvstat.scaling, &ival);
if (fval != 0.0) {
if (ival < 1.0)
ival = 1.0;
x_setscaling(ival);
}
else if (ival > 1.0)
x_setscaling(ival - 1.0);
else
x_setscaling(1.0);
}
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;
if (ev->xkey.state & Mod1Mask && !is_maximized()) { double ival;
modf(x_cvstat.scaling, &ival);
if (ival < 1.0)
ival = 1.0;
if (ival < 7.0) {
int mw, mh, ms;
x11_get_maxsize(&mw,&mh);
pthread_mutex_lock(&vstatlock);
ms = bitmap_largest_mult_inside(mw, mh);
pthread_mutex_unlock(&vstatlock);
if (x_cvstat.scaling + 1 <= ms)
x_setscaling(ival + 1);
}
}
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;
if (key < 128)
key = cpchar_from_unicode_cpoint(getcodepage(), key, key);
write(key_pipe[1], &key, (scan&0xff)?1:2);
}
break;
}
return(1);
}
default:
break;
}
return(0);
}
static void x11_terminate_event_thread(void)
{
terminate = 1;
sem_wait(&event_thread_complete);
}
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;
int mode = (int)(intptr_t)args;
SetThreadName("X11 Events");
if (mode == CIOLIB_MODE_X_FULLSCREEN)
fullscreen = true;
if(video_init()) {
sem_post(&init_complete);
return;
}
sem_init(&event_thread_complete, 0, 0);
atexit(x11_terminate_event_thread);
if(local_pipe[0] > xfd)
high_fd=local_pipe[0];
else
high_fd=xfd;
x11.XSync(dpy, False);
x11_initialized=1;
sem_post(&init_complete);
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 if something really
* was wrong with select....
*/
/* perror("select"); */
break;
case 0:
/* Timeout */
break;
default:
if (FD_ISSET(xfd, &fdset)) {
// This blocks for the event...
x11.XNextEvent(dpy, &ev);
x11_event(&ev);
// And this reads anything else from the queue. while (QLength(dpy) > 0) {
x11.XNextEvent(dpy, &ev);
x11_event(&ev);
}
}
if(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);
set_win_property(ATOM__NET_WM_ICON_NAME, A(UTF8_STRING), 8, PropModeReplace, lev.data.name, strlen(lev.data.name));
x11.XFlush(dpy);
break;
case X11_LOCAL_SETTITLE:
x11.XStoreName(dpy, win, lev.data.title);
set_win_property(ATOM__NET_WM_NAME, A(UTF8_STRING), 8, PropModeReplace, lev.data.name, strlen(lev.data.name));
x11.XFlush(dpy);
break;
case X11_LOCAL_COPY:
x11.XSetSelectionOwner(dpy, copy_paste_selection, win, CurrentTime);
break;
case X11_LOCAL_PASTE:
{
Window sowner=None;
sowner=x11.XGetSelectionOwner(dpy, copy_paste_selection);
if(sowner==win) {
/* Get your own primary selection */
if(copybuf==NULL)
pastebuf=NULL;
else {
pastebuf=strdup(copybuf);
pastebuf_format = copybuf_format;
}
/* Set paste buffer */
sem_post(&pastebuf_set);
sem_wait(&pastebuf_used);
FREE_AND_NULL(pastebuf);
}
else if(sowner!=None) {
x11.XConvertSelection(dpy, copy_paste_selection, A(UTF8_STRING) ? A(UTF8_STRING) : XA_STRING, A(UTF8_STRING) ? A(UTF8_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_SETICON: {
// TODO: set_icon() is obsolete... delete
set_icon(&lev.data.icon_data[2], lev.data.icon_data[0], NULL);
set_win_property(ATOM__NET_WM_ICON, XA_CARDINAL, 32, PropModeReplace, lev.data.icon_data, lev.data.icon_data[0] * lev.data.icon_data[1] + 2);
x11.XFlush(dpy);
free(lev.data.icon_data); break;
}
case X11_LOCAL_MOUSEPOINTER: {
unsigned shape = UINT_MAX;
Cursor oc = curs;
switch (lev.data.ptr) {
case CIOLIB_MOUSEPTR_ARROW:
// Use default
break;
case CIOLIB_MOUSEPTR_BAR:
shape = XC_xterm;
break;
}
if (shape == UINT_MAX)
x11.XDefineCursor(dpy, win, None);
else {
curs = x11.XCreateFontCursor(dpy, shape);
x11.XDefineCursor(dpy, win, curs);
}
if (oc != None && oc != curs)
x11.XFreeCursor(dpy, oc);
break;
}
case X11_LOCAL_SETSCALING_TYPE:
x_internal_scaling = (lev.data.st == CIOLIB_SCALING_INTERNAL);
resize_xim();
break;
}
}
}
}
x11.XCloseDisplay(dpy);
sem_post(&event_thread_complete);
}