int main(void)
{
Display *dpy;
int i, j, fd;
unsigned int attachments[] = {
DRI2BufferBackLeft,
DRI2BufferFrontLeft,
};
XRRScreenResources *res;
dpy = XOpenDisplay(NULL);
if (dpy == NULL)
return 77;
if (!XRRQueryVersion(dpy, &i, &j))
return 77;
fd = dri2_open(dpy);
if (fd < 0)
return 1;
res = _XRRGetScreenResourcesCurrent(dpy, DefaultRootWindow(dpy));
if (res == NULL)
return 1;
printf("noutput=%d, ncrtc=%d\n", res->noutput, res->ncrtc);
for (i = 0; i < res->ncrtc; i++)
XRRSetCrtcConfig(dpy, res, res->crtcs[i], CurrentTime,
0, 0, None, RR_Rotate_0, NULL, 0);
XSync(dpy, True);
for (i = 0; i < res->noutput; i++) {
XRROutputInfo *output;
XRRModeInfo *mode;
output = XRRGetOutputInfo(dpy, res, res->outputs[i]);
if (output == NULL)
continue;
mode = NULL;
if (res->nmode)
mode = lookup_mode(res, output->modes[0]);
for (j = 0; mode && j < output->ncrtc; j++) {
printf("[%d, %d] -- OUTPUT:%ld, CRTC:%ld\n",
i, j, (long)res->outputs[i], (long)output->crtcs[j]);
XRRSetCrtcConfig(dpy, res, output->crtcs[j], CurrentTime,
0, 0, output->modes[0], RR_Rotate_0, &res->outputs[i], 1);
XSync(dpy, True);
run(dpy, mode->width, mode->height, attachments, 1, "fullscreen");
run(dpy, mode->width, mode->height, attachments, 2, "fullscreen (with front)");
run(dpy, mode->width/2, mode->height/2, attachments, 1, "windowed");
run(dpy, mode->width/2, mode->height/2, attachments, 2, "windowed (with front)");
XRRSetCrtcConfig(dpy, res, output->crtcs[j], CurrentTime,
0, 0, None, RR_Rotate_0, NULL, 0);
XSync(dpy, True);
}
XRRFreeOutputInfo(output);
}
return 0;
}
Window xf_CreateDummyWindow(xfContext* xfc)
{
return XCreateSimpleWindow(xfc->display, DefaultRootWindow(xfc->display),
0, 0, 1, 1, 0, 0, 0);
}
static void winopen(void)
{
XWMHints *wmhints;
XClassHint *classhint;
xdpy = XOpenDisplay(NULL);
if (!xdpy)
winerror(&gapp, fz_throw("cannot open display"));
XA_TARGETS = XInternAtom(xdpy, "TARGETS", False);
XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False);
XA_UTF8_STRING = XInternAtom(xdpy, "UTF8_STRING", False);
WM_DELETE_WINDOW = XInternAtom(xdpy, "WM_DELETE_WINDOW", False);
xscr = DefaultScreen(xdpy);
ximage_init(xdpy, xscr, DefaultVisual(xdpy, xscr));
xcarrow = XCreateFontCursor(xdpy, XC_left_ptr);
xchand = XCreateFontCursor(xdpy, XC_hand2);
xcwait = XCreateFontCursor(xdpy, XC_watch);
xbgcolor.red = 0x7000;
xbgcolor.green = 0x7000;
xbgcolor.blue = 0x7000;
xshcolor.red = 0x4000;
xshcolor.green = 0x4000;
xshcolor.blue = 0x4000;
XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xbgcolor);
XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xshcolor);
xwin = XCreateWindow(xdpy, DefaultRootWindow(xdpy),
10, 10, 200, 100, 1,
ximage_get_depth(),
InputOutput,
ximage_get_visual(),
0,
NULL);
if (xwin == None)
winerror(&gapp, fz_throw("cannot create window"));
XSetWindowColormap(xdpy, xwin, ximage_get_colormap());
XSelectInput(xdpy, xwin,
StructureNotifyMask | ExposureMask | KeyPressMask |
PointerMotionMask | ButtonPressMask | ButtonReleaseMask);
mapped = 0;
xgc = XCreateGC(xdpy, xwin, 0, NULL);
XDefineCursor(xdpy, xwin, xcarrow);
wmhints = XAllocWMHints();
if (wmhints)
{
wmhints->flags = IconPixmapHint | IconMaskHint;
xicon = XCreateBitmapFromData(xdpy, xwin,
(char*)mupdf_icon_bitmap_16_bits,
mupdf_icon_bitmap_16_width,
mupdf_icon_bitmap_16_height);
xmask = XCreateBitmapFromData(xdpy, xwin,
(char*)mupdf_icon_bitmap_16_mask_bits,
mupdf_icon_bitmap_16_mask_width,
mupdf_icon_bitmap_16_mask_height);
if (xicon && xmask)
{
wmhints->icon_pixmap = xicon;
wmhints->icon_mask = xmask;
XSetWMHints(xdpy, xwin, wmhints);
}
XFree(wmhints);
}
classhint = XAllocClassHint();
if (classhint)
{
classhint->res_name = "mupdf";
classhint->res_class = "MuPDF";
XSetClassHint(xdpy, xwin, classhint);
XFree(classhint);
}
XSetWMProtocols(xdpy, xwin, &WM_DELETE_WINDOW, 1);
x11fd = ConnectionNumber(xdpy);
}
CXWindowsScreenSaver::CXWindowsScreenSaver(
CXWindowsScreen* screen, Display* display) :
m_screen(screen),
m_display(display),
m_notify(None),
m_xscreensaver(None),
m_xscreensaverActive(false),
m_disabled(false),
m_suppressDisable(false),
m_disableJobInstalled(false)
{
// screen saver disable callback
m_disableJob = new TMethodJob<CXWindowsScreenSaver>(this,
&CXWindowsScreenSaver::disableCallback);
// get atoms
m_atomScreenSaver = XInternAtom(m_display,
"SCREENSAVER", False);
m_atomScreenSaverVersion = XInternAtom(m_display,
"_SCREENSAVER_VERSION", False);
m_atomScreenSaverActivate = XInternAtom(m_display,
"ACTIVATE", False);
m_atomScreenSaverDeactivate = XInternAtom(m_display,
"DEACTIVATE", False);
m_atomSynergyScreenSaver = XInternAtom(m_display,
"SYNERGY_SCREENSAVER", False);
// create dummy window to receive xscreensaver responses. this
// shouldn't be necessary (we should be able to send responses
// to None) but it doesn't hurt.
XSetWindowAttributes attr;
attr.event_mask = 0;//PropertyChangeMask;
attr.do_not_propagate_mask = 0;
attr.override_redirect = True;
m_xscreensaverSink = XCreateWindow(m_display,
DefaultRootWindow(m_display),
0, 0, 1, 1, 0, 0,
InputOnly, CopyFromParent,
CWDontPropagate | CWEventMask |
CWOverrideRedirect,
&attr);
LOG((CLOG_DEBUG "xscreensaver sink window is 0x%08x", m_xscreensaverSink));
// watch top-level windows for changes
{
bool error = false;
CXWindowsUtil::CErrorLock lock(m_display, &error);
Window root = DefaultRootWindow(m_display);
XWindowAttributes attr;
XGetWindowAttributes(m_display, root, &attr);
m_rootEventMask = attr.your_event_mask;
XSelectInput(m_display, root, m_rootEventMask | SubstructureNotifyMask);
if (error) {
LOG((CLOG_DEBUG "didn't set root event mask"));
m_rootEventMask = 0;
}
}
// get the xscreensaver window, if any
if (!findXScreenSaver()) {
setXScreenSaver(None);
}
// get the built-in settings
XGetScreenSaver(m_display, &m_timeout, &m_interval,
&m_preferBlanking, &m_allowExposures);
}
void
setstatus(Display *dpy, char *str) {
XStoreName(dpy, DefaultRootWindow(dpy), str);
XSync(dpy, False);
}
int
X11_Init(void)
{
char buf[512];
char *displayname;
XGCValues gcvalues;
/* grrr, Xtk forced contortions */
char *argv[2];
int argc = 2;
if (cp_getvar("display", VT_STRING, buf)) {
displayname = buf;
} else if (!(displayname = getenv("DISPLAY"))) {
internalerror("Can't open X display.");
return (1);
}
# ifdef DEBUG
_Xdebug = 1;
# endif
argv[0] = "ngspice";
argv[1] = displayname;
/*
argv[2] = "-geometry";
argv[3] = "=1x1+2+2";
*/
/* initialize X toolkit */
toplevel = XtInitialize("ngspice", "Nutmeg", NULL, 0, &argc, argv);
display = XtDisplay(toplevel);
X11_Open = 1;
/* "invert" works better than "xor" for B&W */
/* xor gc should be a function of the pixels that are written on */
/* gcvalues.function = GXxor; */
/* this patch makes lines visible on true color displays
Guenther Roehrich 22-Jan-99 */
gcvalues.function = GXinvert;
gcvalues.line_width = 1;
gcvalues.foreground = 1;
gcvalues.background = 0;
xorgc = XCreateGC(display, DefaultRootWindow(display),
GCLineWidth | GCFunction | GCForeground | GCBackground,
&gcvalues);
/* set correct information */
dispdev->numlinestyles = NUMLINESTYLES;
dispdev->numcolors = NUMCOLORS;
dispdev->width = DisplayWidth(display, DefaultScreen(display));
dispdev->height = DisplayHeight(display, DefaultScreen(display));
/* we don't want non-fatal X errors to call exit */
XSetErrorHandler(errorhandler);
numdispplanes = DisplayPlanes(display, DefaultScreen(display));
return (0);
}
bool CWinSystemX11::HasWindowManager()
{
Window wm_check;
unsigned char *data;
int status, real_format;
Atom real_type, prop;
unsigned long items_read, items_left;
prop = XInternAtom(m_dpy, "_NET_SUPPORTING_WM_CHECK", True);
if (prop == None)
return false;
status = XGetWindowProperty(m_dpy, DefaultRootWindow(m_dpy), prop,
0L, 1L, False, XA_WINDOW, &real_type, &real_format,
&items_read, &items_left, &data);
if(status != Success || ! items_read)
{
if(status == Success)
XFree(data);
return false;
}
wm_check = ((Window*)data)[0];
XFree(data);
status = XGetWindowProperty(m_dpy, wm_check, prop,
0L, 1L, False, XA_WINDOW, &real_type, &real_format,
&items_read, &items_left, &data);
if(status != Success || !items_read)
{
if(status == Success)
XFree(data);
return false;
}
if(wm_check != ((Window*)data)[0])
{
XFree(data);
return false;
}
XFree(data);
prop = XInternAtom(m_dpy, "_NET_WM_NAME", True);
if (prop == None)
{
CLog::Log(LOGDEBUG,"Window Manager Name: ");
return true;
}
status = XGetWindowProperty(m_dpy, wm_check, prop,
0L, (~0L), False, AnyPropertyType, &real_type, &real_format,
&items_read, &items_left, &data);
if(status == Success && items_read)
{
CLog::Log(LOGDEBUG,"Window Manager Name: %s", data);
}
else
CLog::Log(LOGDEBUG,"Window Manager Name: ");
if(status == Success)
XFree(data);
return true;
}
static cairo_surface_t *
_cairo_boilerplate_gl_create_window_db (const char *name,
cairo_content_t content,
double width,
double height,
double max_width,
double max_height,
cairo_boilerplate_mode_t mode,
int id,
void **closure)
{
int rgba_attribs[] = { GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 1,
GLX_DOUBLEBUFFER,
None };
XVisualInfo *vi;
GLXContext ctx;
gl_target_closure_t *gltc;
cairo_surface_t *surface;
Display *dpy;
XSetWindowAttributes attr;
cairo_status_t status;
gltc = calloc (1, sizeof (gl_target_closure_t));
*closure = gltc;
if (width == 0)
width = 1;
if (height == 0)
height = 1;
dpy = XOpenDisplay (NULL);
gltc->dpy = dpy;
if (!gltc->dpy) {
fprintf (stderr, "Failed to open display: %s\n", XDisplayName(0));
free (gltc);
return NULL;
}
if (mode == CAIRO_BOILERPLATE_MODE_TEST)
XSynchronize (gltc->dpy, 1);
vi = glXChooseVisual (dpy, DefaultScreen (dpy), rgba_attribs);
if (vi == NULL) {
fprintf (stderr, "Failed to create RGBA, double-buffered visual\n");
XCloseDisplay (dpy);
free (gltc);
return NULL;
}
attr.colormap = XCreateColormap (dpy,
RootWindow (dpy, vi->screen),
vi->visual,
AllocNone);
attr.border_pixel = 0;
attr.override_redirect = True;
gltc->drawable = XCreateWindow (dpy, DefaultRootWindow (dpy), 0, 0,
width, height, 0, vi->depth,
InputOutput, vi->visual,
CWOverrideRedirect | CWBorderPixel | CWColormap,
&attr);
XMapWindow (dpy, gltc->drawable);
ctx = glXCreateContext (dpy, vi, NULL, True);
XFree (vi);
gltc->ctx = ctx;
gltc->device = cairo_glx_device_create (dpy, ctx);
gltc->surface = cairo_gl_surface_create_for_window (gltc->device,
gltc->drawable,
ceil (width),
ceil (height));
surface = cairo_surface_create_similar (gltc->surface, content, width, height);
status = cairo_surface_set_user_data (surface, &gl_closure_key, gltc, NULL);
if (status == CAIRO_STATUS_SUCCESS)
return surface;
cairo_surface_destroy (surface);
_cairo_boilerplate_gl_cleanup (gltc);
return cairo_boilerplate_surface_create_in_error (status);
}
static int preinit(struct vo *vo)
{
XvPortID xv_p;
int busy_ports = 0;
unsigned int i;
struct xvctx *ctx = vo->priv;
int xv_adaptor = ctx->cfg_xv_adaptor;
if (!vo_x11_init(vo))
return -1;
if (!vo_x11_create_vo_window(vo, NULL, "xv"))
goto error;
struct vo_x11_state *x11 = vo->x11;
/* check for Xvideo extension */
unsigned int ver, rel, req, ev, err;
if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) {
MP_ERR(vo, "Xv not supported by this X11 version/driver\n");
goto error;
}
/* check for Xvideo support */
if (Success !=
XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display),
&ctx->adaptors, &ctx->ai)) {
MP_ERR(vo, "XvQueryAdaptors failed.\n");
goto error;
}
/* check adaptors */
if (ctx->xv_port) {
int port_found;
for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) {
if ((ctx->ai[i].type & XvInputMask)
&& (ctx->ai[i].type & XvImageMask)) {
for (xv_p = ctx->ai[i].base_id;
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports;
++xv_p) {
if (xv_p == ctx->xv_port) {
port_found = 1;
break;
}
}
}
}
if (port_found) {
if (XvGrabPort(x11->display, ctx->xv_port, CurrentTime))
ctx->xv_port = 0;
} else {
MP_WARN(vo, "Invalid port parameter, overriding with port 0.\n");
ctx->xv_port = 0;
}
}
for (i = 0; i < ctx->adaptors && ctx->xv_port == 0; i++) {
/* check if adaptor number has been specified */
if (xv_adaptor != -1 && xv_adaptor != i)
continue;
if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) {
for (xv_p = ctx->ai[i].base_id;
xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p)
if (!XvGrabPort(x11->display, xv_p, CurrentTime)) {
ctx->xv_port = xv_p;
MP_VERBOSE(vo, "Using Xv Adapter #%d (%s)\n",
i, ctx->ai[i].name);
break;
} else {
MP_WARN(vo, "Could not grab port %i.\n", (int) xv_p);
++busy_ports;
}
}
}
if (!ctx->xv_port) {
if (busy_ports)
MP_ERR(vo, "Xvideo ports busy.\n");
else
MP_ERR(vo, "No Xvideo support found.\n");
goto error;
}
if (!xv_init_colorkey(vo)) {
goto error; // bail out, colorkey setup failed
}
xv_enable_vsync(vo);
xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height);
ctx->fo = XvListImageFormats(x11->display, ctx->xv_port,
(int *) &ctx->formats);
MP_WARN(vo, "Warning: this legacy VO has bad quality and performance, "
"and will in particular result in blurry OSD and subtitles. "
"You should fix your graphic drivers, or not force the xv VO.\n");
return 0;
error:
uninit(vo); // free resources
return -1;
}
static int _x11_clip_filter(const SDL_Event *ev)
{
XSelectionRequestEvent *req;
XEvent sevent;
Atom seln_type;
int seln_format;
unsigned long nbytes;
unsigned long overflow;
unsigned char *seln_data;
unsigned char *src;
if (ev->type != SDL_SYSWMEVENT) return 1;
if (ev->syswm.msg->event.xevent.type == SelectionNotify) {
sevent = ev->syswm.msg->event.xevent;
if (sevent.xselection.requestor == SDL_Window) {
lock_display();
src = NULL;
if (XGetWindowProperty(SDL_Display, SDL_Window, atom_sel,
0, 9000, False, XA_STRING,
(Atom *)&seln_type,
(int *)&seln_format,
(unsigned long *)&nbytes,
(unsigned long *)&overflow,
(unsigned char **)&src) == Success) {
if (seln_type == XA_STRING) {
if (_current_selection != _current_clipboard) {
free(_current_clipboard);
}
_current_clipboard = mem_alloc(nbytes+1);
memcpy(_current_clipboard, (char*)src, nbytes);
_current_clipboard[nbytes] = 0;
_string_paste(CLIPPY_BUFFER, _current_clipboard);
_widget_owner[CLIPPY_BUFFER]
= _widget_owner[CLIPPY_SELECT];
}
XFree(src);
}
unlock_display();
}
return 1;
} else if (ev->syswm.msg->event.xevent.type == PropertyNotify) {
sevent = ev->syswm.msg->event.xevent;
return 1;
} else if (ev->syswm.msg->event.xevent.type != SelectionRequest) {
return 1;
}
req = &ev->syswm.msg->event.xevent.xselectionrequest;
sevent.xselection.type = SelectionNotify;
sevent.xselection.display = req->display;
sevent.xselection.selection = req->selection;
sevent.xselection.target = None;
sevent.xselection.property = None;
sevent.xselection.requestor = req->requestor;
sevent.xselection.time = req->time;
if (XGetWindowProperty(SDL_Display, DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER0, 0, 9000, False, req->target,
&sevent.xselection.target, &seln_format,
&nbytes, &overflow, &seln_data) == Success) {
if (sevent.xselection.target == req->target) {
if (sevent.xselection.target == XA_STRING) {
if (nbytes && seln_data[nbytes-1] == '\0')
nbytes--;
}
XChangeProperty(SDL_Display, req->requestor, req->property,
sevent.xselection.target, seln_format, PropModeReplace,
seln_data, nbytes);
sevent.xselection.property = req->property;
}
XFree(seln_data);
}
XSendEvent(SDL_Display,req->requestor,False,0,&sevent);
XSync(SDL_Display, False);
return 1;
}
static void _clippy_copy_to_sys(int do_sel)
{
int j;
char *dst;
char *freeme;
#if defined(__QNXNTO__)
PhClipboardHdr clheader = {Ph_CLIPBOARD_TYPE_TEXT, 0, NULL};
char *tmp;
int *cldata;
int status;
#endif
freeme = NULL;
if (!_current_selection) {
dst = NULL;
j = 0;
} else
#if defined(WIN32)
j = strlen(_current_selection);
#else
if (has_sys_clip) {
int i;
/* convert to local */
freeme = dst = malloc(strlen(_current_selection)+4);
if (!dst) return;
for (i = j = 0; _current_selection[i]; i++) {
dst[j] = _current_selection[i];
if (dst[j] != '\r') j++;
}
dst[j] = '\0';
} else {
dst = NULL;
j = 0;
}
#endif
#if defined(USE_X11)
if (has_sys_clip) {
lock_display();
if (!dst) dst = (char *) ""; /* blah */
if (j < 0) j = 0;
if (do_sel) {
if (XGetSelectionOwner(SDL_Display, XA_PRIMARY) != SDL_Window) {
XSetSelectionOwner(SDL_Display, XA_PRIMARY, SDL_Window, CurrentTime);
}
XChangeProperty(SDL_Display,
DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER1, XA_STRING, 8,
PropModeReplace, (unsigned char *)dst, j);
} else {
if (XGetSelectionOwner(SDL_Display, atom_clip) != SDL_Window) {
XSetSelectionOwner(SDL_Display, atom_clip, SDL_Window, CurrentTime);
}
XChangeProperty(SDL_Display,
DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER0, XA_STRING, 8,
PropModeReplace, (unsigned char *)dst, j);
XChangeProperty(SDL_Display,
DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER1, XA_STRING, 8,
PropModeReplace, (unsigned char *)dst, j);
}
unlock_display();
}
#elif defined(WIN32)
if (!do_sel && OpenClipboard(SDL_Window)) {
_hmem = GlobalAlloc((GMEM_MOVEABLE|GMEM_DDESHARE), j+1);
if (_hmem) {
dst = (char *)GlobalLock(_hmem);
if (dst) {
/* this seems wrong, but msdn does this */
memcpy(dst, _current_selection, j);
dst[j] = '\0';
GlobalUnlock(_hmem);
EmptyClipboard();
SetClipboardData(CF_TEXT, _hmem);
}
}
CloseClipboard();
_hmem = NULL;
dst = 0;
}
#elif defined(__QNXNTO__)
if (!do_sel) {
tmp = (char *)malloc(j+4);
if (!tmp) {
cldata=(int*)tmp;
*cldata = Ph_CL_TEXT;
if (dst) memcpy(tmp+4, dst, j);
clheader.data = tmp;
#if (NTO_VERSION < 620)
if (clheader.length > 65535) clheader.length=65535;
#endif
clheader.length = j + 4;
#if (NTO_VERSION < 620)
PhClipboardCopy(inputgroup, 1, &clheader);
#else
PhClipboardWrite(inputgroup, 1, &clheader);
#endif
free(tmp);
}
}
#elif defined(MACOSX)
if (!do_sel) macosx_clippy_put(_current_clipboard);
#else
// some other system -- linux without x11, maybe
// pretend we used the param to silence warnings
(void) do_sel;
#endif
if (freeme)
free(freeme);
}
int GetIdleTime(Display *dpy, XScreenSaverInfo *info){
XScreenSaverQueryInfo(dpy, DefaultRootWindow(dpy), info);
return (int)info->idle;
}
/*ARGSUSED*/
int
main(int argc, char *argv[]) {
XEvent ev;
XGCValues gv;
XSetWindowAttributes attr;
(void) argc;
argv0 = argv[0];
/* Open a connection to the X server. */
dpy = XOpenDisplay("");
if (dpy == 0)
Panic("can't open display.");
get_resources();
/* Find the screen's dimensions. */
display_width = DisplayWidth(dpy, DefaultScreen(dpy));
display_height = DisplayHeight(dpy, DefaultScreen(dpy));
/* Set up an error handler. */
XSetErrorHandler(ErrorHandler);
/* Get the pixel values of the only two colours we use. */
black = BlackPixel(dpy, DefaultScreen(dpy));
white = WhitePixel(dpy, DefaultScreen(dpy));
/* Get font. */
font = XLoadQueryFont(dpy, font_name);
if (font == 0)
font = XLoadQueryFont(dpy, "fixed");
if (font == 0)
Panic("can't find a font.");
/* Get a cursor. */
initCursor();
/* Create the window. */
root = DefaultRootWindow(dpy);
attr.override_redirect = True;
attr.background_pixel = white;
attr.border_pixel = black;
attr.cursor = mouse_cursor;
attr.event_mask = ExposureMask | VisibilityChangeMask |
ButtonMotionMask | PointerMotionHintMask |
ButtonPressMask | ButtonReleaseMask | StructureNotifyMask |
EnterWindowMask | LeaveWindowMask;
window = XCreateWindow(dpy, root,
0, 0,
display_width, 1.2 * (font->ascent + font->descent),
0, CopyFromParent, InputOutput, CopyFromParent,
CWOverrideRedirect | CWBackPixel | CWBorderPixel |
CWCursor | CWEventMask,
&attr);
/* Create GC. */
gv.foreground = black;
gv.background = white;
gv.font = font->fid;
gc = XCreateGC(dpy, window, GCForeground | GCBackground | GCFont,
&gv);
/* Create the menu items. */
readMenu();
/* Bring up the window. */
XMapRaised(dpy, window);
/* Make sure all our communication to the server got through. */
XSync(dpy, False);
/* The main event loop. */
for (;;) {
getEvent(&ev);
dispatch(&ev);
}
}
/*************************************<->*************************************
*
* Cursor _DtGetHourGlassCursor ()
*
*
* Description:
* -----------
* Builds and returns the appropriate Hourglass cursor
*
*
* Inputs:
* ------
* dpy = display
*
* Outputs:
* -------
* Return = cursor.
*
* Comments:
* --------
* None. (None doesn't count as a comment)
*
*************************************<->***********************************/
Cursor
_DtGetHourGlassCursor(
Display *dpy )
{
unsigned char *bits;
unsigned char *maskBits;
unsigned int width;
unsigned int height;
unsigned int xHotspot;
unsigned int yHotspot;
Pixmap pixmap;
Pixmap maskPixmap;
XColor xcolors[2];
int scr;
unsigned int cWidth;
unsigned int cHeight;
int useLargeCursors = 0;
static Cursor waitCursor=0;
_DtSvcProcessLock();
if (waitCursor != 0) {
_DtSvcProcessUnlock();
return(waitCursor);
}
if (XQueryBestCursor (dpy, DefaultRootWindow(dpy),
32, 32, &cWidth, &cHeight))
{
if ((cWidth >= 32) && (cHeight >= 32))
{
useLargeCursors = 1;
}
}
if (useLargeCursors)
{
width = time32_width;
height = time32_height;
bits = time32_bits;
maskBits = time32m_bits;
xHotspot = time32_x_hot;
yHotspot = time32_y_hot;
}
else
{
width = time16_width;
height = time16_height;
bits = time16_bits;
maskBits = time16m_bits;
xHotspot = time16_x_hot;
yHotspot = time16_y_hot;
}
pixmap = XCreateBitmapFromData (dpy,
DefaultRootWindow(dpy), (char*) bits,
width, height);
maskPixmap = XCreateBitmapFromData (dpy,
DefaultRootWindow(dpy), (char*) maskBits,
width, height);
xcolors[0].pixel = BlackPixelOfScreen(DefaultScreenOfDisplay(dpy));
xcolors[1].pixel = WhitePixelOfScreen(DefaultScreenOfDisplay(dpy));
XQueryColors (dpy,
DefaultColormapOfScreen(DefaultScreenOfDisplay
(dpy)), xcolors, 2);
waitCursor = XCreatePixmapCursor (dpy, pixmap, maskPixmap,
&(xcolors[0]), &(xcolors[1]),
xHotspot, yHotspot);
XFreePixmap (dpy, pixmap);
XFreePixmap (dpy, maskPixmap);
_DtSvcProcessUnlock();
return (waitCursor);
}
bool wxTopLevelWindowGTK::Show( bool show )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
bool deferShow = show && !m_isShown && m_deferShow;
if (deferShow)
{
deferShow = gs_requestFrameExtentsStatus != 2 &&
m_deferShowAllowed && !gtk_widget_get_realized(m_widget);
if (deferShow)
{
deferShow = g_signal_handler_find(m_widget,
GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
0, NULL, NULL, this) != 0;
}
GdkScreen* screen = NULL;
if (deferShow)
{
#ifdef GDK_WINDOWING_X11
screen = gtk_widget_get_screen(m_widget);
GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
#else
deferShow = false;
#endif
// If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
// to m_decorSize, it breaks saving/restoring window size with
// GetSize()/SetSize() because it makes window bigger between each
// restore and save.
m_updateDecorSize = deferShow;
}
m_deferShow = deferShow;
}
if (deferShow)
{
// Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
// calling gtk_widget_show() until _NET_FRAME_EXTENTS property
// notification is received, so correct frame extents are known.
// This allows resizing m_widget to keep the overall size in sync with
// what wxWidgets expects it to be without an obvious change in the
// window size immediately after it becomes visible.
// Realize m_widget, so m_widget->window can be used. Realizing normally
// causes the widget tree to be size_allocated, which generates size
// events in the wrong order. However, the size_allocates will not be
// done if the allocation is not the default (1,1).
GtkAllocation alloc;
gtk_widget_get_allocation(m_widget, &alloc);
const int alloc_width = alloc.width;
if (alloc_width == 1)
{
alloc.width = 2;
gtk_widget_set_allocation(m_widget, &alloc);
}
gtk_widget_realize(m_widget);
if (alloc_width == 1)
{
alloc.width = 1;
gtk_widget_set_allocation(m_widget, &alloc);
}
#ifdef GDK_WINDOWING_X11
// send _NET_REQUEST_FRAME_EXTENTS
XClientMessageEvent xevent;
memset(&xevent, 0, sizeof(xevent));
xevent.type = ClientMessage;
GdkWindow* window = gtk_widget_get_window(m_widget);
xevent.window = GDK_WINDOW_XID(window);
xevent.message_type = gdk_x11_atom_to_xatom_for_display(
gdk_window_get_display(window),
gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
xevent.format = 32;
Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
XSendEvent(display, DefaultRootWindow(display), false,
SubstructureNotifyMask | SubstructureRedirectMask,
(XEvent*)&xevent);
#endif // GDK_WINDOWING_X11
if (gs_requestFrameExtentsStatus == 0)
{
// if WM does not respond to request within 1 second,
// we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
m_netFrameExtentsTimerId =
g_timeout_add(1000, request_frame_extents_timeout, this);
}
// defer calling gtk_widget_show()
m_isShown = true;
return true;
}
if (show && !gtk_widget_get_realized(m_widget))
{
// size_allocate signals occur in reverse order (bottom to top).
// Things work better if the initial wxSizeEvents are sent (from the
// top down), before the initial size_allocate signals occur.
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
HandleWindowEvent(event);
}
bool change = base_type::Show(show);
if (change && !show)
{
// make sure window has a non-default position, so when it is shown
// again, it won't be repositioned by WM as if it were a new window
// Note that this must be done _after_ the window is hidden.
gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
}
return change;
}
int
main(int argc, char *argv[])
{
/* Declare variables */
Window win; /* Window */
int exit_code;
/* set up option table. I can't figure out a better way than this to
* do it while sticking to pure ANSI C. The option and specifier
* members have a type of volatile char *, so they need to be allocated
* by strdup or malloc, you can't set them to a string constant at
* declare time, this is note pure ANSI C apparently, although it does
* work with gcc
*/
/* loop option entry */
opt_tab[0].option = xcstrdup("-loops");
opt_tab[0].specifier = xcstrdup(".loops");
opt_tab[0].argKind = XrmoptionSepArg;
opt_tab[0].value = (XPointer) NULL;
/* display option entry */
opt_tab[1].option = xcstrdup("-display");
opt_tab[1].specifier = xcstrdup(".display");
opt_tab[1].argKind = XrmoptionSepArg;
opt_tab[1].value = (XPointer) NULL;
/* selection option entry */
opt_tab[2].option = xcstrdup("-selection");
opt_tab[2].specifier = xcstrdup(".selection");
opt_tab[2].argKind = XrmoptionSepArg;
opt_tab[2].value = (XPointer) NULL;
/* filter option entry */
opt_tab[3].option = xcstrdup("-filter");
opt_tab[3].specifier = xcstrdup(".filter");
opt_tab[3].argKind = XrmoptionNoArg;
opt_tab[3].value = (XPointer) xcstrdup(ST);
/* in option entry */
opt_tab[4].option = xcstrdup("-in");
opt_tab[4].specifier = xcstrdup(".direction");
opt_tab[4].argKind = XrmoptionNoArg;
opt_tab[4].value = (XPointer) xcstrdup("I");
/* out option entry */
opt_tab[5].option = xcstrdup("-out");
opt_tab[5].specifier = xcstrdup(".direction");
opt_tab[5].argKind = XrmoptionNoArg;
opt_tab[5].value = (XPointer) xcstrdup("O");
/* version option entry */
opt_tab[6].option = xcstrdup("-version");
opt_tab[6].specifier = xcstrdup(".print");
opt_tab[6].argKind = XrmoptionNoArg;
opt_tab[6].value = (XPointer) xcstrdup("V");
/* help option entry */
opt_tab[7].option = xcstrdup("-help");
opt_tab[7].specifier = xcstrdup(".print");
opt_tab[7].argKind = XrmoptionNoArg;
opt_tab[7].value = (XPointer) xcstrdup("H");
/* silent option entry */
opt_tab[8].option = xcstrdup("-silent");
opt_tab[8].specifier = xcstrdup(".olevel");
opt_tab[8].argKind = XrmoptionNoArg;
opt_tab[8].value = (XPointer) xcstrdup("S");
/* quiet option entry */
opt_tab[9].option = xcstrdup("-quiet");
opt_tab[9].specifier = xcstrdup(".olevel");
opt_tab[9].argKind = XrmoptionNoArg;
opt_tab[9].value = (XPointer) xcstrdup("Q");
/* verbose option entry */
opt_tab[10].option = xcstrdup("-verbose");
opt_tab[10].specifier = xcstrdup(".olevel");
opt_tab[10].argKind = XrmoptionNoArg;
opt_tab[10].value = (XPointer) xcstrdup("V");
/* utf8 option entry */
opt_tab[11].option = xcstrdup("-noutf8");
opt_tab[11].specifier = xcstrdup(".noutf8");
opt_tab[11].argKind = XrmoptionNoArg;
opt_tab[11].value = (XPointer) xcstrdup("N");
/* target option entry */
opt_tab[12].option = xcstrdup("-target");
opt_tab[12].specifier = xcstrdup(".target");
opt_tab[12].argKind = XrmoptionSepArg;
opt_tab[12].value = (XPointer) NULL;
/* parse command line options */
doOptMain(argc, argv);
/* Connect to the X server. */
if ((dpy = XOpenDisplay(sdisp))) {
/* successful */
if (fverb == OVERBOSE)
fprintf(stderr, "Connected to X server.\n");
}
else {
/* couldn't connect to X server. Print error and exit */
errxdisplay(sdisp);
}
/* parse selection command line option */
doOptSel();
/* parse noutf8 and target command line options */
doOptTarget();
/* Create a window to trap events */
win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 1, 1, 0, 0, 0);
/* get events about property changes */
XSelectInput(dpy, win, PropertyChangeMask);
if (fdiri)
exit_code = doIn(win, argv[0]);
else
exit_code = doOut(win);
/* Disconnect from the X server */
XCloseDisplay(dpy);
/* exit */
return exit_code;
}
VdpStatus
vdpDeviceCreateX11(Display *display_orig, int screen, VdpDevice *device,
VdpGetProcAddress **get_proc_address)
{
if (!display_orig || !device)
return VDP_STATUS_INVALID_POINTER;
// Let's get own connection to the X server
Display *display = handle_xdpy_ref(display_orig);
if (NULL == display)
return VDP_STATUS_ERROR;
if (global.quirks.buggy_XCloseDisplay) {
// XCloseDisplay could segfault on fglrx. To avoid calling XCloseDisplay,
// make one more reference to xdpy copy.
handle_xdpy_ref(display_orig);
}
VdpDeviceData *data = calloc(1, sizeof(VdpDeviceData));
if (NULL == data)
return VDP_STATUS_RESOURCES;
glx_ctx_lock(); // use glx lock to serialize X calls
data->type = HANDLETYPE_DEVICE;
data->display = display;
data->display_orig = display_orig; // save supplied pointer too
data->screen = screen;
data->refcount = 0;
pthread_mutex_init(&data->refcount_mutex, NULL);
data->root = DefaultRootWindow(display);
XWindowAttributes wnd_attrs;
XGetWindowAttributes(display, data->root, &wnd_attrs);
data->color_depth = wnd_attrs.depth;
data->fn.glXBindTexImageEXT =
(PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress((GLubyte *)"glXBindTexImageEXT");
data->fn.glXReleaseTexImageEXT =
(PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress((GLubyte *)"glXReleaseTexImageEXT");
glx_ctx_unlock();
if (!data->fn.glXBindTexImageEXT || !data->fn.glXReleaseTexImageEXT) {
traceError("error (%s): can't get glXBindTexImageEXT address\n");
free(data);
return VDP_STATUS_RESOURCES;
}
// create master GLX context to share data between further created ones
glx_ctx_ref_glc_hash_table(display, screen);
data->root_glc = glx_ctx_get_root_context();
glx_ctx_push_thread_local(data);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// initialize VAAPI
if (global.quirks.avoid_va) {
// pretend there is no VA-API available
data->va_available = 0;
} else {
data->va_dpy = vaGetDisplay(display);
data->va_available = 0;
VAStatus status = vaInitialize(data->va_dpy, &data->va_version_major,
&data->va_version_minor);
if (VA_STATUS_SUCCESS == status) {
data->va_available = 1;
traceInfo("libva (version %d.%d) library initialized\n",
data->va_version_major, data->va_version_minor);
} else {
data->va_available = 0;
traceInfo("warning: failed to initialize libva. "
"No video decode acceleration available.\n");
}
}
compile_shaders(data);
glGenTextures(1, &data->watermark_tex_id);
glBindTexture(GL_TEXTURE_2D, data->watermark_tex_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, watermark_width, watermark_height, 0, GL_BGRA,
GL_UNSIGNED_BYTE, watermark_data);
glFinish();
*device = handle_insert(data);
if (get_proc_address)
*get_proc_address = &vdpGetProcAddress;
GLenum gl_error = glGetError();
glx_ctx_pop();
if (GL_NO_ERROR != gl_error) {
traceError("error (%s): gl error %d\n", __func__, gl_error);
return VDP_STATUS_ERROR;
}
return VDP_STATUS_OK;
}
static void
update_outputs (CoglRenderer *renderer,
gboolean notify)
{
CoglXlibRenderer *xlib_renderer =
_cogl_xlib_renderer_get_data (renderer);
XRRScreenResources *resources;
CoglXlibTrapState state;
gboolean error = FALSE;
GList *new_outputs = NULL;
GList *l, *m;
gboolean changed = FALSE;
int i;
xlib_renderer->outputs_update_serial = XNextRequest (xlib_renderer->xdpy);
resources = XRRGetScreenResources (xlib_renderer->xdpy,
DefaultRootWindow (xlib_renderer->xdpy));
_cogl_xlib_renderer_trap_errors (renderer, &state);
for (i = 0; resources && i < resources->ncrtc && !error; i++)
{
XRRCrtcInfo *crtc_info = NULL;
XRROutputInfo *output_info = NULL;
CoglOutput *output;
float refresh_rate = 0;
int j;
crtc_info = XRRGetCrtcInfo (xlib_renderer->xdpy,
resources, resources->crtcs[i]);
if (crtc_info == NULL)
{
error = TRUE;
goto next;
}
if (crtc_info->mode == None)
goto next;
for (j = 0; j < resources->nmode; j++)
{
if (resources->modes[j].id == crtc_info->mode)
refresh_rate = (resources->modes[j].dotClock /
((float)resources->modes[j].hTotal *
resources->modes[j].vTotal));
}
output_info = XRRGetOutputInfo (xlib_renderer->xdpy,
resources,
crtc_info->outputs[0]);
if (output_info == NULL)
{
error = TRUE;
goto next;
}
output = _cogl_output_new (output_info->name);
output->x = crtc_info->x;
output->y = crtc_info->y;
output->width = crtc_info->width;
output->height = crtc_info->height;
if ((crtc_info->rotation & (RR_Rotate_90 | RR_Rotate_270)) != 0)
{
output->mm_width = output_info->mm_height;
output->mm_height = output_info->mm_width;
}
else
{
output->mm_width = output_info->mm_width;
output->mm_height = output_info->mm_height;
}
output->refresh_rate = refresh_rate;
switch (output_info->subpixel_order)
{
case SubPixelUnknown:
default:
output->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
break;
case SubPixelNone:
output->subpixel_order = COGL_SUBPIXEL_ORDER_NONE;
break;
case SubPixelHorizontalRGB:
output->subpixel_order = COGL_SUBPIXEL_ORDER_HORIZONTAL_RGB;
break;
case SubPixelHorizontalBGR:
output->subpixel_order = COGL_SUBPIXEL_ORDER_HORIZONTAL_BGR;
break;
case SubPixelVerticalRGB:
output->subpixel_order = COGL_SUBPIXEL_ORDER_VERTICAL_RGB;
break;
case SubPixelVerticalBGR:
output->subpixel_order = COGL_SUBPIXEL_ORDER_VERTICAL_BGR;
break;
}
output->subpixel_order = COGL_SUBPIXEL_ORDER_HORIZONTAL_RGB;
/* Handle the effect of rotation and reflection on subpixel order (ugh) */
for (j = 0; j < 6; j++)
{
if ((crtc_info->rotation & (1 << j)) != 0)
output->subpixel_order = subpixel_map[j][output->subpixel_order];
}
new_outputs = g_list_prepend (new_outputs, output);
next:
if (crtc_info != NULL)
XFree (crtc_info);
if (output_info != NULL)
XFree (output_info);
}
XFree (resources);
if (!error)
{
new_outputs = g_list_sort (new_outputs, (GCompareFunc)compare_outputs);
l = new_outputs;
m = renderer->outputs;
while (l || m)
{
int cmp;
CoglOutput *output_l = l ? (CoglOutput *)l->data : NULL;
CoglOutput *output_m = m ? (CoglOutput *)m->data : NULL;
if (l && m)
cmp = compare_outputs (output_l, output_m);
else if (l)
cmp = -1;
else
cmp = 1;
if (cmp == 0)
{
GList *m_next = m->next;
if (!_cogl_output_values_equal (output_l, output_m))
{
renderer->outputs = g_list_remove_link (renderer->outputs, m);
renderer->outputs = g_list_insert_before (renderer->outputs,
m_next, output_l);
cogl_object_ref (output_l);
changed = TRUE;
}
l = l->next;
m = m_next;
}
else if (cmp < 0)
{
renderer->outputs =
g_list_insert_before (renderer->outputs, m, output_l);
cogl_object_ref (output_l);
changed = TRUE;
l = l->next;
}
else
{
GList *m_next = m->next;
renderer->outputs = g_list_remove_link (renderer->outputs, m);
changed = TRUE;
m = m_next;
}
}
}
g_list_free_full (new_outputs, (GDestroyNotify)cogl_object_unref);
_cogl_xlib_renderer_untrap_errors (renderer, &state);
if (changed)
{
const CoglWinsysVtable *winsys = renderer->winsys_vtable;
if (notify)
COGL_NOTE (WINSYS, "Outputs changed:");
else
COGL_NOTE (WINSYS, "Outputs:");
for (l = renderer->outputs; l; l = l->next)
{
CoglOutput *output = l->data;
const char *subpixel_string;
switch (output->subpixel_order)
{
case COGL_SUBPIXEL_ORDER_UNKNOWN:
default:
subpixel_string = "unknown";
break;
case COGL_SUBPIXEL_ORDER_NONE:
subpixel_string = "none";
break;
case COGL_SUBPIXEL_ORDER_HORIZONTAL_RGB:
subpixel_string = "horizontal_rgb";
break;
case COGL_SUBPIXEL_ORDER_HORIZONTAL_BGR:
subpixel_string = "horizontal_bgr";
break;
case COGL_SUBPIXEL_ORDER_VERTICAL_RGB:
subpixel_string = "vertical_rgb";
break;
case COGL_SUBPIXEL_ORDER_VERTICAL_BGR:
subpixel_string = "vertical_bgr";
break;
}
COGL_NOTE (WINSYS,
" %10s: +%d+%dx%dx%d mm=%dx%d dpi=%.1fx%.1f "
"subpixel_order=%s refresh_rate=%.3f",
output->name,
output->x, output->y, output->width, output->height,
output->mm_width, output->mm_height,
output->width / (output->mm_width / 25.4),
output->height / (output->mm_height / 25.4),
subpixel_string,
output->refresh_rate);
}
if (notify && winsys->renderer_outputs_changed != NULL)
winsys->renderer_outputs_changed (renderer);
}
}
int main(int argc, char *argv[]){
XTextItem textItem;
int whiteColor, blackColor, color;
int speed = 5;
char opt;
textItem.delta = 0;
textItem.font = None;
display = XOpenDisplay(NULL);
if(display == NULL){
fprintf(stderr, "Failed to open display.\n");
exit(EXIT_FAILURE);
}
width = DisplayWidth(display, DefaultScreen(display));
height = DisplayHeight(display, DefaultScreen(display));
whiteColor = WhitePixel(display, DefaultScreen(display));
blackColor = BlackPixel(display, DefaultScreen(display));
color = whiteColor;
while((opt = getopt(argc, argv, "wbs:")) != -1){
switch(opt){
case 'w':
color = whiteColor;
break;
case 'b':
color = blackColor;
break;
case 's':
speed = atoi(optarg);
break;
default:
fprintf(stderr, "Unrecognized option: %c", opt);
XCloseDisplay(display);
exit(EXIT_FAILURE);
}
}
if(optind >= argc){
fprintf(stderr, "Usage: %s [options] command\n", argv[0]);
XCloseDisplay(display);
exit(EXIT_FAILURE);
}
window = DefaultRootWindow(display);
signal(SIGINT, cleanup);
gc = XCreateGC(display, window, 0, NULL);
XSetForeground(display, gc, color);
x = 0;
y = height / 2;
for(;;){
clearScreen();
textItem.chars = argv[optind];
textItem.nchars = strlen(argv[optind]);
XDrawText(display, window, gc, x, y, &textItem, 1);
x += speed;
if(x > width) x = 0;
XFlush(display);
usleep(10000);
}
cleanup(SIGINT);
return 0;
}
int main (int argc, char *argv[])
{
/* Declare variables */
unsigned char *sel_buf; /* buffer for selection data */
unsigned long sel_len = 0; /* length of sel_buf */
unsigned long sel_all = 0; /* allocated size of sel_buf */
Window win; /* Window */
XEvent evt; /* X Event Structures */
int dloop = 0; /* done loops counter */
pid_t pid; /* child pid if forking */
/* set up option table. I can't figure out a better way than this to
* do it while sticking to pure ANSI C. The option and specifier
* members have a type of volatile char *, so they need to be allocated
* by strdup or malloc, you can't set them to a string constant at
* declare time, this is note pure ANSI C apparently, although it does
* work with gcc
*/
/* loop option entry */
opt_tab[0].option = xcstrdup("-loops");
opt_tab[0].specifier = xcstrdup(".loops");
opt_tab[0].argKind = XrmoptionSepArg;
opt_tab[0].value = (XPointer) NULL;
/* display option entry */
opt_tab[1].option = xcstrdup("-display");
opt_tab[1].specifier = xcstrdup(".display");
opt_tab[1].argKind = XrmoptionSepArg;
opt_tab[1].value = (XPointer) NULL;
/* selection option entry */
opt_tab[2].option = xcstrdup("-selection");
opt_tab[2].specifier = xcstrdup(".selection");
opt_tab[2].argKind = XrmoptionSepArg;
opt_tab[2].value = (XPointer) NULL;
/* filter option entry */
opt_tab[3].option = xcstrdup("-filter");
opt_tab[3].specifier = xcstrdup(".filter");
opt_tab[3].argKind = XrmoptionNoArg;
opt_tab[3].value = (XPointer) xcstrdup(ST);
/* in option entry */
opt_tab[4].option = xcstrdup("-in");
opt_tab[4].specifier = xcstrdup(".direction");
opt_tab[4].argKind = XrmoptionNoArg;
opt_tab[4].value = (XPointer) xcstrdup("I");
/* out option entry */
opt_tab[5].option = xcstrdup("-out");
opt_tab[5].specifier = xcstrdup(".direction");
opt_tab[5].argKind = XrmoptionNoArg;
opt_tab[5].value = (XPointer) xcstrdup("O");
/* version option entry */
opt_tab[6].option = xcstrdup("-version");
opt_tab[6].specifier = xcstrdup(".print");
opt_tab[6].argKind = XrmoptionNoArg;
opt_tab[6].value = (XPointer) xcstrdup("V");
/* help option entry */
opt_tab[7].option = xcstrdup("-help");
opt_tab[7].specifier = xcstrdup(".print");
opt_tab[7].argKind = XrmoptionNoArg;
opt_tab[7].value = (XPointer) xcstrdup("H");
/* silent option entry */
opt_tab[8].option = xcstrdup("-silent");
opt_tab[8].specifier = xcstrdup(".olevel");
opt_tab[8].argKind = XrmoptionNoArg;
opt_tab[8].value = (XPointer) xcstrdup("S");
/* quiet option entry */
opt_tab[9].option = xcstrdup("-quiet");
opt_tab[9].specifier = xcstrdup(".olevel");
opt_tab[9].argKind = XrmoptionNoArg;
opt_tab[9].value = (XPointer) xcstrdup("Q");
/* verbose option entry */
opt_tab[10].option = xcstrdup("-verbose");
opt_tab[10].specifier = xcstrdup(".olevel");
opt_tab[10].argKind = XrmoptionNoArg;
opt_tab[10].value = (XPointer) xcstrdup("V");
/* parse command line options */
doOptMain(argc, argv);
/* Connect to the X server. */
if ( (dpy = XOpenDisplay(sdisp)) )
{
/* successful */
if (fverb == OVERBOSE)
fprintf(stderr, "Connected to X server.\n");
} else
{
/* couldn't connect to X server. Print error and exit */
errxdisplay(sdisp);
}
/* parse selection command line option */
doOptSel();
/* Create a window to trap events */
win = XCreateSimpleWindow(
dpy,
DefaultRootWindow(dpy),
0,
0,
1,
1,
0,
0,
0
);
/* get events about property changes */
XSelectInput(dpy, win, PropertyChangeMask);
if (fdiri)
{
/* in mode */
sel_all = 16; /* Reasonable ballpark figure */
sel_buf = xcmalloc(sel_all * sizeof(char));
/* Put chars into inc from stdin or files until we hit EOF */
do {
if (fil_number == 0)
{
/* read from stdin if no files specified */
fil_handle = stdin;
} else
{
if (
(fil_handle = fopen(
fil_names[fil_current],
"r"
)) == NULL
)
{
errperror(
3,
argv[0],
": ",
fil_names[fil_current]
);
exit(EXIT_FAILURE);
} else
{
/* file opened successfully. Print
* message (verbose mode only).
*/
if (fverb == OVERBOSE)
fprintf(
stderr,
"Reading %s...\n",
fil_names[fil_current]
);
}
}
fil_current++;
while (!feof(fil_handle))
{
/* If sel_buf is full (used elems =
* allocated elems)
*/
if (sel_len == sel_all)
{
/* double the number of
* allocated elements
*/
sel_all *= 2;
sel_buf = (unsigned char *)xcrealloc(
sel_buf,
sel_all * sizeof(char)
);
}
sel_len += fread(
sel_buf + sel_len,
sizeof(char),
sel_all - sel_len,
fil_handle
);
}
} while (fil_current < fil_number);
/* if there are no files being read from (i.e., input
* is from stdin not files, and we are in filter mode,
* spit all the input back out to stdout
*/
if ((fil_number == 0) && ffilt)
fwrite(sel_buf, sizeof(char), sel_len, stdout);
/* take control of the selection so that we receive
* SelectionRequest events from other windows
*/
XSetSelectionOwner(dpy, sseln, win, CurrentTime);
/* fork into the background, exit parent process if we
* are in silent mode
*/
if (fverb == OSILENT)
{
pid = fork();
/* exit the parent process; */
if (pid)
exit(EXIT_SUCCESS);
}
/* print a message saying what we're waiting for */
if (fverb > OSILENT)
{
if (sloop == 1)
fprintf(
stderr,
"Waiting for one selection request.\n"
);
if (sloop < 1)
fprintf(
stderr,
"Waiting for selection requests, Control-C to quit\n"
);
if (sloop > 1)
fprintf(
stderr,
"Waiting for %i selection requests, Control-C to quit\n",
sloop
);
}
/* loop and wait for the expected number of
* SelectionRequest events
*/
while (dloop < sloop || sloop < 1)
{
/* print messages about what we're waiting for
* if not in silent mode
*/
if (fverb > OSILENT)
{
if (sloop > 1)
fprintf(
stderr,
" Waiting for selection request %i of %i.\n",
dloop + 1,
sloop
);
if (sloop == 1)
fprintf(
stderr,
" Waiting for a selection request.\n"
);
if (sloop < 1)
fprintf(
stderr,
" Waiting for selection request number %i\n",
dloop + 1
);
}
/* wait for a SelectionRequest event */
while (1)
{
static unsigned int clear = 0;
static unsigned int context = XCLIB_XCIN_NONE;
static unsigned long sel_pos = 0;
static Window cwin;
static Atom pty;
int finished;
XNextEvent(dpy, &evt);
finished = xcin(
dpy,
&cwin,
evt,
&pty,
sel_buf,
sel_len,
&sel_pos,
&context
);
if (evt.type == SelectionClear)
clear = 1;
if ( (context == XCLIB_XCIN_NONE) && clear)
exit(EXIT_SUCCESS);
if (finished)
break;
}
dloop++; /* increment loop counter */
}
} else
{
unsigned int context = XCLIB_XCOUT_NONE;
while (1)
{
/* only get an event if xcout() is doing something */
if (context != XCLIB_XCOUT_NONE)
XNextEvent(dpy, &evt);
/* fetch the selection, or part of it */
xcout(
dpy,
win,
evt,
sseln,
&sel_buf,
&sel_len,
&context
);
/* only continue if xcout() is doing something */
if (context == XCLIB_XCOUT_NONE)
break;
}
if (sel_len)
{
/* only print the buffer out, and free it, if it's not
* empty
*/
fwrite(sel_buf, sizeof(char), sel_len, stdout);
free(sel_buf);
}
}
/* Disconnect from the X server */
XCloseDisplay(dpy);
/* exit */
return(EXIT_SUCCESS);
}
// Creates the event addon
void* FcitxTabletCreate(FcitxInstance* instance) {
FcitxTablet* tablet = fcitx_utils_new(FcitxTablet);
FcitxTabletLoadConfig(&tablet->config);
// TODO select driver from config, currently using lxbi
{ // Initialise the driver
switch(tablet->config.Driver) {
case DRIVER_LXBI:
tablet->driverInstance = &lxbi;
break;
// add other drivers here
}
tablet->driverData = tablet->driverInstance->Create();
tablet->driverPacket = (char*) malloc(tablet->driverInstance->packet_size);
}
{ // Initialise the X display
if(NULL == (tablet->xDisplay = FcitxX11GetDisplay(instance))) {
FcitxLog(ERROR, "Unable to open X display");
return NULL;
}
// get dimensions
int screen = DefaultScreen(tablet->xDisplay);
tablet->xWidth = tablet->config.Width;
tablet->xHeight = tablet->config.Height;
int x = tablet->config.XPos > 0 ? tablet->config.XPos : XDisplayWidth(tablet->xDisplay, screen) - tablet->xWidth + tablet->config.XPos;
int y = tablet->config.YPos > 0 ? tablet->config.YPos : XDisplayHeight(tablet->xDisplay, screen) - tablet->xHeight + tablet->config.YPos;
// create colours
XColor back;
XColor fore;
{
char colourString[32];
{
int r = (255*tablet->config.BackgroundColour.r);
int g = (255*tablet->config.BackgroundColour.g);
int b = (255*tablet->config.BackgroundColour.b);
sprintf(colourString,"rgb:%x/%x/%x",r,g,b);
}
Colormap defaultCMap = DefaultColormap(tablet->xDisplay, screen);
XParseColor(tablet->xDisplay, defaultCMap, colourString, &back);
XAllocColor(tablet->xDisplay, defaultCMap, &back);
{
int r = (255*tablet->config.StrokeColour.r);
int g = (255*tablet->config.StrokeColour.g);
int b = (255*tablet->config.StrokeColour.b);
sprintf(colourString,"rgb:%x/%x/%x",r,g,b);
}
XParseColor(tablet->xDisplay, defaultCMap, colourString, &fore);
XAllocColor(tablet->xDisplay, defaultCMap, &fore);
}
// set window attributes and create window
XSetWindowAttributes attrs;
attrs.override_redirect = True;
attrs.background_pixel = back.pixel;
tablet->xWindow = XCreateWindow(tablet->xDisplay, DefaultRootWindow(tablet->xDisplay),
x, y, tablet->xWidth, tablet->xHeight, tablet->config.BorderWidth, CopyFromParent,
InputOutput, CopyFromParent, CWBackPixel | CWOverrideRedirect, &attrs);
// set up the foreground line (stroke) style
XGCValues gcv;
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
gcv.line_width = 3;
gcv.cap_style = CapRound;
gcv.join_style = JoinRound;
tablet->xGC = XCreateGC(tablet->xDisplay, tablet->xWindow, GCFunction | GCSubwindowMode | GCLineWidth | GCCapStyle | GCJoinStyle, &gcv);
XSetForeground(tablet->xDisplay, tablet->xGC, fore.pixel);
// prevent the window from getting focus or input
XRectangle rect = {0,0,0,0};
XserverRegion region = XFixesCreateRegion(tablet->xDisplay,&rect, 1);
XFixesSetWindowShapeRegion(tablet->xDisplay, tablet->xWindow, ShapeInput, 0, 0, region);
XFixesDestroyRegion(tablet->xDisplay, region);
}
{ // Initialise the stroke buffer
tablet->strokesBufferSize = 2048; // should be heaps. Will get automatically enlarged if required
tablet->strokesBuffer = (pt_t*) malloc(sizeof(pt_t) * tablet->strokesBufferSize);
tablet->strokesPtr = tablet->strokesBuffer;
}
{ // instantiate the engine
switch(tablet->config.Engine) {
case ENGINE_ZINNIA:
tablet->engineInstance = &engZinnia;
break;
case ENGINE_FORK:
tablet->engineInstance = &engFork;
break;
// add other engines here
}
tablet->engineData = tablet->engineInstance->Create(&tablet->config);
}
{ // set up the timerfd
tablet->timeoutFd = timerfd_create(CLOCK_MONOTONIC, 0);
tablet->delay.it_interval.tv_sec = 0;
tablet->delay.it_interval.tv_nsec = 0;
tablet->delay.it_value.tv_sec = tablet->config.CommitCharMs / 1000;
tablet->delay.it_value.tv_nsec = (tablet->config.CommitCharMs % 1000) * 1000000;
tablet->timeoutCommitPending = 0;
}
tablet->fcitx = instance;
return tablet;
}
static inline void post_mouse_button_event(uiohook_event * const event) {
#ifdef USE_XTEST
Window ret_root;
Window ret_child;
int root_x;
int root_y;
int win_x;
int win_y;
unsigned int mask;
Window win_root = XDefaultRootWindow(properties_disp);
Bool query_status = XQueryPointer(properties_disp, win_root, &ret_root, &ret_child, &root_x, &root_y, &win_x, &win_y, &mask);
if (query_status) {
if (event->data.mouse.x != root_x || event->data.mouse.y != root_y) {
// Move the pointer to the specified position.
XTestFakeMotionEvent(properties_disp, -1, event->data.mouse.x, event->data.mouse.y, 0);
}
else {
query_status = False;
}
}
if (event->type == EVENT_MOUSE_WHEEL) {
// Wheel events should be the same as click events on X11.
// type, amount and rotation
if (event->data.wheel.rotation < 0) {
XTestFakeButtonEvent(properties_disp, WheelUp, True, 0);
XTestFakeButtonEvent(properties_disp, WheelUp, False, 0);
}
else {
XTestFakeButtonEvent(properties_disp, WheelDown, True, 0);
XTestFakeButtonEvent(properties_disp, WheelDown, False, 0);
}
}
else if (event->type == EVENT_MOUSE_PRESSED) {
XTestFakeButtonEvent(properties_disp, event->data.mouse.button, True, 0);
}
else if (event->type == EVENT_MOUSE_RELEASED) {
XTestFakeButtonEvent(properties_disp, event->data.mouse.button, False, 0);
}
else if (event->type == EVENT_MOUSE_CLICKED) {
XTestFakeButtonEvent(properties_disp, event->data.mouse.button, True, 0);
XTestFakeButtonEvent(properties_disp, event->data.mouse.button, False, 0);
}
if (query_status) {
// Move the pointer back to the original position.
XTestFakeMotionEvent(properties_disp, -1, root_x, root_y, 0);
}
#else
XButtonEvent btn_event;
btn_event.serial = 0x00;
btn_event.send_event = False;
btn_event.display = properties_disp;
btn_event.time = CurrentTime;
btn_event.same_screen = True;
btn_event.root = DefaultRootWindow(properties_disp);
btn_event.window = btn_event.root;
btn_event.subwindow = None;
btn_event.type = 0x00;
btn_event.state = 0x00;
btn_event.x_root = 0;
btn_event.y_root = 0;
btn_event.x = 0;
btn_event.y = 0;
btn_event.button = 0x00;
btn_event.state = convert_to_native_mask(event->mask);
btn_event.x = event->data.mouse.x;
btn_event.y = event->data.mouse.y;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t screen_count;
screen_data *screens = hook_create_screen_info(&screen_count);
if (screen_count > 1) {
btn_event.x += screens[0].x;
btn_event.y += screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
// These are the same because Window == Root Window.
btn_event.x_root = btn_event.x;
btn_event.y_root = btn_event.y;
if (event->type == EVENT_MOUSE_WHEEL) {
// type, amount and rotation
if (event->data.wheel.rotation < 0) {
btn_event.button = WheelUp;
}
else {
btn_event.button = WheelDown;
}
}
if (event->type != EVENT_MOUSE_RELEASED) {
// FIXME Where do we set event->button?
btn_event.type = ButtonPress;
XSendEvent(properties_disp, InputFocus, False, ButtonPressMask, (XEvent *) &btn_event);
}
if (event->type != EVENT_MOUSE_PRESSED) {
btn_event.type = ButtonRelease;
XSendEvent(properties_disp, InputFocus, False, ButtonReleaseMask, (XEvent *) &btn_event);
}
#endif
}
/**
** X11 initialize.
*/
global void CloneInitDisplay(void)
{
int i;
Window window;
XGCValues gcvalue;
XSizeHints hints;
XWMHints wmhints;
XClassHint classhint;
XSetWindowAttributes attributes;
int shm_major,shm_minor;
Bool pixmap_support;
XShmSegmentInfo shminfo;
XVisualInfo xvi;
XPixmapFormatValues *xpfv;
if( !(TheDisplay=XOpenDisplay(NULL)) ) {
fprintf(stderr,"Cannot connect to X-Server.\n");
exit(-1);
}
TheScreen=DefaultScreen(TheDisplay);
// I need shared memory pixmap extension.
if( !XShmQueryVersion(TheDisplay,&shm_major,&shm_minor,&pixmap_support) ) {
fprintf(stderr,"SHM-Extensions required.\n");
exit(-1);
}
if( !pixmap_support ) {
fprintf(stderr,"SHM-Extensions with pixmap supported required.\n");
exit(-1);
}
// Look for a nice visual
#ifdef USE_HICOLOR
if(XMatchVisualInfo(TheDisplay, TheScreen, 16, TrueColor, &xvi))
goto foundvisual;
if(XMatchVisualInfo(TheDisplay, TheScreen, 15, TrueColor, &xvi))
goto foundvisual;
fprintf(stderr,"Sorry, this version is for 15/16-bit displays only.\n");
#else
if(XMatchVisualInfo(TheDisplay, TheScreen, 8, PseudoColor, &xvi))
goto foundvisual;
fprintf(stderr,"Sorry, this version is for 8-bit displays only.\n");
#endif
#if 0
if(XMatchVisualInfo(TheDisplay, TheScreen, 24, TrueColor, &xvi))
goto foundvisual;
#endif
exit(-1);
foundvisual:
xpfv=XListPixmapFormats(TheDisplay, &i);
for(i--;i>=0;i--) if(xpfv[i].depth==xvi.depth) break;
if(i<0) {
fprintf(stderr,"No Pixmap format for visual depth?\n");
exit(-1);
}
VideoDepth=xvi.depth;
VideoWidth = 640;
VideoHeight = 480;
MapWidth = 14; // FIXME: Not the correct way
MapHeight = 14;
shminfo.shmid=shmget(IPC_PRIVATE,
(VideoWidth*xpfv[i].bits_per_pixel+xpfv[i].scanline_pad-1) /
xpfv[i].scanline_pad * xpfv[i].scanline_pad * VideoHeight / 8,
IPC_CREAT|0777);
XFree(xpfv);
if( !shminfo.shmid==-1 ) {
fprintf(stderr,"shmget failed.\n");
exit(-1);
}
VideoMemory=(VMemType*)shminfo.shmaddr=shmat(shminfo.shmid,0,0);
if( shminfo.shmaddr==(void*)-1 ) {
shmctl(shminfo.shmid,IPC_RMID,0);
fprintf(stderr,"shmat failed.\n");
exit(-1);
}
shminfo.readOnly=False;
if( !XShmAttach(TheDisplay,&shminfo) ) {
shmctl(shminfo.shmid,IPC_RMID,0);
fprintf(stderr,"XShmAttach failed.\n");
exit(-1);
}
// Mark segment as deleted as soon as both clone and the X server have
// attached to it. The POSIX spec says that a segment marked as deleted
// can no longer have addition processes attach to it, but Linux will let
// them anyway.
shmctl(shminfo.shmid,IPC_RMID,0);
TheMainDrawable=attributes.background_pixmap=
XShmCreatePixmap(TheDisplay,DefaultRootWindow(TheDisplay)
,shminfo.shmaddr,&shminfo
,VideoWidth,VideoHeight
,xvi.depth);
attributes.cursor = XCreateFontCursor(TheDisplay,XC_tcross-1);
attributes.backing_store = NotUseful;
attributes.save_under = False;
attributes.event_mask = KeyPressMask|KeyReleaseMask|/*ExposureMask|*/
FocusChangeMask|ButtonPressMask|PointerMotionMask|ButtonReleaseMask;
i = CWBackPixmap|CWBackingStore|CWSaveUnder|CWEventMask|CWCursor;
if(xvi.class==PseudoColor) {
i|=CWColormap;
attributes.colormap =
XCreateColormap( TheDisplay, xvi.screen, xvi.visual, AllocNone);
// FIXME: Really should fill in the colormap right now
}
window=XCreateWindow(TheDisplay,DefaultRootWindow(TheDisplay)
,0,0,VideoWidth,VideoHeight,3
,xvi.depth,InputOutput,xvi.visual ,i,&attributes);
TheMainWindow=window;
gcvalue.graphics_exposures=False;
GcLine=XCreateGC(TheDisplay,window,GCGraphicsExposures,&gcvalue);
//
// Clear initial window.
//
XSetForeground(TheDisplay,GcLine,BlackPixel(TheDisplay,TheScreen));
XFillRectangle(TheDisplay,TheMainDrawable,GcLine,0,0
,VideoWidth,VideoHeight);
WmDeleteWindowAtom=XInternAtom(TheDisplay,"WM_DELETE_WINDOW",False);
//
// Set some usefull min/max sizes as well as a 1.3 aspect
//
#if 0
if( geometry ) {
hints.flags=0;
f=XParseGeometry(geometry
,&hints.x,&hints.y,&hints.width,&hints.height);
if( f&XValue ) {
if( f&XNegative ) {
hints.x+=DisplayWidth-hints.width;
}
hints.flags|=USPosition;
// FIXME: win gravity
}
if( f&YValue ) {
if( f&YNegative ) {
hints.y+=DisplayHeight-hints.height;
}
hints.flags|=USPosition;
// FIXME: win gravity
}
if( f&WidthValue ) {
hints.flags|=USSize;
}
if( f&HeightValue ) {
hints.flags|=USSize;
}
} else {
#endif
hints.width=VideoWidth;
hints.height=VideoHeight;
hints.flags=PSize;
#if 0
}
#endif
hints.min_width=VideoWidth;
hints.min_height=VideoHeight;
hints.max_width=VideoWidth;
hints.max_height=VideoHeight;
hints.min_aspect.x=4;
hints.min_aspect.y=3;
hints.max_aspect.x=4;
hints.max_aspect.y=3;
hints.width_inc=4;
hints.height_inc=3;
hints.flags|=PMinSize|PMaxSize|PAspect|PResizeInc;
wmhints.input=True;
wmhints.initial_state=NormalState;
wmhints.window_group=window;
wmhints.flags=InputHint|StateHint|WindowGroupHint;
classhint.res_name="aleclone";
classhint.res_class="AleClone";
XSetStandardProperties(TheDisplay,window
,"ALE Clone","ALE Clone",None,(char**)0,0,&hints);
XSetClassHint(TheDisplay,window,&classhint);
XSetWMHints(TheDisplay,window,&wmhints);
XSetWMProtocols(TheDisplay,window,&WmDeleteWindowAtom,1);
XMapWindow(TheDisplay,window);
//
// Input handling.
//
XAddConnectionWatch(TheDisplay,MyConnectionWatch,NULL);
}
static inline void post_mouse_motion_event(uiohook_event * const event) {
#ifdef USE_XTEST
XTestFakeMotionEvent(properties_disp, -1, event->data.mouse.x, event->data.mouse.y, 0);
#else
XMotionEvent mov_event;
mov_event.serial = MotionNotify;
mov_event.send_event = False;
mov_event.display = properties_disp;
mov_event.time = CurrentTime;
mov_event.same_screen = True;
mov_event.is_hint = NotifyNormal,
mov_event.root = DefaultRootWindow(properties_disp);
mov_event.window = mov_event.root;
mov_event.subwindow = None;
mov_event.type = 0x00;
mov_event.state = 0x00;
mov_event.x_root = 0;
mov_event.y_root = 0;
mov_event.x = 0;
mov_event.y = 0;
mov_event.state = convert_to_native_mask(event->mask);
mov_event.x = event->data.mouse.x;
mov_event.y = event->data.mouse.y;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t screen_count;
screen_data *screens = hook_create_screen_info(&screen_count);
if (screen_count > 1) {
mov_event.x += screens[0].x;
mov_event.y += screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
// These are the same because Window == Root Window.
mov_event.x_root = mov_event.x;
mov_event.y_root = mov_event.y;
long int event_mask = NoEventMask;
if (event->type == EVENT_MOUSE_DRAGGED) {
#if Button1Mask == Button1MotionMask && \
Button2Mask == Button2MotionMask && \
Button3Mask == Button3MotionMask && \
Button4Mask == Button4MotionMask && \
Button5Mask == Button5MotionMask
// This little trick only works if Button#MotionMasks align with
// the Button#Masks.
event_mask = mov_event.state &
(Button1MotionMask | Button2MotionMask |
Button2MotionMask | Button3MotionMask | Button5MotionMask);
#else
// Fallback to some slightly larger...
if (event->state & Button1Mask) {
event_mask |= Button1MotionMask;
}
if (event->state & Button2Mask) {
event_mask |= Button2MotionMask;
}
if (event->state & Button3Mask) {
event_mask |= Button3MotionMask;
}
if (event->state & Button4Mask) {
event_mask |= Button4MotionMask;
}
if (event->state & Button5Mask) {
event_mask |= Button5MotionMask;
}
#endif
}
// NOTE x_mask = NoEventMask.
XSendEvent(properties_disp, InputFocus, False, event_mask, (XEvent *) &mov_event);
#endif
}
void Injector::injectMotionAbsolute(int x, int y)
{
XWarpPointer(m_display, None, DefaultRootWindow(m_display), 0, 0, 0, 0, x, y);
}
///
// WinCreate()
//
// This function initialized the native X11 display and window for EGL
//
EGLBoolean WinCreate(ESContext *esContext, const char *title)
{
Window root;
XSetWindowAttributes swa;
XSetWindowAttributes xattr;
Atom wm_state;
XWMHints hints;
XEvent xev;
Window win;
/*
* X11 native display initialization
*/
x_display = XOpenDisplay(NULL);
if ( x_display == NULL )
{
return EGL_FALSE;
}
root = DefaultRootWindow(x_display);
swa.event_mask = ExposureMask | PointerMotionMask | KeyPressMask;
win = XCreateWindow(
x_display, root,
0, 0, esContext->width, esContext->height, 0,
CopyFromParent, InputOutput,
CopyFromParent, CWEventMask,
&swa );
xattr.override_redirect = FALSE;
XChangeWindowAttributes ( x_display, win, CWOverrideRedirect, &xattr );
hints.input = TRUE;
hints.flags = InputHint;
XSetWMHints(x_display, win, &hints);
// make the window visible on the screen
XMapWindow (x_display, win);
XStoreName (x_display, win, title);
// get identifiers for the provided atom name strings
wm_state = XInternAtom (x_display, "_NET_WM_STATE", FALSE);
memset ( &xev, 0, sizeof(xev) );
xev.type = ClientMessage;
xev.xclient.window = win;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1;
xev.xclient.data.l[1] = FALSE;
XSendEvent (
x_display,
DefaultRootWindow ( x_display ),
FALSE,
SubstructureNotifyMask,
&xev );
esContext->hWnd = (EGLNativeWindowType) win;
return EGL_TRUE;
}
static Window make_selection_window(Display*dpy)
{
Window win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 1, 1, 0, 0, 0);
XSelectInput(dpy, win, PropertyChangeMask);
return win;
}
/*
* Create an RGB, double-buffered window.
* Return the window and context handles.
*/
static void make_window(Display * dpy, Screen * scr, EGLDisplay eglDisplay,
EGLSurface * winRet, EGLContext * ctxRet)
{
EGLSurface eglSurface = EGL_NO_SURFACE;
EGLContext eglContext;
EGLConfig configs[MAX_NUM_CONFIGS];
EGLint config_count;
XWindowAttributes WinAttr;
int XResult = BadImplementation;
int blackColour = BlackPixel(dpy, DefaultScreen(dpy));
EGLint cfg_attribs[] = {
EGL_NATIVE_VISUAL_TYPE, 0,
/* RGB565 */
EGL_BUFFER_SIZE, 16,
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_DEPTH_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_NONE
};
EGLint i;
win =
XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 1, 1, 0,
blackColour, blackColour);
XStoreName(dpy, win, WINDOW_CLASS_NAME);
XSelectInput(dpy, win, X_MASK);
if (!(XResult = XGetWindowAttributes(dpy, win, &WinAttr)))
GLimp_HandleError();
GLimp_DisableComposition();
XMapWindow(dpy, win);
GLimp_DisableComposition();
XFlush(dpy);
if (!eglGetConfigs(eglDisplay, configs, MAX_NUM_CONFIGS, &config_count))
GLimp_HandleError();
if (!eglChooseConfig
(eglDisplay, cfg_attribs, configs, MAX_NUM_CONFIGS, &config_count))
GLimp_HandleError();
for (i = 0; i < config_count; i++) {
if ((eglSurface =
eglCreateWindowSurface(eglDisplay, configs[i],
(NativeWindowType) win,
NULL)) != EGL_NO_SURFACE)
break;
}
if (eglSurface == EGL_NO_SURFACE)
GLimp_HandleError();
if ((eglContext =
eglCreateContext(eglDisplay, configs[i], EGL_NO_CONTEXT,
NULL)) == EGL_NO_CONTEXT)
GLimp_HandleError();
if (!eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext))
GLimp_HandleError();
*winRet = eglSurface;
*ctxRet = eglContext;
}
//-------------------------------------------------------------------------------------------------//
GLXGLSupport::GLXGLSupport() : mGLDisplay(0), mXDisplay(0)
{
// A connection that might be shared with the application for GL rendering:
mGLDisplay = getGLDisplay();
// A connection that is NOT shared to enable independent event processing:
mXDisplay = getXDisplay();
int dummy;
if (XQueryExtension(mXDisplay, "RANDR", &dummy, &dummy, &dummy))
{
XRRScreenConfiguration *screenConfig;
screenConfig = XRRGetScreenInfo(mXDisplay, DefaultRootWindow(mXDisplay));
if (screenConfig)
{
XRRScreenSize *screenSizes;
int nSizes = 0;
Rotation currentRotation;
int currentSizeID = XRRConfigCurrentConfiguration(screenConfig, ¤tRotation);
screenSizes = XRRConfigSizes(screenConfig, &nSizes);
mCurrentMode.first.first = screenSizes[currentSizeID].width;
mCurrentMode.first.second = screenSizes[currentSizeID].height;
mCurrentMode.second = XRRConfigCurrentRate(screenConfig);
mOriginalMode = mCurrentMode;
for(int sizeID = 0; sizeID < nSizes; sizeID++)
{
short *rates;
int nRates = 0;
rates = XRRConfigRates(screenConfig, sizeID, &nRates);
for (int rate = 0; rate < nRates; rate++)
{
VideoMode mode;
mode.first.first = screenSizes[sizeID].width;
mode.first.second = screenSizes[sizeID].height;
mode.second = rates[rate];
mVideoModes.push_back(mode);
}
}
XRRFreeScreenConfigInfo(screenConfig);
}
}
else
{
mCurrentMode.first.first = DisplayWidth(mXDisplay, DefaultScreen(mXDisplay));
mCurrentMode.first.second = DisplayHeight(mXDisplay, DefaultScreen(mXDisplay));
mCurrentMode.second = 0;
mOriginalMode = mCurrentMode;
mVideoModes.push_back(mCurrentMode);
}
GLXFBConfig *fbConfigs;
int config, nConfigs = 0;
fbConfigs = chooseFBConfig(NULL, &nConfigs);
for (config = 0; config < nConfigs; config++)
{
int caveat, samples;
getFBConfigAttrib (fbConfigs[config], GLX_CONFIG_CAVEAT, &caveat);
if (caveat != GLX_SLOW_CONFIG)
{
getFBConfigAttrib (fbConfigs[config], GLX_SAMPLES, &samples);
mSampleLevels.push_back(StringConverter::toString(samples));
}
}
XFree (fbConfigs);
remove_duplicates(mSampleLevels);
}
static void run(Display *dpy, int width, int height,
unsigned int *attachments, int nattachments,
const char *name)
{
Window win;
XSetWindowAttributes attr;
int count;
DRI2Buffer *buffers;
struct timespec start, end;
/* Be nasty and install a fullscreen window on top so that we
* can guarantee we do not get clipped by children.
*/
attr.override_redirect = 1;
win = XCreateWindow(dpy, DefaultRootWindow(dpy),
0, 0, width, height, 0,
DefaultDepth(dpy, DefaultScreen(dpy)),
InputOutput,
DefaultVisual(dpy, DefaultScreen(dpy)),
CWOverrideRedirect, &attr);
XMapWindow(dpy, win);
xsync(dpy, win);
DRI2CreateDrawable(dpy, win);
buffers = DRI2GetBuffers(dpy, win, &width, &height,
attachments, nattachments, &count);
if (count != nattachments)
return;
xsync(dpy, win);
clock_gettime(CLOCK_MONOTONIC, &start);
for (count = 0; count < COUNT; count++)
DRI2SwapBuffers(dpy, win, 0, 0, 0);
xsync(dpy, win);
clock_gettime(CLOCK_MONOTONIC, &end);
printf("%d %s (%dx%d) swaps in %fs.\n",
count, name, width, height, elapsed(&start, &end));
xsync(dpy, win);
clock_gettime(CLOCK_MONOTONIC, &start);
for (count = 0; count < COUNT; count++)
dri2_copy_swap(dpy, win, width, height, nattachments == 2);
xsync(dpy, win);
clock_gettime(CLOCK_MONOTONIC, &end);
printf("%d %s (%dx%d) blits in %fs.\n",
count, name, width, height, elapsed(&start, &end));
DRI2SwapInterval(dpy, win, 0);
xsync(dpy, win);
clock_gettime(CLOCK_MONOTONIC, &start);
for (count = 0; count < COUNT; count++)
DRI2SwapBuffers(dpy, win, 0, 0, 0);
xsync(dpy, win);
clock_gettime(CLOCK_MONOTONIC, &end);
printf("%d %s (%dx%d) vblank=0 swaps in %fs.\n",
count, name, width, height, elapsed(&start, &end));
XDestroyWindow(dpy, win);
free(buffers);
XSync(dpy, 1);
}