void XWaylandManager::setupVisualAndColormap()
{
xcb_depth_iterator_t depthIterator =
xcb_screen_allowed_depths_iterator(Xcb::screen());
xcb_visualtype_t *visualType = Q_NULLPTR;
xcb_visualtype_iterator_t visualTypeIterator;
while (depthIterator.rem > 0) {
if (depthIterator.data->depth == 32) {
visualTypeIterator = xcb_depth_visuals_iterator(depthIterator.data);
visualType = visualTypeIterator.data;
break;
}
xcb_depth_next(&depthIterator);
}
if (!visualType) {
qCDebug(XWAYLAND) << "No 32-bit visualtype";
return;
}
m_visualId = visualType->visual_id;
m_colorMap = xcb_generate_id(Xcb::connection());
xcb_create_colormap(Xcb::connection(), XCB_COLORMAP_ALLOC_NONE,
m_colorMap, Xcb::rootWindow(), m_visualId);
}
static xcb_screen_t *
_cairo_xcb_screen_from_visual (xcb_connection_t *connection,
xcb_visualtype_t *visual,
int *depth)
{
xcb_depth_iterator_t d;
xcb_screen_iterator_t s;
s = xcb_setup_roots_iterator (xcb_get_setup (connection));
for (; s.rem; xcb_screen_next (&s)) {
if (s.data->root_visual == visual->visual_id) {
*depth = s.data->root_depth;
return s.data;
}
d = xcb_screen_allowed_depths_iterator(s.data);
for (; d.rem; xcb_depth_next (&d)) {
xcb_visualtype_iterator_t v = xcb_depth_visuals_iterator (d.data);
for (; v.rem; xcb_visualtype_next (&v)) {
if (v.data->visual_id == visual->visual_id) {
*depth = d.data->depth;
return s.data;
}
}
}
}
return NULL;
}
/**
* Try to get a visual type for the given screen that
* matches the given depth
*/
optional<xcb_visualtype_t*> connection::visual_type(xcb_screen_t* screen, int match_depth) {
xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(screen);
if (depth_iter.data) {
for (; depth_iter.rem; xcb_depth_next(&depth_iter))
if (match_depth == 0 || match_depth == depth_iter.data->depth)
for (auto it = xcb_depth_visuals_iterator(depth_iter.data); it.rem;
xcb_visualtype_next(&it))
return it.data;
if (match_depth > 0)
return visual_type(screen, 0);
}
return {};
}
xcb_visualtype_t *
xcb_aux_find_visual_by_id (xcb_screen_t *screen,
xcb_visualid_t id)
{
xcb_depth_iterator_t i;
xcb_visualtype_iterator_t j;
for (i = xcb_screen_allowed_depths_iterator(screen);
i.rem; xcb_depth_next(&i))
for (j = xcb_depth_visuals_iterator(i.data);
j.rem; xcb_visualtype_next(&j))
if (j.data->visual_id == id)
return j.data;
return 0;
}
uint8_t
xcb_aux_get_depth_of_visual (xcb_screen_t *screen,
xcb_visualid_t id)
{
xcb_depth_iterator_t i;
xcb_visualtype_iterator_t j;
for (i = xcb_screen_allowed_depths_iterator(screen);
i.rem; xcb_depth_next(&i))
for (j = xcb_depth_visuals_iterator(i.data);
j.rem; xcb_visualtype_next(&j))
if (j.data->visual_id == id)
return i.data->depth;
return 0;
}
/*!
* Some drawing surfaces such as Cairo require the visual type.
* @param s the screen to obtain the visual type from.
* @return pointer to the visual type on success, or NULL.
* @see window_init()
*/
static xcb_visualtype_t *get_root_visual_type(xcb_screen_t *s)
{
for (xcb_depth_iterator_t di =
xcb_screen_allowed_depths_iterator(s);
di.rem ; xcb_depth_next(&di)) {
for (xcb_visualtype_iterator_t vi =
xcb_depth_visuals_iterator(di.data);
vi.rem; xcb_visualtype_next(&vi)) {
if (s->root_visual == vi.data->visual_id)
return vi.data;
}
}
return NULL;
}
static uint8_t
a_visual_depth(xcb_screen_t *s, xcb_visualid_t vis)
{
xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(s);
if(depth_iter.data)
for(; depth_iter.rem; xcb_depth_next (&depth_iter))
for(xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
visual_iter.rem; xcb_visualtype_next (&visual_iter))
if(vis == visual_iter.data->visual_id)
return depth_iter.data->depth;
fatal("Could not find a visual's depth");
}
static xcb_visualtype_t *
a_argb_visual(xcb_screen_t *s)
{
xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(s);
if(depth_iter.data)
for(; depth_iter.rem; xcb_depth_next (&depth_iter))
if(depth_iter.data->depth == 32)
for(xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
visual_iter.rem; xcb_visualtype_next (&visual_iter))
return visual_iter.data;
return NULL;
}
static xcb_visualtype_t *
a_default_visual(xcb_screen_t *s)
{
xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(s);
if(depth_iter.data)
for(; depth_iter.rem; xcb_depth_next (&depth_iter))
for(xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
visual_iter.rem; xcb_visualtype_next (&visual_iter))
if(s->root_visual == visual_iter.data->visual_id)
return visual_iter.data;
return NULL;
}
static xcb_visualtype_t * get_root_visualitype(xcb_screen_t * s) {
xcb_depth_iterator_t depth_iter;
xcb_visualtype_iterator_t visual_iter;
for (depth_iter = xcb_screen_allowed_depths_iterator(s);
depth_iter.rem; xcb_depth_next (&depth_iter)) {
for (visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
visual_iter.rem; xcb_visualtype_next (&visual_iter)) {
if (s->root_visual == visual_iter.data->visual_id)
return visual_iter.data;
}
}
return NULL;
}
static gboolean
_eventd_nd_xcb_get_colormap(EventdNdBackendContext *self)
{
xcb_depth_t *root_depth = NULL;
xcb_visualtype_t *root_visual = NULL;
xcb_depth_iterator_t depth_iter;
for ( depth_iter = xcb_screen_allowed_depths_iterator(self->screen) ; depth_iter.rem ; xcb_depth_next(&depth_iter) )
{
xcb_depth_t *d = depth_iter.data;
xcb_visualtype_iterator_t visual_iter;
for ( visual_iter = xcb_depth_visuals_iterator(d) ; visual_iter.rem ; xcb_visualtype_next(&visual_iter) )
{
xcb_visualtype_t *v = visual_iter.data;
if ( ( d->depth == 32 ) && ( v->_class >= XCB_VISUAL_CLASS_TRUE_COLOR ) )
{
self->depth = d;
self->visual = v;
}
if ( self->screen->root_visual == v->visual_id )
{
root_depth = d;
root_visual = v;
}
}
}
if ( self->visual != NULL )
{
xcb_void_cookie_t c;
xcb_generic_error_t *e;
self->map = xcb_generate_id(self->xcb_connection);
c = xcb_create_colormap_checked(self->xcb_connection, XCB_COLORMAP_ALLOC_NONE, self->map, self->screen->root, self->visual->visual_id);
e = xcb_request_check(self->xcb_connection, c);
if ( e == NULL )
return TRUE;
xcb_free_colormap(self->xcb_connection, self->map);
free(e);
}
self->depth = root_depth;
self->visual = root_visual;
self->map = self->screen->default_colormap;
return FALSE;
}
static PyObject *
_xcb_visualtype(PyObject *self, PyObject *args)
{
xcb_depth_iterator_t depth_iter;
xcb_visualtype_iterator_t visual_iter;
xcb_screen_t *s;
if (!PyArg_ParseTuple(args, "l", &s))
return NULL;
for(depth_iter = xcb_screen_allowed_depths_iterator(s); depth_iter.rem; xcb_depth_next (&depth_iter))
for(visual_iter = xcb_depth_visuals_iterator (depth_iter.data); visual_iter.rem; xcb_visualtype_next (&visual_iter))
if (s->root_visual == visual_iter.data->visual_id)
return Py_BuildValue("l", visual_iter.data);
Py_RETURN_NONE;
}
static xcb_visualtype_t *
lookup_visual (xcb_screen_t *s,
xcb_visualid_t visual)
{
xcb_depth_iterator_t d;
d = xcb_screen_allowed_depths_iterator (s);
for (; d.rem; xcb_depth_next (&d)) {
xcb_visualtype_iterator_t v = xcb_depth_visuals_iterator (d.data);
for (; v.rem; xcb_visualtype_next (&v)) {
if (v.data->visual_id == visual)
return v.data;
}
}
return 0;
}
static xcb_visualtype_t *
get_xcb_visualtype_for_depth(struct dri2_egl_display *dri2_dpy, int depth)
{
xcb_visualtype_iterator_t visual_iter;
xcb_screen_t *screen = dri2_dpy->screen;
xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(screen);
for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
if (depth_iter.data->depth != depth)
continue;
visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
if (visual_iter.rem)
return visual_iter.data;
}
return NULL;
}
static void *
_best_visual_get(int backend, void *connection, int screen)
{
if (!connection) return NULL;
#ifdef BUILD_ENGINE_SOFTWARE_XLIB
if (backend == EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XLIB)
{
return DefaultVisual((Display *)connection, screen);
}
#endif
#ifdef BUILD_ENGINE_SOFTWARE_XCB
if (backend == EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XCB)
{
xcb_screen_iterator_t iter_screen;
xcb_depth_iterator_t iter_depth;
xcb_screen_t *s;
iter_screen = xcb_setup_roots_iterator(xcb_get_setup((xcb_connection_t *)connection));
for (; iter_screen.rem; --screen, xcb_screen_next (&iter_screen))
if (screen == 0)
{
s = iter_screen.data;
break;
}
iter_depth = xcb_screen_allowed_depths_iterator(s);
for (; iter_depth.rem; xcb_depth_next (&iter_depth))
{
xcb_visualtype_iterator_t iter_vis;
iter_vis = xcb_depth_visuals_iterator(iter_depth.data);
for (; iter_vis.rem; xcb_visualtype_next (&iter_vis))
{
if (s->root_visual == iter_vis.data->visual_id)
return iter_vis.data;
}
}
}
#endif
return NULL;
}
xcb_visualtype_t *get_root_visual_type(xcb_screen_t *screen) {
xcb_visualtype_t *visual_type = NULL;
xcb_depth_iterator_t depth_iter;
xcb_visualtype_iterator_t visual_iter;
for (depth_iter = xcb_screen_allowed_depths_iterator(screen);
depth_iter.rem;
xcb_depth_next(&depth_iter)) {
for (visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
visual_iter.rem;
xcb_visualtype_next(&visual_iter)) {
if (screen->root_visual != visual_iter.data->visual_id)
continue;
visual_type = visual_iter.data;
return visual_type;
}
}
return NULL;
}
static xcb_visualtype_t *
get_xcb_visualtype_for_depth(struct vl_screen *vscreen, int depth)
{
xcb_visualtype_iterator_t visual_iter;
xcb_screen_t *screen = vscreen->xcb_screen;
xcb_depth_iterator_t depth_iter;
if (!screen)
return NULL;
depth_iter = xcb_screen_allowed_depths_iterator(screen);
for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {
if (depth_iter.data->depth != depth)
continue;
visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
if (visual_iter.rem)
return visual_iter.data;
}
return NULL;
}
static xcb_visualtype_t *
screen_get_visualtype(xcb_screen_t *screen, xcb_visualid_t visual_id,
unsigned *depth)
{
xcb_depth_iterator_t depth_iter =
xcb_screen_allowed_depths_iterator(screen);
for (; depth_iter.rem; xcb_depth_next (&depth_iter)) {
xcb_visualtype_iterator_t visual_iter =
xcb_depth_visuals_iterator (depth_iter.data);
for (; visual_iter.rem; xcb_visualtype_next (&visual_iter)) {
if (visual_iter.data->visual_id == visual_id) {
if (depth)
*depth = depth_iter.data->depth;
return visual_iter.data;
}
}
}
return NULL;
}
void x11_create_visual_and_colormap ( void )
{
xcb_depth_iterator_t depth_iter;
for ( depth_iter = xcb_screen_allowed_depths_iterator ( xcb->screen ); depth_iter.rem; xcb_depth_next ( &depth_iter ) ) {
xcb_depth_t *d = depth_iter.data;
xcb_visualtype_iterator_t visual_iter;
for ( visual_iter = xcb_depth_visuals_iterator ( d ); visual_iter.rem; xcb_visualtype_next ( &visual_iter ) ) {
xcb_visualtype_t *v = visual_iter.data;
if ( ( d->depth == 32 ) && ( v->_class == XCB_VISUAL_CLASS_TRUE_COLOR ) ) {
depth = d;
visual = v;
}
if ( xcb->screen->root_visual == v->visual_id ) {
root_depth = d;
root_visual = v;
}
}
}
if ( visual != NULL ) {
xcb_void_cookie_t c;
xcb_generic_error_t *e;
map = xcb_generate_id ( xcb->connection );
c = xcb_create_colormap_checked ( xcb->connection, XCB_COLORMAP_ALLOC_NONE, map, xcb->screen->root, visual->visual_id );
e = xcb_request_check ( xcb->connection, c );
if ( e ) {
depth = NULL;
visual = NULL;
free ( e );
}
}
if ( visual == NULL ) {
depth = root_depth;
visual = root_visual;
map = xcb->screen->default_colormap;
}
}
xcb_visualtype_t *
xcb_aux_get_visualtype (xcb_connection_t *c,
int scr,
xcb_visualid_t vid)
{
xcb_screen_t *screen;
xcb_depth_t *depth;
xcb_visualtype_iterator_t iter;
int cur;
screen = xcb_aux_get_screen (c, scr);
if (!screen) return NULL;
depth = xcb_screen_allowed_depths_iterator(screen).data;
if (!depth) return NULL;
iter = xcb_depth_visuals_iterator(depth);
for (cur = 0 ; cur < iter.rem ; xcb_visualtype_next(&iter), ++cur)
if (vid == iter.data->visual_id)
return iter.data;
return NULL;
}
QT_BEGIN_NAMESPACE
QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *scr,
xcb_randr_get_output_info_reply_t *output, QString outputName, int number)
: QXcbObject(connection)
, m_screen(scr)
, m_crtc(output ? output->crtc : 0)
, m_outputName(outputName)
, m_sizeMillimeters(output ? QSize(output->mm_width, output->mm_height) : QSize())
, m_virtualSize(scr->width_in_pixels, scr->height_in_pixels)
, m_virtualSizeMillimeters(scr->width_in_millimeters, scr->height_in_millimeters)
, m_orientation(Qt::PrimaryOrientation)
, m_number(number)
, m_refreshRate(60)
, m_forcedDpi(-1)
{
if (connection->hasXRandr())
xcb_randr_select_input(xcb_connection(), screen()->root, true);
updateGeometry(output ? output->timestamp : 0);
updateRefreshRate();
// On VNC, it can be that physical size is unknown while
// virtual size is known (probably back-calculated from DPI and resolution)
if (m_sizeMillimeters.isEmpty())
m_sizeMillimeters = m_virtualSizeMillimeters;
if (m_geometry.isEmpty())
m_geometry = QRect(QPoint(), m_virtualSize);
if (m_availableGeometry.isEmpty())
m_availableGeometry = QRect(QPoint(), m_virtualSize);
readXResources();
#ifdef Q_XCB_DEBUG
qDebug();
qDebug("Screen output %s of xcb screen %d:", m_outputName.toUtf8().constData(), m_number);
qDebug(" width..........: %lf", m_sizeMillimeters.width());
qDebug(" height.........: %lf", m_sizeMillimeters.height());
qDebug(" geometry.......: %d x %d +%d +%d", m_geometry.width(), m_geometry.height(), m_geometry.x(), m_geometry.y());
qDebug(" virtual width..: %lf", m_virtualSizeMillimeters.width());
qDebug(" virtual height.: %lf", m_virtualSizeMillimeters.height());
qDebug(" virtual geom...: %d x %d", m_virtualSize.width(), m_virtualSize.height());
qDebug(" avail virt geom: %d x %d +%d +%d", m_availableGeometry.width(), m_availableGeometry.height(), m_availableGeometry.x(), m_availableGeometry.y());
qDebug(" depth..........: %d", screen()->root_depth);
qDebug(" white pixel....: %x", screen()->white_pixel);
qDebug(" black pixel....: %x", screen()->black_pixel);
qDebug(" refresh rate...: %d", m_refreshRate);
qDebug(" root ID........: %x", screen()->root);
#endif
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_get_property_reply_t *reply =
xcb_get_property_reply(xcb_connection(),
xcb_get_property_unchecked(xcb_connection(), false, screen()->root,
atom(QXcbAtom::_NET_SUPPORTING_WM_CHECK),
XCB_ATOM_WINDOW, 0, 1024), NULL);
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_unchecked(xcb_connection(), false, windowManager,
atom(QXcbAtom::_NET_WM_NAME),
atom(QXcbAtom::UTF8_STRING), 0, 1024), NULL);
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));
#ifdef Q_XCB_DEBUG
qDebug(" window manager.: %s", qPrintable(m_windowManagerName));
qDebug();
#endif
}
free(windowManagerReply);
}
}
free(reply);
const xcb_query_extension_reply_t *sync_reply = xcb_get_extension_data(xcb_connection(), &xcb_sync_id);
if (!sync_reply || !sync_reply->present)
m_syncRequestSupported = false;
else
m_syncRequestSupported = m_windowManagerName != QLatin1String("KWin");
m_clientLeader = xcb_generate_id(xcb_connection());
Q_XCB_CALL2(xcb_create_window(xcb_connection(),
XCB_COPY_FROM_PARENT,
m_clientLeader,
screen()->root,
0, 0, 1, 1,
0,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
screen()->root_visual,
0, 0), connection);
Q_XCB_CALL2(xcb_change_property(xcb_connection(),
XCB_PROP_MODE_REPLACE,
m_clientLeader,
atom(QXcbAtom::WM_CLIENT_LEADER),
XCB_ATOM_WINDOW,
32,
1,
&m_clientLeader), connection);
xcb_depth_iterator_t depth_iterator =
xcb_screen_allowed_depths_iterator(screen());
while (depth_iterator.rem) {
xcb_depth_t *depth = depth_iterator.data;
xcb_visualtype_iterator_t visualtype_iterator =
xcb_depth_visuals_iterator(depth);
while (visualtype_iterator.rem) {
xcb_visualtype_t *visualtype = visualtype_iterator.data;
m_visuals.insert(visualtype->visual_id, *visualtype);
xcb_visualtype_next(&visualtype_iterator);
}
xcb_depth_next(&depth_iterator);
}
m_cursor = new QXcbCursor(connection, this);
}
void init_tabletwm() {
memset(&key_win, 0, sizeof(key_win));
memset(&shutdown_win, 0, sizeof(shutdown_win));
xcb_void_cookie_t void_cookie;
xcb_intern_atom_cookie_t atom_cookie[TWM_ATOM_LAST_VALUE];
uint32_t v[] = {XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_PROPERTY_CHANGE};
int i;
char *a_atoms[TWM_ATOM_LAST_VALUE] = {
"WM_SIZE_HINTS",
"WM_NORMAL_HINTS",
"WM_PROTOCOLS",
"WM_DELETE_WINDOW",
"WM_TRANSIENT_FOR",
"_NET_SUPPORTING_WM_CHECK",
"_NET_WM_NAME",
"_NET_SUPPORTED",
"_NET_WM_WINDOW_TYPE",
"_NET_WM_WINDOW_TYPE_DESKTOP",
"_NET_WM_WINDOW_TYPE_DOCK",
"_NET_WM_WINDOW_TYPE_TOOLBAR",
"_NET_WM_WINDOW_TYPE_MENU",
"_NET_WM_WINDOW_TYPE_UTILITY",
"_NET_WM_WINDOW_TYPE_SPLASH",
"_NET_WM_WINDOW_TYPE_DIALOG",
"_NET_WM_WINDOW_TYPE_DROPDOWN_MENU",
"_NET_WM_WINDOW_TYPE_POPUP_MENU",
"_NET_WM_WINDOW_TYPE_TOOLTIP",
"_NET_WM_WINDOW_TYPE_NOTIFICATION",
"_NET_WM_WINDOW_TYPE_COMBO",
"_NET_WM_WINDOW_TYPE_DND",
"_NET_WM_WINDOW_TYPE_NORMAL",
"_NET_WM_ALLOWED_ACTIONS",
"_NET_WM_ACTION_MOVE",
"_NET_WM_ACTION_RESIZE",
"_NET_WM_ACTION_MINIMIZE",
"_NET_WM_ACTION_SHADE",
"_NET_WM_ACTION_STICK",
"_NET_WM_ACTION_MAXIMIZE_HORZ",
"_NET_WM_ACTION_MAXIMIZE_VERT",
"_NET_WM_ACTION_FULLSCREEN",
"_NET_WM_ACTION_CHANGE_DESKTOP",
"_NET_WM_ACTION_CLOSE",
"_NET_WM_ACTION_ABOVE",
"_NET_WM_ACTION_BELOW",
"WM_CLASS",
"WM_STATE",
"_NET_ACTIVE_WINDOW",
"WM_HINTS",
"_XKB_RULES_NAMES",
};
init_load_config();
wincache_init();
conn = xcb_connect(0, 0);
assert(conn);
scr = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
width = scr->width_in_pixels;
height = scr->height_in_pixels; // reserve the bottom part for the 1pixel-height, collapsed menu bar
xcb_change_window_attributes(conn, scr->root, XCB_CW_EVENT_MASK, v);
xcb_depth_iterator_t depth_iter;
xcb_visualid_t root_visual = { 0 };
visual_type = NULL;
for (depth_iter = xcb_screen_allowed_depths_iterator (scr); depth_iter.rem; xcb_depth_next (&depth_iter)) {
xcb_visualtype_iterator_t visual_iter;
visual_iter = xcb_depth_visuals_iterator (depth_iter.data);
for (; visual_iter.rem; xcb_visualtype_next (&visual_iter)) {
if (scr->root_visual == visual_iter.data->visual_id) {
visual_type = visual_iter.data;
break;
}
}
}
/* get atoms */
for(i=0; i < TWM_ATOM_LAST_VALUE; i++) {
atom_cookie[i] = xcb_intern_atom_unchecked(conn, 0, strlen(a_atoms[i]), a_atoms[i]);
};
xcb_flush(conn);
xcb_intern_atom_reply_t *atom_reply;
for(i=0; i < TWM_ATOM_LAST_VALUE; i++) {
atom_reply = xcb_intern_atom_reply(conn, atom_cookie[i], 0),
atoms[i] = atom_reply->atom;
free(atom_reply);
};
xcb_change_property(conn, XCB_PROP_MODE_REPLACE, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM_WM_DELETE_WINDOW]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_DESKTOP]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_DOCK]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_TOOLBAR]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_MENU]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED] , XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_UTILITY]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_SPLASH]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_DIALOG]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_DROPDOWN_MENU]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_POPUP_MENU]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_TOOLTIP]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_NOTIFICATION]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_COMBO]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_DND]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_NORMAL]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ALLOWED_ACTIONS]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_MOVE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_RESIZE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_MINIMIZE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_SHADE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_STICK]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_MAXIMIZE_HORZ]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_MAXIMIZE_VERT]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_FULLSCREEN]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_CHANGE_DESKTOP]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_CLOSE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_ABOVE]);
xcb_change_property(conn, XCB_PROP_MODE_APPEND, scr->root, atoms[TWM_ATOM__NET_SUPPORTED], XCB_ATOM_ATOM, 32, 1, &atoms[TWM_ATOM__NET_WM_ACTION_BELOW]);
// This window contains the menu and the virtual keyboard (when showed)
// It is also used to ensure that the window manager is recognized as an Extended Window Manager Hints WM
// By default it occupies one pixel at the bottom of the screen, to allow to detect when the mouse is moved to the bottom
xcb_get_property_cookie_t kbd_info_cookie;
xcb_get_property_reply_t *kbd_info;
kbd_info_cookie = xcb_get_property(conn, 0, scr->root, atoms[TWM__XKB_RULES_NAMES], XCB_ATOM_STRING, 0, 1024);
key_win.window = xcb_generate_id(conn);
uint32_t values[1] = {XCB_EVENT_MASK_EXPOSURE|XCB_EVENT_MASK_BUTTON_RELEASE|XCB_EVENT_MASK_BUTTON_PRESS|XCB_EVENT_MASK_ENTER_WINDOW|XCB_EVENT_MASK_LEAVE_WINDOW};
void_cookie=xcb_create_window_checked (conn, XCB_COPY_FROM_PARENT, key_win.window, scr->root, 0, height-1, width, 1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, scr->root_visual, XCB_CW_EVENT_MASK, values);
xcb_flush(conn);
kbd_info = xcb_get_property_reply(conn, kbd_info_cookie, 0);
if (kbd_info!=NULL) {
if (kbd_info->length>0) {
char *p=((char *)(xcb_get_property_value(kbd_info)));
int counter=0;
int len, max;
max=xcb_get_property_value_length(kbd_info);
char *end=p+max;
do {
len = strnlen(p, max);
if (*p!=0) {
xkb_names[counter++] = strdup(p);
}
p+=len+1;
max-=len+1;
} while ((p < end) && (counter < 5));
}
free(kbd_info);
}
if (xcb_request_check(conn, void_cookie)) {
printf("Can't create the fake window\n");
} else {
menuwin_init();
}
shutdown_init();
}
