static void
cursor_set (xcb_connection_t *c,
xcb_screen_t *screen,
xcb_window_t window,
int cursor_id)
{
uint32_t values_list[3];
xcb_void_cookie_t cookie_font;
xcb_void_cookie_t cookie_gc;
xcb_generic_error_t *error;
xcb_font_t font;
xcb_cursor_t cursor;
xcb_gcontext_t gc;
uint32_t mask;
uint32_t value_list;
font = xcb_generate_id (c);
cookie_font = xcb_open_font_checked (c, font,
strlen ("cursor"),
"cursor");
error = xcb_request_check (c, cookie_font);
if (error) {
fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);
xcb_disconnect (c);
exit (-1);
}
cursor = xcb_generate_id (c);
xcb_create_glyph_cursor (c, cursor, font, font,
cursor_id, cursor_id + 1,
0, 0, 0,
0, 0, 0);
gc = xcb_generate_id (c);
mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
values_list[0] = screen->black_pixel;
values_list[1] = screen->white_pixel;
values_list[2] = font;
cookie_gc = xcb_create_gc_checked (c, gc, window, mask, values_list);
error = xcb_request_check (c, cookie_gc);
if (error) {
fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);
xcb_disconnect (c);
exit (-1);
}
mask = XCB_CW_CURSOR;
value_list = cursor;
xcb_change_window_attributes (c, window, mask, &value_list);
xcb_free_cursor (c, cursor);
cookie_font = xcb_close_font_checked (c, font);
error = xcb_request_check (c, cookie_font);
if (error) {
fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);
xcb_disconnect (c);
exit (-1);
}
}
static xcb_window_t make_window(xcb_connection_t *c,
xcb_screen_t *s,
uint32_t bg,
uint32_t fg,
uint32_t width,
uint32_t height) {
uint32_t mask = 0;
xcb_params_cw_t cwa;
xcb_window_t w;
xcb_void_cookie_t check_cookie;
xcb_generic_error_t *error;
xcb_visualtype_t *v = xcb_aux_find_visual_by_id(s, s->root_visual);
assert(v);
XCB_AUX_ADD_PARAM(&mask, &cwa, back_pixel, bg);
XCB_AUX_ADD_PARAM(&mask, &cwa, border_pixel, fg);
XCB_AUX_ADD_PARAM(&mask, &cwa, override_redirect, 1);
XCB_AUX_ADD_PARAM(&mask, &cwa, event_mask,
XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_EXPOSURE);
w = xcb_generate_id(c);
check_cookie = xcb_aux_create_window_checked(c,
s->root_depth, w, s->root, 0, 0, width, height, 1,
XCB_WINDOW_CLASS_INPUT_OUTPUT, v->visual_id, mask, &cwa);
error = xcb_request_check(c, check_cookie);
assert(!error);
check_cookie = xcb_map_window_checked(c, w);
error = xcb_request_check(c, check_cookie);
assert(!error);
return w;
}
/* Test each depth not explicitly advertised to see if pixmap creation
* succeeds: if it does, that depth is usable. */
static int
pixmap_depths_usable (xcb_connection_t *c, uint32_t missing, xcb_pixmap_t pixmap, xcb_drawable_t root)
{
xcb_void_cookie_t create_cookie[32] = { { 0 } };
xcb_void_cookie_t free_cookie[32] = { { 0 } };
int d;
int success = 1;
for (d = 1; d <= 32; d++)
if (missing & DEPTH_MASK(d))
{
create_cookie[d - 1] = xcb_create_pixmap_checked (c, d, pixmap, root, 1, 1);
free_cookie[d - 1] = xcb_free_pixmap_checked (c, pixmap);
if (!create_cookie[d - 1].sequence || !free_cookie[d - 1].sequence)
{
success = 0;
break;
}
}
for (d = 0; d < 32; d++)
if (create_cookie[d].sequence || free_cookie[d].sequence)
{
xcb_generic_error_t *create_error = xcb_request_check (c, create_cookie[d]);
xcb_generic_error_t *free_error = xcb_request_check (c, free_cookie[d]);
success = success && !create_error;
free(create_error);
free(free_error);
}
return success;
}
/// Xembeds a X window
void xembed(xcb_window_t client) {
client_win = client;
uint32_t values[4];
uint32_t mask;
xcb_void_cookie_t cookie;
xcb_generic_error_t *error;
// order of the following operations is important here!
// move window below other windows
values[0] = XCB_STACK_MODE_BELOW;
mask = XCB_CONFIG_WINDOW_STACK_MODE;
cookie = xcb_configure_window_checked(con, client_win, mask, values);
error = xcb_request_check(con, cookie);
if(error) {
std::cerr << "Could not change client attributes." << std::endl;
exit(1);
}
// reparent client
cookie = xcb_reparent_window_checked(con, client_win, win, 0, 0);
error = xcb_request_check(con, cookie);
if(error) {
std::cerr << "Could not reparent client." << std::endl;
exit(1);
}
// move and resize client window
values[0] = 0;
values[1] = 0;
values[2] = width;
values[3] = height;
mask = XCB_CONFIG_WINDOW_X |XCB_CONFIG_WINDOW_Y |
XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
cookie = xcb_configure_window_checked(con, client_win, mask, values);
error = xcb_request_check(con, cookie);
if(error) {
std::cerr << "Could not resize client." << std::endl;
exit(1);
}
// make client overwrite-redirected
values[0] = true;
mask = XCB_CW_OVERRIDE_REDIRECT;
cookie = xcb_change_window_attributes(con, client_win, mask, values);
error = xcb_request_check(con, cookie);
if(error) {
std::cerr << "Could not change client attributes." << std::endl;
exit(1);
}
}
static xcb_gc_t
gc_font_get (xcb_connection_t *c,
xcb_screen_t *screen,
xcb_window_t window,
const char *font_name)
{
uint32_t value_list[3];
xcb_void_cookie_t cookie_font;
xcb_void_cookie_t cookie_gc;
xcb_generic_error_t *error;
xcb_font_t font;
xcb_gcontext_t gc;
uint32_t mask;
font = xcb_generate_id (c);
cookie_font = xcb_open_font_checked (c, font,
strlen (font_name),
font_name);
error = xcb_request_check (c, cookie_font);
if (error) {
fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);
xcb_disconnect (c);
return -1;
}
gc = xcb_generate_id (c);
mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
value_list[0] = screen->black_pixel;
value_list[1] = screen->white_pixel;
value_list[2] = font;
cookie_gc = xcb_create_gc_checked (c, gc, window, mask, value_list);
error = xcb_request_check (c, cookie_gc);
if (error) {
fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);
xcb_disconnect (c);
exit (-1);
}
cookie_font = xcb_close_font_checked (c, font);
error = xcb_request_check (c, cookie_font);
if (error) {
fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);
xcb_disconnect (c);
exit (-1);
}
return gc;
}
static
int init_bar() {
uint32_t vals[4];
xcb_void_cookie_t cookie;
xcb_generic_error_t *err;
/* create status bar window at the bottom */
bar_.w = nil_.scr->width_in_pixels;
bar_.h = nil_.font.ascent + nil_.font.descent + 2;
bar_.x = 0;
bar_.y = nil_.scr->height_in_pixels - bar_.h;
bar_.win = xcb_generate_id(nil_.con);
vals[0] = XCB_BACK_PIXMAP_PARENT_RELATIVE;
vals[1] = 1; /* override_redirect */
vals[2] = XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_EXPOSURE;
vals[3] = nil_.cursor[CURSOR_NORMAL];
cookie = xcb_create_window_checked(nil_.con, nil_.scr->root_depth, bar_.win,
nil_.scr->root, bar_.x, bar_.y, bar_.w, bar_.h, 0, XCB_COPY_FROM_PARENT,
nil_.scr->root_visual, XCB_CW_BACK_PIXMAP | XCB_CW_OVERRIDE_REDIRECT
| XCB_CW_EVENT_MASK | XCB_CW_CURSOR, vals);
err = xcb_request_check(nil_.con, cookie);
if (err) {
NIL_ERR("create window %d", err->error_code);
return -1;
}
vals[0] = XCB_STACK_MODE_ABOVE;
xcb_configure_window(nil_.con, bar_.win, XCB_CONFIG_WINDOW_STACK_MODE, &vals[0]);
cookie = xcb_map_window_checked(nil_.con, bar_.win);
err = xcb_request_check(nil_.con, cookie);
if (err) {
NIL_ERR("map window %d", err->error_code);
return -1;
}
/* graphic context */
bar_.gc = xcb_generate_id(nil_.con);
vals[0] = nil_.color.bar_fg;
vals[1] = nil_.color.bar_bg;
vals[2] = nil_.font.id;
cookie = xcb_create_gc_checked(nil_.con, bar_.gc, bar_.win, XCB_GC_FOREGROUND
| XCB_GC_BACKGROUND | XCB_GC_FONT, vals);
err = xcb_request_check(nil_.con, cookie);
if (err) {
NIL_ERR("map window %d", err->error_code);
return -1;
}
return 0;
}
static
int init_font() {
xcb_void_cookie_t cookie;
xcb_generic_error_t *err;
xcb_list_fonts_with_info_cookie_t info_cookie;
xcb_list_fonts_with_info_reply_t *info;
/* open font */
nil_.font.id = xcb_generate_id(nil_.con);
cookie = xcb_open_font_checked(nil_.con, nil_.font.id,
strlen(cfg_.font_name), cfg_.font_name);
err = xcb_request_check(nil_.con, cookie);
if (err) {
NIL_ERR("open font: %d", err->error_code);
return -1;
}
info_cookie = xcb_list_fonts_with_info(nil_.con, 1,
strlen(cfg_.font_name), cfg_.font_name);
info = xcb_list_fonts_with_info_reply(nil_.con, info_cookie, 0);
if (!info) {
NIL_ERR("load font: %s", cfg_.font_name);
return -1;
}
NIL_LOG("font ascent=%d, descent=%d", info->font_ascent, info->font_descent);
nil_.font.ascent = info->font_ascent;
nil_.font.descent = info->font_descent;
free(info);
return 0;
}
static BOOL PRESENTPrivChangeWindow(PRESENTpriv *present_priv, XID window)
{
xcb_void_cookie_t cookie;
xcb_generic_error_t *error;
xcb_present_event_t eid;
PRESENTForceReleases(present_priv);
PRESENTFreeXcbQueue(present_priv);
present_priv->window = window;
if (window) {
cookie = xcb_present_select_input_checked(present_priv->xcb_connection,
(eid = xcb_generate_id(present_priv->xcb_connection)),
window,
XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY|
XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY);
present_priv->special_event = xcb_register_for_special_xge(present_priv->xcb_connection,
&xcb_present_id,
eid, NULL);
error = xcb_request_check(present_priv->xcb_connection, cookie); /* performs a flush */
if (error || !present_priv->special_event) {
ERR("FAILED to use the X PRESENT extension. Was the destination a window ?\n");
if (present_priv->special_event)
xcb_unregister_for_special_event(present_priv->xcb_connection, present_priv->special_event);
present_priv->special_event = NULL;
present_priv->window = 0;
}
}
return (present_priv->window != 0);
}
BOOL
PRESENTHelperCopyFront(Display *dpy, PRESENTPixmapPriv *present_pixmap_priv)
{
PRESENTpriv *present_priv = present_pixmap_priv->present_priv;
xcb_void_cookie_t cookie;
xcb_generic_error_t *error;
uint32_t v = 0;
xcb_gcontext_t gc;
pthread_mutex_lock(&present_priv->mutex_present);
if (!present_priv->window) {
pthread_mutex_unlock(&present_priv->mutex_present);
return FALSE;
}
xcb_create_gc(present_priv->xcb_connection,
(gc = xcb_generate_id(present_priv->xcb_connection)),
present_priv->window,
XCB_GC_GRAPHICS_EXPOSURES,
&v);
cookie = xcb_copy_area_checked(present_priv->xcb_connection,
present_priv->window,
present_pixmap_priv->pixmap,
gc,
0, 0, 0, 0,
present_pixmap_priv->width,
present_pixmap_priv->height);
error = xcb_request_check(present_priv->xcb_connection, cookie);
xcb_free_gc(present_priv->xcb_connection, gc);
pthread_mutex_unlock(&present_priv->mutex_present);
return (error != NULL);
}
static bool
dri3_set_drawable(struct vl_dri3_screen *scrn, Drawable drawable)
{
xcb_get_geometry_cookie_t geom_cookie;
xcb_get_geometry_reply_t *geom_reply;
xcb_void_cookie_t cookie;
xcb_generic_error_t *error;
xcb_present_event_t peid;
bool ret = true;
assert(drawable);
if (scrn->drawable == drawable)
return true;
scrn->drawable = drawable;
geom_cookie = xcb_get_geometry(scrn->conn, scrn->drawable);
geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
if (!geom_reply)
return false;
scrn->width = geom_reply->width;
scrn->height = geom_reply->height;
scrn->depth = geom_reply->depth;
free(geom_reply);
if (scrn->special_event) {
xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
scrn->special_event = NULL;
}
scrn->is_pixmap = false;
peid = xcb_generate_id(scrn->conn);
cookie =
xcb_present_select_input_checked(scrn->conn, peid, scrn->drawable,
XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY |
XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY |
XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY);
error = xcb_request_check(scrn->conn, cookie);
if (error) {
if (error->error_code != BadWindow)
ret = false;
else {
scrn->is_pixmap = true;
if (scrn->front_buffer) {
dri3_free_front_buffer(scrn, scrn->front_buffer);
scrn->front_buffer = NULL;
}
}
free(error);
} else
scrn->special_event =
xcb_register_for_special_xge(scrn->conn, &xcb_present_id, peid, 0);
dri3_flush_present_events(scrn);
return ret;
}
QXcbShmImage::QXcbShmImage(QXcbScreen *screen, const QSize &size, uint depth, QImage::Format format)
: QXcbObject(screen->connection())
, m_gc(0)
, m_gc_window(0)
{
Q_XCB_NOOP(connection());
m_xcb_image = xcb_image_create_native(xcb_connection(),
size.width(),
size.height(),
XCB_IMAGE_FORMAT_Z_PIXMAP,
depth,
0,
~0,
0);
m_shm_info.shmid = shmget (IPC_PRIVATE,
m_xcb_image->stride * m_xcb_image->height, IPC_CREAT|0777);
m_shm_info.shmaddr = m_xcb_image->data = (quint8 *)shmat (m_shm_info.shmid, 0, 0);
m_shm_info.shmseg = xcb_generate_id(xcb_connection());
xcb_generic_error_t *error = xcb_request_check(xcb_connection(), xcb_shm_attach_checked(xcb_connection(), m_shm_info.shmseg, m_shm_info.shmid, false));
if (error) {
qWarning() << "QXcbWindowSurface: Unable to attach to shared memory segment";
free(error);
}
if (shmctl(m_shm_info.shmid, IPC_RMID, 0) == -1)
qWarning() << "QXcbWindowSurface: Error while marking the shared memory segment to be destroyed";
m_qimage = QImage( (uchar*) m_xcb_image->data, m_xcb_image->width, m_xcb_image->height, m_xcb_image->stride, format);
}
void
randr_restore(randr_state_t *state)
{
xcb_generic_error_t *error;
/* Restore CRTC gamma ramps */
for (int i = 0; i < state->crtc_count; i++) {
xcb_randr_crtc_t crtc = state->crtcs[i].crtc;
unsigned int ramp_size = state->crtcs[i].ramp_size;
uint16_t *gamma_r = &state->crtcs[i].saved_ramps[0*ramp_size];
uint16_t *gamma_g = &state->crtcs[i].saved_ramps[1*ramp_size];
uint16_t *gamma_b = &state->crtcs[i].saved_ramps[2*ramp_size];
/* Set gamma ramps */
xcb_void_cookie_t gamma_set_cookie =
xcb_randr_set_crtc_gamma_checked(state->conn, crtc,
ramp_size, gamma_r,
gamma_g, gamma_b);
error = xcb_request_check(state->conn, gamma_set_cookie);
if (error) {
fprintf(stderr, _("`%s' returned error %d\n"),
"RANDR Set CRTC Gamma", error->error_code);
fprintf(stderr, _("Unable to restore CRTC %i\n"), i);
}
}
}
EAPI Eina_Bool
ecore_x_fixes_selection_notification_request(Ecore_X_Atom selection)
{
#ifdef ECORE_XCB_XFIXES
Ecore_X_Window root = 0;
xcb_void_cookie_t cookie;
xcb_generic_error_t *err;
int mask = 0;
#endif
CHECK_XCB_CONN;
if (!_xfixes_avail) return EINA_FALSE;
#ifdef ECORE_XCB_XFIXES
root = ((xcb_screen_t *)_ecore_xcb_screen)->root;
mask = (XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE);
cookie =
xcb_xfixes_select_selection_input_checked(_ecore_xcb_conn, root,
selection, mask);
err = xcb_request_check(_ecore_xcb_conn, cookie);
if (err)
{
free(err);
return EINA_FALSE;
}
return EINA_TRUE;
#endif
return EINA_FALSE;
}
ExcCode screen_window_resize(xcb_window_t window, int width, int height) {
xcb_window_t client_window;
find_toplevel_window(window, &client_window);
get_client_window(client_window, &client_window);
TRY(screen_window_unmaximize(client_window));
int coord, prev_width, prev_height;
TRY(screen_window_get_geometry(window, &coord, &coord,
&prev_width, &prev_height));
int prev_client_window_width, prev_client_window_height;
TRY(window_get_real_geometry(client_window, &coord, &coord,
&prev_client_window_width, &prev_client_window_height));
uint32_t values[2] = {
width - (prev_width - prev_client_window_width),
height - (prev_height - prev_client_window_height)
};
xcb_void_cookie_t cookie = xcb_configure_window_checked(display,
client_window, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
values);
if (xcb_request_check(display, cookie) != NULL)
PANIC(ERR_X_REQUEST, "screen_window_resize (xcb_request_check)");
if (xcb_flush(display) <= 0)
PANIC(ERR_X_REQUEST, "screen_window_resize (xcb_flush)");
return 0;
}
/*
* Returns the ID of the font matching the given pattern and stores the height
* of the font (in pixels) in *font_height. die()s if no font matches.
*
*/
int get_font_id(xcb_connection_t *conn, char *pattern, int *font_height) {
xcb_void_cookie_t font_cookie;
xcb_list_fonts_with_info_cookie_t info_cookie;
/* Send all our requests first */
int result;
result = xcb_generate_id(conn);
font_cookie = xcb_open_font_checked(conn, result, strlen(pattern), pattern);
info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
xcb_generic_error_t *error = xcb_request_check(conn, font_cookie);
if (error != NULL) {
fprintf(stderr, "ERROR: Could not open font: %d\n", error->error_code);
exit(1);
}
/* Get information (height/name) for this font */
xcb_list_fonts_with_info_reply_t *reply = xcb_list_fonts_with_info_reply(conn, info_cookie, NULL);
if (reply == NULL)
errx(1, "Could not load font \"%s\"\n", pattern);
*font_height = reply->font_ascent + reply->font_descent;
return result;
}
ExcCode screen_shm_init() {
xcb_query_extension_cookie_t extension_cookie =
xcb_query_extension(display,
strlen(MIT_SHM_EXTENSION_NAME), MIT_SHM_EXTENSION_NAME);
xcb_query_extension_reply_t *extension_reply =
xcb_query_extension_reply(display, extension_cookie, NULL);
if (extension_reply == NULL)
PANIC(ERR_X_EXTENSION, MIT_SHM_EXTENSION_NAME);
free(extension_reply);
xcb_shm_query_version_cookie_t version_cookie =
xcb_shm_query_version(display);
xcb_shm_query_version_reply_t *version_reply =
xcb_shm_query_version_reply(display, version_cookie, NULL);
if (version_reply == NULL)
PANIC(ERR_X_EXTENSION, MIT_SHM_EXTENSION_NAME);
free(version_reply);
size_t max_size = screen->width_in_pixels * screen->height_in_pixels *
sizeof (unsigned);
shmid = shmget(IPC_PRIVATE, max_size, IPC_CREAT | 0777);
if (shmid < 0)
PANIC(ERR_SHM_ALLOC);
shmaddr = shmat(shmid, 0, 0);
if (shmaddr == (uint8_t *) -1)
PANIC(ERR_SHM_ATTACH);
shmseg = xcb_generate_id(display);
xcb_void_cookie_t attach_cookie = xcb_shm_attach_checked(display,
shmseg, shmid, 0);
if (xcb_request_check(display, attach_cookie) != NULL)
PANIC(ERR_SHM_ATTACH);
return 0;
}
ExcCode screen_window_unmaximize(xcb_window_t window) {
xcb_atom_t net_wm_state,
net_wm_state_maximized_horz, net_wm_state_maximized_vert;
TRY(create_atom("_NET_WM_STATE", 0, &net_wm_state));
TRY(create_atom("_NET_WM_STATE_MAXIMIZED_HORZ", 0,
&net_wm_state_maximized_horz));
TRY(create_atom("_NET_WM_STATE_MAXIMIZED_VERT", 0,
&net_wm_state_maximized_vert));
xcb_client_message_event_t event;
event.response_type = XCB_CLIENT_MESSAGE;
event.format = 32;
event.sequence = 0;
event.window = window;
event.type = net_wm_state;
event.data.data32[0] = 0; // 0 - disable, 1 - enable, 2 - toggle
event.data.data32[1] = net_wm_state_maximized_horz;
event.data.data32[2] = net_wm_state_maximized_vert;
event.data.data32[3] = 0;
event.data.data32[4] = 0;
xcb_void_cookie_t cookie = xcb_send_event_checked(display, 0, root,
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
(const char*) &event);
if (xcb_request_check(display, cookie) != NULL)
PANIC(ERR_X_REQUEST, "screen_window_unmaximize (xcb_request_check)");
if (xcb_flush(display) <= 0)
PANIC(ERR_X_REQUEST, "screen_window_unmaximize (xcb_flush)");
return 0;
}
virtual
std::shared_ptr<xcb_generic_error_t>
request_check(xcb_void_cookie_t cookie) const
{
return std::shared_ptr<xcb_generic_error_t>(
xcb_request_check(m_c.get(), cookie));
}
void InputImpl::setMousePosition(const Vector2i& position, const Window& relativeTo)
{
// Open a connection with the X server
xcb_connection_t* connection = OpenConnection();
WindowHandle handle = relativeTo.getSystemHandle();
if (handle)
{
ScopedXcbPtr<xcb_generic_error_t> error(xcb_request_check(
connection,
xcb_warp_pointer(
connection,
None, // Source window
handle, // Destination window
0, 0, // Source position
0, 0, // Source size
position.x, position.y // Destination position
)
));
if (error)
err() << "Failed to set mouse position" << std::endl;
xcb_flush(connection);
}
// Close the connection with the X server
CloseConnection(connection);
}
static void Display(vout_display_t *vd, picture_t *pic)
{
vout_display_sys_t *sys = vd->sys;
xcb_connection_t *conn = sys->conn;
xcb_void_cookie_t ck;
vlc_xcb_Manage(vd, conn);
/* Copy the scaled picture into the target picture, in other words
* copy the rendered pixmap into the window.
*/
ck = xcb_render_composite_checked(conn, XCB_RENDER_PICT_OP_SRC,
sys->picture.scale,
XCB_RENDER_PICTURE_NONE,
sys->picture.dest, 0, 0, 0, 0, 0, 0,
vd->cfg->display.width,
vd->cfg->display.height);
xcb_generic_error_t *e = xcb_request_check(conn, ck);
if (e != NULL) { /* Not all errors will be detected here. */
msg_Dbg(vd, "%s: RENDER error %d", "cannot composite",
e->error_code);
free(e);
}
(void) pic;
}
CGError CGSetDisplayTransferByTable(CGDirectDisplayID display, uint32_t gamma_size, const CGGammaValue* red,
const CGGammaValue* green, const CGGammaValue* blue)
{
xcb_void_cookie_t gamma_cookie;
uint16_t r_int[256];
uint16_t g_int[256];
uint16_t b_int[256];
long i;
int32_t v;
if (gamma_size != 256)
{
fprintf(stderr, "Gamma size should be 256\n");
abort();
}
for (i = 0; i < 256; i++)
{
v = (int32_t)(red[i] * UINT16_MAX);
r_int[i] = (uint16_t)(v < 0 ? 0 : v > UINT16_MAX ? UINT16_MAX : v);
v = (int32_t)(green[i] * UINT16_MAX);
g_int[i] = (uint16_t)(v < 0 ? 0 : v > UINT16_MAX ? UINT16_MAX : v);
v = (int32_t)(blue[i] * UINT16_MAX);
b_int[i] = (uint16_t)(v < 0 ? 0 : v > UINT16_MAX ? UINT16_MAX : v);
}
gamma_cookie = xcb_randr_set_crtc_gamma_checked(conn, crtcs[display],
(uint16_t)gamma_size, r_int, g_int, b_int);
return xcb_request_check(conn, gamma_cookie) == NULL ? kCGErrorSuccess : ~kCGErrorSuccess;
}
void InputImpl::setMousePosition(const Vector2i& position)
{
// Open a connection with the X server
xcb_connection_t* connection = OpenConnection();
ScopedXcbPtr<xcb_generic_error_t> error(xcb_request_check(
connection,
xcb_warp_pointer(
connection,
None, // Source window
XCBDefaultRootWindow(connection), // Destination window
0, 0, // Source position
0, 0, // Source size
position.x, position.y // Destination position
)
));
if (error)
err() << "Failed to set mouse position" << std::endl;
xcb_flush(connection);
// Close the connection with the X server
CloseConnection(connection);
}
/*
* Checks a generic cookie for errors and quits with the given message if there
* was an error.
*
*/
void check_error(xcb_connection_t *conn, xcb_void_cookie_t cookie, char *err_message) {
xcb_generic_error_t *error = xcb_request_check(conn, cookie);
if (error != NULL) {
fprintf(stderr, "ERROR: %s (X error %d)\n", err_message, error->error_code);
xcb_disconnect(conn);
exit(-1);
}
}
/* @brief Check the xcb cookie and prints an error if it has one.
*
* @param cookie A generic xcb cookie.
* @param connection A connection to the Xorg server.
* @param The error to be printed if the cookie contains an error.
* @return
*/
static inline int32_t check_xcb_cookie(xcb_void_cookie_t cookie, xcb_connection_t *connection, char *error) {
xcb_generic_error_t *xcb_error = xcb_request_check(connection, cookie);
if (xcb_error) {
fprintf(stderr, "[error:%"PRIu8"] %s\n", xcb_error->error_code, error);
return 1;
}
return 0;
}
int main(int argc, char **argv) {
uint32_t width = test_width - 2 * INSET_X;
uint32_t height = test_height - 2 * INSET_Y;
int snum;
xcb_void_cookie_t check_cookie;
xcb_window_t w;
xcb_gcontext_t gc;
xcb_pixmap_t pix;
xcb_connection_t *c = xcb_connect(0, &snum);
xcb_screen_t *s = xcb_aux_get_screen(c, snum);
xcb_alloc_named_color_cookie_t bg_cookie =
xcb_alloc_named_color(c, s->default_colormap,
strlen("white"), "white");
xcb_alloc_named_color_cookie_t fg_cookie =
xcb_alloc_named_color(c, s->default_colormap,
strlen("black"), "black");
xcb_alloc_named_color_reply_t *bg_reply =
xcb_alloc_named_color_reply(c, bg_cookie, 0);
xcb_alloc_named_color_reply_t *fg_reply =
xcb_alloc_named_color_reply(c, fg_cookie, 0);
uint32_t fg, bg;
xcb_image_t *image, *native_image, *subimage;
uint32_t mask = 0;
xcb_params_gc_t gcv;
assert(bg_reply && fg_reply);
bg = bg_reply->pixel;
fg = fg_reply->pixel;
free(bg_reply);
free(fg_reply);
w = make_window(c, s, bg, fg, width, height);
gc = xcb_generate_id(c);
check_cookie = xcb_create_gc_checked(c, gc, w, 0, 0);
assert(!xcb_request_check(c, check_cookie));
image = xcb_image_create_from_bitmap_data((uint8_t *)test_bits,
test_width, test_height);
native_image = xcb_image_native(c, image, 1);
assert(native_image);
if (native_image != image)
xcb_image_destroy(image);
subimage = xcb_image_subimage(native_image, INSET_X, INSET_Y,
width, height,
0, 0, 0);
assert(subimage);
xcb_image_destroy(native_image);
subimage->format = XCB_IMAGE_FORMAT_XY_BITMAP;
pix = xcb_generate_id(c);
xcb_create_pixmap(c, s->root_depth, pix, w,
subimage->width, subimage->height);
gc = xcb_generate_id(c);
XCB_AUX_ADD_PARAM(&mask, &gcv, foreground, fg);
XCB_AUX_ADD_PARAM(&mask, &gcv, background, bg);
xcb_aux_create_gc(c, gc, pix, mask, &gcv);
xcb_image_put(c, pix, gc, subimage, 0, 0, 0);
process_events(c, gc, w, pix, width, height);
xcb_disconnect(c);
return 1;
}
void check_request(xcb_connection_t *dpy, xcb_void_cookie_t cookie, char *msg)
{
xcb_generic_error_t *err = xcb_request_check(dpy, cookie);
if (err != NULL) {
fprintf(stderr, "%s: error code: %u.\n", msg, err->error_code);
xcb_disconnect(dpy);
exit(-1);
}
}
void register_events(void)
{
uint32_t values[] = {ROOT_EVENT_MASK};
xcb_generic_error_t *e = xcb_request_check(dpy, xcb_change_window_attributes_checked(dpy, screen->root, XCB_CW_EVENT_MASK, values));
if (e != NULL) {
xcb_disconnect(dpy);
err("another WM is already running\n");
}
}
ExcCode screen_cursor_set_position(int x, int y) {
xcb_void_cookie_t cookie =
xcb_warp_pointer(display, XCB_NONE, root, 0, 0, 0, 0, x, y);
if (xcb_request_check(display, cookie) != NULL)
PANIC(ERR_X_REQUEST, "screen_cursor_set_position (xcb_request_check)");
if (xcb_flush(display) <= 0)
PANIC(ERR_X_REQUEST, "screen_cursor_set_position (xcb_flush)");
return 0;
}
int XChangeKeyboardMapping(Display *display, int first_keycode, int keysyms_per_keycode,
KeySym *keysyms, int num_codes)
{
xcb_void_cookie_t cookie = xcb_change_keyboard_mapping_checked(display, num_codes, first_keycode, keysyms_per_keycode, keysyms);
xcb_generic_error_t *error = xcb_request_check(display, cookie);
if (error != NULL)
fatal("Error in X11 communication\n");
return 0;
}
int run(config_t* config, key_handler_t key_handler)
{
int default_screen;
xcb_connection_t* c = xcb_connect(NULL, &default_screen);
if(xcb_connection_has_error(c))
{
fprintf(stderr, "Cannot open display %s\n",
getenv("DISPLAY") ? getenv("DISPLAY") : "<NULL>");
return -1;
}
xcb_screen_t* screen;
if(!(screen = xcb_aux_get_screen(c, default_screen)))
{
fprintf(stderr, "Cannot obtain default screen.\n");
return -1;
}
context_t context = { config, key_handler };
xcb_event_handlers_t eh;
memset(&eh, 0, sizeof(xcb_event_handlers_t));
xcb_event_handlers_init(c, &eh);
xcb_event_set_key_press_handler(&eh, handle_keypress, &context);
xcb_void_cookie_t* cookies = alloca(sizeof(xcb_void_cookie_t)
* config->count);
if(!cookies)
return -1;
int i;
for(i = 0; i < config->count; ++i)
cookies[i] = xcb_grab_key(c, true, screen->root,
config->keys[i].is_alt ? XCB_MOD_MASK_1 : 0,
config->keys[i].keysym, XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC);
for(i = 0; i < config->count; ++i)
{
xcb_generic_error_t* e = xcb_request_check(c, cookies[i]);
if(e)
{
fprintf(stderr, "WARNING: unable to grab key: %d\n", e->error_code);
free(e);
}
}
xcb_generic_event_t* e;
while((e = xcb_wait_for_event(c)))
{
xcb_event_handle(&eh, e);
free(e);
}
return 0;
}
