static xcb_window_t xdndProxy(QXcbConnection *c, xcb_window_t w) { xcb_window_t proxy = XCB_NONE; xcb_get_property_cookie_t cookie = Q_XCB_CALL2(xcb_get_property(c->xcb_connection(), false, w, c->atom(QXcbAtom::XdndProxy), XCB_ATOM_WINDOW, 0, 1), c); xcb_get_property_reply_t *reply = xcb_get_property_reply(c->xcb_connection(), cookie, 0); if (reply && reply->type == XCB_ATOM_WINDOW) proxy = *((xcb_window_t *)xcb_get_property_value(reply)); free(reply); if (proxy == XCB_NONE) return proxy; // exists and is real? cookie = Q_XCB_CALL2(xcb_get_property(c->xcb_connection(), false, proxy, c->atom(QXcbAtom::XdndProxy), XCB_ATOM_WINDOW, 0, 1), c); reply = xcb_get_property_reply(c->xcb_connection(), cookie, 0); if (reply && reply->type == XCB_ATOM_WINDOW) { xcb_window_t p = *((xcb_window_t *)xcb_get_property_value(reply)); if (proxy != p) proxy = 0; } else { proxy = 0; } free(reply); return proxy; }
QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *screen, int number) : QXcbObject(connection) , m_screen(screen) , m_number(number) { printf ("\n"); printf ("Information of screen %d:\n", screen->root); printf (" width.........: %d\n", screen->width_in_pixels); printf (" height........: %d\n", screen->height_in_pixels); printf (" depth.........: %d\n", screen->root_depth); printf (" white pixel...: %x\n", screen->white_pixel); printf (" black pixel...: %x\n", screen->black_pixel); printf ("\n"); const quint32 mask = XCB_CW_EVENT_MASK; const quint32 values[] = { // XCB_CW_EVENT_MASK XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_PROPERTY_CHANGE }; xcb_change_window_attributes(xcb_connection(), screen->root, mask, values); xcb_generic_error_t *error; xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), xcb_get_property(xcb_connection(), false, screen->root, atom(QXcbAtom::_NET_SUPPORTING_WM_CHECK), XCB_ATOM_WINDOW, 0, 1024), &error); if (reply && reply->format == 32 && reply->type == XCB_ATOM_WINDOW) { xcb_window_t windowManager = *((xcb_window_t *)xcb_get_property_value(reply)); if (windowManager != XCB_WINDOW_NONE) { xcb_get_property_reply_t *windowManagerReply = xcb_get_property_reply(xcb_connection(), xcb_get_property(xcb_connection(), false, windowManager, atom(QXcbAtom::_NET_WM_NAME), atom(QXcbAtom::UTF8_STRING), 0, 1024), &error); if (windowManagerReply && windowManagerReply->format == 8 && windowManagerReply->type == atom(QXcbAtom::UTF8_STRING)) { m_windowManagerName = QString::fromUtf8((const char *)xcb_get_property_value(windowManagerReply), xcb_get_property_value_length(windowManagerReply)); printf("Running window manager: %s\n", qPrintable(m_windowManagerName)); } else if (error) { connection->handleXcbError(error); free(error); } free(windowManagerReply); } } else if (error) { connection->handleXcbError(error); free(error); } free(reply); m_syncRequestSupported = m_windowManagerName != QLatin1String("KWin"); }
void x_client_name::update_wm_class(void) { m_class_name.clear(); m_instance_name.clear(); xcb_generic_error_t * error; xcb_get_property_cookie_t c = xcb_icccm_get_wm_class(m_c(), m_x_client.window()); xcb_get_property_reply_t * r = xcb_get_property_reply(m_c(), c, &error); if (error) { delete error; } else { xcb_icccm_get_wm_class_reply_t wm_class; if (xcb_icccm_get_wm_class_from_reply(&wm_class, r)) { m_class_name = wm_class.class_name; m_instance_name = wm_class.instance_name; xcb_icccm_get_wm_class_reply_wipe(&wm_class); r = NULL; } } if (r) delete r; }
//! Process _NET_WM_STRUT reply and update fields void Client::process_ewmh_strut(xcb_get_property_cookie_t gpc) { autofree_ptr<xcb_get_property_reply_t> gpr( xcb_get_property_reply(g_xcb.connection, gpc, NULL) ); if (!gpr) { WARN << "Could not retrieve _NET_WM_STRUT for window"; m_ewmh_strut.clear(); return; } TRACE << *gpr; if (gpr->type != XCB_ATOM_CARDINAL || gpr->format != 32 || gpr->length != 4) { WARN << "Could not retrieve _NET_WM_STRUT for window"; m_ewmh_strut.clear(); return; } uint32_t* strut = (uint32_t*)xcb_get_property_value(gpr.get()); m_ewmh_strut.valid = true; m_ewmh_strut.left = strut[0]; m_ewmh_strut.right = strut[1]; m_ewmh_strut.top = strut[2]; m_ewmh_strut.bottom = strut[3]; INFO << "EWMH _NET_WM_STRUT of window " << window() << " is " << m_ewmh_strut; }
void QXcbScreen::readXResources() { int offset = 0; QByteArray resources; while(1) { xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), xcb_get_property_unchecked(xcb_connection(), false, screen()->root, XCB_ATOM_RESOURCE_MANAGER, XCB_ATOM_STRING, offset/4, 8192), NULL); bool more = false; if (reply && reply->format == 8 && reply->type == XCB_ATOM_STRING) { resources += QByteArray((const char *)xcb_get_property_value(reply), xcb_get_property_value_length(reply)); offset += xcb_get_property_value_length(reply); more = reply->bytes_after != 0; } if (reply) free(reply); if (!more) break; } QList<QByteArray> split = resources.split('\n'); for (int i = 0; i < split.size(); ++i) { const QByteArray &r = split.at(i); int value; if (xResource(r, "Xft.dpi:\t", &value)) m_forcedDpi = value; else if (xResource(r, "Xft.hintstyle:\t", &value)) m_hintStyle = QFontEngine::HintStyle(value); } }
char *xcb_util_get_property(xcb_connection_t *conn, xcb_window_t window, xcb_atom_t atom, xcb_atom_t type, size_t size) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; xcb_generic_error_t *err; int reply_length; char *content; cookie = xcb_get_property(conn, 0, window, atom, type, 0, size); reply = xcb_get_property_reply(conn, cookie, &err); if (err != NULL) { FREE(err); return NULL; } if (reply == NULL || (reply_length = xcb_get_property_value_length(reply)) == 0) { FREE(reply); return NULL; } if (reply->bytes_after > 0) { size_t adjusted_size = size + ceil(reply->bytes_after / 4.0); FREE(reply); return xcb_util_get_property(conn, window, atom, type, adjusted_size); } if (asprintf(&content, "%.*s", reply_length, (char *)xcb_get_property_value(reply)) < 0) { FREE(reply); return NULL; } FREE(reply); return content; }
//! Process _NET_WM_STATE reply and update fields void Client::process_ewmh_state(xcb_get_property_cookie_t gpc) { autofree_ptr<xcb_get_property_reply_t> gpr( xcb_get_property_reply(g_xcb.connection, gpc, NULL) ); if (!gpr || gpr->type != XCB_ATOM_ATOM) { INFO << "Could not retrieve _NET_WM_STATE for window"; return; } TRACE << *gpr; m_state_sticky = false; m_state_above = false; m_state_fullscreen = false; m_state_maximized_vert = false; m_state_maximized_horz = false; m_state_skip_taskbar = false; m_state_skip_pager = false; xcb_atom_t* atoms = (xcb_atom_t*)xcb_get_property_value(gpr.get()); int n = xcb_get_property_value_length(gpr.get()) / sizeof(xcb_atom_t); // iterate and apply properties to window for (int i = 0; i < n; ++i) change_ewmh_state(atoms[i], EWMH_STATE_ADD); }
/* * Find virtual roots (_NET_VIRTUAL_ROOTS) */ static xcb_window_t * Find_Roots(xcb_connection_t * dpy, xcb_window_t root, unsigned int *num) { xcb_atom_t atom_virtual_root; xcb_get_property_cookie_t prop_cookie; xcb_get_property_reply_t *prop_reply; xcb_window_t *prop_ret = NULL; *num = 0; atom_virtual_root = Get_Atom (dpy, "_NET_VIRTUAL_ROOTS"); if (atom_virtual_root == XCB_ATOM_NONE) return NULL; prop_cookie = xcb_get_property (dpy, False, root, atom_virtual_root, XCB_ATOM_WINDOW, 0, 0x7fffffff); prop_reply = xcb_get_property_reply (dpy, prop_cookie, NULL); if (!prop_reply) return NULL; if ((prop_reply->value_len > 0) && (prop_reply->type == XCB_ATOM_WINDOW) && (prop_reply->format == 32)) { int length = xcb_get_property_value_length (prop_reply); prop_ret = malloc(length); if (prop_ret) { memcpy (prop_ret, xcb_get_property_value(prop_reply), length); *num = prop_reply->value_len; } } free (prop_reply); return prop_ret; }
static void weston_wm_get_selection_data(struct weston_wm *wm) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; cookie = xcb_get_property(wm->conn, 1, /* delete */ wm->selection_window, wm->atom.wl_selection, XCB_GET_PROPERTY_TYPE_ANY, 0, /* offset */ 0x1fffffff /* length */); reply = xcb_get_property_reply(wm->conn, cookie, NULL); if (reply->type == wm->atom.incr) { dump_property(wm, wm->atom.wl_selection, reply); wm->incr = 1; free(reply); } else { dump_property(wm, wm->atom.wl_selection, reply); wm->incr = 0; weston_wm_write_property(wm, reply); } }
static void weston_wm_get_selection_data(struct weston_wm *wm) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; cookie = xcb_get_property(wm->conn, 1, /* delete */ wm->selection_window, wm->atom.wl_selection, XCB_GET_PROPERTY_TYPE_ANY, 0, /* offset */ 0x1fffffff /* length */); reply = xcb_get_property_reply(wm->conn, cookie, NULL); dump_property(wm, wm->atom.wl_selection, reply); if (reply == NULL) { return; } else if (reply->type == wm->atom.incr) { wm->incr = 1; free(reply); } else { wm->incr = 0; /* reply's ownership is transferred to wm, which is responsible * for freeing it */ weston_wm_write_property(wm, reply); } }
void QXcbScreen::updateGeometry(xcb_timestamp_t timestamp) { if (connection()->hasXRandr()) { xcb_randr_get_crtc_info_reply_t *crtc = xcb_randr_get_crtc_info_reply(xcb_connection(), xcb_randr_get_crtc_info_unchecked(xcb_connection(), m_crtc, timestamp), NULL); if (crtc) { m_geometry = QRect(crtc->x, crtc->y, crtc->width, crtc->height); m_availableGeometry = m_geometry; free(crtc); } } xcb_get_property_reply_t * workArea = xcb_get_property_reply(xcb_connection(), xcb_get_property_unchecked(xcb_connection(), false, screen()->root, atom(QXcbAtom::_NET_WORKAREA), XCB_ATOM_CARDINAL, 0, 1024), NULL); if (workArea && workArea->type == XCB_ATOM_CARDINAL && workArea->format == 32 && workArea->value_len >= 4) { // If workArea->value_len > 4, the remaining ones seem to be for virtual desktops. // But QScreen doesn't know about that concept. In reality there could be a // "docked" panel (with _NET_WM_STRUT_PARTIAL atom set) on just one desktop. // But for now just assume the first 4 values give us the geometry of the // "work area", AKA "available geometry" uint32_t *geom = (uint32_t*)xcb_get_property_value(workArea); QRect virtualAvailableGeometry(geom[0], geom[1], geom[2], geom[3]); // Take the intersection of the desktop's available geometry with this screen's geometry // to get the part of the available geometry which belongs to this screen. m_availableGeometry = m_geometry & virtualAvailableGeometry; } free(workArea); }
QByteArray getSettings() { QXcbConnectionGrabber connectionGrabber(screen->connection()); int offset = 0; QByteArray settings; xcb_atom_t _xsettings_atom = screen->connection()->atom(QXcbAtom::_XSETTINGS_SETTINGS); while (1) { xcb_get_property_cookie_t get_prop_cookie = xcb_get_property_unchecked(screen->xcb_connection(), false, x_settings_window, _xsettings_atom, _xsettings_atom, offset/4, 8192); xcb_get_property_reply_t *reply = xcb_get_property_reply(screen->xcb_connection(), get_prop_cookie, NULL); bool more = false; if (!reply) return settings; settings += QByteArray((const char *)xcb_get_property_value(reply), xcb_get_property_value_length(reply)); offset += xcb_get_property_value_length(reply); more = reply->bytes_after != 0; free(reply); if (!more) break; } return settings; }
static void weston_wm_get_incr_chunk(struct weston_wm *wm) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; cookie = xcb_get_property(wm->conn, 0, /* delete */ wm->selection_window, wm->atom.wl_selection, XCB_GET_PROPERTY_TYPE_ANY, 0, /* offset */ 0x1fffffff /* length */); reply = xcb_get_property_reply(wm->conn, cookie, NULL); dump_property(wm, wm->atom.wl_selection, reply); if (xcb_get_property_value_length(reply) > 0) { weston_wm_write_property(wm, reply); } else { weston_log("transfer complete\n"); close(wm->data_source_fd); free(reply); } }
//! Process WM_STATE reply and update fields void Client::process_wm_state(xcb_get_property_cookie_t gpc) { // *** process WM_STATE property autofree_ptr<xcb_get_property_reply_t> gpr( xcb_get_property_reply(g_xcb.connection, gpc, NULL) ); if (!gpr) { WARN << "Could not retrieve WM_STATE for window"; m_wm_state = XCB_ICCCM_WM_STATE_NORMAL; return; } TRACE << *gpr; if (gpr->type != g_xcb.WM_STATE.atom || gpr->format != 32 || gpr->length != 2) { WARN << "Could not retrieve WM_STATE for window"; m_wm_state = XCB_ICCCM_WM_STATE_NORMAL; return; } m_wm_state = (xcb_icccm_wm_state_t)( *(uint32_t*)xcb_get_property_value(gpr.get()) ); INFO << "ICCCM WM_STATE of window " << window() << " is " << IcccmWmStateFormatter(m_wm_state); }
void property_update_net_wm_pid(client_t *c, xcb_get_property_reply_t *reply) { bool no_reply = !reply; if(no_reply) { xcb_get_property_cookie_t prop_c = xcb_get_property_unchecked(globalconf.connection, false, c->window, _NET_WM_PID, XCB_ATOM_CARDINAL, 0L, 1L); reply = xcb_get_property_reply(globalconf.connection, prop_c, NULL); } if(reply && reply->value_len) { uint32_t *rdata = xcb_get_property_value(reply); if(rdata) { luaA_object_push(globalconf.L, c); client_set_pid(globalconf.L, -1, *rdata); lua_pop(globalconf.L, 1); } } if(no_reply) p_delete(&reply); }
/** Get a window state (WM_STATE). * \param cookie The cookie. * \return The current state of the window, or 0 on error. */ uint32_t window_state_get_reply(xcb_get_property_cookie_t cookie, int* pStateFound) { /* This is a bug fixed in updated versions of awesome already */ /* setting the result to 0 maps to XCB_WM_STATE_WITHDRAWN which */ /* causes a problem in scan. The default value should be XCB_WM_STATE_NORMAL */ /* returning 0 inside pStateFound to indicate to the caller that */ /* it was not found */ uint32_t result = XCB_WM_STATE_NORMAL; if (pStateFound){ *pStateFound = 0; } xcb_get_property_reply_t *prop_r; if((prop_r = xcb_get_property_reply(globalconf.connection, cookie, NULL))) { if(xcb_get_property_value_length(prop_r)){ result = *(uint32_t *) xcb_get_property_value(prop_r); if (pStateFound){ *pStateFound = 1; } } p_delete(&prop_r); } return result; }
void find_window_by_property(xcb_window_t window, xcb_atom_t property, xcb_window_t *res) { *res = XCB_WINDOW_NONE; xcb_get_property_cookie_t get_property_cookie = xcb_get_property(display, 0, window, property, XCB_ATOM_ANY, 0, 0); xcb_get_property_reply_t *get_property_reply = xcb_get_property_reply(display, get_property_cookie, NULL); if (get_property_reply != NULL) { if (get_property_reply->type != XCB_ATOM_NONE) { *res = window; free(get_property_reply); return; } free(get_property_reply); } xcb_query_tree_cookie_t query_tree_cookie = xcb_query_tree(display, window); xcb_query_tree_reply_t *query_tree_reply = xcb_query_tree_reply(display, query_tree_cookie, NULL); if (query_tree_reply == NULL) return; int length = xcb_query_tree_children_length(query_tree_reply); xcb_window_t *children = xcb_query_tree_children(query_tree_reply); for (int i = 0; i < length; i++) { find_window_by_property(children[i], property, res); if (*res != XCB_WINDOW_NONE) break; } free(query_tree_reply); }
uint32_t get_wm_state(xcb_drawable_t win) { xcb_get_property_reply_t *reply; xcb_get_property_cookie_t cookie; uint32_t *statep; uint32_t state = 0; cookie = xcb_get_property(conn, false, win, wm_state, wm_state, 0, sizeof (int32_t)); reply = xcb_get_property_reply(conn, cookie, NULL); if (NULL == reply) { fprintf(stderr, "qtwm: Couldn't get properties for win %d\n", win); return -1; } /* Length is 0 if we didn't find it. */ if (0 == xcb_get_property_value_length(reply)) { goto bad; } statep = xcb_get_property_value(reply); state = *statep; bad: free(reply); return state; }
static void weston_wm_get_selection_data(struct weston_wm *wm) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; cookie = xcb_get_property(wm->conn, 1, /* delete */ wm->selection_window, wm->atom.wl_selection, XCB_GET_PROPERTY_TYPE_ANY, 0, /* offset */ 0x1fffffff /* length */); reply = xcb_get_property_reply(wm->conn, cookie, NULL); if (reply->type == wm->atom.incr) { dump_property(wm, wm->atom.wl_selection, reply); wm->incr = 1; free(reply); } else { dump_property(wm, wm->atom.wl_selection, reply); wm->incr = 0; wm->property_start = 0; wm->property_source = wl_event_loop_add_fd(wm->server->loop, wm->data_source_fd, WL_EVENT_WRITABLE, weston_wm_write_property, wm); wm->property_reply = reply; } }
xcb_window_t find_focused_window(xcb_connection_t *conn, const xcb_window_t root) { xcb_window_t result = XCB_NONE; _init_net_active_window(conn); xcb_get_property_reply_t *prop_reply = xcb_get_property_reply( conn, xcb_get_property_unchecked( conn, false, root, _NET_ACTIVE_WINDOW, XCB_GET_PROPERTY_TYPE_ANY, 0, 1 /* word */), NULL); if (prop_reply == NULL) { goto out; } if (xcb_get_property_value_length(prop_reply) == 0) { goto out_prop; } if (prop_reply->type != XCB_ATOM_WINDOW) { goto out_prop; } result = *((xcb_window_t *)xcb_get_property_value(prop_reply)); out_prop: free(prop_reply); out: return result; }
static void weston_wm_get_selection_targets(struct weston_wm *wm) { struct x11_data_source *source; struct weston_compositor *compositor; struct weston_seat *seat = weston_wm_pick_seat(wm); xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; xcb_atom_t *value; char **p; uint32_t i; cookie = xcb_get_property(wm->conn, 1, /* delete */ wm->selection_window, wm->atom.wl_selection, XCB_GET_PROPERTY_TYPE_ANY, 0, /* offset */ 4096 /* length */); reply = xcb_get_property_reply(wm->conn, cookie, NULL); if (reply == NULL) return; dump_property(wm, wm->atom.wl_selection, reply); if (reply->type != XCB_ATOM_ATOM) { free(reply); return; } source = zalloc(sizeof *source); if (source == NULL) { free(reply); return; } wl_signal_init(&source->base.destroy_signal); source->base.accept = data_source_accept; source->base.send = data_source_send; source->base.cancel = data_source_cancel; source->wm = wm; wl_array_init(&source->base.mime_types); value = xcb_get_property_value(reply); for (i = 0; i < reply->value_len; i++) { if (value[i] == wm->atom.utf8_string) { p = wl_array_add(&source->base.mime_types, sizeof *p); if (p) *p = strdup("text/plain;charset=utf-8"); } } compositor = wm->server->compositor; weston_seat_set_selection(seat, &source->base, wl_display_next_serial(compositor->wl_display)); free(reply); }
EAPI char * ecore_x_window_prop_string_get(Ecore_X_Window win, Ecore_X_Atom type) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; char *str = NULL; int len = 0; LOGFN(__FILE__, __LINE__, __FUNCTION__); CHECK_XCB_CONN; cookie = xcb_get_property_unchecked(_ecore_xcb_conn, 0, win ? win : ((xcb_screen_t *)_ecore_xcb_screen)->root, type, XCB_GET_PROPERTY_TYPE_ANY, 0, 1000000L); reply = xcb_get_property_reply(_ecore_xcb_conn, cookie, NULL); if (!reply) return NULL; len = ((reply->value_len * reply->format) / 8); str = (char *)malloc((len + 1) * sizeof(char)); memcpy(str, xcb_get_property_value(reply), len); str[len] = '\0'; if (reply->type != ECORE_X_ATOM_UTF8_STRING) { Ecore_Xcb_Textproperty prop; int count = 0; char **list = NULL; Eina_Bool ret = EINA_FALSE; prop.value = strdup(str); prop.nitems = len; prop.encoding = reply->type; #ifdef HAVE_ICONV ret = _ecore_xcb_utf8_textproperty_to_textlist(&prop, &list, &count); #else ret = _ecore_xcb_mb_textproperty_to_textlist(&prop, &list, &count); #endif if (ret) { if (count > 0) str = strdup(list[0]); else str = strdup((char *)prop.value); if (list) free(list); } else str = strdup((char *)prop.value); } free(reply); return str; }
/*! Returns WM_CLIENT_LEADER property for a given window. */ xcb_window_t Toplevel::staticWmClientLeader(xcb_window_t w) { xcb_connection_t *c = connection(); auto cookie = xcb_get_property_unchecked(c, false, w, atoms->wm_client_leader, XCB_ATOM_WINDOW, 0, 10000); ScopedCPointer<xcb_get_property_reply_t> prop(xcb_get_property_reply(c, cookie, nullptr)); if (prop.isNull() || prop->value_len <= 0) { return w; } return static_cast<xcb_window_t*>(xcb_get_property_value(prop.data()))[0]; }
/** * Gets the reply of the GetProperty request sent by ecore_x_window_prop_string_get_prefetch(). */ EAPI void ecore_x_window_prop_string_get_fetch(void) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; cookie.sequence = _ecore_xcb_cookie_get(); reply = xcb_get_property_reply(_ecore_xcb_conn, cookie, NULL); _ecore_xcb_reply_cache(reply); } /* ecore_x_window_prop_string_get_fetch */
/* window_get_state {{{ */ uint32_t window_get_state(xcb_get_property_cookie_t cookie) { xcb_get_property_reply_t *reply = xcb_get_property_reply(rootconf.connection, cookie, NULL); if(reply) if(xcb_get_property_value_length(reply)) return *(uint32_t *) xcb_get_property_value(reply); return 0; } /* }}} */
/** Update leader hint of a client. * \param c The client. * \param cookie Cookie returned by property_get_wm_client_leader. */ void property_update_wm_client_leader(client_t *c, xcb_get_property_cookie_t cookie) { xcb_get_property_reply_t *reply; void *data; reply = xcb_get_property_reply(globalconf.connection, cookie, NULL); if(reply && reply->value_len && (data = xcb_get_property_value(reply))) c->leader_window = *(xcb_window_t *) data; p_delete(&reply); }
void Client::updateLeader(xcb_connection_t* conn, xcb_get_property_cookie_t cookie) { AutoPointer<xcb_get_property_reply_t> leader(xcb_get_property_reply(conn, cookie, 0)); if (!leader || leader->type != XCB_ATOM_WINDOW || leader->format != 32 || !leader->length) { mGroup = ClientGroup::clientGroup(mWindow); mGroup->add(this); return; } const xcb_window_t win = *static_cast<xcb_window_t *>(xcb_get_property_value(leader)); mGroup = ClientGroup::clientGroup(win); mGroup->add(this); }
Property readProperty(xcb_connection_t& connection, xcb_atom_t atom, xcb_window_t window, xcb_generic_error_t* error, bool del) { error = nullptr; xcb_generic_error_t* errorPtr; auto length = 1; auto cookie = xcb_get_property(&connection, false, window, atom, XCB_ATOM_ANY, 0, length); auto reply = xcb_get_property_reply(&connection, cookie, &errorPtr); if(reply && !errorPtr && (reply->bytes_after || del)) { length = reply->length; free(reply); cookie = xcb_get_property(&connection, del, window, atom, XCB_ATOM_ANY, 0, length); reply = xcb_get_property_reply(&connection, cookie, &errorPtr); } Property ret {}; if(!errorPtr && reply) { ret.format = reply->format; ret.type = reply->type; auto begin = static_cast<uint8_t*>(xcb_get_property_value(reply)); ret.data = {begin, begin + xcb_get_property_value_length(reply)}; free(reply); } else if(errorPtr) { if(error) *error = *errorPtr; free(errorPtr); } return ret; }
//_______________________________________________________ bool ShadowHelper::checkSupported( void ) const { // create atom #if MENDA_HAVE_X11 // make sure we are on X11 if( !Helper::isX11() ) return false; // create atom xcb_atom_t netSupportedAtom( _helper.createAtom( "_NET_SUPPORTED" ) ); if( !netSupportedAtom ) return false; // store connection locally xcb_connection_t* connection( Helper::connection() ); // get property const quint32 maxLength = std::string().max_size(); xcb_get_property_cookie_t cookie( xcb_get_property( connection, 0, QX11Info::appRootWindow(), netSupportedAtom, XCB_ATOM_ATOM, 0, (maxLength+3) / 4 ) ); ScopedPointer<xcb_get_property_reply_t> reply( xcb_get_property_reply( connection, cookie, nullptr ) ); if( !reply ) return false; // get reply length and data const int count( xcb_get_property_value_length( reply.data() )/sizeof( xcb_atom_t ) ); xcb_atom_t *atoms = reinterpret_cast<xcb_atom_t*>( xcb_get_property_value( reply.data() ) ); bool found( false ); for( int i = 0; i < count && !found; ++i ) { // get atom name and print xcb_atom_t atom( atoms[i] ); xcb_get_atom_name_cookie_t cookie( xcb_get_atom_name( connection, atom ) ); ScopedPointer<xcb_get_atom_name_reply_t> reply( xcb_get_atom_name_reply( connection, cookie, 0 ) ); if( !reply ) continue; // get name and compare const QString name( QByteArray( xcb_get_atom_name_name( reply.data() ), xcb_get_atom_name_name_length( reply.data() ) ) ); if( strcmp( netWMShadowAtomName, xcb_get_atom_name_name( reply.data() ) ) == 0 ) found = true; } return found; #else return false; #endif }
EAPI int ecore_x_window_prop_card32_list_get(Ecore_X_Window win, Ecore_X_Atom atom, unsigned int **list) { xcb_get_property_cookie_t cookie; xcb_get_property_reply_t *reply; int num = -1; LOGFN(__FILE__, __LINE__, __FUNCTION__); CHECK_XCB_CONN; if (list) *list = NULL; cookie = xcb_get_property_unchecked(_ecore_xcb_conn, 0, win, atom, XCB_ATOM_CARDINAL, 0, 0x7fffffff); reply = xcb_get_property_reply(_ecore_xcb_conn, cookie, NULL); if (!reply) return -1; if ((reply->type != XCB_ATOM_CARDINAL) || (reply->format != 32)) num = -1; else if ((reply->value_len == 0) || (!xcb_get_property_value(reply))) num = 0; else { num = reply->value_len; if (list) { unsigned int *val; void *data; int i = 0; val = malloc(num * sizeof(unsigned int)); if (!val) { free(reply); return num; } data = xcb_get_property_value(reply); for (i = 0; i < num; i++) val[i] = ((unsigned long *)data)[i]; *list = val; } } free(reply); return num; }