static EGLBoolean
dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
EGLint numRects, const EGLint *rects)
{
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
EGLBoolean ret;
xcb_xfixes_region_t region;
xcb_rectangle_t rectangles[16];
int i;
if (numRects > (int)ARRAY_SIZE(rectangles))
return dri2_copy_region(drv, disp, draw, dri2_surf->region);
for (i = 0; i < numRects; i++) {
rectangles[i].x = rects[i * 4];
rectangles[i].y = dri2_surf->base.Height - rects[i * 4 + 1] - rects[i * 4 + 3];
rectangles[i].width = rects[i * 4 + 2];
rectangles[i].height = rects[i * 4 + 3];
}
region = xcb_generate_id(dri2_dpy->conn);
xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
ret = dri2_copy_region(drv, disp, draw, region);
xcb_xfixes_destroy_region(dri2_dpy->conn, region);
return ret;
}
void QDri2Context::swapBuffers()
{
Q_D(QDri2Context);
xcb_rectangle_t rectangle;
rectangle.x = 0;
rectangle.y = 0;
rectangle.width = d->qXcbWindow->widget()->geometry().width();
rectangle.height = d->qXcbWindow->widget()->geometry().height();
xcb_xfixes_region_t xfixesRegion = xcb_generate_id(d->xcbConnection());
xcb_xfixes_create_region(d->xcbConnection(), xfixesRegion,
1, &rectangle);
xcb_dri2_copy_region_cookie_t cookie = xcb_dri2_copy_region_unchecked(d->xcbConnection(),
d->qXcbWindow->window(),
xfixesRegion,
XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT);
xcb_dri2_copy_region_reply_t *reply = xcb_dri2_copy_region_reply(d->xcbConnection(),cookie,NULL);
//cleanup
delete reply;
xcb_xfixes_destroy_region(d->xcbConnection(), xfixesRegion);
}
/**
* Destroy a region.
* @param region The region to destroy.
*
* Destroy the specified @p region.
* @ingroup Ecore_X_Fixes_Group
*/
EAPI void
ecore_x_region_free(Ecore_X_Region region)
{
LOGFN(__FILE__, __LINE__, __FUNCTION__);
CHECK_XCB_CONN;
if (!_xfixes_avail) return;
#ifdef ECORE_XCB_XFIXES
xcb_xfixes_destroy_region(_ecore_xcb_conn, region);
// ecore_x_flush();
#endif
}
void remove_win(struct window **list, struct window *w)
{
struct window **prev;
for (prev = list; *prev; prev = &(*prev)->next)
if (*prev == w)
break;
*prev = w->next;
xcb_damage_destroy(X, w->damage);
xcb_xfixes_destroy_region(X, w->region);
if (w->pixmap)
xcb_free_pixmap(X, w->pixmap);
if (w->picture)
xcb_render_free_picture(X, w->picture);
if (w->alpha)
xcb_render_free_picture(X, w->alpha);
free(w);
}
/** Add the given Region to the damaged Region by either copying it if
* the global Damaged is currently empty or adding it otherwise
*
* @todo: Perhaps the copy of the region could be avoided if it
* really impacts on performances, but for now this does not
* seem to be an issue
*
* \param region Damaged Region to be added to the global one
*/
void
display_add_damaged_region(xcb_xfixes_region_t *region,
bool do_destroy_region)
{
if(!*region)
return;
if(globalconf.damaged)
{
xcb_xfixes_union_region(globalconf.connection, globalconf.damaged,
*region, globalconf.damaged);
debug("Added %x to damaged region %x", *region, globalconf.damaged);
if(do_destroy_region)
xcb_xfixes_destroy_region(globalconf.connection, *region);
}
else
{
/* If the region should not be destroyed, then copy the given
Region as it is generally the Window Region and can still be
used later on whereas the damaged Region is cleared at each
painting iteration */
if(!do_destroy_region)
{
globalconf.damaged = xcb_generate_id(globalconf.connection);
xcb_xfixes_create_region(globalconf.connection,
globalconf.damaged,
0, NULL);
xcb_xfixes_copy_region(globalconf.connection, *region,
globalconf.damaged);
}
else
globalconf.damaged = *region;
debug("Initialized damaged region to %x (copied: %d)",
globalconf.damaged, !do_destroy_region);
}
if(do_destroy_region)
*region = XCB_NONE;
}
/**
* Process list of buffer received from the server
*
* Processes the list of buffers received in a reply from the server to either
* \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
*/
static void
dri2_process_buffers(struct dri2_egl_surface *dri2_surf,
xcb_dri2_dri2_buffer_t *buffers, unsigned count)
{
struct dri2_egl_display *dri2_dpy =
dri2_egl_display(dri2_surf->base.Resource.Display);
xcb_rectangle_t rectangle;
unsigned i;
dri2_surf->buffer_count = count;
dri2_surf->have_fake_front = 0;
/* This assumes the DRI2 buffer attachment tokens matches the
* __DRIbuffer tokens. */
for (i = 0; i < count; i++) {
dri2_surf->buffers[i].attachment = buffers[i].attachment;
dri2_surf->buffers[i].name = buffers[i].name;
dri2_surf->buffers[i].pitch = buffers[i].pitch;
dri2_surf->buffers[i].cpp = buffers[i].cpp;
dri2_surf->buffers[i].flags = buffers[i].flags;
/* We only use the DRI drivers single buffer configs. This
* means that if we try to render to a window, DRI2 will give us
* the fake front buffer, which we'll use as a back buffer.
* Note that EGL doesn't require that several clients rendering
* to the same window must see the same aux buffers. */
if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
dri2_surf->have_fake_front = 1;
}
if (dri2_surf->region != XCB_NONE)
xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
rectangle.x = 0;
rectangle.y = 0;
rectangle.width = dri2_surf->base.Width;
rectangle.height = dri2_surf->base.Height;
dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
}
void *
run_event_loop(void *thread_arg_struct)
{
_connection_data *conn_data;
xcwm_context_t *context;
xcb_connection_t *event_conn;
xcb_generic_event_t *evt;
xcwm_event_t return_evt;
xcwm_event_cb_t callback_ptr;
conn_data = thread_arg_struct;
context = conn_data->context;
event_conn = context->conn;
callback_ptr = conn_data->callback;
free(thread_arg_struct);
_xcwm_windows_adopt(context, callback_ptr);
/* Start the event loop, and flush if first */
xcb_flush(event_conn);
while ((evt = xcb_wait_for_event(event_conn))) {
uint8_t response_type = evt->response_type & ~0x80;
if (response_type == context->damage_event_mask) {
xcb_damage_notify_event_t *dmgevnt =
(xcb_damage_notify_event_t *)evt;
/* printf("damage %d,%d @ %d,%d reported against window 0x%08x\n", */
/* dmgevnt->area.width, dmgevnt->area.height, dmgevnt->area.x, dmgevnt->area.y, */
/* dmgevnt->drawable); */
xcwm_window_t *window = _xcwm_get_window_node_by_window_id(dmgevnt->drawable);
return_evt.event_type = XCWM_EVENT_WINDOW_DAMAGE;
return_evt.window = window;
if (!window) {
printf("damage reported against unknown window 0x%08x\n", dmgevnt->drawable);
continue;
}
/* Increase the damaged area of window if new damage is
* larger than current. */
xcwm_event_get_thread_lock();
/* Initial damage events for override-redirect windows are
* reported relative to the root window, subsequent events
* are relative to the window itself. We also catch cases
* where the damage area is larger than the bounds of the
* window. */
if (window->initial_damage == 1
|| (dmgevnt->area.width > window->bounds.width)
|| (dmgevnt->area.height > window->bounds.height) ) {
xcb_xfixes_region_t region =
xcb_generate_id(window->context->conn);
xcb_rectangle_t rect;
/* printf("initial damage on window 0x%08x\n", dmgevnt->drawable); */
/* Remove the damage */
xcb_xfixes_create_region(window->context->conn,
region,
1,
&dmgevnt->area);
xcb_damage_subtract(window->context->conn,
window->damage,
region,
XCB_NONE);
/* Add new damage area for entire window */
rect.x = 0;
rect.y = 0;
rect.width = window->bounds.width;
rect.height = window->bounds.height;
xcb_xfixes_set_region(window->context->conn,
region,
1,
&rect);
xcb_damage_add(window->context->conn,
window->window_id,
region);
window->initial_damage = 0;
xcb_xfixes_destroy_region(window->context->conn,
region);
xcwm_event_release_thread_lock();
continue;
}
window->dmg_bounds.x = dmgevnt->area.x;
window->dmg_bounds.y = dmgevnt->area.y;
window->dmg_bounds.width = dmgevnt->area.width;
window->dmg_bounds.height = dmgevnt->area.height;
xcwm_event_release_thread_lock();
callback_ptr(&return_evt);
}
else if (response_type == context->shape_event) {
xcb_shape_notify_event_t *shapeevnt =
(xcb_shape_notify_event_t *)evt;
if (shapeevnt->shape_kind == XCB_SHAPE_SK_BOUNDING) {
xcwm_window_t *window = _xcwm_get_window_node_by_window_id(shapeevnt->affected_window);
_xcwm_window_set_shape(window, shapeevnt->shaped);
return_evt.event_type = XCWM_EVENT_WINDOW_SHAPE;
return_evt.window = window;
callback_ptr(&return_evt);
}
}
else if (response_type == context->fixes_event_base + XCB_XFIXES_CURSOR_NOTIFY) {
/* xcb_xfixes_cursor_notify_event_t *cursorevnt = */
/* (xcb_xfixes_cursor_notify_event_t *)evt; */
return_evt.event_type = XCWM_EVENT_CURSOR;
return_evt.window = NULL;
callback_ptr(&return_evt);
}
else {
switch (response_type) {
case 0:
{
/* Error case. Something very bad has happened. Spit
* out some hopefully useful information and then
* die.
* FIXME: Decide under what circumstances we should
* acutally kill the application. */
xcb_generic_error_t *err = (xcb_generic_error_t *)evt;
fprintf(stderr, "Error received in event loop.\n"
"Error code: %i\n",
err->error_code);
if ((err->error_code >= XCB_VALUE)
&& (err->error_code <= XCB_FONT)) {
xcb_value_error_t *val_err = (xcb_value_error_t *)evt;
fprintf(stderr, "Bad value: %i\n"
"Major opcode: %i\n"
"Minor opcode: %i\n",
val_err->bad_value,
val_err->major_opcode,
val_err->minor_opcode);
}
break;
}
case XCB_EXPOSE:
{
xcb_expose_event_t *exevnt = (xcb_expose_event_t *)evt;
printf(
"Window %u exposed. Region to be redrawn at location (%d, %d), ",
exevnt->window, exevnt->x, exevnt->y);
printf("with dimensions (%d, %d).\n", exevnt->width,
exevnt->height);
return_evt.event_type = XCWM_EVENT_WINDOW_EXPOSE;
callback_ptr(&return_evt);
break;
}
case XCB_CREATE_NOTIFY:
{
/* We don't actually allow our client to create its
* window here, wait until the XCB_MAP_REQUEST */
break;
}
case XCB_DESTROY_NOTIFY:
{
// Window destroyed in root window
xcb_destroy_notify_event_t *notify =
(xcb_destroy_notify_event_t *)evt;
xcwm_window_t *window =
_xcwm_window_remove(event_conn, notify->window);
if (!window) {
/* Not a window in the list, don't try and destroy */
break;
}
return_evt.event_type = XCWM_EVENT_WINDOW_DESTROY;
return_evt.window = window;
callback_ptr(&return_evt);
// Release memory for the window
_xcwm_window_release(window);
break;
}
case XCB_MAP_NOTIFY:
{
xcb_map_notify_event_t *notify =
(xcb_map_notify_event_t *)evt;
/* notify->event holds parent of the window */
xcwm_window_t *window =
_xcwm_get_window_node_by_window_id(notify->window);
if (!window)
{
/*
No MAP_REQUEST for override-redirect windows, so
need to create the xcwm_window_t for it now
*/
/* printf("MAP_NOTIFY without MAP_REQUEST\n"); */
window =
_xcwm_window_create(context, notify->window,
notify->event);
if (window)
{
_xcwm_window_composite_pixmap_update(window);
return_evt.window = window;
return_evt.event_type = XCWM_EVENT_WINDOW_CREATE;
callback_ptr(&return_evt);
}
}
else
{
_xcwm_window_composite_pixmap_update(window);
}
break;
}
case XCB_MAP_REQUEST:
{
xcb_map_request_event_t *request =
(xcb_map_request_event_t *)evt;
/* Map the window */
xcb_map_window(context->conn, request->window);
xcb_flush(context->conn);
return_evt.window =
_xcwm_window_create(context, request->window,
request->parent);
if (!return_evt.window) {
break;
}
return_evt.event_type = XCWM_EVENT_WINDOW_CREATE;
callback_ptr(&return_evt);
break;
}
case XCB_UNMAP_NOTIFY:
{
xcb_unmap_notify_event_t *notify =
(xcb_unmap_notify_event_t *)evt;
xcwm_window_t *window =
_xcwm_window_remove(event_conn, notify->window);
if (!window) {
/* Not a window in the list, don't try and destroy */
break;
}
return_evt.event_type = XCWM_EVENT_WINDOW_DESTROY;
return_evt.window = window;
callback_ptr(&return_evt);
_xcwm_window_composite_pixmap_release(window);
// Release memory for the window
_xcwm_window_release(window);
break;
}
case XCB_CONFIGURE_NOTIFY:
{
xcb_configure_notify_event_t *request =
(xcb_configure_notify_event_t *)evt;
printf("CONFIGURE_NOTIFY: XID 0x%08x %dx%d @ %d,%d\n",
request->window, request->width, request->height,
request->x, request->y);
xcwm_window_t *window =
_xcwm_get_window_node_by_window_id(request->window);
if (window)
_xcwm_window_composite_pixmap_update(window);
break;
}
case XCB_CONFIGURE_REQUEST:
{
xcb_configure_request_event_t *request =
(xcb_configure_request_event_t *)evt;
printf("CONFIGURE_REQUEST: XID 0x%08x %dx%d @ %d,%d mask 0x%04x\n",
request->window, request->width, request->height,
request->x, request->y, request->value_mask);
/*
relying on the server's idea of the current values of values not
in value_mask is a bad idea, we might have a configure request of
our own on this window in flight
*/
if (request->value_mask &
(XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT))
_xcwm_resize_window(event_conn, request->window,
request->x, request->y,
request->width, request->height);
/* Ignore requests to change stacking ? */
break;
}
case XCB_PROPERTY_NOTIFY:
{
xcb_property_notify_event_t *notify =
(xcb_property_notify_event_t *)evt;
xcwm_window_t *window =
_xcwm_get_window_node_by_window_id(notify->window);
if (!window) {
break;
}
/* If this is WM_PROTOCOLS, do not send event, just
* handle internally */
if (notify->atom == window->context->atoms.ewmh_conn.WM_PROTOCOLS) {
_xcwm_atoms_set_wm_delete(window);
break;
}
xcwm_event_type_t event;
if (_xcwm_atom_change_to_event(notify->atom, window, &event))
{
/* Send the appropriate event */
return_evt.event_type = event;
return_evt.window = window;
callback_ptr(&return_evt);
}
else {
printf("PROPERTY_NOTIFY for ignored property atom %d\n", notify->atom);
/*
We need a mechanism to forward properties we don't know about to WM,
otherwise everything needs to be in libXcwm ...?
*/
}
break;
}
case XCB_MAPPING_NOTIFY:
break;
default:
{
printf("UNKNOWN EVENT: %i\n", (evt->response_type & ~0x80));
break;
}
}
}
/* Free the event */
free(evt);
}
return NULL;
}
BOOL
PRESENTPixmap(Display *dpy, XID window,
PRESENTPixmapPriv *present_pixmap_priv, D3DPRESENT_PARAMETERS *pPresentationParameters,
const RECT *pSourceRect, const RECT *pDestRect, const RGNDATA *pDirtyRegion)
{
PRESENTpriv *present_priv = present_pixmap_priv->present_priv;
#ifdef D3DADAPTER9_DRI2
struct DRI2priv *dri2_priv = present_pixmap_priv->dri2_info.dri2_priv;
EGLenum current_api = 0;
#endif
xcb_void_cookie_t cookie;
xcb_generic_error_t *error;
int64_t target_msc, presentationInterval;
xcb_xfixes_region_t valid, update;
int16_t x_off, y_off;
uint32_t options = XCB_PRESENT_OPTION_NONE;
pthread_mutex_lock(&present_priv->mutex_present);
if (window != present_priv->window)
PRESENTPrivChangeWindow(present_priv, window);
if (!window) {
ERR("ERROR: Try to Present a pixmap on a NULL window\n");
pthread_mutex_unlock(&present_priv->mutex_present);
return FALSE;
}
PRESENTflush_events(present_priv, FALSE);
if (!present_pixmap_priv->released || present_pixmap_priv->present_complete_pending) {
ERR("FATAL ERROR: Trying to Present a pixmap not released\n");
pthread_mutex_unlock(&present_priv->mutex_present);
return FALSE;
}
#ifdef D3DADAPTER9_DRI2
if (present_pixmap_priv->dri2_info.is_dri2) {
current_api = eglQueryAPI();
eglBindAPI(EGL_OPENGL_API);
if(eglMakeCurrent(dri2_priv->display, EGL_NO_SURFACE, EGL_NO_SURFACE, dri2_priv->context)) {
glBindFramebuffer(GL_READ_FRAMEBUFFER, present_pixmap_priv->dri2_info.fbo_read);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, present_pixmap_priv->dri2_info.fbo_write);
glBlitFramebuffer(0, 0, present_pixmap_priv->width, present_pixmap_priv->height,
0, 0, present_pixmap_priv->width, present_pixmap_priv->height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glFlush(); /* Perhaps useless */
} else {
ERR("eglMakeCurrent failed with 0x%0X\n", eglGetError());
}
eglMakeCurrent(dri2_priv->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglBindAPI(current_api);
}
#endif
target_msc = present_priv->last_msc;
switch(pPresentationParameters->PresentationInterval) {
case D3DPRESENT_INTERVAL_DEFAULT:
case D3DPRESENT_INTERVAL_ONE:
presentationInterval = 1;
break;
case D3DPRESENT_INTERVAL_TWO:
presentationInterval = 2;
break;
case D3DPRESENT_INTERVAL_THREE:
presentationInterval = 3;
break;
case D3DPRESENT_INTERVAL_FOUR:
presentationInterval = 4;
break;
case D3DPRESENT_INTERVAL_IMMEDIATE:
default:
presentationInterval = 0;
options |= XCB_PRESENT_OPTION_ASYNC;
break;
}
target_msc += presentationInterval * (present_priv->pixmap_present_pending + 1);
/* Note: PRESENT defines some way to do partial copy:
* presentproto:
* 'x-off' and 'y-off' define the location in the window where
* the 0,0 location of the pixmap will be presented. valid-area
* and update-area are relative to the pixmap.
*/
if (!pSourceRect && !pDestRect && !pDirtyRegion) {
valid = 0;
update = 0;
x_off = 0;
y_off = 0;
} else {
xcb_rectangle_t rect_update;
xcb_rectangle_t *rect_updates;
int i;
rect_update.x = 0;
rect_update.y = 0;
rect_update.width = present_pixmap_priv->width;
rect_update.height = present_pixmap_priv->height;
x_off = 0;
y_off = 0;
if (pSourceRect) {
x_off = -pSourceRect->left;
y_off = -pSourceRect->top;
rect_update.x = pSourceRect->left;
rect_update.y = pSourceRect->top;
rect_update.width = pSourceRect->right - pSourceRect->left;
rect_update.height = pSourceRect->bottom - pSourceRect->top;
}
if (pDestRect) {
x_off += pDestRect->left;
y_off += pDestRect->top;
rect_update.width = pDestRect->right - pDestRect->left;
rect_update.height = pDestRect->bottom - pDestRect->top;
/* Note: the size of pDestRect and pSourceRect are supposed to be the same size
* because the driver would have done things to assure that. */
}
valid = xcb_generate_id(present_priv->xcb_connection_bis);
update = xcb_generate_id(present_priv->xcb_connection_bis);
xcb_xfixes_create_region(present_priv->xcb_connection_bis, valid, 1, &rect_update);
if (pDirtyRegion && pDirtyRegion->rdh.nCount) {
rect_updates = (void *) calloc(pDirtyRegion->rdh.nCount, sizeof(xcb_rectangle_t));
for (i = 0; i < pDirtyRegion->rdh.nCount; i++)
{
RECT rc;
memcpy(&rc, pDirtyRegion->Buffer + i * sizeof(RECT), sizeof(RECT));
rect_update.x = rc.left;
rect_update.y = rc.top;
rect_update.width = rc.right - rc.left;
rect_update.height = rc.bottom - rc.top;
memcpy(rect_updates + i * sizeof(xcb_rectangle_t), &rect_update, sizeof(xcb_rectangle_t));
}
xcb_xfixes_create_region(present_priv->xcb_connection_bis, update, pDirtyRegion->rdh.nCount, rect_updates);
free(rect_updates);
} else
xcb_xfixes_create_region(present_priv->xcb_connection_bis, update, 1, &rect_update);
}
if (pPresentationParameters->SwapEffect == D3DSWAPEFFECT_COPY)
options |= XCB_PRESENT_OPTION_COPY;
cookie = xcb_present_pixmap_checked(present_priv->xcb_connection_bis,
window,
present_pixmap_priv->pixmap,
present_pixmap_priv->serial,
valid, update, x_off, y_off,
None, None, None, options,
target_msc, 0, 0, 0, NULL);
error = xcb_request_check(present_priv->xcb_connection_bis, cookie); /* performs a flush */
if (update)
xcb_xfixes_destroy_region(present_priv->xcb_connection_bis, update);
if (valid)
xcb_xfixes_destroy_region(present_priv->xcb_connection_bis, valid);
if (error) {
xcb_get_geometry_cookie_t cookie_geom;
xcb_get_geometry_reply_t *reply;
cookie_geom = xcb_get_geometry(present_priv->xcb_connection_bis, window);
reply = xcb_get_geometry_reply(present_priv->xcb_connection_bis, cookie_geom, NULL);
ERR("Error using PRESENT. Here some debug info\n");
if (!reply) {
ERR("Error querying window info. Perhaps it doesn't exist anymore\n");
pthread_mutex_unlock(&present_priv->mutex_present);
return FALSE;
}
ERR("Pixmap: width=%d, height=%d, depth=%d\n",
present_pixmap_priv->width, present_pixmap_priv->height,
present_pixmap_priv->depth);
ERR("Window: width=%d, height=%d, depth=%d, x=%d, y=%d\n",
(int) reply->width, (int) reply->height,
(int) reply->depth, (int) reply->x, (int) reply->y);
ERR("Present parameter: PresentationInterval=%d, BackBufferCount=%d, Pending presentations=%d\n",
pPresentationParameters->PresentationInterval,
pPresentationParameters->BackBufferCount,
present_priv->pixmap_present_pending
);
if (present_pixmap_priv->depth != reply->depth)
ERR("Depths are different. PRESENT needs the pixmap and the window have same depth\n");
free(reply);
pthread_mutex_unlock(&present_priv->mutex_present);
return FALSE;
}
present_priv->last_target = target_msc;
present_priv->pixmap_present_pending++;
present_pixmap_priv->present_complete_pending = TRUE;
present_pixmap_priv->released = FALSE;
pthread_mutex_unlock(&present_priv->mutex_present);
return TRUE;
}
Compositor::Compositor()
: connection_(QX11Info::connection()),
root_(QX11Info::appRootWindow()),
damageExt_(xcb_get_extension_data(connection_, &xcb_damage_id)),
initFinished_(false)
{
qRegisterMetaType<ClientWindow *>();
Q_ASSERT(QCoreApplication::instance());
QCoreApplication::instance()->installNativeEventFilter(this);
auto ewmhCookie = xcb_ewmh_init_atoms(connection_, &ewmh_);
if (!xcb_ewmh_init_atoms_replies(&ewmh_, ewmhCookie, Q_NULLPTR)) {
qFatal("Cannot init EWMH");
}
auto wmCmCookie = xcb_ewmh_get_wm_cm_owner_unchecked(&ewmh_, QX11Info::appScreen());
xcb_window_t wmCmOwnerWin = XCB_NONE;
if (!xcb_ewmh_get_wm_cm_owner_reply(&ewmh_, wmCmCookie, &wmCmOwnerWin, Q_NULLPTR)) {
qFatal("Cannot check _NET_WM_CM_Sn");
}
if (wmCmOwnerWin) {
qFatal("Another compositing manager is already running");
}
auto attributesCookie = xcb_get_window_attributes_unchecked(connection_, root_);
auto damageQueryVersionCookie = xcb_damage_query_version_unchecked(connection_, 1, 1);
auto overlayWindowCookie = xcb_composite_get_overlay_window_unchecked(connection_, root_);
auto attributes =
xcbReply(xcb_get_window_attributes_reply(connection_, attributesCookie, Q_NULLPTR));
if (!attributes) {
qFatal("Cannot get root window attributes");
}
auto newEventMask = attributes->your_event_mask
| XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY
| XCB_EVENT_MASK_STRUCTURE_NOTIFY
| XCB_EVENT_MASK_PROPERTY_CHANGE;
xcb_change_window_attributes(connection_, root_, XCB_CW_EVENT_MASK, &newEventMask);
auto treeCookie = xcb_query_tree_unchecked(connection_, root_);
auto rootGeometryCookie = xcb_get_geometry_unchecked(connection_, root_);
auto damageVersion =
xcbReply(xcb_damage_query_version_reply(connection_, damageQueryVersionCookie, Q_NULLPTR));
if (!damageVersion) {
qFatal("Cannot query version of Damage extension");
}
auto overlayWindow =
xcbReply(xcb_composite_get_overlay_window_reply(connection_, overlayWindowCookie, Q_NULLPTR));
if (!overlayWindow) {
qFatal("Cannot get overlay window");
}
overlayWindow_.reset(QWindow::fromWinId(overlayWindow->overlay_win));
auto region = xcb_generate_id(connection_);
xcb_xfixes_create_region(connection_, region, 0, Q_NULLPTR);
xcb_xfixes_set_window_shape_region(connection_, overlayWindow->overlay_win, XCB_SHAPE_SK_INPUT, 0, 0, region);
xcb_xfixes_destroy_region(connection_, region);
xcb_composite_redirect_subwindows(connection_, root_, XCB_COMPOSITE_REDIRECT_MANUAL);
auto rootGeometry =
xcbReply(xcb_get_geometry_reply(connection_, rootGeometryCookie, Q_NULLPTR));
if (!rootGeometry) {
qFatal("Cannot query root window geometry");
}
rootGeometry_ = QRect(rootGeometry->x, rootGeometry->y, rootGeometry->width, rootGeometry->height);
auto tree = xcbReply(xcb_query_tree_reply(connection_, treeCookie, Q_NULLPTR));
if (!tree) {
qFatal("Cannot query window tree");
}
auto children = xcb_query_tree_children(tree.get());
for (int i = 0; i < xcb_query_tree_children_length(tree.get()); i++) {
addChildWindow(children[i]);
}
updateActiveWindow();
initFinished_ = true;
}
/** Destroy the global damaged Region and set it to None, meaningful
* at each re-painting iteration to check whether a repaint is
* necessary. This region is filled in event handlers
*/
void
display_reset_damaged(void)
{
xcb_xfixes_destroy_region(globalconf.connection, globalconf.damaged);
globalconf.damaged = XCB_NONE;
}
