void initScreen() {
/* Open Xlib Display */
display = XOpenDisplay(0);
if (!display) printf("Can't open display");
default_screen = ((_XPrivDisplay)display)->default_screen;
/* Get the XCB connection from the display */
connection = XGetXCBConnection(display);
if (!connection) printf("Can't get xcb connection from display");
/* Acquire event queue ownership */
XSetEventQueueOwner(display, XCBOwnsEventQueue);
/* Find XCB screen */
screen = 0;
xcb_screen_iterator_t screen_iter =
xcb_setup_roots_iterator(xcb_get_setup(connection));
for (int screen_num = default_screen;
screen_iter.rem && screen_num > 0;
--screen_num, xcb_screen_next(&screen_iter));
screen = screen_iter.data;
/*
width = screen->width_in_pixels;
height = screen->height_in_pixels;
*/
width = 250;
height = 260;
}
/** Handle systray message.
* \param ev The event.
* \return 0 on no error.
*/
int
systray_process_client_message(xcb_client_message_event_t *ev)
{
int screen_nbr = 0, ret = 0;
xcb_get_geometry_cookie_t geom_c;
xcb_get_geometry_reply_t *geom_r;
xcb_screen_iterator_t iter;
switch(ev->data.data32[1])
{
case SYSTEM_TRAY_REQUEST_DOCK:
geom_c = xcb_get_geometry_unchecked(globalconf.connection, ev->window);
if(!(geom_r = xcb_get_geometry_reply(globalconf.connection, geom_c, NULL)))
return -1;
for(iter = xcb_setup_roots_iterator(xcb_get_setup(globalconf.connection)), screen_nbr = 0;
iter.rem && iter.data->root != geom_r->root; xcb_screen_next (&iter), ++screen_nbr);
p_delete(&geom_r);
ret = systray_request_handle(ev->data.data32[2], screen_nbr, NULL);
break;
}
return ret;
}
static int
_best_depth_get(int backend, void *connection, int screen)
{
if (!connection) return 0;
#ifdef BUILD_ENGINE_SOFTWARE_XLIB
if (backend == EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XLIB)
{
return DefaultDepth((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_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;
}
return s->root_depth;
}
#endif
return 0;
}
void SimplicityApplication::initialize_x_connection(void)
{
int nScreenNum = 0;
m_pXConnection = xcb_connect(m_sDisplayName.c_str(), &nScreenNum);
if (check_xcb_connection(m_pXConnection))
{
xcb_disconnect(m_pXConnection);
m_bRunning = false;
return;
}
xcb_screen_iterator_t iter = xcb_setup_roots_iterator(xcb_get_setup(m_pXConnection));
for (int i = 0; i != nScreenNum; i++)
xcb_screen_next(&iter);
m_pRootScreen = iter.data;
if (m_pRootScreen == nullptr)
{
global_log_error << "Could not get the current screen. Exiting";
xcb_disconnect(m_pXConnection);
m_bRunning = false;
}
global_log_debug << "Root screen dimensions: "
<< m_pRootScreen->width_in_pixels
<< "x"
<< m_pRootScreen->height_in_pixels;
global_log_debug << "Root window: "
<< m_pRootScreen->root;
}
static int
deploy(void)
{
/* init xcb and grab events */
uint32_t values[2];
int mask;
if (xcb_connection_has_error(conn = xcb_connect(NULL, NULL)))
return -1;
scr = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
focuswin = scr->root;
#ifdef ENABLE_MOUSE
xcb_grab_button(conn, 0, scr->root, XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_BUTTON_RELEASE, XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC, scr->root, XCB_NONE, 1, MOD);
xcb_grab_button(conn, 0, scr->root, XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_BUTTON_RELEASE, XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC, scr->root, XCB_NONE, 3, MOD);
#endif
mask = XCB_CW_EVENT_MASK;
values[0] = XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY;
xcb_change_window_attributes_checked(conn, scr->root, mask, values);
xcb_flush(conn);
return 0;
}
int main(int argc, char **argv){
xcb_connection_t *c = xcb_connect(0, 0);
xcb_screen_t *s = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
int w, h, n,
depth = s->root_depth,
win_class = XCB_WINDOW_CLASS_INPUT_OUTPUT,
format = XCB_IMAGE_FORMAT_Z_PIXMAP;
xcb_colormap_t colormap = s->default_colormap;
xcb_drawable_t win = xcb_generate_id(c);
xcb_gcontext_t gc = xcb_generate_id(c);
xcb_pixmap_t pixmap = xcb_generate_id(c);
xcb_generic_event_t *ev;
xcb_image_t *image;
char *data = NULL;
uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
value_mask = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS,
values[] = { s->black_pixel, value_mask };
if (argc<2) return -1;
data = stbi_load(argv[1], &w, &h, &n, 4);
if (data) {
unsigned *dp = (unsigned *)data;
size_t i, len = w*h;
for(i=0;i<len;i++) //rgba to bgra
dp[i]=dp[i]&0xff00ff00|((dp[i]>>16)&0xFF)|((dp[i]<<16)&0xFF0000);
}else return -1;
void QXcbCursor::queryPointer(QXcbConnection *c, xcb_window_t *rootWin, QPoint *pos, int *keybMask)
{
if (pos)
*pos = QPoint();
xcb_screen_iterator_t it = xcb_setup_roots_iterator(c->setup());
while (it.rem) {
xcb_window_t root = it.data->root;
xcb_query_pointer_cookie_t cookie = xcb_query_pointer(c->xcb_connection(), root);
xcb_generic_error_t *err = 0;
xcb_query_pointer_reply_t *reply = xcb_query_pointer_reply(c->xcb_connection(), cookie, &err);
if (!err && reply) {
if (pos)
*pos = QPoint(reply->root_x, reply->root_y);
if (rootWin)
*rootWin = root;
if (keybMask)
*keybMask = reply->mask;
free(reply);
return;
}
free(err);
free(reply);
xcb_screen_next(&it);
}
}
int main()
{
/* Open the connection to the X server */
xcb_connection_t *connection = xcb_connect(NULL, NULL);
/* Get the first screen */
const xcb_setup_t *setup = xcb_get_setup(connection);
xcb_screen_iterator_t iter = xcb_setup_roots_iterator(setup);
xcb_screen_t *screen = iter.data;
/* Create the window */
xcb_window_t window = xcb_generate_id(connection);
xcb_create_window(connection, /* Connection */
XCB_COPY_FROM_PARENT, /* depth (same as root) */
window, /* window Id */
screen->root, /* parent window */
0, 0, /* x, y */
150, 150, /* width, height */
10, /* border_width */
XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */
screen->root_visual, /* visual */
0, NULL); /* masks, not used yet */
/* Map the window on the screen */
xcb_map_window(connection, window);
/* Make sure commands are sent before we pause so that the window gets shown */
xcb_flush(connection);
pause(); /* hold client until Ctrl-C */
xcb_disconnect(connection);
return 0;
}
int vkDisplay::init(const unsigned int gpu_idx)
{
//m_gpuIdx = gpu_idx;
#if 0
VkResult result = init_vk(gpu_idx);
if (result != VK_SUCCESS) {
vktrace_LogError("could not init vulkan library");
return -1;
} else {
m_initedVK = true;
}
#endif
#if defined(PLATFORM_LINUX)
const xcb_setup_t *setup;
xcb_screen_iterator_t iter;
int scr;
m_pXcbConnection = xcb_connect(NULL, &scr);
setup = xcb_get_setup(m_pXcbConnection);
iter = xcb_setup_roots_iterator(setup);
while (scr-- > 0)
xcb_screen_next(&iter);
m_pXcbScreen = iter.data;
#endif
return 0;
}
static int
has_required_depths (xcb_connection_t *c)
{
xcb_screen_iterator_t screens;
xcb_pixmap_t pixmap = { -1 };
for (screens = xcb_setup_roots_iterator(xcb_get_setup(c)); screens.rem; xcb_screen_next(&screens))
{
xcb_depth_iterator_t depths;
uint32_t missing = REQUIRED_DEPTHS;
xcb_drawable_t root;
for (depths = xcb_screen_allowed_depths_iterator(screens.data); depths.rem; xcb_depth_next(&depths))
missing &= ~DEPTH_MASK(depths.data->depth);
if (!missing)
continue;
/*
* Ok, this is ugly. It should be sufficient at this
* point to just return false, but Xinerama is broken at
* this point and only advertises depths which have an
* associated visual. Of course, the other depths still
* work, but the only way to find out is to try them.
*/
if (pixmap == -1)
pixmap = xcb_generate_id(c);
root = screens.data->root;
if (!pixmap_depths_usable (c, missing, pixmap, root))
return 0;
}
return 1;
}
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;
}
void init(void)
{
int scrno;
xcb_screen_iterator_t iter;
conn = xcb_connect(NULL, &scrno);
if (!conn)
{
fprintf(stderr, "can't connect to an X server\n");
exit(1);
}
iter = xcb_setup_roots_iterator(xcb_get_setup(conn));
for (int i = 0; i < scrno; ++i)
{
xcb_screen_next(&iter);
}
screen = iter.data;
if (!screen)
{
fprintf(stderr, "can't get the current screen\n");
xcb_disconnect(conn);
exit(1);
}
}
xcb_screen_t* IdlenessWatcher::screenOfDisplay(xcb_connection_t* conn, int screen)
{
xcb_screen_iterator_t iter = xcb_setup_roots_iterator(xcb_get_setup(conn));
for (; iter.rem; --screen, xcb_screen_next(&iter))
if (screen == 0)
return iter.data;
return NULL;
}
static xcb_window_t xconn_get_root(xconn_t c)
{
const xcb_setup_t *setup;
setup=xcb_get_setup(c->c);
xcb_screen_iterator_t iter = xcb_setup_roots_iterator (setup);
xcb_screen_t *screen = iter.data;
return screen->root;
}
bool X11IdleDetector::idleCheckPossible()
{
m_connection = xcb_connect(NULL, NULL); //krazy:exclude=null
m_screen = xcb_setup_roots_iterator(xcb_get_setup(m_connection)).data;
if (m_screen)
return true;
return false;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys;
p_intf->p_sys = p_sys = calloc( 1, sizeof(*p_sys) );
if( !p_sys )
return VLC_ENOMEM;
char *psz_display = var_CreateGetNonEmptyString( p_intf, "x11-display" );
int i_screen_default;
p_sys->p_connection = xcb_connect( psz_display, &i_screen_default );
free( psz_display );
if( !p_sys->p_connection )
goto error;
/* Get the root windows of the default screen */
const xcb_setup_t* xcbsetup = xcb_get_setup( p_sys->p_connection );
if( !xcbsetup )
goto error;
xcb_screen_iterator_t iter = xcb_setup_roots_iterator( xcbsetup );
for( int i = 0; i < i_screen_default; i++ )
{
if( !iter.rem )
break;
xcb_screen_next( &iter );
}
if( !iter.rem )
goto error;
p_sys->root = iter.data->root;
/* */
p_sys->p_symbols = xcb_key_symbols_alloc( p_sys->p_connection ); // FIXME
if( !p_sys->p_symbols )
goto error;
Mapping( p_intf );
Register( p_intf );
if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) )
{
Unregister( p_intf );
free( p_sys->p_map );
goto error;
}
return VLC_SUCCESS;
error:
if( p_sys->p_symbols )
xcb_key_symbols_free( p_sys->p_symbols );
if( p_sys->p_connection )
xcb_disconnect( p_sys->p_connection );
free( p_sys );
return VLC_EGENERIC;
}
cairo_surface_t *
_cairo_boilerplate_xcb_create_surface (const char *name,
cairo_content_t content,
int width,
int height,
int max_width,
int max_height,
cairo_boilerplate_mode_t mode,
int id,
void **closure)
{
xcb_screen_t *root;
xcb_target_closure_t *xtc;
xcb_connection_t *c;
xcb_render_pictforminfo_t *render_format;
xcb_pict_standard_t format;
*closure = xtc = xmalloc (sizeof (xcb_target_closure_t));
if (width == 0)
width = 1;
if (height == 0)
height = 1;
xtc->c = c = xcb_connect(NULL,NULL);
if (xcb_connection_has_error(c)) {
fprintf (stderr, "Failed to connect to X server through XCB\n");
return NULL;
}
root = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
xtc->pixmap = xcb_generate_id (c);
xcb_create_pixmap (c, 32, xtc->pixmap, root->root,
width, height);
switch (content) {
case CAIRO_CONTENT_COLOR:
format = XCB_PICT_STANDARD_RGB_24;
break;
case CAIRO_CONTENT_COLOR_ALPHA:
format = XCB_PICT_STANDARD_ARGB_32;
break;
case CAIRO_CONTENT_ALPHA: /* would be XCB_PICT_STANDARD_A_8 */
default:
fprintf (stderr, "Invalid content for XCB test: %d\n", content);
return NULL;
}
render_format = xcb_render_util_find_standard_format (xcb_render_util_query_formats (c), format);
if (render_format->id == 0)
return NULL;
return cairo_xcb_surface_create_with_xrender_format (c, xtc->pixmap, root,
render_format,
width, height);
}
int iterate_screens(int, char **)
{
xcb_connection_t *conn = xcb_connect(0, 0);
xcb_screen_iterator_t i = xcb_setup_roots_iterator(xcb_get_setup(conn));
std::vector<xcb_screen_t> screens;
std::copy(i, xcb::end(i), std::back_inserter(screens));
assert(screens.size() == xcb_setup_roots_length(xcb_get_setup(conn)));
return EXIT_SUCCESS;
}
static leaf_error_t leaf_init()
{
int first_screen = 0;
xcb_screen_iterator_t iter;
struct sigaction action;
uint32_t values;
xcb_void_cookie_t cookie;
xcb_generic_error_t *status = NULL;
gconf.running = false;
action.sa_handler = stop_signal_handler;
action.sa_flags = 0;
sigemptyset(&action.sa_mask);
/* Catch signals */
/*
* TODO: Catch sighup
*/
sigaction(SIGINT, &action, NULL);
sigaction(SIGTERM, &action, NULL);
/* Initialize connection to the X server */
gconf.conn = xcb_connect(NULL, &first_screen);
if (xcb_connection_has_error(gconf.conn)) {
print_e("Cannot initialize connection to the X server");
return ERR_CONN;
}
print_d("First screen = %i", first_screen);
/* Get back X data */
gconf.xsetup = xcb_get_setup(gconf.conn);
/* Find the first screen */
iter = xcb_setup_roots_iterator(gconf.xsetup);
while (first_screen--)
xcb_screen_next(&iter);
gconf.screen = iter.data;
/* Configure the root screen to get window's events */
values = \
XCB_EVENT_MASK_STRUCTURE_NOTIFY |
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY;
cookie = xcb_change_window_attributes_checked(gconf.conn,
gconf.screen->root,
XCB_CW_EVENT_MASK,
&values);
status = xcb_request_check(gconf.conn, cookie);
xcb_flush(gconf.conn);
if (status)
{
print_d("X is busy, another window manager may be running (%d)",
status->error_code);
free(status);
return ERR_CONN;
}
return ERR_NONE;
}
xcb_screen_t *defaultScreen(xcb_connection_t *c, int screen)
{
for (auto it = xcb_setup_roots_iterator(xcb_get_setup(c)); it.rem; --screen, xcb_screen_next(&it)) {
if (screen == 0) {
return it.data;
}
}
return nullptr;
}
xcb_screen_t *
xcb_aux_get_screen (xcb_connection_t *c,
int screen)
{
xcb_screen_iterator_t i = xcb_setup_roots_iterator(xcb_get_setup(c));
for (; i.rem; --screen, xcb_screen_next(&i))
if (screen == 0)
return i.data;
return 0;
}
Watcher::Watcher() : QTimer()
{
connection = xcb_connect (NULL, NULL);
screen = xcb_setup_roots_iterator (xcb_get_setup (connection)).data;
xcb_dpms_disable (connection);
connect(this, SIGNAL(timeout()), this, SLOT(onTimeout()));
setInterval(1000);
start();
}
int
main ()
{
xcb_connection_t* connection;
xcb_screen_t* screen;
xcb_window_t root_window;
xcb_alloc_color_reply_t *color_reply;
xcb_colormap_t colormap = { 0 };
uint32_t params[1];
uint16_t r,g,b;
connection = xcb_connect(NULL, NULL);
if (!connection) {
fprintf(stderr, "ERROR: can't connect to an X server\n");
return -1;
}
screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data;
if (!screen)
{
fprintf(stderr, "ERROR: can't setup a screen\n");
xcb_disconnect(connection);
return -1;
}
root_window = screen->root;
colormap = screen->default_colormap;
r = 60000, g = 20000, b = 20000;
color_reply = xcb_alloc_color_reply(connection,
xcb_alloc_color(connection, colormap, r, g, b), NULL);
if(!color_reply)
{
fprintf(stderr, "ERROR: can't alloc an color\n");
xcb_disconnect(connection);
return 0;
}
params[0] = color_reply->pixel;
// sets the root_window back_pixel to pixel(params)
xcb_change_window_attributes(connection, root_window, XCB_CW_BACK_PIXEL, params);
// free color resources
free(color_reply);
// waits all things are send??
xcb_flush(connection);
// xcb_destroy_window(connection, window);
xcb_disconnect(connection);
return 0;
}
QXcbConnection::QXcbConnection(const char *displayName)
: m_displayName(displayName ? QByteArray(displayName) : qgetenv("DISPLAY"))
#ifdef XCB_USE_DRI2
, m_dri2_major(0)
, m_dri2_minor(0)
, m_dri2_support_probed(false)
, m_has_support_for_dri2(false)
#endif
{
int primaryScreen = 0;
#ifdef XCB_USE_XLIB
Display *dpy = XOpenDisplay(m_displayName.constData());
primaryScreen = DefaultScreen(dpy);
m_connection = XGetXCBConnection(dpy);
XSetEventQueueOwner(dpy, XCBOwnsEventQueue);
m_xlib_display = dpy;
#ifdef XCB_USE_EGL
EGLDisplay eglDisplay = eglGetDisplay(dpy);
m_egl_display = eglDisplay;
EGLint major, minor;
eglBindAPI(EGL_OPENGL_ES_API);
m_has_egl = eglInitialize(eglDisplay,&major,&minor);
#endif //XCB_USE_EGL
#else
m_connection = xcb_connect(m_displayName.constData(), &primaryScreen);
#endif //XCB_USE_XLIB
m_setup = xcb_get_setup(xcb_connection());
initializeAllAtoms();
xcb_screen_iterator_t it = xcb_setup_roots_iterator(m_setup);
int screenNumber = 0;
while (it.rem) {
m_screens << new QXcbScreen(this, it.data, screenNumber++);
xcb_screen_next(&it);
}
m_keyboard = new QXcbKeyboard(this);
#ifdef XCB_USE_DRI2
initializeDri2();
#endif
QSocketNotifier *notifier = new QSocketNotifier(xcb_get_file_descriptor(xcb_connection()), QSocketNotifier::Read, this);
connect(notifier, SIGNAL(activated(int)), this, SLOT(processXcbEvents()));
QAbstractEventDispatcher *dispatcher = QAbstractEventDispatcher::instance(qApp->thread());
connect(dispatcher, SIGNAL(aboutToBlock()), this, SLOT(processXcbEvents()));
sync();
}
static void
pipe_loader_drm_x_auth(int fd)
{
#ifdef HAVE_PIPE_LOADER_XCB
/* Try authenticate with the X server to give us access to devices that X
* is running on. */
xcb_connection_t *xcb_conn;
const xcb_setup_t *xcb_setup;
xcb_screen_iterator_t s;
xcb_dri2_connect_cookie_t connect_cookie;
xcb_dri2_connect_reply_t *connect;
drm_magic_t magic;
xcb_dri2_authenticate_cookie_t authenticate_cookie;
xcb_dri2_authenticate_reply_t *authenticate;
int screen;
xcb_conn = xcb_connect(NULL, &screen);
if(!xcb_conn)
return;
xcb_setup = xcb_get_setup(xcb_conn);
if (!xcb_setup)
goto disconnect;
s = xcb_setup_roots_iterator(xcb_setup);
connect_cookie = xcb_dri2_connect_unchecked(xcb_conn,
get_xcb_screen(s, screen)->root,
XCB_DRI2_DRIVER_TYPE_DRI);
connect = xcb_dri2_connect_reply(xcb_conn, connect_cookie, NULL);
if (!connect || connect->driver_name_length
+ connect->device_name_length == 0) {
goto disconnect;
}
if (drmGetMagic(fd, &magic))
goto disconnect;
authenticate_cookie = xcb_dri2_authenticate_unchecked(xcb_conn,
s.data->root,
magic);
authenticate = xcb_dri2_authenticate_reply(xcb_conn,
authenticate_cookie,
NULL);
FREE(authenticate);
disconnect:
xcb_disconnect(xcb_conn);
#endif
}
xcb_screen_t *
screen_of_display(int screen)
{
xcb_screen_iterator_t iter;
iter = xcb_setup_roots_iterator(xcb_get_setup(m_c.get()));
for (; iter.rem; --screen, xcb_screen_next(&iter))
if (screen == 0)
return iter.data;
return NULL;
}
int
get_screen(xcb_connection_t *con, xcb_screen_t **scr)
{
*scr = xcb_setup_roots_iterator(xcb_get_setup(con)).data;
if (*scr == NULL) {
perror("unable to retrieve screen information");
return -1;
}
return 0;
}
static xcb_screen_t *
find_xcb_screen(xcb_connection_t *c, int default_screen)
{
xcb_screen_iterator_t screen_iter;
int screen_num;
screen_iter = xcb_setup_roots_iterator(xcb_get_setup(c));
for (screen_num = default_screen; screen_iter.rem && screen_num > 0;
--screen_num, xcb_screen_next(&screen_iter));
return screen_iter.data;
}
static EGLBoolean
dri2_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
_EGLDisplay *disp)
{
xcb_screen_iterator_t s;
xcb_depth_iterator_t d;
xcb_visualtype_t *visuals;
int i, j, id;
EGLint surface_type;
EGLint config_attrs[] = {
EGL_NATIVE_VISUAL_ID, 0,
EGL_NATIVE_VISUAL_TYPE, 0,
EGL_NONE
};
s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
d = xcb_screen_allowed_depths_iterator(s.data);
id = 1;
surface_type =
EGL_WINDOW_BIT |
EGL_PIXMAP_BIT |
EGL_PBUFFER_BIT |
EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
while (d.rem > 0) {
EGLBoolean class_added[6] = { 0, };
visuals = xcb_depth_visuals(d.data);
for (i = 0; i < xcb_depth_visuals_length(d.data); i++) {
if (class_added[visuals[i]._class])
continue;
class_added[visuals[i]._class] = EGL_TRUE;
for (j = 0; dri2_dpy->driver_configs[j]; j++) {
config_attrs[1] = visuals[i].visual_id;
config_attrs[3] = visuals[i]._class;
dri2_add_config(disp, dri2_dpy->driver_configs[j], id++,
d.data->depth, surface_type, config_attrs, NULL);
}
}
xcb_depth_next(&d);
}
if (!_eglGetArraySize(disp->Configs)) {
_eglLog(_EGL_WARNING, "DRI2: failed to create any config");
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLNativeWindowType QEglFSX11Hooks::createNativeWindow(QPlatformWindow *platformWindow,
const QSize &size,
const QSurfaceFormat &format)
{
Q_UNUSED(format);
m_platformWindow = platformWindow;
xcb_screen_iterator_t it = xcb_setup_roots_iterator(xcb_get_setup(m_connection));
m_window = xcb_generate_id(m_connection);
xcb_create_window(m_connection, XCB_COPY_FROM_PARENT, m_window, it.data->root,
0, 0, size.width(), size.height(), 0,
XCB_WINDOW_CLASS_INPUT_OUTPUT, it.data->root_visual,
0, 0);
xcb_map_window(m_connection, m_window);
xcb_intern_atom_cookie_t cookies[Atoms::N_ATOMS];
static const char *atomNames[Atoms::N_ATOMS] = {
"_NET_WM_NAME",
"UTF8_STRING",
"WM_PROTOCOLS",
"WM_DELETE_WINDOW",
"_NET_WM_STATE",
"_NET_WM_STATE_FULLSCREEN"
};
for (int i = 0; i < Atoms::N_ATOMS; ++i) {
cookies[i] = xcb_intern_atom(m_connection, false, strlen(atomNames[i]), atomNames[i]);
xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(m_connection, cookies[i], 0);
m_atoms[i] = reply->atom;
free(reply);
}
// Set window title
xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_window,
m_atoms[Atoms::_NET_WM_NAME], m_atoms[Atoms::UTF8_STRING], 8, 5, "EGLFS");
// Enable WM_DELETE_WINDOW
xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_window,
m_atoms[Atoms::WM_PROTOCOLS], XCB_ATOM_ATOM, 32, 1, &m_atoms[Atoms::WM_DELETE_WINDOW]);
if (qgetenv("EGLFS_X11_FULLSCREEN").toInt()) {
// Go fullscreen. The QScreen and QWindow size is controlled by EGLFS_X11_SIZE regardless,
// this is just the native window.
xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, m_window,
m_atoms[Atoms::_NET_WM_STATE], XCB_ATOM_ATOM, 32, 1, &m_atoms[Atoms::_NET_WM_STATE_FULLSCREEN]);
}
xcb_flush(m_connection);
return m_window;
}
