static xcb_image_t *take_screenshot(xcb_connection_t *conn, xcb_screen_t *screen) {
return xcb_image_get(conn,
screen->root,
0, 0,
screen->width_in_pixels, screen->height_in_pixels,
UINT32_MAX,
XCB_IMAGE_FORMAT_Z_PIXMAP);
}
QImage SNIProxy::getImageNonComposite()
{
auto c = QX11Info::connection();
auto cookie = xcb_get_geometry(c, m_windowId);
QScopedPointer<xcb_get_geometry_reply_t> geom(xcb_get_geometry_reply(c, cookie, Q_NULLPTR));
xcb_image_t *image = xcb_image_get(c, m_windowId, 0, 0, geom->width, geom->height, 0xFFFFFF, XCB_IMAGE_FORMAT_Z_PIXMAP);
QImage qimage(image->data, image->width, image->height, image->stride, QImage::Format_ARGB32, sni_cleanup_xcb_image, image);
return qimage;
}
xcwm_image_t *
xcwm_image_copy_damaged(xcwm_window_t *window)
{
xcb_image_t *image;
xcb_flush(window->context->conn);
/* Return null if image is 0 by 0 */
if (window->dmg_bounds->width == 0 || window->dmg_bounds->height == 0) {
return NULL;
}
/* Get the image of the damaged area of the window */
image = xcb_image_get(window->context->conn,
window->window_id,
window->dmg_bounds->x,
window->dmg_bounds->y,
window->dmg_bounds->width,
window->dmg_bounds->height,
(unsigned int)~0L,
XCB_IMAGE_FORMAT_Z_PIXMAP);
/* Failed to get a valid image, return null */
if (!image) {
return NULL;
}
xcwm_image_t * xcwm_image = malloc(sizeof(xcwm_image_t));
xcwm_image->image = image;
xcwm_image->x = window->dmg_bounds->x;
xcwm_image->y = window->dmg_bounds->y;
xcwm_image->width = window->dmg_bounds->width;
xcwm_image->height = window->dmg_bounds->height;
return xcwm_image;
}
xcwm_image_t *
xcwm_image_copy_full(xcwm_window_t *window)
{
xcb_get_geometry_reply_t *geom_reply;
xcb_image_t *image;
geom_reply = _xcwm_get_window_geometry(window->context->conn,
window->window_id);
xcb_flush(window->context->conn);
/* Get the full image of the window */
image = xcb_image_get(window->context->conn,
window->window_id,
0,
0,
geom_reply->width,
geom_reply->height,
(unsigned int)~0L,
XCB_IMAGE_FORMAT_Z_PIXMAP);
if (!image) {
return NULL;
}
xcwm_image_t * xcwm_image = malloc(sizeof(xcwm_image_t));
xcwm_image->image = image;
xcwm_image->x = geom_reply->x;
xcwm_image->y = geom_reply->y;
xcwm_image->width = geom_reply->width;
xcwm_image->height = geom_reply->height;
free(geom_reply);
return xcwm_image;
}
void
x_client_icon::update_wm_hints_icon(void)
{
xcb_free_pixmap(m_c(), m_wm_hints_icon);
m_wm_hints_icon = XCB_NONE;
xcb_generic_error_t * error;
xcb_get_property_cookie_t c =
xcb_icccm_get_wm_hints(m_c(), m_x_client.window());
xcb_get_property_reply_t * r = xcb_get_property_reply(m_c(), c, &error);
if (error) {
std::free(error);
} else {
xcb_icccm_wm_hints_t wm_hints;
xcb_icccm_get_wm_hints_from_reply(&wm_hints, r);
if (wm_hints.flags & XCB_ICCCM_WM_HINT_ICON_PIXMAP) {
unsigned int width, height;
{
Window root;
int x, y;
unsigned int border_width, depth;
XGetGeometry(m_c.dpy(), wm_hints.icon_pixmap, &root,
&x, &y, &width, &height, &border_width, &depth);
m_icon_geometry.first = width;
m_icon_geometry.second = height;
}
xcb_image_t * icon_rgb = xcb_image_get(m_c(), wm_hints.icon_pixmap,
0, 0, width, height, 0xffffffff, XCB_IMAGE_FORMAT_XY_PIXMAP);
xcb_image_t * icon_mask;
if (wm_hints.flags & XCB_ICCCM_WM_HINT_ICON_MASK) {
icon_mask = xcb_image_get(m_c(), wm_hints.icon_mask,
0, 0, width, height, 0xffffffff, XCB_IMAGE_FORMAT_XY_PIXMAP);
} else {
icon_mask = xcb_image_create_native(
m_c(), width, height, XCB_IMAGE_FORMAT_Z_PIXMAP, 32, NULL, 0, NULL);
std::memset(icon_mask->data, 0xff,
width * height * (icon_mask->bpp / icon_mask->stride));
}
xcb_image_t * icon_rgba = xcb_image_create_native(
m_c(), width, height, XCB_IMAGE_FORMAT_Z_PIXMAP, 32, NULL, 0, NULL);
for (std::size_t x = 0; x < width; ++x) {
for (std::size_t y = 0; y < height; ++y) {
uint32_t rgba = 0;
if (xcb_image_get_pixel(icon_mask, x, y)) {
uint32_t rgb = xcb_image_get_pixel(icon_rgb, x, y);
uint8_t * s = (uint8_t *)&rgb;
uint8_t * d = (uint8_t *)&rgba;
d[0] = s[0];
d[1] = s[1];
d[2] = s[2];
d[3] = 0xff;
}
xcb_image_put_pixel(icon_rgba, x, y, rgba);
}
}
m_wm_hints_icon = xcb_generate_id(m_c());
xcb_create_pixmap(
m_c(), 32, m_wm_hints_icon, m_c.root_window(), width, height);
xcb_gcontext_t gc = xcb_generate_id(m_c());
xcb_create_gc(m_c(), gc, m_wm_hints_icon, 0, NULL);
xcb_image_put(m_c(), m_wm_hints_icon, gc, icon_rgba, 0, 0, 0);
xcb_image_destroy(icon_rgb);
xcb_image_destroy(icon_mask);
xcb_image_destroy(icon_rgba);
xcb_free_gc(m_c(), gc);
}
}
if (r) std::free(r);
}
/* Main driver */
int
main (int argc, char **argv)
{
xcb_connection_t *conn;
int conn_screen;
xcb_screen_t *root_screen;
xcb_drawable_t root_window;
xcb_connection_t *conn_two;
int conn_two_screen;
xcb_screen_t *root_two_screen;
xcb_drawable_t root_two_window;
xcb_drawable_t window;
uint32_t mask;
uint32_t values[1];
xcb_void_cookie_t cookie;
xcb_get_geometry_reply_t *geom_reply;
xcb_generic_event_t *event;
image_data_t img_data;
xcb_image_t *image;
xcb_pixmap_t pixmap;
xcb_gcontext_t gc;
/* Check the first argument to see what display to connect to. If
empty, then use default display. */
if (argc > 1) {
conn = xcb_connect(argv[1], &conn_screen);
} else {
conn = xcb_connect(NULL, &conn_screen);
}
root_screen = xcb_aux_get_screen(conn, conn_screen);
root_window = root_screen->root;
/* Get the geometry of the root window */
geom_reply = GetWindowGeometry(conn, root_window);
WriteWindowInfo(conn, root_window);
WriteAllChildrenWindowInfo(conn, root_window);
img_data = GetWindowImageData(conn, root_window);
xcb_flush(conn);
/* Get the image of the root window */
image = xcb_image_get(conn,
root_window,
geom_reply->x,
geom_reply->y,
geom_reply->width,
geom_reply->height,
(unsigned int) ~0L,
XCB_IMAGE_FORMAT_Z_PIXMAP);
/* Set up the events the window will recognize */
mask = XCB_CW_EVENT_MASK;
values[0] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;
/* Create our new window on the default display. Make it half the size */
conn_two = xcb_connect(NULL, &conn_two_screen);
root_two_screen = xcb_aux_get_screen(conn_two, conn_two_screen);
root_two_window = root_two_screen->root;
window = xcb_generate_id(conn_two);
cookie = xcb_create_window_checked(conn_two,
XCB_COPY_FROM_PARENT,
window,
root_two_window,
geom_reply->x,
geom_reply->y,
geom_reply->width / 2,
geom_reply->height / 2,
geom_reply->border_width,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
root_two_screen->root_visual,
mask,
values);
if (RequestCheck(conn_two, cookie, "Falied to create new window")) {
exit(1);
}
WriteWindowInfo(conn_two, window);
/* Map the window and flush the connection so it draws to the screen */
xcb_map_window(conn_two, window);
xcb_flush(conn_two);
WriteWindowInfo(conn_two, window);
/* Create the pixmap and associate it with our new window. */
pixmap = xcb_generate_id(conn_two);
cookie = xcb_create_pixmap(conn_two,
geom_reply->depth,
pixmap,
window,
geom_reply->width,
geom_reply->height);
if (RequestCheck(conn_two, cookie, "Failed to create pixmap")) {
exit(1);
}
/* Put the root_window image into the pixmap. Note that a gc is
* created, but I believe it is ignored. */
gc = xcb_generate_id(conn_two);
xcb_create_gc(conn_two, gc, window, 0, 0);
cookie = xcb_image_put(conn_two,
pixmap,
gc,
image,
0,
0,
0);
if (RequestCheck(conn_two, cookie, "Failed to put image into pixmap")) {
exit(1);
}
/* Copy the pixmap into the new window */
cookie = xcb_copy_area(conn_two,
pixmap,
window,
gc,
0,
0,
0,
0,
geom_reply->width / 2,
geom_reply->height / 2);
if (RequestCheck(conn_two, cookie, "Failed to put image into pixmap")) {
exit(1);
}
xcb_flush(conn_two);
WriteWindowInfo(conn_two, window);
/* Enter infinte loop so the window stays open */
while (1) {
}
/* Never get here, but if we could, would still want to clean up memory */
free(geom_reply);
xcb_disconnect(conn);
xcb_disconnect(conn_two);
return 0;
}
