自学教程：C++ xcb_create_window函数代码示例

static void_e_alert_create(void){   uint32_t mask, mask_list[4];   int wx = 0, wy = 0;   wx = ((sw - WINDOW_WIDTH) / 2);   wy = ((sh - WINDOW_HEIGHT) / 2);   font = xcb_generate_id(conn);   xcb_open_font(conn, font, strlen("fixed"), "fixed");   /* create main window */   mask = (XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL |           XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK);   mask_list[0] = screen->white_pixel;   mask_list[1] = screen->black_pixel;   mask_list[2] = 1;   mask_list[3] = (XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |                   XCB_EVENT_MASK_EXPOSURE);   win = xcb_generate_id(conn);   xcb_create_window(conn, XCB_COPY_FROM_PARENT, win, screen->root,                     wx, wy, WINDOW_WIDTH, WINDOW_HEIGHT, 0,                     XCB_WINDOW_CLASS_INPUT_OUTPUT,                     XCB_COPY_FROM_PARENT, mask, mask_list);   /* create button 1 */   mask_list[3] = (XCB_EVENT_MASK_BUTTON_PRESS |                   XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_EXPOSURE);   btn1 = xcb_generate_id(conn);   xcb_create_window(conn, XCB_COPY_FROM_PARENT, btn1, win,                     -100, -100, 1, 1, 0,                     XCB_WINDOW_CLASS_INPUT_OUTPUT,                     XCB_COPY_FROM_PARENT, mask, mask_list);   xcb_map_window(conn, btn1);   /* create button 2 */   btn2 = xcb_generate_id(conn);   xcb_create_window(conn, XCB_COPY_FROM_PARENT, btn2, win,                     -100, -100, 1, 1, 0,                     XCB_WINDOW_CLASS_INPUT_OUTPUT,                     XCB_COPY_FROM_PARENT, mask, mask_list);   xcb_map_window(conn, btn2);   /* create drawing gc */   mask = (XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT);   mask_list[0] = screen->black_pixel;   mask_list[1] = screen->white_pixel;   mask_list[2] = font;   gc = xcb_generate_id(conn);   xcb_create_gc(conn, gc, win, mask, mask_list);}

/** Initialize systray information in X. */voidsystray_init(void){    xcb_intern_atom_cookie_t atom_systray_q;    xcb_intern_atom_reply_t *atom_systray_r;    char *atom_name;    xcb_screen_t *xscreen = globalconf.screen;    globalconf.systray.window = xcb_generate_id(globalconf.connection);    xcb_create_window(globalconf.connection, xscreen->root_depth,                      globalconf.systray.window,                      xscreen->root,                      -1, -1, 1, 1, 0,                      XCB_COPY_FROM_PARENT, xscreen->root_visual,                      0, NULL);    atom_name = xcb_atom_name_by_screen("_NET_SYSTEM_TRAY", globalconf.default_screen);    if(!atom_name)        fatal("error getting systray atom name");    atom_systray_q = xcb_intern_atom_unchecked(globalconf.connection, false,                                               a_strlen(atom_name), atom_name);    p_delete(&atom_name);    atom_systray_r = xcb_intern_atom_reply(globalconf.connection, atom_systray_q, NULL);    if(!atom_systray_r)        fatal("error getting systray atom");    globalconf.systray.atom = atom_systray_r->atom;    p_delete(&atom_systray_r);}

void update_root(monitor_t *m, xcb_rectangle_t *rect){	xcb_rectangle_t last_rect = m->rectangle;	m->rectangle = *rect;	if (m->root == XCB_NONE) {		uint32_t values[] = {XCB_EVENT_MASK_ENTER_WINDOW};		m->root = xcb_generate_id(dpy);		xcb_create_window(dpy, XCB_COPY_FROM_PARENT, m->root, root,		                  rect->x, rect->y, rect->width, rect->height, 0,		                  XCB_WINDOW_CLASS_INPUT_ONLY, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);		xcb_icccm_set_wm_class(dpy, m->root, sizeof(ROOT_WINDOW_IC), ROOT_WINDOW_IC);		window_lower(m->root);		if (focus_follows_pointer) {			window_show(m->root);		}	} else {		window_move_resize(m->root, rect->x, rect->y, rect->width, rect->height);		put_status(SBSC_MASK_MONITOR_GEOMETRY, "monitor_geometry 0x%08X %ux%u+%i+%i/n",		           m->id, rect->width, rect->height, rect->x, rect->y);	}	for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {		for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {			if (n->client == NULL) {				continue;			}			adapt_geometry(&last_rect, rect, n);		}		arrange(m, d);	}}

int main(void){  xcb_connection_t    *conn;  xcb_screen_t        *screen;  xcb_window_t         win;  xcb_gcontext_t       gcontext;  xcb_generic_event_t *event;  uint32_t             mask;  uint32_t             values[2];                          /* open connection with the server */  conn = xcb_connect(NULL,NULL);  if (xcb_connection_has_error(conn)) {    printf("Cannot open display/n");    exit(1);  }                        /* get the first screen */  screen = xcb_setup_roots_iterator( xcb_get_setup(conn) ).data;                        /* create black graphics gcontext */  gcontext = xcb_generate_id(conn);  win = screen->root;  mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;  values[0] = screen->black_pixel;  values[1] = 0;  xcb_create_gc(conn, gcontext, win, mask, values);                        /* create window */  win = xcb_generate_id(conn);  mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;  values[0] = screen->white_pixel;  values[1] = XCB_EVENT_MASK_EXPOSURE               | XCB_EVENT_MASK_KEY_PRESS              | XCB_EVENT_MASK_KEY_RELEASE;  xcb_create_window(conn, screen->root_depth, win, screen->root,                    10, 10, 100, 100, 1,                    XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual,                    mask, values);                         /* map (show) the window */  xcb_map_window(conn, win);   xcb_flush(conn);  cterm_add_event_listener(XCB_KEY_PRESS, output_string);  cterm_add_event_listener(XCB_KEY_PRESS, close_window);                         /* event loop */  while (!done) {    event = xcb_poll_for_event(conn);    if(event == NULL) continue;    cterm_handle_event(event);    free(event);  }                        /* close connection to server */  xcb_disconnect(conn);  cterm_free_event_handlers();  return 0;}

void X11WindowedBackend::createWindow(){    Xcb::Atom protocolsAtom(QByteArrayLiteral("WM_PROTOCOLS"), false, m_connection);    Xcb::Atom deleteWindowAtom(QByteArrayLiteral("WM_DELETE_WINDOW"), false, m_connection);    for (int i = 0; i < initialOutputCount(); ++i) {        Output o;        o.window = xcb_generate_id(m_connection);        uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;        const uint32_t values[] = {            m_screen->black_pixel,            XCB_EVENT_MASK_KEY_PRESS |            XCB_EVENT_MASK_KEY_RELEASE |            XCB_EVENT_MASK_BUTTON_PRESS |            XCB_EVENT_MASK_BUTTON_RELEASE |            XCB_EVENT_MASK_POINTER_MOTION |            XCB_EVENT_MASK_ENTER_WINDOW |            XCB_EVENT_MASK_LEAVE_WINDOW |            XCB_EVENT_MASK_STRUCTURE_NOTIFY |            XCB_EVENT_MASK_EXPOSURE        };        o.size = initialWindowSize();        if (!m_windows.isEmpty()) {            const auto &p = m_windows.last();            o.internalPosition = QPoint(p.internalPosition.x() + p.size.width(), 0);        }        xcb_create_window(m_connection, XCB_COPY_FROM_PARENT, o.window, m_screen->root,                        0, 0, o.size.width(), o.size.height(),                        0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, mask, values);        o.winInfo = new NETWinInfo(m_connection, o.window, m_screen->root, NET::WMWindowType, NET::Properties2());        o.winInfo->setWindowType(NET::Normal);        o.winInfo->setPid(QCoreApplication::applicationPid());        QIcon windowIcon = QIcon::fromTheme(QStringLiteral("kwin"));        auto addIcon = [&o, &windowIcon] (const QSize &size) {            if (windowIcon.actualSize(size) != size) {                return;            }            NETIcon icon;            icon.data = windowIcon.pixmap(size).toImage().bits();            icon.size.width = size.width();            icon.size.height = size.height();            o.winInfo->setIcon(icon, false);        };        addIcon(QSize(16, 16));        addIcon(QSize(32, 32));        addIcon(QSize(48, 48));        xcb_map_window(m_connection, o.window);        m_protocols = protocolsAtom;        m_deleteWindowProtocol = deleteWindowAtom;        xcb_change_property(m_connection, XCB_PROP_MODE_REPLACE, o.window, m_protocols, XCB_ATOM_ATOM, 32, 1, &m_deleteWindowProtocol);        m_windows << o;    }    updateWindowTitle();    xcb_flush(m_connection);}

static voidweston_dnd_start(struct weston_wm *wm, xcb_window_t owner){	uint32_t values[1], version = 4;	wm->dnd_window = xcb_generate_id(wm->conn);	values[0] =		XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |		XCB_EVENT_MASK_PROPERTY_CHANGE;	xcb_create_window(wm->conn,			  XCB_COPY_FROM_PARENT,			  wm->dnd_window,			  wm->screen->root,			  0, 0,			  8192, 8192,			  0,			  XCB_WINDOW_CLASS_INPUT_ONLY,			  wm->screen->root_visual,			  XCB_CW_EVENT_MASK, values);	xcb_change_property(wm->conn,			    XCB_PROP_MODE_REPLACE,			    wm->dnd_window,			    wm->atom.xdnd_aware,			    XCB_ATOM_ATOM,			    32, /* format */			    1, &version);	xcb_map_window(wm->conn, wm->dnd_window);	wm->dnd_owner = owner;}

xcb_window_t create_window() {  // http://www.x.org/releases/current/doc/xproto/x11protocol.html#requests:CreateWindow  // http://www.x.org/archive/current/doc/man/man3/xcb_create_window.3.xhtml  //  // N.B. xcb's order corresponds to the order of the wire.  // You can look at the protocol encoding: http://www.x.org/releases/current/doc/xproto/x11protocol.html#Encoding::Requests    uint32_t mask;  uint32_t values[2];    xcb_window_t window;  xcb_void_cookie_t cookie;    mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;  values[0] = screen->white_pixel;  values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;    window = xcb_generate_id(connection);  cookie = xcb_create_window(connection,			     XCB_COPY_FROM_PARENT, window, screen->root,			     0, 0, 640, 480,			     0,			     XCB_WINDOW_CLASS_INPUT_OUTPUT,			     screen->root_visual,			     mask, values);    xcb_map_window(connection, window);    return window;}

void XWaylandManager::wmSelection(){    m_selRequest.requestor = XCB_NONE;    quint32 values[1];    values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE;    m_selWindow = xcb_generate_id(Xcb::connection());    xcb_create_window(Xcb::connection(), XCB_COPY_FROM_PARENT,                      m_selWindow, Xcb::rootWindow(),                      0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,                      Xcb::rootVisual(),                      XCB_CW_EVENT_MASK, values);    xcb_set_selection_owner(Xcb::connection(), m_selWindow,                            Xcb::resources()->atoms->clipboard_manager,                            XCB_TIME_CURRENT_TIME);    quint32 mask =        XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |        XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |        XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;    xcb_xfixes_select_selection_input(Xcb::connection(),                                      m_selWindow,                                      Xcb::resources()->atoms->clipboard,                                      mask);    //weston_wm_set_selection}

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;}

Client *Client::create(const Rect& rect, int screenNumber, const String &clazz, const String &instance, bool movable){    WindowManager *wm = WindowManager::instance();    xcb_connection_t* conn = wm->connection();    xcb_screen_t* scr = wm->screens().at(screenNumber);    xcb_window_t window = xcb_generate_id(conn);    const uint32_t values[] = {        scr->black_pixel,        XCB_GRAVITY_NORTH_WEST,        XCB_GRAVITY_NORTH_WEST,        1,        (XCB_EVENT_MASK_STRUCTURE_NOTIFY         | XCB_EVENT_MASK_ENTER_WINDOW         | XCB_EVENT_MASK_LEAVE_WINDOW         | XCB_EVENT_MASK_EXPOSURE         | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT         | XCB_EVENT_MASK_POINTER_MOTION         | XCB_EVENT_MASK_BUTTON_PRESS         | XCB_EVENT_MASK_BUTTON_RELEASE)    };    warning() << "creating client window" << rect;    xcb_create_window(conn, XCB_COPY_FROM_PARENT, window, scr->root,                      rect.x, rect.y, rect.width, rect.height, 0,                      XCB_COPY_FROM_PARENT, XCB_COPY_FROM_PARENT,                      XCB_CW_BORDER_PIXEL | XCB_CW_BIT_GRAVITY | XCB_CW_WIN_GRAVITY                      | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK, values);    xcb_icccm_wm_hints_t wmHints;    xcb_icccm_wm_hints_set_none(&wmHints);    xcb_icccm_wm_hints_set_input(&wmHints, 0);    xcb_icccm_set_wm_hints(conn, window, &wmHints);    xcb_size_hints_t wmNormalHints;    memset(&wmNormalHints, 0, sizeof(wmNormalHints));    xcb_icccm_size_hints_set_position(&wmNormalHints, 1, rect.x, rect.y);    xcb_icccm_size_hints_set_size(&wmNormalHints, 1, rect.width, rect.height);    xcb_icccm_set_wm_normal_hints(conn, window, &wmNormalHints);    String className = clazz + ' ' + instance;    className[clazz.size()] = '/0';    xcb_icccm_set_wm_class(conn, window, className.size(), className.constData());    Client *ptr = new Client(window);    ptr->mMovable = movable;    ptr->mRect = rect;    ptr->mOwned = true;    ptr->mScreenNumber = screenNumber;    ptr->init();    ptr->mNoFocus = true;    Workspace *ws = wm->activeWorkspace(screenNumber);    assert(ws);    ptr->mWorkspace = ws;    ws->addClient(ptr);    wm->js().onClient(ptr);    ptr->complete();    sClients[window] = ptr;    return ptr;}

void ShellXcb::create_window() {    win_ = xcb_generate_id(c_);    uint32_t value_mask, value_list[32];    value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;    value_list[0] = scr_->black_pixel;    value_list[1] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_STRUCTURE_NOTIFY;    xcb_create_window(c_, XCB_COPY_FROM_PARENT, win_, scr_->root, 0, 0, settings_.initial_width, settings_.initial_height, 0,                      XCB_WINDOW_CLASS_INPUT_OUTPUT, scr_->root_visual, value_mask, value_list);    xcb_intern_atom_cookie_t utf8_string_cookie = intern_atom_cookie(c_, "UTF8_STRING");    xcb_intern_atom_cookie_t _net_wm_name_cookie = intern_atom_cookie(c_, "_NET_WM_NAME");    xcb_intern_atom_cookie_t wm_protocols_cookie = intern_atom_cookie(c_, "WM_PROTOCOLS");    xcb_intern_atom_cookie_t wm_delete_window_cookie = intern_atom_cookie(c_, "WM_DELETE_WINDOW");    // set title    xcb_atom_t utf8_string = intern_atom(c_, utf8_string_cookie);    xcb_atom_t _net_wm_name = intern_atom(c_, _net_wm_name_cookie);    xcb_change_property(c_, XCB_PROP_MODE_REPLACE, win_, _net_wm_name, utf8_string, 8, settings_.name.size(),                        settings_.name.c_str());    // advertise WM_DELETE_WINDOW    wm_protocols_ = intern_atom(c_, wm_protocols_cookie);    wm_delete_window_ = intern_atom(c_, wm_delete_window_cookie);    xcb_change_property(c_, XCB_PROP_MODE_REPLACE, win_, wm_protocols_, XCB_ATOM_ATOM, 32, 1, &wm_delete_window_);}

xcb_window_t open_fullscreen_window(xcb_connection_t *conn, xcb_screen_t *scr, char *color, xcb_pixmap_t pixmap) {    uint32_t mask = 0;    uint32_t values[3];    xcb_window_t win = xcb_generate_id(conn);    if (pixmap == XCB_NONE) {        mask |= XCB_CW_BACK_PIXEL;        values[0] = get_colorpixel(color);    } else {        mask |= XCB_CW_BACK_PIXMAP;        values[0] = pixmap;    }    mask |= XCB_CW_OVERRIDE_REDIRECT;    values[1] = 1;    mask |= XCB_CW_EVENT_MASK;    values[2] = XCB_EVENT_MASK_EXPOSURE |                XCB_EVENT_MASK_KEY_PRESS |                XCB_EVENT_MASK_KEY_RELEASE |                XCB_EVENT_MASK_VISIBILITY_CHANGE |                XCB_EVENT_MASK_STRUCTURE_NOTIFY;    xcb_create_window(conn,                      XCB_COPY_FROM_PARENT,                      win,       /* the window id */                      scr->root, /* parent == root */                      0, 0,                      scr->width_in_pixels,                      scr->height_in_pixels, /* dimensions */                      0,                     /* border = 0, we draw our own */                      XCB_WINDOW_CLASS_INPUT_OUTPUT,                      XCB_WINDOW_CLASS_COPY_FROM_PARENT, /* copy visual from parent */                      mask,                      values);    char *name = "i3lock";    xcb_change_property(conn,                        XCB_PROP_MODE_REPLACE,                        win,                        XCB_ATOM_WM_NAME,                        XCB_ATOM_STRING,                        8,                        strlen(name),                        name);    /* Map the window (= make it visible) */    xcb_map_window(conn, win);    /* Raise window (put it on top) */    values[0] = XCB_STACK_MODE_ABOVE;    xcb_configure_window(conn, win, XCB_CONFIG_WINDOW_STACK_MODE, values);    /* Ensure that the window is created and set up before returning */    xcb_aux_sync(conn);    return win;}

/** Initialize systray information in X. * /param phys_screen Physical screen. */voidsystray_init(int phys_screen){    xcb_client_message_event_t ev;    xcb_screen_t *xscreen = xutil_screen_get(globalconf.connection, phys_screen);    char *atom_name;    xcb_intern_atom_cookie_t atom_systray_q;    xcb_intern_atom_reply_t *atom_systray_r;    xcb_atom_t atom_systray;    /* Send requests */    if(!(atom_name = xcb_atom_name_by_screen("_NET_SYSTEM_TRAY", phys_screen)))    {        warn("error getting systray atom");        return;    }    atom_systray_q = xcb_intern_atom_unchecked(globalconf.connection, false,                                               a_strlen(atom_name), atom_name);    p_delete(&atom_name);    globalconf.screens[phys_screen].systray.window = xcb_generate_id(globalconf.connection);    xcb_create_window(globalconf.connection, xscreen->root_depth,                      globalconf.screens[phys_screen].systray.window,                      xscreen->root,                      -1, -1, 1, 1, 0,                      XCB_COPY_FROM_PARENT, xscreen->root_visual, 0, NULL);    /* Fill event */    p_clear(&ev, 1);    ev.response_type = XCB_CLIENT_MESSAGE;    ev.window = xscreen->root;    ev.format = 32;    ev.type = MANAGER;    ev.data.data32[0] = XCB_CURRENT_TIME;    ev.data.data32[2] = globalconf.screens[phys_screen].systray.window;    ev.data.data32[3] = ev.data.data32[4] = 0;    if(!(atom_systray_r = xcb_intern_atom_reply(globalconf.connection, atom_systray_q, NULL)))    {        warn("error getting systray atom");        return;    }    ev.data.data32[1] = atom_systray = atom_systray_r->atom;    p_delete(&atom_systray_r);    xcb_set_selection_owner(globalconf.connection,                            globalconf.screens[phys_screen].systray.window,                            atom_systray,                            XCB_CURRENT_TIME);    xcb_send_event(globalconf.connection, false, xscreen->root, 0xFFFFFF, (char *) &ev);}

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;}

/** Initialize systray information in X. * /param phys_screen Physical screen. */voidsystray_init(int phys_screen){    xcb_screen_t *xscreen = xutil_screen_get(globalconf.connection, phys_screen);    globalconf.screens.tab[phys_screen].systray.window = xcb_generate_id(globalconf.connection);    xcb_create_window(globalconf.connection, xscreen->root_depth,                      globalconf.screens.tab[phys_screen].systray.window,                      xscreen->root,                      -1, -1, 1, 1, 0,                      XCB_COPY_FROM_PARENT, xscreen->root_visual, 0, NULL);}

void createWindow() {  eventmask =      XCB_EVENT_MASK_KEY_PRESS |      XCB_EVENT_MASK_POINTER_MOTION |      XCB_EVENT_MASK_KEY_RELEASE;  uint32_t valuelist[] = { eventmask, colormap };  uint32_t valuemask = XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;  xcb_create_window(      connection,      XCB_COPY_FROM_PARENT,      window,      screen->root,      0, 0,      width, height,      0,      XCB_WINDOW_CLASS_INPUT_OUTPUT,      visualID,      valuemask,      valuelist);  // NOTE: window must be mapped before glXMakeContextCurrent  xcb_map_window(connection, window);  // Create GLX Window  glxwindow = glXCreateWindow(display, fb_config, window, 0);  if (!glxwindow)    printf("glXCreateWindow failed");  drawable = glxwindow;  // make OpenGL context current  if (!glXMakeContextCurrent(display, drawable, drawable, context))    printf("glXMakeContextCurrent failed");  // Set swap interval#ifdef NVIDIA_GL  PFNGLXSWAPINTERVALSGIPROC    glXSwapInterval =          reinterpret_cast<PFNGLXSWAPINTERVALSGIPROC> (glXGetProcAddress(                  reinterpret_cast<GLubyte const *>("glXSwapIntervalSGI")));  if (!glXSwapInterval) {    printf("VSync is not supported");  } else {    glXSwapInterval(1);  }#endif  setWindowTitle(programTile);  }

/** Initialize systray information in X. */voidsystray_init(void){    xcb_screen_t *xscreen = globalconf.screen;    globalconf.systray.window = xcb_generate_id(globalconf.connection);    xcb_create_window(globalconf.connection, xscreen->root_depth,                      globalconf.systray.window,                      xscreen->root,                      -1, -1, 1, 1, 0,                      XCB_COPY_FROM_PARENT, xscreen->root_visual,                      0, NULL);}

XCBWindow::XCBWindow(const WindowCreationDescriptor& creationInfo)    : m_connection()    , m_handle()    , m_deleteWindowReply(nullptr){    int screen_index;    m_connection = xcb_connect(nullptr, &screen_index);    Assert(m_connection != nullptr);    const xcb_setup_t*    setup = xcb_get_setup(m_connection);    xcb_screen_iterator_t screen_iterator = xcb_setup_roots_iterator(setup);    while (screen_index-- > 0)        xcb_screen_next(&screen_iterator);    m_screen = screen_iterator.data;    Assert(m_screen != nullptr);    m_handle = xcb_generate_id(m_connection);    uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;    uint32_t value_list[] = {m_screen->white_pixel,                             XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_STRUCTURE_NOTIFY};    xcb_create_window(m_connection,                      XCB_COPY_FROM_PARENT,                      m_handle,                      m_screen->root,                      0,                      0,                      creationInfo.width,                      creationInfo.height,                      0,                      XCB_WINDOW_CLASS_INPUT_OUTPUT,                      m_screen->root_visual,                      mask,                      value_list);    xcb_change_property(m_connection,                        XCB_PROP_MODE_REPLACE,                        m_handle,                        XCB_ATOM_WM_NAME,                        XCB_ATOM_STRING,                        8,                        std::strlen(creationInfo.title),                        creationInfo.title);    xcb_flush(m_connection);    Assert(xcb_connection_has_error(m_connection) == 0);}

    bool Window::Create( const char *title ) {      int screen_index;      Parameters.Connection = xcb_connect( nullptr, &screen_index );      if( !Parameters.Connection ) {        return false;      }      const xcb_setup_t *setup = xcb_get_setup( Parameters.Connection );      xcb_screen_iterator_t screen_iterator = xcb_setup_roots_iterator( setup );      while( screen_index-- > 0 ) {        xcb_screen_next( &screen_iterator );      }      xcb_screen_t *screen = screen_iterator.data;      Parameters.Handle = xcb_generate_id( Parameters.Connection );      uint32_t value_list[] = {        screen->white_pixel,        XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_STRUCTURE_NOTIFY      };      xcb_create_window(        Parameters.Connection,        XCB_COPY_FROM_PARENT,        Parameters.Handle,        screen->root,        20,        20,        500,        500,        0,        XCB_WINDOW_CLASS_INPUT_OUTPUT,        screen->root_visual,        XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,        value_list );      xcb_change_property(        Parameters.Connection,        XCB_PROP_MODE_REPLACE,        Parameters.Handle,        XCB_ATOM_WM_NAME,        XCB_ATOM_STRING,        8,        strlen( title ),        title );      return true;    }

intmain(void){    xcb_connection_t *conn;    xcb_screen_t *root;    xcb_window_t window;    uint32_t mask;    uint32_t values[5];    xcb_generic_event_t *event;    struct xamine_context *ctx;    struct xamine_conversation *conversation;    conn = xcb_connect(NULL, NULL);    root = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;    window = xcb_generate_id(conn);    mask = XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_BACKING_STORE | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;    values[0] = root->white_pixel;    values[1] = root->black_pixel;    values[2] = XCB_BACKING_STORE_ALWAYS;    values[3] = 0;    values[4] = AllEventsMask;    xcb_create_window(conn, 0, window, root->root, 0, 0, 256, 256, 10, XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual, mask, values);    xcb_map_window(conn, window);    xcb_flush(conn);    ctx = xamine_context_new(0);    conversation = xamine_conversation_new(ctx, 0);    while ((event = xcb_wait_for_event(conn)) != NULL) {        struct xamine_item *item = xamine_examine(conversation, XAMINE_RESPONSE, event, 32);        free(event);        print_tree(item, 0);        /* Exit on ESC. */        if (strcmp(item->definition->name, "KeyPress") == 0 &&            item->child->next->u.unsigned_value == 9) {            xamine_item_free(item);            break;        }        xamine_item_free(item);    }    xamine_conversation_unref(conversation);    xamine_context_unref(ctx);    xcb_disconnect(conn);    xmlCleanupParser();    return 0;}

/** Initialize a simple window. * /param sw The simple window to initialize. * /param phys_screen Physical screen number. * /param geometry Window geometry. * /param border_width Window border width. * /param orientation The rendering orientation. * /param bg Default foreground color. * /param bg Default background color. */voidsimplewindow_init(simple_window_t *sw,                  int phys_screen,                  area_t geometry,                  uint16_t border_width,                  orientation_t orientation,                  const xcolor_t *fg, const xcolor_t *bg){    xcb_screen_t *s = xutil_screen_get(globalconf.connection, phys_screen);    uint32_t create_win_val[3];    const uint32_t gc_mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND;    const uint32_t gc_values[2] = { s->black_pixel, s->white_pixel };    sw->geometry.x = geometry.x;    sw->geometry.y = geometry.y;    sw->geometry.width = geometry.width;    sw->geometry.height = geometry.height;    sw->border.width = border_width;    sw->orientation = orientation;    sw->ctx.fg = *fg;    sw->ctx.bg = *bg;    create_win_val[0] = XCB_BACK_PIXMAP_PARENT_RELATIVE;    create_win_val[1] = 1;    create_win_val[2] = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT        | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_ENTER_WINDOW        | XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_STRUCTURE_NOTIFY        | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE        | XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_EXPOSURE;    sw->window = xcb_generate_id(globalconf.connection);    xcb_create_window(globalconf.connection, s->root_depth, sw->window, s->root,                      geometry.x, geometry.y, geometry.width, geometry.height,                      border_width, XCB_COPY_FROM_PARENT, s->root_visual,                      XCB_CW_BACK_PIXMAP | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK,                      create_win_val);    sw->pixmap = xcb_generate_id(globalconf.connection);    xcb_create_pixmap(globalconf.connection, s->root_depth, sw->pixmap, s->root,                      geometry.width, geometry.height);    sw->ctx.phys_screen = phys_screen;    simplewindow_draw_context_update(sw, s);    /* The default GC is just a newly created associated to the root window */    sw->gc = xcb_generate_id(globalconf.connection);    xcb_create_gc(globalconf.connection, sw->gc, s->root, gc_mask, gc_values);}

/* * Opens the window we use for input/output and maps it * */xcb_window_t open_input_window(xcb_connection_t *conn, uint32_t width, uint32_t height) {        xcb_window_t win = xcb_generate_id(conn);        //xcb_cursor_t cursor_id = xcb_generate_id(conn);#if 0        /* Use the default cursor (left pointer) */        if (cursor > -1) {                i3Font *cursor_font = load_font(conn, "cursor");                xcb_create_glyph_cursor(conn, cursor_id, cursor_font->id, cursor_font->id,                                XCB_CURSOR_LEFT_PTR, XCB_CURSOR_LEFT_PTR + 1,                                0, 0, 0, 65535, 65535, 65535);        }#endif        uint32_t mask = 0;        uint32_t values[3];        mask |= XCB_CW_BACK_PIXEL;        values[0] = 0;        mask |= XCB_CW_OVERRIDE_REDIRECT;        values[1] = 1;	mask |= XCB_CW_EVENT_MASK;	values[2] = XCB_EVENT_MASK_EXPOSURE;        xcb_create_window(conn,                          XCB_COPY_FROM_PARENT,                          win, /* the window id */                          root, /* parent == root */                          50, 50, width, height, /* dimensions */                          0, /* border = 0, we draw our own */                          XCB_WINDOW_CLASS_INPUT_OUTPUT,                          XCB_WINDOW_CLASS_COPY_FROM_PARENT, /* copy visual from parent */                          mask,                          values);#if 0        if (cursor > -1)                xcb_change_window_attributes(conn, result, XCB_CW_CURSOR, &cursor_id);#endif        /* Map the window (= make it visible) */        xcb_map_window(conn, win);	return win;}

void v_window::_initOSWindow() {    int screenNumber = 0;    _xcb_connection = xcb_connect(nullptr,&screenNumber);    const xcb_setup_t* setup = xcb_get_setup(_xcb_connection);    xcb_screen_iterator_t it = xcb_setup_roots_iterator(setup);    xcb_screen_t* screen = it.data;    _xcb_window = xcb_generate_id(_xcb_connection);    uint32_t value_mask, value_list[ 32 ];    int16_t x=0,y=0;    value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;    value_list[0] = screen->black_pixel;    value_list[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;   //需要接收的事件    xcb_create_window(_xcb_connection,                      XCB_COPY_FROM_PARENT,                      _xcb_window,                      screen->root,                      x,y,                      _width,_height,                      1,                      XCB_WINDOW_CLASS_INPUT_OUTPUT,                      screen->root_visual,                      value_mask,                      value_list);    /* Magic code that will send notification when window is destroyed */    xcb_intern_atom_cookie_t cookie = xcb_intern_atom( _xcb_connection, 1, 12, "WM_PROTOCOLS" );    xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply( _xcb_connection, cookie, 0 );    xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom( _xcb_connection, 0, 16, "WM_DELETE_WINDOW" );    _xcb_atom_window_reply = xcb_intern_atom_reply( _xcb_connection, cookie2, 0 );    xcb_change_property( _xcb_connection, XCB_PROP_MODE_REPLACE, _xcb_window,                         ( *reply ).atom, 4, 32, 1,                         &( *_xcb_atom_window_reply ).atom );    free( reply );    xcb_map_window(_xcb_connection,_xcb_window);    // Force the x/y coordinates to 100,100 results are identical in consecutive    const uint32_t coords[] = { 100, 100 };    xcb_configure_window( _xcb_connection, _xcb_window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords );    xcb_flush(_xcb_connection);}

// Set up a window using XCB and request event typesxcb_window_t VulkanExampleBase::setupWindow(){	uint32_t value_mask, value_list[32];	window = xcb_generate_id(connection);	value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;	value_list[0] = screen->black_pixel;	value_list[1] =		XCB_EVENT_MASK_KEY_RELEASE |		XCB_EVENT_MASK_EXPOSURE |		XCB_EVENT_MASK_STRUCTURE_NOTIFY |		XCB_EVENT_MASK_POINTER_MOTION |		XCB_EVENT_MASK_BUTTON_PRESS |		XCB_EVENT_MASK_BUTTON_RELEASE;	xcb_create_window(connection,		XCB_COPY_FROM_PARENT,		window, screen->root,		0, 0, width, height, 0,		XCB_WINDOW_CLASS_INPUT_OUTPUT,		screen->root_visual,		value_mask, value_list);	/* Magic code that will send notification when window is destroyed */	xcb_intern_atom_cookie_t cookie = xcb_intern_atom(connection, 1, 12, "WM_PROTOCOLS");	xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(connection, cookie, 0);	xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(connection, 0, 16, "WM_DELETE_WINDOW");	atom_wm_delete_window = xcb_intern_atom_reply(connection, cookie2, 0);	xcb_change_property(connection, XCB_PROP_MODE_REPLACE,		window, (*reply).atom, 4, 32, 1,		&(*atom_wm_delete_window).atom);	std::string windowTitle = getWindowTitle();	xcb_change_property(connection, XCB_PROP_MODE_REPLACE,		window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8,		title.size(), windowTitle.c_str());	free(reply);	xcb_map_window(connection, window);	return(window);}

int main(void){	xcb_connection_t *dpy = xcb_connect(NULL, NULL);	if (dpy == NULL) {		fprintf(stderr, "Can't connect to X./n");		return EXIT_FAILURE;	}	xcb_atom_t WM_PROTOCOLS, WM_DELETE_WINDOW;	if (!get_atom(dpy, "WM_PROTOCOLS", &WM_PROTOCOLS) ||	    !get_atom(dpy, "WM_DELETE_WINDOW", &WM_DELETE_WINDOW)) {		fprintf(stderr, "Can't get required atoms./n");		xcb_disconnect(dpy);		return EXIT_FAILURE;	}	xcb_screen_t *screen = xcb_setup_roots_iterator(xcb_get_setup(dpy)).data;	if (screen == NULL) {		fprintf(stderr, "Can't get current screen./n");		xcb_disconnect(dpy);		return EXIT_FAILURE;	}	xcb_window_t win = xcb_generate_id(dpy);	uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;	uint32_t values[] = {0xff111111, XCB_EVENT_MASK_EXPOSURE};	xcb_create_window(dpy, XCB_COPY_FROM_PARENT, win, screen->root, 0, 0, 320, 240, 2,	                  XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, mask, values);	xcb_icccm_set_wm_class(dpy, win, sizeof(TEST_WINDOW_IC), TEST_WINDOW_IC);	xcb_map_window(dpy, win);	xcb_flush(dpy);	xcb_generic_event_t *evt;	bool running = true;	while (running && (evt = xcb_wait_for_event(dpy)) != NULL) {		uint8_t rt = XCB_EVENT_RESPONSE_TYPE(evt);		if (rt == XCB_CLIENT_MESSAGE)  {			xcb_client_message_event_t *cme = (xcb_client_message_event_t *) evt;			if (cme->type == WM_PROTOCOLS && cme->data.data32[0] == WM_DELETE_WINDOW) {				running = false;			}		} else if (rt == XCB_EXPOSE) {			render_text(dpy, win, 12, 24);		}		free(evt);	}	xcb_destroy_window(dpy, win);	xcb_disconnect(dpy);	return EXIT_SUCCESS;}

staticxcb_window_t create_window(xcb_connection_t * connection, xcb_screen_t * screen) {    xcb_window_t window = xcb_generate_id(connection);    uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_OVERRIDE_REDIRECT;    uint32_t values[2] = { 0xffff0000, 1 };    xcb_create_window(connection,            XCB_COPY_FROM_PARENT,            window,            screen->root,            0, 0,            1, 1,            0,            XCB_WINDOW_CLASS_INPUT_OUTPUT,            screen->root_visual,            mask, values);    return window;}

void NGBCreateWindow(){	xcb_create_window(con,					XCB_COPY_FROM_PARENT,					win,					screen->root,					0, 0,					640, 480,					10,					XCB_WINDOW_CLASS_INPUT_OUTPUT,					screen->root_visual,					mask, values);	xcb_map_window(con, win);	xcb_flush(con);}

int main() {    xcb_connection_t    *conn        = xcb_connect(NULL, NULL);    xcb_screen_t        *screen      = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;    xcb_drawable_t      win          = screen->root;    xcb_gcontext_t      fg           = xcb_generate_id(conn);    uint32_t    mask        = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;    uint32_t    values[2]   = { screen->black_pixel, 0 };    xcb_create_gc(conn, fg, win, mask, values);    win         = xcb_generate_id(conn);    mask        = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;    values[0]   = screen->white_pixel;    values[1]   = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS;    xcb_create_window(conn, XCB_COPY_FROM_PARENT, win, screen->root, x, y, w, h, bw,            XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, mask, values);    xcb_map_window(conn, win);    xcb_flush(conn);    xcb_generic_event_t *event;    // xcb_poll_for_event does not block, so this will only catch the EXPOSE event then die out.    // If we used xcb_wait_for_event, we'd block, thus continuing the loop and would actually    // have a window to receive a possible XCB_BUTTON_PRESS.    while ((event = xcb_wait_for_event(conn))) {        switch (event->response_type & ~0x80) {            case XCB_EXPOSE:                printf("Expose event/n");                xcb_flush(conn);                break;            case XCB_BUTTON_PRESS:                printf("Button press/n");                xcb_flush(conn);                break;            default:                printf("Some otherrr event/n");                break;        }        free(event);    }    return 0;}

monitor_t *make_monitor(xcb_rectangle_t rect){    monitor_t *m = malloc(sizeof(monitor_t));    snprintf(m->name, sizeof(m->name), "%s%02d", DEFAULT_MON_NAME, ++monitor_uid);    m->prev = m->next = NULL;    m->desk = m->desk_head = m->desk_tail = NULL;    m->rectangle = rect;    m->top_padding = m->right_padding = m->bottom_padding = m->left_padding = 0;    m->wired = true;    m->num_sticky = 0;    uint32_t mask = XCB_CW_EVENT_MASK;    uint32_t values[] = {XCB_EVENT_MASK_ENTER_WINDOW};    m->root = xcb_generate_id(dpy);    xcb_create_window(dpy, XCB_COPY_FROM_PARENT, m->root, root, rect.x, rect.y, rect.width, rect.height, 0, XCB_WINDOW_CLASS_INPUT_ONLY, XCB_COPY_FROM_PARENT, mask, values);    window_lower(m->root);    if (focus_follows_pointer)        window_show(m->root);    return m;}