If we end up reading all pending X events in the course of other server execution, then our notify FD callback won't get invoked and we won't process them. Fix this by noting that there are queued events in the block handler, setting the poll timeout to zero and queuing a work proc to clear the event queue. v2: use a work proc to clear the event queue rather than doing it in the block handler directly. Signed-off-by: Keith Packard <keithp@keithp.com> Reviewed-by: Adam Jackson <ajax@redhat.com>
1592 lines
49 KiB
C
1592 lines
49 KiB
C
/*
|
|
* Xephyr - A kdrive X server thats runs in a host X window.
|
|
* Authored by Matthew Allum <mallum@o-hand.com>
|
|
*
|
|
* Copyright © 2004 Nokia
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Nokia not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Nokia makes no
|
|
* representations about the suitability of this software for any purpose. It
|
|
* is provided "as is" without express or implied warranty.
|
|
*
|
|
* NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL NOKIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <kdrive-config.h>
|
|
#endif
|
|
|
|
#include "hostx.h"
|
|
#include "input.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <string.h> /* for memset */
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <err.h>
|
|
|
|
#include <sys/ipc.h>
|
|
#include <sys/shm.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <X11/keysym.h>
|
|
#include <xcb/xcb.h>
|
|
#include <xcb/xproto.h>
|
|
#include <xcb/xcb_icccm.h>
|
|
#include <xcb/xcb_aux.h>
|
|
#include <xcb/shm.h>
|
|
#include <xcb/xcb_image.h>
|
|
#include <xcb/shape.h>
|
|
#include <xcb/xcb_keysyms.h>
|
|
#include <xcb/randr.h>
|
|
#include <xcb/xkb.h>
|
|
#ifdef GLAMOR
|
|
#include <epoxy/gl.h>
|
|
#include "glamor.h"
|
|
#include "ephyr_glamor_glx.h"
|
|
#endif
|
|
#include "ephyrlog.h"
|
|
#include "ephyr.h"
|
|
|
|
struct EphyrHostXVars {
|
|
char *server_dpy_name;
|
|
xcb_connection_t *conn;
|
|
int screen;
|
|
xcb_visualtype_t *visual;
|
|
Window winroot;
|
|
xcb_gcontext_t gc;
|
|
xcb_render_pictformat_t argb_format;
|
|
xcb_cursor_t empty_cursor;
|
|
xcb_generic_event_t *saved_event;
|
|
int depth;
|
|
Bool use_sw_cursor;
|
|
Bool use_fullscreen;
|
|
Bool have_shm;
|
|
|
|
int n_screens;
|
|
KdScreenInfo **screens;
|
|
|
|
long damage_debug_msec;
|
|
Bool size_set_from_configure;
|
|
};
|
|
|
|
/* memset ( missing> ) instead of below */
|
|
/*static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};*/
|
|
static EphyrHostXVars HostX;
|
|
|
|
static int HostXWantDamageDebug = 0;
|
|
|
|
extern Bool EphyrWantResize;
|
|
|
|
char *ephyrResName = NULL;
|
|
int ephyrResNameFromCmd = 0;
|
|
char *ephyrTitle = NULL;
|
|
Bool ephyr_glamor = FALSE;
|
|
|
|
Bool
|
|
hostx_has_extension(xcb_extension_t *extension)
|
|
{
|
|
const xcb_query_extension_reply_t *rep;
|
|
|
|
rep = xcb_get_extension_data(HostX.conn, extension);
|
|
|
|
return rep && rep->present;
|
|
}
|
|
|
|
static void
|
|
hostx_set_fullscreen_hint(void);
|
|
|
|
#define host_depth_matches_server(_vars) (HostX.depth == (_vars)->server_depth)
|
|
|
|
int
|
|
hostx_want_screen_geometry(KdScreenInfo *screen, int *width, int *height, int *x, int *y)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
if (scrpriv && (scrpriv->win_pre_existing != None ||
|
|
scrpriv->output != NULL ||
|
|
HostX.use_fullscreen == TRUE)) {
|
|
*x = scrpriv->win_x;
|
|
*y = scrpriv->win_y;
|
|
*width = scrpriv->win_width;
|
|
*height = scrpriv->win_height;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
hostx_add_screen(KdScreenInfo *screen, unsigned long win_id, int screen_num, Bool use_geometry, const char *output)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
int index = HostX.n_screens;
|
|
|
|
HostX.n_screens += 1;
|
|
HostX.screens = reallocarray(HostX.screens,
|
|
HostX.n_screens, sizeof(HostX.screens[0]));
|
|
HostX.screens[index] = screen;
|
|
|
|
scrpriv->screen = screen;
|
|
scrpriv->win_pre_existing = win_id;
|
|
scrpriv->win_explicit_position = use_geometry;
|
|
scrpriv->output = output;
|
|
}
|
|
|
|
void
|
|
hostx_set_display_name(char *name)
|
|
{
|
|
HostX.server_dpy_name = strdup(name);
|
|
}
|
|
|
|
void
|
|
hostx_set_screen_number(KdScreenInfo *screen, int number)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
if (scrpriv) {
|
|
scrpriv->mynum = number;
|
|
hostx_set_win_title(screen, "");
|
|
}
|
|
}
|
|
|
|
void
|
|
hostx_set_win_title(KdScreenInfo *screen, const char *extra_text)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
if (!scrpriv)
|
|
return;
|
|
|
|
if (ephyrTitle) {
|
|
xcb_icccm_set_wm_name(HostX.conn,
|
|
scrpriv->win,
|
|
XCB_ATOM_STRING,
|
|
8,
|
|
strlen(ephyrTitle),
|
|
ephyrTitle);
|
|
} else {
|
|
#define BUF_LEN 256
|
|
char buf[BUF_LEN + 1];
|
|
|
|
memset(buf, 0, BUF_LEN + 1);
|
|
snprintf(buf, BUF_LEN, "Xephyr on %s.%d %s",
|
|
HostX.server_dpy_name ? HostX.server_dpy_name : ":0",
|
|
scrpriv->mynum, (extra_text != NULL) ? extra_text : "");
|
|
|
|
xcb_icccm_set_wm_name(HostX.conn,
|
|
scrpriv->win,
|
|
XCB_ATOM_STRING,
|
|
8,
|
|
strlen(buf),
|
|
buf);
|
|
xcb_flush(HostX.conn);
|
|
}
|
|
}
|
|
|
|
int
|
|
hostx_want_host_cursor(void)
|
|
{
|
|
return !HostX.use_sw_cursor;
|
|
}
|
|
|
|
void
|
|
hostx_use_sw_cursor(void)
|
|
{
|
|
HostX.use_sw_cursor = TRUE;
|
|
}
|
|
|
|
xcb_cursor_t
|
|
hostx_get_empty_cursor(void)
|
|
{
|
|
return HostX.empty_cursor;
|
|
}
|
|
|
|
int
|
|
hostx_want_preexisting_window(KdScreenInfo *screen)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
if (scrpriv && scrpriv->win_pre_existing) {
|
|
return 1;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
hostx_get_output_geometry(const char *output,
|
|
int *x, int *y,
|
|
int *width, int *height)
|
|
{
|
|
int i, name_len = 0, output_found = FALSE;
|
|
char *name = NULL;
|
|
xcb_generic_error_t *error;
|
|
xcb_randr_query_version_cookie_t version_c;
|
|
xcb_randr_query_version_reply_t *version_r;
|
|
xcb_randr_get_screen_resources_cookie_t screen_resources_c;
|
|
xcb_randr_get_screen_resources_reply_t *screen_resources_r;
|
|
xcb_randr_output_t *randr_outputs;
|
|
xcb_randr_get_output_info_cookie_t output_info_c;
|
|
xcb_randr_get_output_info_reply_t *output_info_r;
|
|
xcb_randr_get_crtc_info_cookie_t crtc_info_c;
|
|
xcb_randr_get_crtc_info_reply_t *crtc_info_r;
|
|
|
|
/* First of all, check for extension */
|
|
if (!hostx_has_extension(&xcb_randr_id))
|
|
{
|
|
fprintf(stderr, "\nHost X server does not support RANDR extension (or it's disabled).\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Check RandR version */
|
|
version_c = xcb_randr_query_version(HostX.conn, 1, 2);
|
|
version_r = xcb_randr_query_version_reply(HostX.conn,
|
|
version_c,
|
|
&error);
|
|
|
|
if (error != NULL || version_r == NULL)
|
|
{
|
|
fprintf(stderr, "\nFailed to get RandR version supported by host X server.\n");
|
|
exit(1);
|
|
}
|
|
else if (version_r->major_version < 1 || version_r->minor_version < 2)
|
|
{
|
|
free(version_r);
|
|
fprintf(stderr, "\nHost X server doesn't support RandR 1.2, needed for -output usage.\n");
|
|
exit(1);
|
|
}
|
|
|
|
free(version_r);
|
|
|
|
/* Get list of outputs from screen resources */
|
|
screen_resources_c = xcb_randr_get_screen_resources(HostX.conn,
|
|
HostX.winroot);
|
|
screen_resources_r = xcb_randr_get_screen_resources_reply(HostX.conn,
|
|
screen_resources_c,
|
|
NULL);
|
|
randr_outputs = xcb_randr_get_screen_resources_outputs(screen_resources_r);
|
|
|
|
for (i = 0; !output_found && i < screen_resources_r->num_outputs; i++)
|
|
{
|
|
/* Get info on the output */
|
|
output_info_c = xcb_randr_get_output_info(HostX.conn,
|
|
randr_outputs[i],
|
|
XCB_CURRENT_TIME);
|
|
output_info_r = xcb_randr_get_output_info_reply(HostX.conn,
|
|
output_info_c,
|
|
NULL);
|
|
|
|
/* Get output name */
|
|
name_len = xcb_randr_get_output_info_name_length(output_info_r);
|
|
name = malloc(name_len + 1);
|
|
strncpy(name, (char*)xcb_randr_get_output_info_name(output_info_r), name_len);
|
|
name[name_len] = '\0';
|
|
|
|
if (!strcmp(name, output))
|
|
{
|
|
output_found = TRUE;
|
|
|
|
/* Check if output is connected */
|
|
if (output_info_r->crtc == XCB_NONE)
|
|
{
|
|
free(name);
|
|
free(output_info_r);
|
|
free(screen_resources_r);
|
|
fprintf(stderr, "\nOutput %s is currently disabled (or not connected).\n", output);
|
|
exit(1);
|
|
}
|
|
|
|
/* Get CRTC from output info */
|
|
crtc_info_c = xcb_randr_get_crtc_info(HostX.conn,
|
|
output_info_r->crtc,
|
|
XCB_CURRENT_TIME);
|
|
crtc_info_r = xcb_randr_get_crtc_info_reply(HostX.conn,
|
|
crtc_info_c,
|
|
NULL);
|
|
|
|
/* Get CRTC geometry */
|
|
*x = crtc_info_r->x;
|
|
*y = crtc_info_r->y;
|
|
*width = crtc_info_r->width;
|
|
*height = crtc_info_r->height;
|
|
|
|
free(crtc_info_r);
|
|
}
|
|
|
|
free(name);
|
|
free(output_info_r);
|
|
}
|
|
|
|
free(screen_resources_r);
|
|
|
|
if (!output_found)
|
|
{
|
|
fprintf(stderr, "\nOutput %s not available in host X server.\n", output);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
void
|
|
hostx_use_fullscreen(void)
|
|
{
|
|
HostX.use_fullscreen = TRUE;
|
|
}
|
|
|
|
int
|
|
hostx_want_fullscreen(void)
|
|
{
|
|
return HostX.use_fullscreen;
|
|
}
|
|
|
|
static xcb_intern_atom_cookie_t cookie_WINDOW_STATE,
|
|
cookie_WINDOW_STATE_FULLSCREEN;
|
|
|
|
static void
|
|
hostx_set_fullscreen_hint(void)
|
|
{
|
|
xcb_atom_t atom_WINDOW_STATE, atom_WINDOW_STATE_FULLSCREEN;
|
|
int index;
|
|
xcb_intern_atom_reply_t *reply;
|
|
|
|
reply = xcb_intern_atom_reply(HostX.conn, cookie_WINDOW_STATE, NULL);
|
|
atom_WINDOW_STATE = reply->atom;
|
|
free(reply);
|
|
|
|
reply = xcb_intern_atom_reply(HostX.conn, cookie_WINDOW_STATE_FULLSCREEN,
|
|
NULL);
|
|
atom_WINDOW_STATE_FULLSCREEN = reply->atom;
|
|
free(reply);
|
|
|
|
for (index = 0; index < HostX.n_screens; index++) {
|
|
EphyrScrPriv *scrpriv = HostX.screens[index]->driver;
|
|
xcb_change_property(HostX.conn,
|
|
PropModeReplace,
|
|
scrpriv->win,
|
|
atom_WINDOW_STATE,
|
|
XCB_ATOM_ATOM,
|
|
32,
|
|
1,
|
|
&atom_WINDOW_STATE_FULLSCREEN);
|
|
}
|
|
}
|
|
|
|
static void
|
|
hostx_toggle_damage_debug(void)
|
|
{
|
|
HostXWantDamageDebug ^= 1;
|
|
}
|
|
|
|
void
|
|
hostx_handle_signal(int signum)
|
|
{
|
|
hostx_toggle_damage_debug();
|
|
EPHYR_DBG("Signal caught. Damage Debug:%i\n", HostXWantDamageDebug);
|
|
}
|
|
|
|
void
|
|
hostx_use_resname(char *name, int fromcmd)
|
|
{
|
|
ephyrResName = name;
|
|
ephyrResNameFromCmd = fromcmd;
|
|
}
|
|
|
|
void
|
|
hostx_set_title(char *title)
|
|
{
|
|
ephyrTitle = title;
|
|
}
|
|
|
|
#ifdef __SUNPRO_C
|
|
/* prevent "Function has no return statement" error for x_io_error_handler */
|
|
#pragma does_not_return(exit)
|
|
#endif
|
|
|
|
int
|
|
hostx_init(void)
|
|
{
|
|
uint32_t attrs[2];
|
|
uint32_t attr_mask = 0;
|
|
xcb_pixmap_t cursor_pxm;
|
|
xcb_gcontext_t cursor_gc;
|
|
uint16_t red, green, blue;
|
|
uint32_t pixel;
|
|
int index;
|
|
char *tmpstr;
|
|
char *class_hint;
|
|
size_t class_len;
|
|
xcb_screen_t *xscreen;
|
|
xcb_rectangle_t rect = { 0, 0, 1, 1 };
|
|
|
|
attrs[0] =
|
|
XCB_EVENT_MASK_BUTTON_PRESS
|
|
| XCB_EVENT_MASK_BUTTON_RELEASE
|
|
| XCB_EVENT_MASK_POINTER_MOTION
|
|
| XCB_EVENT_MASK_KEY_PRESS
|
|
| XCB_EVENT_MASK_KEY_RELEASE
|
|
| XCB_EVENT_MASK_EXPOSURE
|
|
| XCB_EVENT_MASK_STRUCTURE_NOTIFY;
|
|
attr_mask |= XCB_CW_EVENT_MASK;
|
|
|
|
EPHYR_DBG("mark");
|
|
#ifdef GLAMOR
|
|
if (ephyr_glamor)
|
|
HostX.conn = ephyr_glamor_connect();
|
|
else
|
|
#endif
|
|
HostX.conn = xcb_connect(NULL, &HostX.screen);
|
|
if (!HostX.conn || xcb_connection_has_error(HostX.conn)) {
|
|
fprintf(stderr, "\nXephyr cannot open host display. Is DISPLAY set?\n");
|
|
exit(1);
|
|
}
|
|
|
|
xscreen = xcb_aux_get_screen(HostX.conn, HostX.screen);
|
|
HostX.winroot = xscreen->root;
|
|
HostX.gc = xcb_generate_id(HostX.conn);
|
|
HostX.depth = xscreen->root_depth;
|
|
#ifdef GLAMOR
|
|
if (ephyr_glamor) {
|
|
HostX.visual = ephyr_glamor_get_visual();
|
|
if (HostX.visual->visual_id != xscreen->root_visual) {
|
|
attrs[1] = xcb_generate_id(HostX.conn);
|
|
attr_mask |= XCB_CW_COLORMAP;
|
|
xcb_create_colormap(HostX.conn,
|
|
XCB_COLORMAP_ALLOC_NONE,
|
|
attrs[1],
|
|
HostX.winroot,
|
|
HostX.visual->visual_id);
|
|
}
|
|
} else
|
|
#endif
|
|
HostX.visual = xcb_aux_find_visual_by_id(xscreen,xscreen->root_visual);
|
|
|
|
xcb_create_gc(HostX.conn, HostX.gc, HostX.winroot, 0, NULL);
|
|
cookie_WINDOW_STATE = xcb_intern_atom(HostX.conn, FALSE,
|
|
strlen("_NET_WM_STATE"),
|
|
"_NET_WM_STATE");
|
|
cookie_WINDOW_STATE_FULLSCREEN =
|
|
xcb_intern_atom(HostX.conn, FALSE,
|
|
strlen("_NET_WM_STATE_FULLSCREEN"),
|
|
"_NET_WM_STATE_FULLSCREEN");
|
|
|
|
for (index = 0; index < HostX.n_screens; index++) {
|
|
KdScreenInfo *screen = HostX.screens[index];
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
scrpriv->win = xcb_generate_id(HostX.conn);
|
|
scrpriv->server_depth = HostX.depth;
|
|
scrpriv->ximg = NULL;
|
|
scrpriv->win_x = 0;
|
|
scrpriv->win_y = 0;
|
|
|
|
if (scrpriv->win_pre_existing != XCB_WINDOW_NONE) {
|
|
xcb_get_geometry_reply_t *prewin_geom;
|
|
xcb_get_geometry_cookie_t cookie;
|
|
xcb_generic_error_t *e = NULL;
|
|
|
|
/* Get screen size from existing window */
|
|
cookie = xcb_get_geometry(HostX.conn,
|
|
scrpriv->win_pre_existing);
|
|
prewin_geom = xcb_get_geometry_reply(HostX.conn, cookie, &e);
|
|
|
|
if (e) {
|
|
free(e);
|
|
free(prewin_geom);
|
|
fprintf (stderr, "\nXephyr -parent window' does not exist!\n");
|
|
exit (1);
|
|
}
|
|
|
|
scrpriv->win_width = prewin_geom->width;
|
|
scrpriv->win_height = prewin_geom->height;
|
|
|
|
free(prewin_geom);
|
|
|
|
xcb_create_window(HostX.conn,
|
|
XCB_COPY_FROM_PARENT,
|
|
scrpriv->win,
|
|
scrpriv->win_pre_existing,
|
|
0,0,
|
|
scrpriv->win_width,
|
|
scrpriv->win_height,
|
|
0,
|
|
XCB_WINDOW_CLASS_COPY_FROM_PARENT,
|
|
HostX.visual->visual_id,
|
|
attr_mask,
|
|
attrs);
|
|
}
|
|
else {
|
|
xcb_create_window(HostX.conn,
|
|
XCB_COPY_FROM_PARENT,
|
|
scrpriv->win,
|
|
HostX.winroot,
|
|
0,0,100,100, /* will resize */
|
|
0,
|
|
XCB_WINDOW_CLASS_COPY_FROM_PARENT,
|
|
HostX.visual->visual_id,
|
|
attr_mask,
|
|
attrs);
|
|
|
|
hostx_set_win_title(screen,
|
|
"(ctrl+shift grabs mouse and keyboard)");
|
|
|
|
if (HostX.use_fullscreen) {
|
|
scrpriv->win_width = xscreen->width_in_pixels;
|
|
scrpriv->win_height = xscreen->height_in_pixels;
|
|
|
|
hostx_set_fullscreen_hint();
|
|
}
|
|
else if (scrpriv->output) {
|
|
hostx_get_output_geometry(scrpriv->output,
|
|
&scrpriv->win_x,
|
|
&scrpriv->win_y,
|
|
&scrpriv->win_width,
|
|
&scrpriv->win_height);
|
|
|
|
HostX.use_fullscreen = TRUE;
|
|
hostx_set_fullscreen_hint();
|
|
}
|
|
|
|
|
|
tmpstr = getenv("RESOURCE_NAME");
|
|
if (tmpstr && (!ephyrResNameFromCmd))
|
|
ephyrResName = tmpstr;
|
|
class_len = strlen(ephyrResName) + 1 + strlen("Xephyr") + 1;
|
|
class_hint = malloc(class_len);
|
|
if (class_hint) {
|
|
strcpy(class_hint, ephyrResName);
|
|
strcpy(class_hint + strlen(ephyrResName) + 1, "Xephyr");
|
|
xcb_change_property(HostX.conn,
|
|
XCB_PROP_MODE_REPLACE,
|
|
scrpriv->win,
|
|
XCB_ATOM_WM_CLASS,
|
|
XCB_ATOM_STRING,
|
|
8,
|
|
class_len,
|
|
class_hint);
|
|
free(class_hint);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!xcb_aux_parse_color("red", &red, &green, &blue)) {
|
|
xcb_lookup_color_cookie_t c =
|
|
xcb_lookup_color(HostX.conn, xscreen->default_colormap, 3, "red");
|
|
xcb_lookup_color_reply_t *reply =
|
|
xcb_lookup_color_reply(HostX.conn, c, NULL);
|
|
red = reply->exact_red;
|
|
green = reply->exact_green;
|
|
blue = reply->exact_blue;
|
|
free(reply);
|
|
}
|
|
|
|
{
|
|
xcb_alloc_color_cookie_t c = xcb_alloc_color(HostX.conn,
|
|
xscreen->default_colormap,
|
|
red, green, blue);
|
|
xcb_alloc_color_reply_t *r = xcb_alloc_color_reply(HostX.conn, c, NULL);
|
|
red = r->red;
|
|
green = r->green;
|
|
blue = r->blue;
|
|
pixel = r->pixel;
|
|
free(r);
|
|
}
|
|
|
|
xcb_change_gc(HostX.conn, HostX.gc, XCB_GC_FOREGROUND, &pixel);
|
|
|
|
cursor_pxm = xcb_generate_id(HostX.conn);
|
|
xcb_create_pixmap(HostX.conn, 1, cursor_pxm, HostX.winroot, 1, 1);
|
|
cursor_gc = xcb_generate_id(HostX.conn);
|
|
pixel = 0;
|
|
xcb_create_gc(HostX.conn, cursor_gc, cursor_pxm,
|
|
XCB_GC_FOREGROUND, &pixel);
|
|
xcb_poly_fill_rectangle(HostX.conn, cursor_pxm, cursor_gc, 1, &rect);
|
|
xcb_free_gc(HostX.conn, cursor_gc);
|
|
HostX.empty_cursor = xcb_generate_id(HostX.conn);
|
|
xcb_create_cursor(HostX.conn,
|
|
HostX.empty_cursor,
|
|
cursor_pxm, cursor_pxm,
|
|
0,0,0,
|
|
0,0,0,
|
|
1,1);
|
|
xcb_free_pixmap(HostX.conn, cursor_pxm);
|
|
if (!hostx_want_host_cursor ()) {
|
|
CursorVisible = TRUE;
|
|
/* Ditch the cursor, we provide our 'own' */
|
|
for (index = 0; index < HostX.n_screens; index++) {
|
|
KdScreenInfo *screen = HostX.screens[index];
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
xcb_change_window_attributes(HostX.conn,
|
|
scrpriv->win,
|
|
XCB_CW_CURSOR,
|
|
&HostX.empty_cursor);
|
|
}
|
|
}
|
|
|
|
/* Try to get share memory ximages for a little bit more speed */
|
|
if (!hostx_has_extension(&xcb_shm_id) || getenv("XEPHYR_NO_SHM")) {
|
|
fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
|
|
HostX.have_shm = FALSE;
|
|
}
|
|
else {
|
|
/* Really really check we have shm - better way ?*/
|
|
xcb_shm_segment_info_t shminfo;
|
|
xcb_generic_error_t *e;
|
|
xcb_void_cookie_t cookie;
|
|
xcb_shm_seg_t shmseg;
|
|
|
|
HostX.have_shm = TRUE;
|
|
|
|
shminfo.shmid = shmget(IPC_PRIVATE, 1, IPC_CREAT|0777);
|
|
shminfo.shmaddr = shmat(shminfo.shmid,0,0);
|
|
|
|
shmseg = xcb_generate_id(HostX.conn);
|
|
cookie = xcb_shm_attach_checked(HostX.conn, shmseg, shminfo.shmid,
|
|
TRUE);
|
|
e = xcb_request_check(HostX.conn, cookie);
|
|
|
|
if (e) {
|
|
fprintf(stderr, "\nXephyr unable to use SHM XImages\n");
|
|
HostX.have_shm = FALSE;
|
|
free(e);
|
|
}
|
|
|
|
shmdt(shminfo.shmaddr);
|
|
shmctl(shminfo.shmid, IPC_RMID, 0);
|
|
}
|
|
|
|
xcb_flush(HostX.conn);
|
|
|
|
/* Setup the pause time between paints when debugging updates */
|
|
|
|
HostX.damage_debug_msec = 20000; /* 1/50 th of a second */
|
|
|
|
if (getenv("XEPHYR_PAUSE")) {
|
|
HostX.damage_debug_msec = strtol(getenv("XEPHYR_PAUSE"), NULL, 0);
|
|
EPHYR_DBG("pause is %li\n", HostX.damage_debug_msec);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
hostx_get_depth(void)
|
|
{
|
|
return HostX.depth;
|
|
}
|
|
|
|
int
|
|
hostx_get_server_depth(KdScreenInfo *screen)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
return scrpriv ? scrpriv->server_depth : 0;
|
|
}
|
|
|
|
int
|
|
hostx_get_bpp(KdScreenInfo *screen)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
if (!scrpriv)
|
|
return 0;
|
|
|
|
if (host_depth_matches_server(scrpriv))
|
|
return HostX.visual->bits_per_rgb_value;
|
|
else
|
|
return scrpriv->server_depth; /*XXX correct ?*/
|
|
}
|
|
|
|
void
|
|
hostx_get_visual_masks(KdScreenInfo *screen,
|
|
CARD32 *rmsk, CARD32 *gmsk, CARD32 *bmsk)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
if (!scrpriv)
|
|
return;
|
|
|
|
if (host_depth_matches_server(scrpriv)) {
|
|
*rmsk = HostX.visual->red_mask;
|
|
*gmsk = HostX.visual->green_mask;
|
|
*bmsk = HostX.visual->blue_mask;
|
|
}
|
|
else if (scrpriv->server_depth == 16) {
|
|
/* Assume 16bpp 565 */
|
|
*rmsk = 0xf800;
|
|
*gmsk = 0x07e0;
|
|
*bmsk = 0x001f;
|
|
}
|
|
else {
|
|
*rmsk = 0x0;
|
|
*gmsk = 0x0;
|
|
*bmsk = 0x0;
|
|
}
|
|
}
|
|
|
|
static int
|
|
hostx_calculate_color_shift(unsigned long mask)
|
|
{
|
|
int shift = 1;
|
|
|
|
/* count # of bits in mask */
|
|
while ((mask = (mask >> 1)))
|
|
shift++;
|
|
/* cmap entry is an unsigned char so adjust it by size of that */
|
|
shift = shift - sizeof(unsigned char) * 8;
|
|
if (shift < 0)
|
|
shift = 0;
|
|
return shift;
|
|
}
|
|
|
|
void
|
|
hostx_set_cmap_entry(ScreenPtr pScreen, unsigned char idx,
|
|
unsigned char r, unsigned char g, unsigned char b)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
KdScreenInfo *screen = pScreenPriv->screen;
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
/* need to calculate the shifts for RGB because server could be BGR. */
|
|
/* XXX Not sure if this is correct for 8 on 16, but this works for 8 on 24.*/
|
|
static int rshift, bshift, gshift = 0;
|
|
static int first_time = 1;
|
|
|
|
if (first_time) {
|
|
first_time = 0;
|
|
rshift = hostx_calculate_color_shift(HostX.visual->red_mask);
|
|
gshift = hostx_calculate_color_shift(HostX.visual->green_mask);
|
|
bshift = hostx_calculate_color_shift(HostX.visual->blue_mask);
|
|
}
|
|
scrpriv->cmap[idx] = ((r << rshift) & HostX.visual->red_mask) |
|
|
((g << gshift) & HostX.visual->green_mask) |
|
|
((b << bshift) & HostX.visual->blue_mask);
|
|
}
|
|
|
|
/**
|
|
* hostx_screen_init creates the XImage that will contain the front buffer of
|
|
* the ephyr screen, and possibly offscreen memory.
|
|
*
|
|
* @param width width of the screen
|
|
* @param height height of the screen
|
|
* @param buffer_height height of the rectangle to be allocated.
|
|
*
|
|
* hostx_screen_init() creates an XImage, using MIT-SHM if it's available.
|
|
* buffer_height can be used to create a larger offscreen buffer, which is used
|
|
* by fakexa for storing offscreen pixmap data.
|
|
*/
|
|
void *
|
|
hostx_screen_init(KdScreenInfo *screen,
|
|
int x, int y,
|
|
int width, int height, int buffer_height,
|
|
int *bytes_per_line, int *bits_per_pixel)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
Bool shm_success = FALSE;
|
|
|
|
if (!scrpriv) {
|
|
fprintf(stderr, "%s: Error in accessing hostx data\n", __func__);
|
|
exit(1);
|
|
}
|
|
|
|
EPHYR_DBG("host_screen=%p x=%d, y=%d, wxh=%dx%d, buffer_height=%d",
|
|
screen, x, y, width, height, buffer_height);
|
|
|
|
if (scrpriv->ximg != NULL) {
|
|
/* Free up the image data if previously used
|
|
* i.ie called by server reset
|
|
*/
|
|
|
|
if (HostX.have_shm) {
|
|
xcb_shm_detach(HostX.conn, scrpriv->shminfo.shmseg);
|
|
xcb_image_destroy(scrpriv->ximg);
|
|
shmdt(scrpriv->shminfo.shmaddr);
|
|
shmctl(scrpriv->shminfo.shmid, IPC_RMID, 0);
|
|
}
|
|
else {
|
|
free(scrpriv->ximg->data);
|
|
scrpriv->ximg->data = NULL;
|
|
|
|
xcb_image_destroy(scrpriv->ximg);
|
|
}
|
|
}
|
|
|
|
if (!ephyr_glamor && HostX.have_shm) {
|
|
scrpriv->ximg = xcb_image_create_native(HostX.conn,
|
|
width,
|
|
buffer_height,
|
|
XCB_IMAGE_FORMAT_Z_PIXMAP,
|
|
HostX.depth,
|
|
NULL,
|
|
~0,
|
|
NULL);
|
|
|
|
scrpriv->shminfo.shmid =
|
|
shmget(IPC_PRIVATE,
|
|
scrpriv->ximg->stride * buffer_height,
|
|
IPC_CREAT | 0777);
|
|
scrpriv->ximg->data = shmat(scrpriv->shminfo.shmid, 0, 0);
|
|
scrpriv->shminfo.shmaddr = scrpriv->ximg->data;
|
|
|
|
if (scrpriv->ximg->data == (uint8_t *) -1) {
|
|
EPHYR_DBG
|
|
("Can't attach SHM Segment, falling back to plain XImages");
|
|
HostX.have_shm = FALSE;
|
|
xcb_image_destroy (scrpriv->ximg);
|
|
shmctl(scrpriv->shminfo.shmid, IPC_RMID, 0);
|
|
}
|
|
else {
|
|
EPHYR_DBG("SHM segment attached %p", scrpriv->shminfo.shmaddr);
|
|
scrpriv->shminfo.shmseg = xcb_generate_id(HostX.conn);
|
|
xcb_shm_attach(HostX.conn,
|
|
scrpriv->shminfo.shmseg,
|
|
scrpriv->shminfo.shmid,
|
|
FALSE);
|
|
shm_success = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!ephyr_glamor && !shm_success) {
|
|
EPHYR_DBG("Creating image %dx%d for screen scrpriv=%p\n",
|
|
width, buffer_height, scrpriv);
|
|
scrpriv->ximg = xcb_image_create_native(HostX.conn,
|
|
width,
|
|
buffer_height,
|
|
XCB_IMAGE_FORMAT_Z_PIXMAP,
|
|
HostX.depth,
|
|
NULL,
|
|
~0,
|
|
NULL);
|
|
|
|
/* Match server byte order so that the image can be converted to
|
|
* the native byte order by xcb_image_put() before drawing */
|
|
if (host_depth_matches_server(scrpriv))
|
|
scrpriv->ximg->byte_order = IMAGE_BYTE_ORDER;
|
|
|
|
scrpriv->ximg->data =
|
|
xallocarray(scrpriv->ximg->stride, buffer_height);
|
|
}
|
|
|
|
if (!HostX.size_set_from_configure)
|
|
{
|
|
uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
|
|
uint32_t values[2] = {width, height};
|
|
xcb_configure_window(HostX.conn, scrpriv->win, mask, values);
|
|
}
|
|
|
|
if (scrpriv->win_pre_existing == None && !EphyrWantResize) {
|
|
/* Ask the WM to keep our size static */
|
|
xcb_size_hints_t size_hints = {0};
|
|
size_hints.max_width = size_hints.min_width = width;
|
|
size_hints.max_height = size_hints.min_height = height;
|
|
size_hints.flags = (XCB_ICCCM_SIZE_HINT_P_MIN_SIZE |
|
|
XCB_ICCCM_SIZE_HINT_P_MAX_SIZE);
|
|
xcb_icccm_set_wm_normal_hints(HostX.conn, scrpriv->win,
|
|
&size_hints);
|
|
}
|
|
|
|
xcb_map_window(HostX.conn, scrpriv->win);
|
|
|
|
/* Set explicit window position if it was informed in
|
|
* -screen option (WxH+X or WxH+X+Y). Otherwise, accept the
|
|
* position set by WM.
|
|
* The trick here is putting this code after xcb_map_window() call,
|
|
* so these values won't be overriden by WM. */
|
|
if (scrpriv->win_explicit_position)
|
|
{
|
|
uint32_t mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y;
|
|
uint32_t values[2] = {x, y};
|
|
xcb_configure_window(HostX.conn, scrpriv->win, mask, values);
|
|
}
|
|
|
|
|
|
xcb_aux_sync(HostX.conn);
|
|
|
|
scrpriv->win_width = width;
|
|
scrpriv->win_height = height;
|
|
scrpriv->win_x = x;
|
|
scrpriv->win_y = y;
|
|
|
|
#ifdef GLAMOR
|
|
if (ephyr_glamor) {
|
|
*bytes_per_line = 0;
|
|
*bits_per_pixel = 0;
|
|
ephyr_glamor_set_window_size(scrpriv->glamor,
|
|
scrpriv->win_width, scrpriv->win_height);
|
|
return NULL;
|
|
} else
|
|
#endif
|
|
if (host_depth_matches_server(scrpriv)) {
|
|
*bytes_per_line = scrpriv->ximg->stride;
|
|
*bits_per_pixel = scrpriv->ximg->bpp;
|
|
|
|
EPHYR_DBG("Host matches server");
|
|
return scrpriv->ximg->data;
|
|
}
|
|
else {
|
|
int bytes_per_pixel = scrpriv->server_depth >> 3;
|
|
int stride = (width * bytes_per_pixel + 0x3) & ~0x3;
|
|
|
|
*bytes_per_line = stride;
|
|
*bits_per_pixel = scrpriv->server_depth;
|
|
|
|
EPHYR_DBG("server bpp %i", bytes_per_pixel);
|
|
scrpriv->fb_data = xallocarray (stride, buffer_height);
|
|
return scrpriv->fb_data;
|
|
}
|
|
}
|
|
|
|
static void hostx_paint_debug_rect(KdScreenInfo *screen,
|
|
int x, int y, int width, int height);
|
|
|
|
void
|
|
hostx_paint_rect(KdScreenInfo *screen,
|
|
int sx, int sy, int dx, int dy, int width, int height)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
|
|
EPHYR_DBG("painting in screen %d\n", scrpriv->mynum);
|
|
|
|
#ifdef GLAMOR
|
|
if (ephyr_glamor) {
|
|
BoxRec box;
|
|
RegionRec region;
|
|
|
|
box.x1 = dx;
|
|
box.y1 = dy;
|
|
box.x2 = dx + width;
|
|
box.y2 = dy + height;
|
|
|
|
RegionInit(®ion, &box, 1);
|
|
ephyr_glamor_damage_redisplay(scrpriv->glamor, ®ion);
|
|
RegionUninit(®ion);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Copy the image data updated by the shadow layer
|
|
* on to the window
|
|
*/
|
|
|
|
if (HostXWantDamageDebug) {
|
|
hostx_paint_debug_rect(screen, dx, dy, width, height);
|
|
}
|
|
|
|
/*
|
|
* If the depth of the ephyr server is less than that of the host,
|
|
* the kdrive fb does not point to the ximage data but to a buffer
|
|
* ( fb_data ), we shift the various bits from this onto the XImage
|
|
* so they match the host.
|
|
*
|
|
* Note, This code is pretty new ( and simple ) so may break on
|
|
* endian issues, 32 bpp host etc.
|
|
* Not sure if 8bpp case is right either.
|
|
* ... and it will be slower than the matching depth case.
|
|
*/
|
|
|
|
if (!host_depth_matches_server(scrpriv)) {
|
|
int x, y, idx, bytes_per_pixel = (scrpriv->server_depth >> 3);
|
|
int stride = (scrpriv->win_width * bytes_per_pixel + 0x3) & ~0x3;
|
|
unsigned char r, g, b;
|
|
unsigned long host_pixel;
|
|
|
|
EPHYR_DBG("Unmatched host depth scrpriv=%p\n", scrpriv);
|
|
for (y = sy; y < sy + height; y++)
|
|
for (x = sx; x < sx + width; x++) {
|
|
idx = y * stride + x * bytes_per_pixel;
|
|
|
|
switch (scrpriv->server_depth) {
|
|
case 16:
|
|
{
|
|
unsigned short pixel =
|
|
*(unsigned short *) (scrpriv->fb_data + idx);
|
|
|
|
r = ((pixel & 0xf800) >> 8);
|
|
g = ((pixel & 0x07e0) >> 3);
|
|
b = ((pixel & 0x001f) << 3);
|
|
|
|
host_pixel = (r << 16) | (g << 8) | (b);
|
|
|
|
xcb_image_put_pixel(scrpriv->ximg, x, y, host_pixel);
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
unsigned char pixel =
|
|
*(unsigned char *) (scrpriv->fb_data + idx);
|
|
xcb_image_put_pixel(scrpriv->ximg, x, y,
|
|
scrpriv->cmap[pixel]);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (HostX.have_shm) {
|
|
xcb_image_shm_put(HostX.conn, scrpriv->win,
|
|
HostX.gc, scrpriv->ximg,
|
|
scrpriv->shminfo,
|
|
sx, sy, dx, dy, width, height, FALSE);
|
|
}
|
|
else {
|
|
xcb_image_t *subimg = xcb_image_subimage(scrpriv->ximg, sx, sy,
|
|
width, height, 0, 0, 0);
|
|
xcb_image_t *img = xcb_image_native(HostX.conn, subimg, 1);
|
|
xcb_image_put(HostX.conn, scrpriv->win, HostX.gc, img, dx, dy, 0);
|
|
if (subimg != img)
|
|
xcb_image_destroy(img);
|
|
xcb_image_destroy(subimg);
|
|
}
|
|
|
|
xcb_aux_sync(HostX.conn);
|
|
}
|
|
|
|
static void
|
|
hostx_paint_debug_rect(KdScreenInfo *screen,
|
|
int x, int y, int width, int height)
|
|
{
|
|
EphyrScrPriv *scrpriv = screen->driver;
|
|
struct timespec tspec;
|
|
xcb_rectangle_t rect = { .x = x, .y = y, .width = width, .height = height };
|
|
xcb_void_cookie_t cookie;
|
|
xcb_generic_error_t *e;
|
|
|
|
tspec.tv_sec = HostX.damage_debug_msec / (1000000);
|
|
tspec.tv_nsec = (HostX.damage_debug_msec % 1000000) * 1000;
|
|
|
|
EPHYR_DBG("msec: %li tv_sec %li, tv_msec %li",
|
|
HostX.damage_debug_msec, tspec.tv_sec, tspec.tv_nsec);
|
|
|
|
/* fprintf(stderr, "Xephyr updating: %i+%i %ix%i\n", x, y, width, height); */
|
|
|
|
cookie = xcb_poly_fill_rectangle_checked(HostX.conn, scrpriv->win,
|
|
HostX.gc, 1, &rect);
|
|
e = xcb_request_check(HostX.conn, cookie);
|
|
free(e);
|
|
|
|
/* nanosleep seems to work better than usleep for me... */
|
|
nanosleep(&tspec, NULL);
|
|
}
|
|
|
|
Bool
|
|
hostx_load_keymap(KeySymsPtr keySyms, CARD8 *modmap, XkbControlsPtr controls)
|
|
{
|
|
int min_keycode, max_keycode;
|
|
int map_width;
|
|
size_t i, j;
|
|
int keymap_len;
|
|
xcb_keysym_t *keymap;
|
|
xcb_keycode_t *modifier_map;
|
|
xcb_get_keyboard_mapping_cookie_t mapping_c;
|
|
xcb_get_keyboard_mapping_reply_t *mapping_r;
|
|
xcb_get_modifier_mapping_cookie_t modifier_c;
|
|
xcb_get_modifier_mapping_reply_t *modifier_r;
|
|
xcb_xkb_use_extension_cookie_t use_c;
|
|
xcb_xkb_use_extension_reply_t *use_r;
|
|
xcb_xkb_get_controls_cookie_t controls_c;
|
|
xcb_xkb_get_controls_reply_t *controls_r;
|
|
|
|
/* First of all, collect host X server's
|
|
* min_keycode and max_keycode, which are
|
|
* independent from XKB support. */
|
|
min_keycode = xcb_get_setup(HostX.conn)->min_keycode;
|
|
max_keycode = xcb_get_setup(HostX.conn)->max_keycode;
|
|
|
|
EPHYR_DBG("min: %d, max: %d", min_keycode, max_keycode);
|
|
|
|
keySyms->minKeyCode = min_keycode;
|
|
keySyms->maxKeyCode = max_keycode;
|
|
|
|
/* Check for XKB availability in host X server */
|
|
if (!hostx_has_extension(&xcb_xkb_id)) {
|
|
EPHYR_LOG_ERROR("XKB extension is not supported in host X server.");
|
|
return FALSE;
|
|
}
|
|
|
|
use_c = xcb_xkb_use_extension(HostX.conn,
|
|
XCB_XKB_MAJOR_VERSION,
|
|
XCB_XKB_MINOR_VERSION);
|
|
use_r = xcb_xkb_use_extension_reply(HostX.conn, use_c, NULL);
|
|
|
|
if (!use_r) {
|
|
EPHYR_LOG_ERROR("Couldn't use XKB extension.");
|
|
return FALSE;
|
|
} else if (!use_r->supported) {
|
|
EPHYR_LOG_ERROR("XKB extension is not supported in host X server.");
|
|
free(use_r);
|
|
return FALSE;
|
|
}
|
|
|
|
free(use_r);
|
|
|
|
/* Send all needed XCB requests at once,
|
|
* and process the replies as needed. */
|
|
mapping_c = xcb_get_keyboard_mapping(HostX.conn,
|
|
min_keycode,
|
|
max_keycode - min_keycode + 1);
|
|
modifier_c = xcb_get_modifier_mapping(HostX.conn);
|
|
controls_c = xcb_xkb_get_controls(HostX.conn,
|
|
XCB_XKB_ID_USE_CORE_KBD);
|
|
|
|
mapping_r = xcb_get_keyboard_mapping_reply(HostX.conn,
|
|
mapping_c,
|
|
NULL);
|
|
|
|
if (!mapping_r) {
|
|
EPHYR_LOG_ERROR("xcb_get_keyboard_mapping_reply() failed.");
|
|
return FALSE;
|
|
}
|
|
|
|
map_width = mapping_r->keysyms_per_keycode;
|
|
keymap = xcb_get_keyboard_mapping_keysyms(mapping_r);
|
|
keymap_len = xcb_get_keyboard_mapping_keysyms_length(mapping_r);
|
|
|
|
keySyms->mapWidth = map_width;
|
|
keySyms->map = calloc(keymap_len, sizeof(KeySym));
|
|
|
|
if (!keySyms->map) {
|
|
EPHYR_LOG_ERROR("Failed to allocate KeySym map.");
|
|
free(mapping_r);
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < keymap_len; i++) {
|
|
keySyms->map[i] = keymap[i];
|
|
}
|
|
|
|
free(mapping_r);
|
|
|
|
modifier_r = xcb_get_modifier_mapping_reply(HostX.conn,
|
|
modifier_c,
|
|
NULL);
|
|
|
|
if (!modifier_r) {
|
|
EPHYR_LOG_ERROR("xcb_get_modifier_mapping_reply() failed.");
|
|
return FALSE;
|
|
}
|
|
|
|
modifier_map = xcb_get_modifier_mapping_keycodes(modifier_r);
|
|
memset(modmap, 0, sizeof(CARD8) * MAP_LENGTH);
|
|
|
|
for (j = 0; j < 8; j++) {
|
|
for (i = 0; i < modifier_r->keycodes_per_modifier; i++) {
|
|
CARD8 keycode;
|
|
|
|
if ((keycode = modifier_map[j * modifier_r->keycodes_per_modifier + i])) {
|
|
modmap[keycode] |= 1 << j;
|
|
}
|
|
}
|
|
}
|
|
|
|
free(modifier_r);
|
|
|
|
controls_r = xcb_xkb_get_controls_reply(HostX.conn,
|
|
controls_c,
|
|
NULL);
|
|
|
|
if (!controls_r) {
|
|
EPHYR_LOG_ERROR("xcb_xkb_get_controls_reply() failed.");
|
|
return FALSE;
|
|
}
|
|
|
|
controls->enabled_ctrls = controls_r->enabledControls;
|
|
|
|
for (i = 0; i < XkbPerKeyBitArraySize; i++) {
|
|
controls->per_key_repeat[i] = controls_r->perKeyRepeat[i];
|
|
}
|
|
|
|
free(controls_r);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
hostx_size_set_from_configure(Bool ss)
|
|
{
|
|
HostX.size_set_from_configure = ss;
|
|
}
|
|
|
|
xcb_connection_t *
|
|
hostx_get_xcbconn(void)
|
|
{
|
|
return HostX.conn;
|
|
}
|
|
|
|
xcb_generic_event_t *
|
|
hostx_get_event(Bool queued_only)
|
|
{
|
|
xcb_generic_event_t *xev;
|
|
|
|
if (HostX.saved_event) {
|
|
xev = HostX.saved_event;
|
|
HostX.saved_event = NULL;
|
|
} else {
|
|
if (queued_only)
|
|
xev = xcb_poll_for_queued_event(HostX.conn);
|
|
else
|
|
xev = xcb_poll_for_event(HostX.conn);
|
|
}
|
|
return xev;
|
|
}
|
|
|
|
Bool
|
|
hostx_has_queued_event(void)
|
|
{
|
|
if (!HostX.saved_event)
|
|
HostX.saved_event = xcb_poll_for_queued_event(HostX.conn);
|
|
return HostX.saved_event != NULL;
|
|
}
|
|
|
|
int
|
|
hostx_get_screen(void)
|
|
{
|
|
return HostX.screen;
|
|
}
|
|
|
|
int
|
|
hostx_get_fd(void)
|
|
{
|
|
return xcb_get_file_descriptor(HostX.conn);
|
|
}
|
|
|
|
int
|
|
hostx_get_window(int a_screen_number)
|
|
{
|
|
EphyrScrPriv *scrpriv;
|
|
if (a_screen_number < 0 || a_screen_number >= HostX.n_screens) {
|
|
EPHYR_LOG_ERROR("bad screen number:%d\n", a_screen_number);
|
|
return 0;
|
|
}
|
|
scrpriv = HostX.screens[a_screen_number]->driver;
|
|
return scrpriv->win;
|
|
}
|
|
|
|
int
|
|
hostx_get_window_attributes(int a_window, EphyrHostWindowAttributes * a_attrs)
|
|
{
|
|
xcb_get_geometry_cookie_t geom_cookie;
|
|
xcb_get_window_attributes_cookie_t attr_cookie;
|
|
xcb_get_geometry_reply_t *geom_reply;
|
|
xcb_get_window_attributes_reply_t *attr_reply;
|
|
|
|
geom_cookie = xcb_get_geometry(HostX.conn, a_window);
|
|
attr_cookie = xcb_get_window_attributes(HostX.conn, a_window);
|
|
geom_reply = xcb_get_geometry_reply(HostX.conn, geom_cookie, NULL);
|
|
attr_reply = xcb_get_window_attributes_reply(HostX.conn, attr_cookie, NULL);
|
|
|
|
a_attrs->x = geom_reply->x;
|
|
a_attrs->y = geom_reply->y;
|
|
a_attrs->width = geom_reply->width;
|
|
a_attrs->height = geom_reply->height;
|
|
a_attrs->visualid = attr_reply->visual;
|
|
|
|
free(geom_reply);
|
|
free(attr_reply);
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
hostx_get_visuals_info(EphyrHostVisualInfo ** a_visuals, int *a_num_entries)
|
|
{
|
|
Bool is_ok = FALSE;
|
|
EphyrHostVisualInfo *host_visuals = NULL;
|
|
int nb_items = 0, i = 0, screen_num;
|
|
xcb_screen_iterator_t screens;
|
|
xcb_depth_iterator_t depths;
|
|
|
|
EPHYR_RETURN_VAL_IF_FAIL(a_visuals && a_num_entries, FALSE);
|
|
EPHYR_LOG("enter\n");
|
|
|
|
screens = xcb_setup_roots_iterator(xcb_get_setup(HostX.conn));
|
|
for (screen_num = 0; screens.rem; screen_num++, xcb_screen_next(&screens)) {
|
|
depths = xcb_screen_allowed_depths_iterator(screens.data);
|
|
for (; depths.rem; xcb_depth_next(&depths)) {
|
|
xcb_visualtype_t *visuals = xcb_depth_visuals(depths.data);
|
|
EphyrHostVisualInfo *tmp_visuals =
|
|
reallocarray(host_visuals,
|
|
nb_items + depths.data->visuals_len,
|
|
sizeof(EphyrHostVisualInfo));
|
|
if (!tmp_visuals) {
|
|
goto out;
|
|
}
|
|
host_visuals = tmp_visuals;
|
|
for (i = 0; i < depths.data->visuals_len; i++) {
|
|
host_visuals[nb_items + i].visualid = visuals[i].visual_id;
|
|
host_visuals[nb_items + i].screen = screen_num;
|
|
host_visuals[nb_items + i].depth = depths.data->depth;
|
|
host_visuals[nb_items + i].class = visuals[i]._class;
|
|
host_visuals[nb_items + i].red_mask = visuals[i].red_mask;
|
|
host_visuals[nb_items + i].green_mask = visuals[i].green_mask;
|
|
host_visuals[nb_items + i].blue_mask = visuals[i].blue_mask;
|
|
host_visuals[nb_items + i].colormap_size = visuals[i].colormap_entries;
|
|
host_visuals[nb_items + i].bits_per_rgb = visuals[i].bits_per_rgb_value;
|
|
}
|
|
nb_items += depths.data->visuals_len;
|
|
}
|
|
}
|
|
|
|
EPHYR_LOG("host advertises %d visuals\n", nb_items);
|
|
*a_visuals = host_visuals;
|
|
*a_num_entries = nb_items;
|
|
host_visuals = NULL;
|
|
|
|
is_ok = TRUE;
|
|
out:
|
|
free(host_visuals);
|
|
host_visuals = NULL;
|
|
EPHYR_LOG("leave\n");
|
|
return is_ok;
|
|
|
|
}
|
|
|
|
int
|
|
hostx_create_window(int a_screen_number,
|
|
EphyrBox * a_geometry,
|
|
int a_visual_id, int *a_host_peer /*out parameter */ )
|
|
{
|
|
Bool is_ok = FALSE;
|
|
xcb_window_t win;
|
|
int winmask = 0;
|
|
uint32_t attrs[2];
|
|
xcb_screen_t *screen = xcb_aux_get_screen(HostX.conn, hostx_get_screen());
|
|
xcb_visualtype_t *visual;
|
|
int depth = 0;
|
|
EphyrScrPriv *scrpriv = HostX.screens[a_screen_number]->driver;
|
|
|
|
EPHYR_RETURN_VAL_IF_FAIL(screen && a_geometry, FALSE);
|
|
|
|
EPHYR_LOG("enter\n");
|
|
|
|
visual = xcb_aux_find_visual_by_id(screen, a_visual_id);
|
|
if (!visual) {
|
|
EPHYR_LOG_ERROR ("argh, could not find a remote visual with id:%d\n",
|
|
a_visual_id);
|
|
goto out;
|
|
}
|
|
depth = xcb_aux_get_depth_of_visual(screen, a_visual_id);
|
|
|
|
winmask = XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;
|
|
attrs[0] = XCB_EVENT_MASK_BUTTON_PRESS
|
|
|XCB_EVENT_MASK_BUTTON_RELEASE
|
|
|XCB_EVENT_MASK_POINTER_MOTION
|
|
|XCB_EVENT_MASK_KEY_PRESS
|
|
|XCB_EVENT_MASK_KEY_RELEASE
|
|
|XCB_EVENT_MASK_EXPOSURE;
|
|
attrs[1] = xcb_generate_id(HostX.conn);
|
|
xcb_create_colormap(HostX.conn,
|
|
XCB_COLORMAP_ALLOC_NONE,
|
|
attrs[1],
|
|
hostx_get_window(a_screen_number),
|
|
a_visual_id);
|
|
|
|
win = xcb_generate_id(HostX.conn);
|
|
xcb_create_window(HostX.conn,
|
|
depth,
|
|
win,
|
|
hostx_get_window (a_screen_number),
|
|
a_geometry->x, a_geometry->y,
|
|
a_geometry->width, a_geometry->height, 0,
|
|
XCB_WINDOW_CLASS_COPY_FROM_PARENT,
|
|
a_visual_id, winmask, attrs);
|
|
|
|
if (scrpriv->peer_win == XCB_NONE) {
|
|
scrpriv->peer_win = win;
|
|
}
|
|
else {
|
|
EPHYR_LOG_ERROR("multiple peer windows created for same screen\n");
|
|
}
|
|
xcb_flush(HostX.conn);
|
|
xcb_map_window(HostX.conn, win);
|
|
*a_host_peer = win;
|
|
is_ok = TRUE;
|
|
out:
|
|
EPHYR_LOG("leave\n");
|
|
return is_ok;
|
|
}
|
|
|
|
int
|
|
hostx_destroy_window(int a_win)
|
|
{
|
|
xcb_destroy_window(HostX.conn, a_win);
|
|
xcb_flush(HostX.conn);
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
hostx_set_window_geometry(int a_win, EphyrBox * a_geo)
|
|
{
|
|
uint32_t mask = XCB_CONFIG_WINDOW_X
|
|
| XCB_CONFIG_WINDOW_Y
|
|
| XCB_CONFIG_WINDOW_WIDTH
|
|
| XCB_CONFIG_WINDOW_HEIGHT;
|
|
uint32_t values[4];
|
|
|
|
EPHYR_RETURN_VAL_IF_FAIL(a_geo, FALSE);
|
|
|
|
EPHYR_LOG("enter. x,y,w,h:(%d,%d,%d,%d)\n",
|
|
a_geo->x, a_geo->y, a_geo->width, a_geo->height);
|
|
|
|
values[0] = a_geo->x;
|
|
values[1] = a_geo->y;
|
|
values[2] = a_geo->width;
|
|
values[3] = a_geo->height;
|
|
xcb_configure_window(HostX.conn, a_win, mask, values);
|
|
|
|
EPHYR_LOG("leave\n");
|
|
return TRUE;
|
|
}
|
|
|
|
int
|
|
hostx_set_window_bounding_rectangles(int a_window,
|
|
EphyrRect * a_rects, int a_num_rects)
|
|
{
|
|
Bool is_ok = FALSE;
|
|
int i = 0;
|
|
xcb_rectangle_t *rects = NULL;
|
|
|
|
EPHYR_RETURN_VAL_IF_FAIL(a_rects, FALSE);
|
|
|
|
EPHYR_LOG("enter. num rects:%d\n", a_num_rects);
|
|
|
|
rects = calloc(a_num_rects, sizeof (xcb_rectangle_t));
|
|
if (!rects)
|
|
goto out;
|
|
for (i = 0; i < a_num_rects; i++) {
|
|
rects[i].x = a_rects[i].x1;
|
|
rects[i].y = a_rects[i].y1;
|
|
rects[i].width = abs(a_rects[i].x2 - a_rects[i].x1);
|
|
rects[i].height = abs(a_rects[i].y2 - a_rects[i].y1);
|
|
EPHYR_LOG("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
|
|
rects[i].x, rects[i].y, rects[i].width, rects[i].height);
|
|
}
|
|
xcb_shape_rectangles(HostX.conn,
|
|
XCB_SHAPE_SO_SET,
|
|
XCB_SHAPE_SK_BOUNDING,
|
|
XCB_CLIP_ORDERING_YX_BANDED,
|
|
a_window,
|
|
0, 0,
|
|
a_num_rects,
|
|
rects);
|
|
is_ok = TRUE;
|
|
|
|
out:
|
|
free(rects);
|
|
rects = NULL;
|
|
EPHYR_LOG("leave\n");
|
|
return is_ok;
|
|
}
|
|
|
|
#ifdef GLAMOR
|
|
Bool
|
|
ephyr_glamor_init(ScreenPtr screen)
|
|
{
|
|
KdScreenPriv(screen);
|
|
KdScreenInfo *kd_screen = pScreenPriv->screen;
|
|
EphyrScrPriv *scrpriv = kd_screen->driver;
|
|
|
|
scrpriv->glamor = ephyr_glamor_glx_screen_init(scrpriv->win);
|
|
ephyr_glamor_set_window_size(scrpriv->glamor,
|
|
scrpriv->win_width, scrpriv->win_height);
|
|
|
|
if (!glamor_init(screen, 0)) {
|
|
FatalError("Failed to initialize glamor\n");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int
|
|
ephyrSetPixmapVisitWindow(WindowPtr window, void *data)
|
|
{
|
|
ScreenPtr screen = window->drawable.pScreen;
|
|
|
|
if (screen->GetWindowPixmap(window) == data) {
|
|
screen->SetWindowPixmap(window, screen->GetScreenPixmap(screen));
|
|
return WT_WALKCHILDREN;
|
|
}
|
|
return WT_DONTWALKCHILDREN;
|
|
}
|
|
|
|
Bool
|
|
ephyr_glamor_create_screen_resources(ScreenPtr pScreen)
|
|
{
|
|
KdScreenPriv(pScreen);
|
|
KdScreenInfo *kd_screen = pScreenPriv->screen;
|
|
EphyrScrPriv *scrpriv = kd_screen->driver;
|
|
PixmapPtr old_screen_pixmap, screen_pixmap;
|
|
uint32_t tex;
|
|
|
|
if (!ephyr_glamor)
|
|
return TRUE;
|
|
|
|
/* kdrive's fbSetupScreen() told mi to have
|
|
* miCreateScreenResources() (which is called before this) make a
|
|
* scratch pixmap wrapping ephyr-glamor's NULL
|
|
* KdScreenInfo->fb.framebuffer.
|
|
*
|
|
* We want a real (texture-based) screen pixmap at this point.
|
|
* This is what glamor will render into, and we'll then texture
|
|
* out of that into the host's window to present the results.
|
|
*
|
|
* Thus, delete the current screen pixmap, and put a fresh one in.
|
|
*/
|
|
old_screen_pixmap = pScreen->GetScreenPixmap(pScreen);
|
|
pScreen->DestroyPixmap(old_screen_pixmap);
|
|
|
|
screen_pixmap = pScreen->CreatePixmap(pScreen,
|
|
pScreen->width,
|
|
pScreen->height,
|
|
pScreen->rootDepth,
|
|
GLAMOR_CREATE_NO_LARGE);
|
|
|
|
pScreen->SetScreenPixmap(screen_pixmap);
|
|
if (pScreen->root && pScreen->SetWindowPixmap)
|
|
TraverseTree(pScreen->root, ephyrSetPixmapVisitWindow, old_screen_pixmap);
|
|
|
|
/* Tell the GLX code what to GL texture to read from. */
|
|
tex = glamor_get_pixmap_texture(screen_pixmap);
|
|
ephyr_glamor_set_texture(scrpriv->glamor, tex);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
ephyr_glamor_enable(ScreenPtr screen)
|
|
{
|
|
}
|
|
|
|
void
|
|
ephyr_glamor_disable(ScreenPtr screen)
|
|
{
|
|
}
|
|
|
|
void
|
|
ephyr_glamor_fini(ScreenPtr screen)
|
|
{
|
|
KdScreenPriv(screen);
|
|
KdScreenInfo *kd_screen = pScreenPriv->screen;
|
|
EphyrScrPriv *scrpriv = kd_screen->driver;
|
|
|
|
glamor_fini(screen);
|
|
ephyr_glamor_glx_screen_fini(scrpriv->glamor);
|
|
scrpriv->glamor = NULL;
|
|
}
|
|
#endif
|