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

void Client::map(){    if (!mFrame)        return;    xcb_connection_t* conn = WindowManager::instance()->connection();    warning() << "mapping frame" << mFrame;    xcb_map_window(conn, mWindow);    xcb_map_window(conn, mFrame);}

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

// === EmbedWindow() ===uint LXCB::EmbedWindow(WId win, WId container){  if(DEBUG){ qDebug() << "XCB: EmbedWindow()"; }  //This returns the damage control ID number (or 0 for a failure)  if(win==0 || container==0){ return 0; }  //qDebug() << "Embed Window:" << win << container;  //Initialize any atoms that will be needed  xcb_intern_atom_cookie_t ecookie = xcb_intern_atom_unchecked(QX11Info::connection(), 0, 7, "_XEMBED");    xcb_intern_atom_reply_t *ereply = xcb_intern_atom_reply(QX11Info::connection(), ecookie, NULL);  if(ereply==0){ return 0; } //unable to initialize the atom  xcb_atom_t emb = ereply->atom;  free(ereply); //done with this structure    //Reparent the window into the container  xcb_reparent_window(QX11Info::connection(), win, container, 0, 0);  xcb_map_window(QX11Info::connection(), win);    //Now send the embed event to the app  //qDebug() << " - send _XEMBED event";  xcb_client_message_event_t event;    event.response_type = XCB_CLIENT_MESSAGE;    event.format = 32;    event.window = win;    event.type = emb; //_XEMBED    event.data.data32[0] = XCB_TIME_CURRENT_TIME; //CurrentTime;     event.data.data32[1] = 0; //XEMBED_EMBEDDED_NOTIFY    event.data.data32[2] = 0;    event.data.data32[3] = container; //WID of the container    event.data.data32[4] = 0;    xcb_send_event(QX11Info::connection(), 0, win,  XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *) &event);    //Now setup any redirects and return  //qDebug() << " - select Input";  //XSelectInput(disp, win, StructureNotifyMask); //Notify of structure changes  //uint32_t val[] = {XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY};  //xcb_change_window_attributes(QX11Info::connection(), win, XCB_CW_EVENT_MASK, val);  this->SelectInput(win);  //qDebug() << " - Composite Redirect";  xcb_composite_redirect_window(QX11Info::connection(), win, XCB_COMPOSITE_REDIRECT_MANUAL);  //Now map the window (will be a transparent child of the container)  xcb_map_window(QX11Info::connection(), win);    //Now create/register the damage handler  xcb_damage_damage_t dmgID = xcb_generate_id(QX11Info::connection()); //This is a typedef for a 32-bit unsigned integer  xcb_damage_create(QX11Info::connection(), dmgID, win, XCB_DAMAGE_REPORT_LEVEL_RAW_RECTANGLES);    //qDebug() << " - Done";  return ( (uint) dmgID );	}

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

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

/* Displays all of the current windows of the frame on the screen */void mapCurrentFrame(xcb_connection_t *conn,std::vector<xcb_window_t> (&frames)[NUM_FRAMES], int frameNum) {  int size = frames[frameNum].size();  std::vector<xcb_window_t> windowVector = frames[frameNum];  for(int i=0; i<size; i++) {    xcb_map_window(conn,windowVector.at(i));  }}

static voidsystray_update(int base_size, bool horizontal){    if(base_size <= 0)        return;    /* Give the systray window the correct size */    uint32_t config_vals[4] = { base_size, base_size, 0, 0 };    if(horizontal)        config_vals[0] = base_size * globalconf.embedded.len;    else        config_vals[1] = base_size * globalconf.embedded.len;    xcb_configure_window(globalconf.connection,                         globalconf.systray.window,                         XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,                         config_vals);    /* Now resize each embedded window */    config_vals[0] = config_vals[1] = 0;    config_vals[2] = config_vals[3] = base_size;    for(int i = 0; i < globalconf.embedded.len; i++)    {        xembed_window_t *em = &globalconf.embedded.tab[i];        xcb_configure_window(globalconf.connection, em->win,                             XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,                             config_vals);        xcb_map_window(globalconf.connection, em->win);        if(horizontal)            config_vals[0] += base_size;        else            config_vals[1] += base_size;    }}

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 QXcbWindow::setVisible(bool visible){    xcb_wm_hints_t hints;    if (visible) {        if (widget()->isMinimized())            xcb_wm_hints_set_iconic(&hints);        else            xcb_wm_hints_set_normal(&hints);        xcb_set_wm_hints(xcb_connection(), m_window, &hints);        Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));        connection()->sync();    } else {        Q_XCB_CALL(xcb_unmap_window(xcb_connection(), m_window));        // send synthetic UnmapNotify event according to icccm 4.1.4        xcb_unmap_notify_event_t event;        event.response_type = XCB_UNMAP_NOTIFY;        event.sequence = 0; // does this matter?        event.event = m_screen->root();        event.window = m_window;        event.from_configure = false;        Q_XCB_CALL(xcb_send_event(xcb_connection(), false, m_screen->root(),                                  XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));        xcb_flush(xcb_connection());    }}

int handle_map_request_event(void *data, xcb_connection_t *c, xcb_map_request_event_t *event){    xcb_get_window_attributes_cookie_t win_attrs_cookie;    xcb_get_window_attributes_reply_t *win_attrs_reply;    win_attrs_cookie = xcb_get_window_attributes_unchecked(c, event->window);    win_attrs_reply = xcb_get_window_attributes_reply(c, win_attrs_cookie, NULL);    if (!win_attrs_reply) {        fprintf(stderr, "map request: failed to get window attributes/n");        return -1;    }    if (win_attrs_reply->override_redirect) {        fprintf(stderr, "map request: window has override redirect set - ignoring map request/n");        return 0;    }    client_t *client = NULL;    client = find_client(event->window);    if (!client)        client = manage_window(event->window);    xcb_map_window(c, event->window);    run_arrange_hook();    free(win_attrs_reply);    return 0;}

int handle_unmap_notify_event(void *data, xcb_connection_t *c, xcb_unmap_notify_event_t *event){    client_t *client = find_client(event->window);    if (client && XCB_EVENT_SENT(event)) {        fprintf(stderr, "unmap notify: unmapping window %u/n", client->window);        sglib_client_t_delete(&client_list, client);        xcb_unmap_window(wm_conf.connection, client->window);        xcb_map_window(wm_conf.connection, event->event);        free(client);    }    /* not right */    xcb_map_window(wm_conf.connection, event->event);    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 voidtowel_window_map(towel_window_t *win){  xcb_atom_t ATOM = towel_window_get_atom(win, "ATOM");  xcb_atom_t wm_state = towel_window_get_atom(win, "_NET_WM_STATE");  xcb_atom_t wm_state_fullscreen = towel_window_get_atom(win, "_NET_WM_STATE_FULLSCREEN");  xcb_client_message_event_t ev = {    .response_type = XCB_CLIENT_MESSAGE,    .format = 32,    .window = win->id,    .type = wm_state,  };  ev.data.data32[0] = 1;  ev.data.data32[1] = wm_state_fullscreen;  ev.data.data32[2] = 0;  ev.data.data32[3] = 1;  xcb_change_property(win->conn, XCB_PROP_MODE_REPLACE,                      win->id, wm_state, ATOM, 8, sizeof(xcb_atom_t), &wm_state_fullscreen);  xcb_map_window(win->conn, win->id);}static voidtowel_window_unmap(towel_window_t *win){  xcb_unmap_window(win->conn, win->id);}

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

void xcbosd_expose(xcbosd *osd){  assert (osd);  lprintf("expose (state:%d)/n", osd->clean );  switch (osd->mode) {    case XCBOSD_SHAPED:      xcb_shape_mask(osd->connection, XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING,		     osd->u.shaped.window, 0, 0, osd->u.shaped.mask_bitmap);      if( osd->clean==DRAWN ) {	if( !osd->u.shaped.mapped ) {	  unsigned int stack_mode = XCB_STACK_MODE_ABOVE;	  xcb_configure_window(osd->connection, osd->u.shaped.window, XCB_CONFIG_WINDOW_STACK_MODE, &stack_mode);	  xcb_map_window(osd->connection, osd->u.shaped.window);	}	osd->u.shaped.mapped = 1;	xcb_copy_area(osd->connection, osd->bitmap, osd->u.shaped.window,		      osd->gc, 0, 0, 0, 0, osd->width, osd->height);      } else {	if( osd->u.shaped.mapped )	  xcb_unmap_window(osd->connection, osd->u.shaped.window);	osd->u.shaped.mapped = 0;      }      break;    case XCBOSD_COLORKEY:      if( osd->clean!=UNDEFINED )	xcb_copy_area(osd->connection, osd->bitmap, osd->window, osd->gc, 0, 0,		      0, 0, osd->width, osd->height);  }}

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

/** Update the systray * /param L The Lua VM state. * /return The number of elements pushed on stack. * /luastack * /lparam The drawin to display the systray in. * /lparam x X position for the systray. * /lparam y Y position for the systray. * /lparam base_size The size (width and height) each systray item gets. * /lparam horiz If true, the systray is horizontal, else vertical. * /lparam bg Color of the systray background. * /lparam revers If true, the systray icon order will be reversed, else default. * /lparam spacing The size of the spacing between icons. */intluaA_systray(lua_State *L){    systray_register();    if(lua_gettop(L) != 0)    {        size_t bg_len;        drawin_t *w = luaA_checkudata(L, 1, &drawin_class);        int x = luaL_checkinteger(L, 2);        int y = luaL_checkinteger(L, 3);        int base_size = luaL_checkinteger(L, 4);        bool horiz = lua_toboolean(L, 5);        const char *bg = luaL_checklstring(L, 6, &bg_len);        bool revers = lua_toboolean(L, 7);        int spacing = luaL_checkinteger(L, 8);        color_t bg_color;        if(color_init_reply(color_init_unchecked(&bg_color, bg, bg_len)))        {            uint32_t config_back[] = { bg_color.pixel };            xcb_change_window_attributes(globalconf.connection,                                         globalconf.systray.window,                                         XCB_CW_BACK_PIXEL, config_back);        }        if(globalconf.systray.parent != w)            xcb_reparent_window(globalconf.connection,                                globalconf.systray.window,                                w->window,                                x, y);        else        {            uint32_t config_vals[2] = { x, y };            xcb_configure_window(globalconf.connection,                                 globalconf.systray.window,                                 XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y,                                 config_vals);        }        globalconf.systray.parent = w;        if(globalconf.embedded.len != 0)        {            systray_update(base_size, horiz, revers, spacing);            xcb_map_window(globalconf.connection,                           globalconf.systray.window);        }        else            xcb_unmap_window(globalconf.connection,                             globalconf.systray.window);    }    lua_pushinteger(L, globalconf.embedded.len);    luaA_object_push(L, globalconf.systray.parent);    return 2;}

void overlay_show(struct overlay * overlay, int x, int y, int w, int h, int border) {    xcb_connection_t * connection = overlay->connection;    const uint32_t XYWH = XCB_CONFIG_WINDOW_X                        | XCB_CONFIG_WINDOW_Y                        | XCB_CONFIG_WINDOW_WIDTH                        | XCB_CONFIG_WINDOW_HEIGHT;    xcb_map_window(overlay->connection, overlay->top);    xcb_map_window(overlay->connection, overlay->left);    xcb_map_window(overlay->connection, overlay->right);    xcb_map_window(overlay->connection, overlay->bottom);    uint32_t xywh[4];    xywh[0] = x; xywh[1] = y; xywh[2] = w; xywh[3] = border;    xcb_configure_window(connection, overlay->top, XYWH, xywh);    xywh[0] = x; xywh[1] = y; xywh[2] = border; xywh[3] = h;    xcb_configure_window(connection, overlay->left, XYWH, xywh);    xywh[0] = x+w-border; xywh[1] = y; xywh[2] = border; xywh[3] = h;    xcb_configure_window(connection, overlay->right, XYWH, xywh);    xywh[0] = x; xywh[1] = y+h-border; xywh[2] = w; xywh[3] = border;    xcb_configure_window(connection, overlay->bottom, XYWH, xywh);    xcb_flush(overlay->connection);}

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

void window_set_visibility(xcb_window_t win, bool visible){	uint32_t values_off[] = {ROOT_EVENT_MASK & ~XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY};	uint32_t values_on[] = {ROOT_EVENT_MASK};	xcb_change_window_attributes(dpy, root, XCB_CW_EVENT_MASK, values_off);	if (visible) {		xcb_map_window(dpy, win);	} else {		xcb_unmap_window(dpy, win);	}	xcb_change_window_attributes(dpy, root, XCB_CW_EVENT_MASK, values_on);}

/** The map request event handler. * /param ev The event. */static voidevent_handle_maprequest(xcb_map_request_event_t *ev){    client_t *c;    xcb_get_window_attributes_cookie_t wa_c;    xcb_get_window_attributes_reply_t *wa_r;    xcb_get_geometry_cookie_t geom_c;    xcb_get_geometry_reply_t *geom_r;    wa_c = xcb_get_window_attributes_unchecked(globalconf.connection, ev->window);    if(!(wa_r = xcb_get_window_attributes_reply(globalconf.connection, wa_c, NULL)))        return;    if(wa_r->override_redirect)        goto bailout;    if(xembed_getbywin(&globalconf.embedded, ev->window))    {        xcb_map_window(globalconf.connection, ev->window);        xembed_window_activate(globalconf.connection, ev->window);    }    else if((c = client_getbywin(ev->window)))    {        /* Check that it may be visible, but not asked to be hidden */        if(client_on_selected_tags(c) && !c->hidden)        {            lua_State *L = globalconf_get_lua_State();            luaA_object_push(L, c);            client_set_minimized(L, -1, false);            lua_pop(L, 1);            /* it will be raised, so just update ourself */            client_raise(c);        }    }    else    {        geom_c = xcb_get_geometry_unchecked(globalconf.connection, ev->window);        if(!(geom_r = xcb_get_geometry_reply(globalconf.connection, geom_c, NULL)))        {            goto bailout;        }        client_manage(ev->window, geom_r, wa_r);        p_delete(&geom_r);    }bailout:    p_delete(&wa_r);}

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

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

    //_____________________________________________    void SizeGrip::updateActiveState( void )    {        #if OXYGEN_HAVE_X11        if( QX11Info::isPlatformX11() )        {            const quint32 value = XCB_STACK_MODE_ABOVE;            xcb_configure_window( QX11Info::connection(), winId(), XCB_CONFIG_WINDOW_STACK_MODE, &value );            xcb_map_window( QX11Info::connection(), winId() );        }        #endif        update();    }

client_t *manage_window(xcb_window_t window){    client_t *client = client_init(client_alloc());    client->window = window;    sglib_client_t_add(&client_list, client);    read_client_geometry(client);    client->border_width = 0;    update_client_geometry(client);    xcb_map_window(wm_conf.connection, client->window);    run_arrange_hook();    return client;    }

/* * 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);}