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 );
}
static void
weston_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));
}
}
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;
}
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;
}
static void
systray_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;
}
}
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 void
towel_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 void
towel_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.
*/
int
luaA_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 shutdown_show() {
if (shutdown_win.cache->mapped==0) {
xcb_map_window(conn,shutdown_win.window);
xcb_flush(conn);
shutdown_win.cache->mapped=1;
printf("Show\n");
}
}
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);
}
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 void
event_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);
}
int
main(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 types
xcb_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);
}
void menuwin_init() {
key_win.surface=cairo_xcb_surface_create(conn,key_win.window,visual_type,width,1);
// Set the _NET_SUPPORTING_WM_CHECK property pointing to the window ID in both the root and fake windows
// Also set the WM_NAME property in both windows to TWM_NAME
xcb_change_property(conn,XCB_PROP_MODE_REPLACE,scr->root,atoms[TWM_ATOM__NET_SUPPORTING_WM_CHECK],XCB_ATOM_WINDOW,32,1,&key_win.window);
xcb_change_property(conn,XCB_PROP_MODE_REPLACE,scr->root,atoms[TWM_ATOM__NET_WM_NAME],XCB_ATOM_STRING,8,strlen(TWM_NAME),TWM_NAME);
xcb_change_property(conn,XCB_PROP_MODE_REPLACE,key_win.window,atoms[TWM_ATOM__NET_SUPPORTING_WM_CHECK],XCB_ATOM_WINDOW,32,1,&key_win.window);
xcb_change_property(conn,XCB_PROP_MODE_REPLACE,key_win.window,atoms[TWM_ATOM__NET_WM_NAME],XCB_ATOM_STRING,8,strlen(TWM_NAME),TWM_NAME);
xcb_change_property(conn,XCB_PROP_MODE_REPLACE,key_win.window,atoms[TWM_ATOM__NET_WM_WINDOW_TYPE],XCB_ATOM_ATOM,32,1,&atoms[TWM_ATOM__NET_WM_WINDOW_TYPE_DOCK]);
xcb_map_window(conn,key_win.window);
xcb_flush(conn);
key_win.cache=wincache_fill_element(key_win.window);
key_win.cache->mapped=1;
key_win.possition=0;
key_win.has_keyboard=0;
key_win.width=width;
key_win.height=1;
key_win.enabled_by_mouse=0;
key_win.wait_for=0;
fill_keycodes();
}
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;
}
