下载手机最新版tp|xcb

作者: 下载手机最新版tp
2024-03-07 22:06:04

【星辰变】官网——2D次世代动作网游

进入官网

这里是副标题

领取礼包

礼遇2022礼盒

兑换方法

前往炎京城车侯辕（313,325）处领取

这里是副标题

3分钟极速下载

DOWNLOAD

完整客户端

DOWNLOAD

赤阳

血魔

蓝央

清虚

阴月

炎魔

原掌门的突然飞升让紫阳门陷入动荡，危难之际，赤阳真人横空出世，以通天手段扭转乾坤，兼容并蓄，重建门墙。重建后的紫阳门正式改名为赤阳门。

血魔门修炼的正是魔道三大秘法之一的血魔魔道。能够传承此秘法的人相当稀少。不过真正的血魔战士都是敌人的梦魇，他们的出现就是死亡的宣告。

蓝央门的创始人是一对出生在腾龙大陆的孪生兄弟：哥哥天生驭火、弟弟点物成石。两兄弟在飞升时留下两座神塔，借助双塔神力修行的人们创立了蓝央门。

这些最早迎来天劫的道人们，便是清虚观的创立之祖。到现在，没人知道清虚观究竟有多久的历史，但无论时代如何变迁，清虚观的强大从来没有改变过。

第一次修真者大战，致使仙魔之间长期压抑的积怨集中爆发。大战过后，修魔者重新划分形成了众多的新势力，而这些势力之中又以阴月宫最为独特。

为了将血脉延续，炎魔与凡人女子通婚，以减轻血液中的“天罚之力”。渐渐地，炎魔的子孙恢复了常人的样子，获得重生的炎魔后裔也知感恩。

您已获得礼包激活码

复制

※ 请至游戏内炎京城车侯辕（313,325）处领取

关于qt缺少xcb问题终极解决办法_qt xcb-CSDN博客

关于qt缺少xcb问题终极解决办法

最新推荐文章于 2024-01-29 14:56:40 发布

我爱下午茶

最新推荐文章于 2024-01-29 14:56:40 发布

阅读量7.9w

191

点赞数

分类专栏：

学习工作

文章标签：

qt移植

xcb

本文链接：https://blog.csdn.net/sinat_26106275/article/details/82778951

版权

学习工作

专栏收录该内容

12 篇文章

0 订阅

订阅专栏

关于qt缺少xcb问题终极解决办法

问题背景系统环境qt版本问题描述

解决过程走的弯路解决问题的关键

总结

问题背景

系统环境

中标麒麟，龙芯平台

qt版本

qt5.6

问题描述

原来的Qt程序是qt5.3.2版本，但是由于各种原因，升级成了qt5.6版本。编译完成后放在其他机器上报错缺少xcb，报错如下：

This application failed to start because it could not find or load the Qt platform plugin "xcb"

in "".

Available platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, xcb, xcb.

Reinstalling the application may fix this problem.

解决过程

走的弯路

几乎尝试百度到的各种方式，无非就这么几种。 1、运行目录下添加platform文件夹，文件夹里放上libqxcb.so。 2、指定环境变量，具体什么变量记不清楚了。 3、在运行目录下，添加 libQt5Core.so libQt5Gui.so libQt5Network.so libQt5Widgets.so libQt5DBus.so libicuuc.so libicudata.so libicui18n.so

最终结果还是不行。

解决问题的关键

设置环境变量 export QT_DEBUG_PLUGINS=1 加了这个环境变量，让我看到了QT程序加载的过程，看到了详细的报错信息。最后一部分是这样的：

Found metadata in lib /usr/lib64/qt5/plugins/platforms/libqxcb.so, metadata=

{

"IID": "org.qt-project.Qt.QPA.QPlatformIntegrationFactoryInterface.5.3",

"MetaData": {

"Keys": [

"xcb"

]

"className": "QXcbIntegrationPlugin",

"debug": false,

"version": 329218

}

Found metadata in lib /opt/dky/SASClient/bin/platforms/libqxcb.so, metadata=

{

"IID": "org.qt-project.Qt.QPA.QPlatformIntegrationFactoryInterface.5.3",

"MetaData": {

"Keys": [

"xcb"

]

"className": "QXcbIntegrationPlugin",

"debug": false,

"version": 329216

}

QLibraryPrivate::loadPlugin failed on "/usr/lib64/qt5/plugins/platforms/libqxcb.so" : "Cannot load library /usr/lib64/qt5/plugins/platforms/libqxcb.so: (/lib64/libQt5XcbQpa.so.5: symbol _ZNK11QFontEngine6handleEv, version Qt_5_PRIVATE_API not defined in file libQt5Gui.so.5 with link time reference)"

This application failed to start because it could not find or load the Qt platform plugin "xcb"

in "".

Available platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, xcb, xcb.

Reinstalling the application may fix this problem.

看到问题没？ /lib64/libQt5XcbQpa.so.5 这个库有问题。于是我把libQt5XcbQpa.so，也放在运行目录下。奇迹发生了，一切OK了！！！

总结

网上大部分搜到的解决办法，可能都是基于qt5.6之前的，但是qt5.6之后新加了几个库，所以网上的解决办法搜不到，所以才困扰了我这么久。这次解决问题的关键在于，添加环境变量：export QT_DEBUG_PLUGINS=1 相信遇到此问题，利用这个方法，都可以很快的定位并解决问题了。最后，祝大家好运！！！

优惠劵

我爱下午茶

关注

踩

191

觉得还不错?

一键收藏

知道了

关于qt缺少xcb问题终极解决办法

关于qt缺少xcb问题终极解决办法问题背景系统环境qt版本问题描述解决过程走的弯路解决问题的关键总结问题背景系统环境中标麒麟，龙芯平台qt版本qt5.6问题描述原来的Qt程序是qt5.3.2版本，但是由于各种原因，升级成了qt5.6版本。编译完成后放在其他机器上报错缺少xcb，报错如下：This application failed to start because it cou...

复制链接

扫一扫

专栏目录

Ubuntu18.04下解决Qt出现qt.qpa.plugin:Could not load the Qt platform plugin “xcb“问题

09-14

主要介绍了Ubuntu18.04下解决Qt出现qt.qpa.plugin:Could not load the Qt platform plugin “xcb“问题,本文给大家分享解决方案，需要的朋友可以参考下

QT 安装libX11-xcb.so.1

07-01

安装Qt时候，显示缺少libX11-xcb.so.1，这个是安装源码文件

49 条评论

您还未登录，请先

后发表或查看评论

Python qt.qpa.xcb: could not connect to display解决办法

smile_5me的博客

01-29

445

遇到问题：qt.qpa.xcb: could not connect to display。然后重新跑python程序，解决！

Linux关于qt缺少xcb问题解决办法

LEGENDA的博客

07-20

1960

Linux关于qt缺少xcb问题解决办法，包解决

ubuntu, debain, uos, deepin qt安装后打不开

07-10

解决下面报错

qt.qpa.plugin: Could not load the Qt platform plugin "xcb" in "" even though it was found.

This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.

Available platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, vnc, xcb.

关于Qt 缺少xcb 解决办法

子非鱼的博客

11-15

9381

最近在ARM上编译Qt5.13 编译完之后出现这个错误

This application failed to start because it could not find or load the Qt platform plugin "xcb"

in "".

Available platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, xcb, xcb.

Reinstalling the application may

【ARM开发】交叉编译Qt源码之（4）添加xcb支持

console_log的博客

02-16

5163

Debian 9

1、依赖

Qt源码添加xcb支持，依赖xcb-util-wm、xcb-util、xcb-util-image、xcb-util-keysyms、xcb-util-renderutil、libxkbcommon，其中libxkbcommon依赖libxml。

1.1、xcb-util-wm

下载地址：Index of /releases/individual/xcbhttps://www.x.org/releases/individual/xcb/

#解压

tar -zxvf x

qt 打包程序到别的电脑上缺少xcb错误两个大坑

qq_45988470的博客

02-25

2619

This application failed to start because it could not find or load the

Qt platform plugin “xcb” in “”.

一般我们都知道，打包的时候要添加添加platform文件夹，文件夹里放上libqxcb.so。我这里遇到了两个另外的问题，

一

需添加libQt5XcbQpa.so.5，注意是就是我下面选中的文件，不要去复制快捷方式，具体的做法应该是把那个文件复制到你的程序所在目录去，并将libQt5XcbQpa.s.

kylin aarch-64位下编译qt-xcb 。

malihong1的专栏

01-05

1409

为了再kylin 64位下编译qt源码，先编译xcb，可以先参考一位博主的文章CentOS7 环境下交叉编译（银河麒麟）_lijing_sun的博客-CSDN博客_银河麒麟交叉编译

，按照步骤来，前面其他的还好编译，就是在编译xproto的时候一直有问题，提示类似无法猜测编译类型啥的，后来使用如下命令，成功编译：

sudo ./configure --enable-static --build=arm-linux

sudo make

sudo make install

...

在Ubuntu上运行Qt发布的应用程序时遇到xcb问题，可以尝试以下几个步骤：

ylfdragon2005的博客

09-11

1263

可以尝试设置QT_QPA_PLATFORM_PLUGIN_PATH环境变量。如果以上步骤都无法解决xcb问题，则可能需要升级Qt库或重新安装Qt Creator。尝试安装libqt5xcbqpa插件。或者将其添加到~/.bashrc文件中（如果它不存在，请创建）。重新启动应用程序或系统，并尝试再次运行Qt应用程序。// 或者使用一下命令再尝试一下。

Qt+x11+xcb的例子

03-08

Qt+x11+xcb的例子, 详见http://blog.csdn.net/xgbing/article/details/79479380

解决安装QT时报的libX11-xcb.so.1 缺包问题

02-21

解决安装QT时报的libX11-xcb.so.1 缺包问题解决安装QT时报的libX11-xcb.so.1 缺包问题解决安装QT时报的libX11-xcb.so.1 缺包问题解决安装QT时报的libX11-xcb.so.1 缺包问题解决安装QT时报的libX11-xcb.so.1 缺包问题...

qt-5.9.9-gcc485-libc217-static-qt-xcb.tar.gz

04-09

./configure -confirm-license -opensource -debug-and-release -static -prefix ../build -no-opengl -nomake tests -no-compile-examples -nomake examples -qt-xcb ———————————————— 原文链接：...

x86上交叉编译的arm xcb插件，配合qt源码编译使用

xcb

Edit

Page History

Repo Info

Introduction

The X protocol C-language Binding (XCB) is a replacement for Xlib featuring a small footprint, latency hiding, direct access to the protocol, improved threading support, and extensibility.

News

August 2023: xcb-proto 1.16 and libxcb 1.16 were released. In addition to fixing bugs, this adds support for DPMS 1.2 & Present 1.3.

May 2022: xcb-proto 1.15 and libxcb 1.15 were released. In addition to fixing bugs, this adds support for XInput 2.4.

February 2020: xcb-proto 1.14 and libxcb 1.14 were released. In addition to fixing bugs, this brings compatibility with check >= 0.13 and adds xcb_total_read() and xcb_total_written() APIs.

March 2018: xcb-proto 1.13 and libxcb 1.13 were released. In addition to fixing bugs, this enables new and completed versions of some protocols.

May 2016: xcb-proto 1.12 and libxcb 1.12 were released.

September 2015: libxcb 1.11.1 was released. This fixes some thread-related issues and adds 64-bit versions of some APIs.

August 2014: xcb-proto 1.11 and libxcb 1.11 were released. This is again mostly a bug-fix release.

December 2013: xcb-proto 1.10 and libxcb 1.10 were released, this time mainly fixing some API and ABI issues introduced with libxcb 1.9.2. See the linked announcements for more details.

May 2013: libxcb 1.9.1 was released, fixing the python code to work with Python 3, and fixing an integer overflow in the read_packet() function (CVE-2013-2064)

October 2012: New releases of the XCB packages have been published, including autogenerated man pages for XCB API's - see the linked announcements for full details of what's changed in each one:

xcb-proto 1.8

libxcb 1.9

Download

You can obtain released versions of XCB from http://xcb.freedesktop.org/dist.

Follow the instructions from the developer's guide to build, except that you can use released versions of the dependencies, and you don't need git, automake, autoconf, or libtool.

Development

If you wish to work on XCB, please read the developer's guide.

Mailing list: Discussion of XCB and Xlib/XCB is through the XCB mailing list.

IRC: XCB developers also hang out on IRC, and have occasional meetings.

Of course, there's still a lot to do .

Documentation

The XCB API is documented. There is also a tutorial and some random notes.

People wanting to implement higher level applications can use xcb-util.

XCB is built atop an XML description of the X core protocol and common extension protocols called XML/XCB. This protocol can be used in other interesting ways. Documentation of the X Window System protocol is also available at X.org's website, and can be used in combination with XCB documentation as XCB functions largely reflect the protocol.

To aid in porting applications, you can configure Xlib to use XCB for the transport layer. We call this Xlib/XCB.

There is automatically-generated documentation for the XCB protocol bindings.

The Windows (32 bit) port of XCB will be merged into the main code base soon. You can read more on that here.

Miscellaneous

The XCB logo

The XCB project has a long history, during which it has produced many academic publications. Various projects have adopted XCB.

Links:

XCBDevelopmentPlan

XCBToDo

XcbApi

XmlXcb

usingxcb

Last edited Sat Mar 2 22:47:09 2024

XCB - 维基百科，自由的百科全书

跳转到内容

主菜单

移至侧栏

隐藏

导航

首页分类索引特色内容新闻动态最近更改随机条目资助维基百科

帮助

帮助维基社群方针与指引互助客栈知识问答字词转换IRC即时聊天联络我们关于维基百科

语言

语言链接位于页面顶部，标题的另一侧。

搜索

创建账号

个人工具

创建账号登录

未登录编辑者的页面了解详情

贡献讨论

移至侧栏

隐藏

序言

1理念

2示例

3注释

4外部链接

开关目录

XCB

7种语言

DeutschEnglishEspañolFrançais日本語한국어Русский

编辑链接

条目讨论

大陆简体

不转换简体繁體大陆简体香港繁體澳門繁體大马简体新加坡简体臺灣正體

阅读编辑查看历史

工具

移至侧栏

隐藏

操作

阅读编辑查看历史

常规

链入页面相关更改上传文件特殊页面固定链接页面信息引用本页获取短URL下载二维码维基数据项目

打印/导出

下载为PDF可打印版

在其他项目中

维基共享资源

维基百科，自由的百科全书

XCB开发者Jamey Sharp、Josh Triplett、Bart Massey当前版本1.16.1 (2024年3月2日；稳定版本)[1]

源代码库gitlab.freedesktop.org/xorg/lib/libxcb

操作系统POSIX类型X Window核心协议开发函式库许可协议MIT许可证网站xcb.freedesktop.org

XCB（X C Binding）是一套以 C语言撰写，并用于绑定（Binding） X Window System之上。XCB是一套免费的软件，目标在于取代 Xlib。这个计划开始于2001年，作者是Bart Massey.

理念[编辑]

XCB 主要目标是:

减轻函式库的大小与复杂度;

可直接访问 X Window核心协议。

示例[编辑]

/* Simple XCB application drawing a box in a window */

#include

int main()

{

xcb_connection_t *c;

xcb_screen_t *s;

xcb_window_t w;

xcb_gcontext_t g;

xcb_generic_event_t *e;

uint32_t mask;

uint32_t values[2];

int done = 0;

xcb_rectangle_t r = { 20, 20, 60, 60 };

/* open connection with the server */

c = xcb_connect(NULL,NULL);

if (xcb_connection_has_error(c)) {

printf("Cannot open display\n");

exit(1);

}

/* get the first screen */

s = xcb_setup_roots_iterator( xcb_get_setup(c) ).data;

/* create black graphics context */

g = xcb_generate_id(c);

w = s->root;

mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;

values[0] = s->black_pixel;

values[1] = 0;

xcb_create_gc(c, g, w, mask, values);

/* create window */

w = xcb_generate_id(c);

mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;

values[0] = s->white_pixel;

values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;

xcb_create_window(c, s->root_depth, w, s->root,

10, 10, 100, 100, 1,

XCB_WINDOW_CLASS_INPUT_OUTPUT, s->root_visual,

mask, values);

/* map (show) the window */

xcb_map_window(c, w);

xcb_flush(c);

/* event loop */

while (!done && (e = xcb_wait_for_event(c))) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: /* draw or redraw the window */

xcb_poly_fill_rectangle(c, w, g, 1, &r);

xcb_flush(c);

break;

case XCB_KEY_PRESS: /* exit on key press */

done = 1;

break;

}

free(e);

}

/* close connection to server */

xcb_disconnect(c);

return 0;

}

注释[编辑]

^ libxcb-1.16.1.

^ [ANNOUNCE] libxcb 1.14. xcb (邮件列表). 2020-02-22 [2020-02-22]. （原始内容存档于2021-02-26）.

外部链接[编辑]

XCB wiki （页面存档备份，存于互联网档案馆） (freedesktop.org)

XCB API reference （页面存档备份，存于互联网档案馆）

Further publications （页面存档备份，存于互联网档案馆）

查论编Freedesktop.org托管的自由及开放源代码软件项目操作系统组件音频

PulseAudio

PipeWire

图形

Compiz

DRI（英语：Direct Rendering Infrastructure）

Enchant（英语：Enchant (software)）

nouveau

Plymouth

Wayland

X.Org Server

Glamor

Xephyr（英语：Xephyr）

其它

Avahi（英语：Avahi (software)）

D-Bus

Flatpak

kmscon（英语：kmscon）

luit（英语：luit）

PackageKit

pkg-config

Systemd

函式库

AppStream

cairo

Fontconfig

GStreamer

Mesa 3D

fprint（英语：fprint）

HarfBuzz

Pango

Poppler

Swfdec（英语：Swfdec）

Video Acceleration API（英语：Video Acceleration API）

XCB

Xft（英语：Xft）

软件框架

CppUnit（英语：CppUnit）

Galago（英语：Galago (software)）

GeoClue（英语：GeoClue）

Open Collaboration Services（英语：Open Collaboration Services）

Telepathy

会议

Create Project（英语：Create Project）

波特兰计划

查论编X窗口系统架构

核心协议

X Window选择（英语：X Window selection）

X Toolkit Intrinsics

X窗口授权（英语：X Window authorization）

X11颜色名称（英语：X11 color names）

X输入法

Wayland

扩展

X图像扩展（英语：X Image Extension）

X键盘扩展（英语：X keyboard extension）

RandR

X渲染扩展（英语：X Rendering Extension）

形状扩展（英语：Shape extension）

共享内存扩展（英语：MIT-SHM）

X显示管理器控制协议（英语：XDM (display manager)）

X视频扩展（英语：X video extension）

X视频运动补偿（英语：X-Video Motion Compensation）

AIGLX（英语：AIGLX）

GLX（英语：GLX）

多指针X（英语：Multi-Pointer X）

Display PostScript

合成（英语：Composite (graphics)）

Xinerama（英语：Xinerama）

组件和值得注意的实现显示服务器（英语：display server）

X.Org Server

Cygwin/X

X-Win32（英语：X-Win32）

X386（英语：X386）

XFree86

XGGI（英语：XGGI）

XDarwin（英语：XDarwin）

Xming

Xsgi（英语：Xsgi）

Xsun（英语：Xsun）

Xgl

Xnest（英语：Xnest）

Xephyr（英语：Xephyr）

XQuartz

XWayland

客户端库

Xlib

XCB

显示管理器会话管理器

GNOME显示管理器

KDM

SDDM（英语：Simple Desktop Display Manager）

XDM（英语：XDM (display manager)）

LightDM

LXDM

SLiM（英语：SLiM）

Entrance（英语：Entrance (display manager)）

WDM

X视窗管理器合成（英语：compositing window manager）

Compiz

KWin

Metacity

Mutter

Xfwm

平铺（英语：tiling window manager）

awesome

dwm

Ion（英语：Ion (window manager)）

PWM（英语：PWM (window manager)）

ratpoison

wmii（英语：wmii）

xmonad

堆叠（英语：stacking window manager）

AfterStep（英语：AfterStep）

amiwm（英语：amiwm）

Blackbox

cwm（英语：cwm (window manager)）

Enlightenment

Fluxbox

FVWM

IceWM

JWM

Matchbox（英语：Matchbox (window manager)）

MWM

Openbox

Sawfish

twm

Window Maker

标准

ICCCM

EWMH

XDS

freedesktop.org

应用程序

xcalc

xclock

xedit

xload

xterm

xeyes

桌面环境（英语：Comparison of X Window System desktop environments）

取自“https://zh.wikipedia.org/w/index.php?title=XCB&oldid=71704018”

分类：X Window系统隐藏分类：使用未知软件信息框参数的页面

本页面最后修订于2022年5月19日 (星期四) 01:16。

本站的全部文字在知识共享署名-相同方式共享 4.0协议之条款下提供，附加条款亦可能应用。（请参阅使用条款）

Wikipedia®和维基百科标志是维基媒体基金会的注册商标；维基™是维基媒体基金会的商标。

维基媒体基金会是按美国国内税收法501(c)(3)登记的非营利慈善机构。

隐私政策

关于维基百科

免责声明

行为准则

开发者

统计

Cookie声明

手机版视图

开关有限宽度模式

tutorial

xcb/

tutorial

Edit

Page History

Repo Info

Tutorial based off original here, which in turn was based off an Xlib tutorial by Guy Keren.

After reading this page, read these pages (in this order):

Basic Windows and Drawing

Events

Text and Fonts

Window Context and Manipulation

Colors and PixMaps

Mouse Cursors

Xlib to XCB Translation Guide

Introduction

This tutorial is intended for people who want to program with the XCB library. Keep in mind that XCB, like the Xlib library, isn't what most programmers wanting to write X applications are looking for. Rather, most application developers will want to use a much higher-level GUI toolkit, like Motif, LessTiff, GTK, Qt, EWL, or ETK or perhaps use the higher-level drawing library Cairo. However, the basics of XCB are not all that complicated, and knowing about the layers those other libraries are built on top of is not a bad idea.

After reading this tutorial, one should be able to write very simple graphical programs but not write programs with decent user interfaces (at least easily). For real applications, the previously mentioned libraries are much more appropriate.

What is XCB and why does it exist?

XCB ("X C Binding") is an low-level API for the X window server. XCB is an alternative to Xlib, which has been the standard C binding for the X Window System protocol for many years now. Xlib is an excellent piece of work, but there are applications for which it is not ideal, for example:

Small platforms: Xlib is a large piece of code, and it's difficult to make it smaller

Latency hiding: Xlib requests requiring a reply are effectively synchronous: they block until the reply appears, whether the result is needed immediately or not.

Direct access to the protocol: Xlib does quite a bit of caching, layering, and similar optimizations. While this is normally a feature, it makes it difficult to simply emit specified X protocol requests and process specific responses.

Threaded applications: While Xlib does attempt to support multithreading, the API makes this difficult and error-prone.

New extensions: The Xlib infrastructure provides limited support for the new creation of X extension client side code.

XCB has been designed to solve the above problems and thus provide a base for:

Toolkit implementation.

Direct protocol-level programming.

Lightweight emulation of commonly used portions of the Xlib API.

The client and server model of the X window system

The X Window System was developed with one major goal: flexibility. The idea was that the way things look is one thing, but the way things work is another matter. Thus, the lower levels provide the tools required to draw windows, handle user input, allow drawing graphics using colors (or black and white screens), etc. To this point, a decision was made to separate the system into two parts. A client that decides what to do, and a server that actually draws on the screen and reads user input in order to send it to the client for processing.

This model is the complete opposite of what is used to when dealing with clients and servers. In our case, the user sits near the machine controlled by the server, while the client might be running on a remote machine. The server controls the screens, mouse and keyboard. A client may connect to the server, request that it draws a window (or several windows), and ask the server to send it any input the user sends to these windows. Thus, several clients may connect to a single X server (one might be running mail software, one running a WWW browser, etc). When input is sent by the user to some window, the server sends a message to the client controlling this window for processing. The client decides what to do with this input, and sends the server requests for drawing in the window.

The whole session is carried out using the X message protocol. This protocol was originally carried over the TCP/IP protocol suite, allowing the client to run on any machine connected to the same network that the server is. Later on, the X servers were extended to allow clients running on the local machine with more optimized access to the server (note that an X protocol message may be several hundreds of KB in size), such as using shared memory, or using Unix domain sockets (a method for creating a logical channel on a Unix system between two processes).

GUI programming: the asynchronous model

Unlike conventional computer programs, that carry some serial nature, a GUI program usually uses an asynchronous programming model, also known as "event-driven programming". This means that that program mostly sits idle, waiting for events sent by the X server, and then acts upon these events. An event may say "The user pressed the 1st button mouse in spot (x,y)", or "The window you control needs to be redrawn". In order for the program to be responsive to the user input, as well as to refresh requests, it needs to handle each event in a rather short period of time (e.g. less that 200 milliseconds, as a rule of thumb).

This also implies that the program may not perform operations that might take a long time while handling an event (such as opening a network connection to some remote server, or connecting to a database server, or even performing a long file copy operation). Instead, it needs to perform all these operations in an asynchronous manner. This may be done by using various asynchronous models to perform the longish operations, or by performing them in a different process or thread.

So the way a GUI program looks is something like that:

Perform initialization routines.

Connect to the X server.

Perform X-related initialization.

While not finished:

Receive the next event from the X server.

Handle the event, possibly sending various drawing requests to the X server.

If the event was a quit message, exit the loop.

Close down the connection to the X server.

Perform cleanup operations.

Basic XCB notions

XCB has been created to eliminate the need for programs to actually implement the X protocol layer. This library gives a program a very low-level access to any X server. Since the protocol is standardized, a client using any implementation of XCB may talk with any X server (the same occurs for Xlib, of course). We now give a brief description of the basic XCB notions. They will be detailed later.

1. The X Connection

The major notion of using XCB is the X Connection. This is a structure representing the connection we have open with a given X server. It hides a queue of messages coming from the server, and a queue of pending requests that our client intends to send to the server. In XCB, this structure is named 'xcb_connection_t'. It is analogous to the Xlib Display. When we open a connection to an X server, the library returns a pointer to such a structure. Later, we supply this pointer to any XCB function that should send messages to the X server or receive messages from this server.

2. Requests and replies: the Xlib killers

To ask for information from the X server, we have to make a request and ask for a reply. With Xlib, these two tasks are automatically done: Xlib locks the system, sends a request, waits for a reply from the X server and unlocks. This is annoying, especially if one makes a lot of requests to the X server. Indeed, Xlib has to wait for the end of a reply before asking for the next request (because of the locks that Xlib sends). For example, here is a time-line of N=4 requests/replies with Xlib, with a round-trip latency T_round_trip that is 5 times long as the time required to write or read a request/reply (T_write/T_read):

W-----RW-----RW-----RW-----R

* W: Writing request

* -: Stalled, waiting for data

* R: Reading reply

The total time is N * (T_write + T_round_trip + T_read).

With XCB, we can suppress most of the round-trips as the requests and the replies are not locked. We usually send a request, then XCB returns to us a cookie, which is an identifier. Then, later, we ask for a reply using this cookie and XCB returns a pointer to that reply. Hence, with XCB, we can send a lot of requests, and later in the program, ask for all the replies when we need them. Here is the time-line for 4 requests/replies when we use this property of XCB:

WWWW--RRRR

The total time is N * T_write + max (0, T_round_trip - (N-1) * T_write) + N * T_read. Which can be considerably faster than all those Xlib round-trips.

Here is a program that computes the time to create 500 atoms with Xlib and XCB. It shows the Xlib way, the bad XCB way (which is similar to Xlib) and the good XCB way. On my computer, XCB is 25 times faster than Xlib. On another random machine XCB has been observed to be up to 117 times faster than Xlib, on rare occasions.

To further compare Xlib to XCB, there's a XInternAtoms routine. It's the Xlib method to request all the atoms in an array at one time to help hide the latency. Mostly the good Xlib time takes twice the time as the good XCB time. It also highlights the complexity of using XCB, 3 simple statements for Xlib vs 9 statements including two loops for XCB. If this simple test was expanded beyond requesting Atoms, XCB would allow submitting all the various requests at one time, Xlib wouldn't.

/* It's a good idea to paste this and other long code examples

into a text editor for easier reading */

#include

#define NUM_NAMES 500

NOTE: For concision, we're going to be cheesy and use arrays where real code

would use points and memory allocation.s

#ifndef __GNUC__

char* strdup(const char* s) {

int n = strlen(s) + 1;

char *dup = malloc(n);

if(dup)

strcpy(dup, s);

return dup;

}

#endif

return interval of time (uses time.h)

double

get_time (void) {

struct timeval timev;

gettimeofday(&timev, NULL);

return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);

}

void

useXlib (char **names,

Display *display ) {

Atom atoms[NUM_NAMES];

for (int i = 0; i < NUM_NAMES; ++i) {

atoms[i] = XInternAtom(display, names[i], 0);

}

Request all atoms at once.

void

useXlibProperly (char **names,

Display *display ) {

Atom atoms[NUM_NAMES];

if(!XInternAtoms(display, names, NUM_NAMES, 0, atoms))

fprintf(stderr, "XInternAtoms failed\n");

}

void

useXCBPoorly (char **names,

xcb_connection_t *connection ) {

xcb_atom_t atoms[NUM_NAMES];

// in this bad use of xcb, we use the cookie immediately after posting the request with xcb_intern_atom

for (int i = 0; i < NUM_NAMES; ++i) {

/* make request */

xcb_intern_atom_cookie_t cookie = xcb_intern_atom (connection,

strlen(names[i]),

names[i] );

/* get response */

xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply (connection,

cookie,

NULL ); // normally a pointer to receive error, but we'll just ignore error handling

if (reply) {

atoms[i] = reply->atom;

free (reply);

}

// now we have our atoms (replies), but this is just a demo, so we do nothing with them

}

void

useXCBProperly (char **names,

xcb_connection_t *connection ) {

xcb_atom_t atoms[NUM_NAMES];

xcb_intern_atom_cookie_t cookies[NUM_NAMES];

// in this good example, we make all our requests before checking for

// replies because it's best to queue requests when we have many at once

/* make requests */

for (int i = 0; i < NUM_NAMES; ++i) {

cookies[i] = xcb_intern_atom (connection,

strlen (names[i]),

names[i] );

}

/* get responses */

for (int i = 0; i < NUM_NAMES; ++i) {

xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply (connection,

cookies[i],

NULL ); // normally a pointer to receive errors, but we'll just ignore error handling

if (reply) {

atoms[i] = reply->atom;

free (reply);

}

// now we have our atoms (replies), but this is just a demo, so we do nothing with them

}

int

main () {

/* setup names for tests */

char (**names) = malloc(NUM_NAMES*sizeof(*names));

// init names to "NAME0", "NAME1", "NAME2" ... and so on

for (int i = 0; i < NUM_NAMES; ++i) {

char buf[100];

sprintf (buf, "NAME%d", i);

names[i] = strdup (buf);

}

/* do tests */

double start, XlibTime, XlibGoodTime, XCBBadTime, XCBGoodTime;

/* test Xlib */

Display *display = XOpenDisplay (NULL);

start = get_time ();

useXlib (names, display);

XlibTime = get_time () - start;

start = get_time ();

useXlibProperly (names, display);

XlibGoodTime = get_time () - start;

XCloseDisplay (display);

/* test XCB */

xcb_connection_t *connection = xcb_connect (NULL, NULL);

start = get_time ();

useXCBPoorly (names, connection);

XCBBadTime = get_time () - start;

start = get_time ();

useXCBProperly (names, connection);

XCBGoodTime = get_time () - start;

xcb_disconnect (connection);

/* report times */

printf ("Bad Xlib time : %f\n", XlibTime);

printf ("Good Xlib time : %f\n", XlibGoodTime);

printf ("Bad xcb time : %f\n", XCBBadTime);

printf ("Good xcb time : %f\n", XCBGoodTime);

printf ("ratio of good xcb time to bad xcb time: %f\n", XCBGoodTime / XCBBadTime);

printf ("ratio of Xlib time to good xcb time: %f\n", XlibTime / XCBGoodTime);

printf ("ratio of good Xlib time to bad Xlib time: %f\n", XlibGoodTime / XlibTime);

return 0;

}

3. The Graphics Context

When we perform various drawing operations (graphics, text, etc), we may specify various options for controlling how the data will be drawn (what foreground and background colors to use, how line edges will be connected, what font to use when drawing some text, etc). In order to avoid the need to supply hundreds of parameters to each drawing function, a graphical context structure is used. We set the various drawing options in this structure, and then we pass a pointer to this structure to any drawing routines. This is rather handy, as we often need to perform several drawing requests with the same options. Thus, we would initialize a graphical context, set the desired options, and pass this structure to all drawing functions.

Note that graphic contexts have no client-side structure in XCB, they're just XIDs. Xlib has a client-side structure because it caches the GC contents so it can avoid making redundant requests, but of course XCB doesn't do that.

4. Events

A structure is used to pass events received from the X server. XCB supports exactly the events specified in the protocol (33 events). This structure contains the type of event received (including a bit for whether it came from the server or another client), as well as the data associated with the event (e.g. position on the screen where the event was generated, mouse button associated with the event, region of the screen associated with a "redraw" event, etc). The way to read the event's data depends on the event type.

Using XCB-based programs

1. Installing XCB

TODO: These instructions are out of date. Just reference the main XCB page so we don't have to maintain these instructions in more than one place.

To build XCB from source, you need to have installed at least:

pkgconfig 0.15.0

automake 1.7

autoconf 2.50

check

xsltproc

gperf 3.0.1

You have to checkout in the git repository the following modules:

Xau from xlibs

xcb-proto

xcb

Note that xcb-proto exists only to install header files, so typing 'make' or 'make all' will produce the message "Nothing to be done for 'all'". That's normal.

2. Compiling XCB-based programs

Compiling XCB-based programs requires linking them with the XCB library. This is easily done thanks to pkgconfig:

gcc -Wall prog.c -o prog `pkg-config --cflags --libs xcb`

or simply :

gcc -Wall prog.c -lxcb

Opening and closing the connection to an X server

An X program first needs to open the connection to the X server, using xcb_connect():

xcb_connection_t *xcb_connect (const char *displayname, // if NULL, uses the DISPLAY environment variable

int *screenp ); // returns the screen number of the connection; can provide NULL if you don't care

To close a connection, it suffices to use:

void xcb_disconnect (xcb_connection_t *c);

So for example:

#include

...

xcb_connection_t *connection = xcb_connect (NULL, NULL);

xcb_disconnect (connection);

Comparison Xlib/XCB:

XOpenDisplay () => xcb_connect ()

XCloseDisplay () => xcb_disconnect ()

Checking basic information about a connection

Once we have opened a connection to an X server, we should check some basic information about it: what screens it has, what is the size (width and height) of the screen, how many colors it supports (black and white ? grey scale ?, 256 colors ? more ?), and so on. We get such information from the xcbscreent structure:

typedef struct {

xcb_window_t root;

xcb_colormap_t default_colormap;

uint32_t white_pixel;

uint32_t black_pixel;

uint32_t current_input_masks;

uint16_t width_in_pixels;

uint16_t height_in_pixels;

uint16_t width_in_millimeters;

uint16_t height_in_millimeters;

uint16_t min_installed_maps;

uint16_t max_installed_maps;

xcb_visualid_t root_visual;

uint8_t backing_stores;

uint8_t save_unders;

uint8_t root_depth;

uint8_t allowed_depths_len;

} xcb_screen_t;

We could retrieve the first screen of the connection by using the following function:

xcb_screen_iterator_t xcb_setup_roots_iterator (xcb_setup_t *R);

Here is a small program that shows how to use this function:

#include

int

main ()

{

/* Open the connection to the X server. Use the DISPLAY environment variable */

int i, screenNum;

xcb_connection_t *connection = xcb_connect (NULL, &screenNum);

/* Get the screen whose number is screenNum */

const xcb_setup_t *setup = xcb_get_setup (connection);

xcb_screen_iterator_t iter = xcb_setup_roots_iterator (setup);

// we want the screen at index screenNum of the iterator

for (i = 0; i < screenNum; ++i) {

xcb_screen_next (&iter);

}

xcb_screen_t *screen = iter.data;

/* report */

printf ("\n");

printf ("Informations of screen %"PRIu32":\n", screen->root);

printf (" width.........: %"PRIu16"\n", screen->width_in_pixels);

printf (" height........: %"PRIu16"\n", screen->height_in_pixels);

printf (" white pixel...: %"PRIu32"\n", screen->white_pixel);

printf (" black pixel...: %"PRIu32"\n", screen->black_pixel);

printf ("\n");

return 0;

}

The window hierarchy

TODO

Links:

index

Last edited Sat 29 Mar 2014 03:59:04 PM UTC

XCB - Wikipedia

Jump to content

Main menu

move to sidebar

hide

Navigation

Main pageContentsCurrent eventsRandom articleAbout WikipediaContact usDonate

Contribute

HelpLearn to editCommunity portalRecent changesUpload file

Languages

Language links are at the top of the page.

Create account

Personal tools

Create account Log in

Pages for logged out editors learn more

ContributionsTalk

Contents

move to sidebar

hide

(Top)

1Overview

Toggle Overview subsection

1.1Xlib compatibility

2Example

3Protocol description

4Logo

5Other language bindings

6Notes

7References

8External links

Toggle the table of contents

XCB

7 languages

DeutschEspañolFrançais한국어日本語Русский中文

Edit links

ArticleTalk

English

ReadEditView history

Tools

move to sidebar

hide

Actions

ReadEditView history

General

What links hereRelated changesUpload fileSpecial pagesPermanent linkPage informationCite this pageGet shortened URLDownload QR codeWikidata item

Print/export

Download as PDFPrintable version

In other projects

Wikimedia Commons

From Wikipedia, the free encyclopedia

X protocol C language binding library

This article relies excessively on references to primary sources. Please improve this article by adding secondary or tertiary sources. Find sources: "XCB" – news · newspapers · books · scholar · JSTOR (November 2009) (Learn how and when to remove this template message)

Original author(s)Bart MasseyDeveloper(s)Jamey Sharp, Josh Triplett, Bart MasseyInitial release2001; 23 years ago (2001)Stable release1.16.1[1]

/ 2 March 2024; 3 days ago (2 March 2024)

Repositorygitlab.freedesktop.org/xorg/lib/libxcb

Written inCOperating systemPOSIXTypeX11 client libraryLicenseMIT LicenseWebsitexcb.freedesktop.org

X11-clients use XCB to communicate with the X server.

A more complete view of the Linux graphics stack

Programs often use GTK or FLTK or Qt for their GUI widgets.

A more complete view of the components of an operating system for home computers.

XCB (X protocol C-language Binding) is a library implementing the client-side of the X11 display server protocol. XCB is written in the C programming language and distributed under the MIT License. The project was started in 2001 by Bart Massey and aims to replace Xlib.

Overview[edit]

XCB was designed as a smaller, modernized replacement for Xlib, previously the primary C library for communicating with the X window system, coinciding with a more complete overhaul of the X implementation that took place during the early 2000s.[2] The main goals of XCB are to:

reduce library size and complexity

provide direct access to the X11 protocol

The required size reduction is achieved primarily by restricting XCB's scope to handling the X protocol and omitting Xlib functionality such as its extensive utility library, much of which saw little use by applications. This results in a factor thirty reduction of the compiled library size (as of 2004).[3]

Secondary goals include making the C interface asynchronous, facilitating better multithreading and making it easier to implement extensions (via XML protocol descriptions).

The core and extension protocol descriptions are in XML, with a program written in Python creating the C bindings. (Previous versions used XSLT and M4.)

A further goal is to be able to use these protocol descriptions to create protocol documentation, more language bindings, and server-side stubs.

Massey and others have worked to prove key portions of XCB formally correct using Z notation.[4] (Xlib has long been known to contain errors.[5])

Xlib compatibility[edit]

Xlib/XCB provides application binary interface compatibility with both Xlib and XCB, providing an incremental porting path.[6] Xlib/XCB uses the protocol layer of Xlib, but replaces the Xlib transport layer with XCB, and provides access to the underlying XCB connection for direct use of XCB. Xlib/XCB allows an application to open a single connection to the X display server and use both XCB and Xlib, possibly through a mixture of libraries designed for one or the other.[7][8]

Example[edit]

// Simple XCB application for opening a window and drawing a box in it

// To compile it using GNU, use:

// gcc x.c -lxcb

#include

int main(void)

{

xcb_connection_t *c;

xcb_screen_t *s;

xcb_window_t w;

xcb_gcontext_t g;

xcb_generic_event_t *e;

uint32_t mask;

uint32_t values[2];

int done = 0;

xcb_rectangle_t r = { 20, 20, 60, 60 };

// open connection to the server

c = xcb_connect(NULL,NULL);

if (xcb_connection_has_error(c)) {

printf("Cannot open display\n");

exit(EXIT_FAILURE);

}

// get the first screen

s = xcb_setup_roots_iterator( xcb_get_setup(c) ).data;

// create black graphics context

g = xcb_generate_id(c);

w = s->root;

mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;

values[0] = s->black_pixel;

values[1] = 0;

xcb_create_gc(c, g, w, mask, values);

// create window

w = xcb_generate_id(c);

mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;

values[0] = s->white_pixel;

values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;

xcb_create_window(c, s->root_depth, w, s->root,

10, 10, 100, 100, 1,

XCB_WINDOW_CLASS_INPUT_OUTPUT, s->root_visual,

mask, values);

// map (show) the window

xcb_map_window(c, w);

xcb_flush(c);

// event loop

while (!done && (e = xcb_wait_for_event(c))) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: // draw or redraw the window

xcb_poly_fill_rectangle(c, w, g, 1, &r);

xcb_flush(c);

break;

case XCB_KEY_PRESS: // exit on key press

done = 1;

break;

}

free(e);

}

// close connection to server

xcb_disconnect(c);

exit(EXIT_SUCCESS);

}

XCB has a comparable, but slightly lower-level API than Xlib,[9] as can be seen with this example.

Protocol description[edit]

Creators of XCB have invented a specialized interface description language to model X11 protocol in language-neutral way and facilitate generation of bindings to other programming languages. libxcb itself is implemented as a code generator and a tiny C stub of utility functions.

An example:

extension-name="BigRequests" extension-multiword="true"

major-version="0" minor-version="0">

Logo[edit]

The XCB logo was produced by Gearóid Molloy, author of the web comic Neko the Kitty, and donated to the project.[10]

Other language bindings[edit]

XCB.pm - Perl module implementing bindings to XCB.

xpyb - The Python binding to the X Window System using XCB. As of June 2013, it does not support Python 3. Provided by freedesktop.org.

xcffib - Another Python binding which supports Python 2 & 3 as well as several more X extensions than xpyb.

Notes[edit]

^ "libxcb-1.16.1".

^ Gettys, James; Packard, Keith (2004). The (Re) Architecture of the X Window System (PDF). Proc. Linux Symposium. Vol. 1.

^ Sharp, Jamey (2004). How Xlib is Implemented (And What We're Doing About It) (PDF). Proc. Usenix Annual Techn. Conf., Freenix Track.

^ Massey and Bauer, 2002.

^ Sharp and Massey, 2002, §2.4. "While Xlib was designed to support threaded applications, and while that support is not unusable, there are known race conditions that cannot be eliminated without changing the Xlib interface."

^ Maloney, Ross J. (31 March 2018). Low Level X Window Programming: An Introduction by Examples. Springer. pp. 225–244. ISBN 978-3-319-74250-2. Retrieved 17 May 2022.

^ "Xlib/XCB: Xlib with XCB transport". 2008-01-11. Retrieved 2009-09-11.

^ Jamey Sharp and Josh Triplett (2006-11-26). "libx11 with Xlib/XCB now in experimental; please test with your packages". debian-devel-announce (Mailing list). Retrieved 2009-09-11.

^ Jamey Sharp; Bart Massey (2002), XCL : An Xlib Compatibility Layer For XCB, USENIX 2002 Annual Technical Conference, Freenix Track

^ KittyLogo (xcb.freedesktop.org)

References[edit]

Massey, Bart; Sharp, Jamey (2001-09-19). "XCB: An X Protocol C Binding" (PDF). Proceedings of the XFree86 Technical Conference. Oakland, California: USENIX. Retrieved 2012-03-12.

Massey, Bart; Bauer, Robert (2002). "X Meets Z: Verifying Correctness In The Presence Of POSIX Threads". Proceedings of the FREENIX Track: 2002 USENIX Annual Technical Conference. Monterey, California: USENIX. pp. 221–234. Retrieved 2008-11-07.

Sharp, Jamey; Massey, Bart (2002). "XCL: A Compatibility Layer For XCB". Proceedings of the FREENIX Track: 2002 USENIX Annual Technical Conference. Monterey, California: USENIX. pp. 71–83. Retrieved 2008-11-07.

External links[edit]

Free Software portal

XCB wiki (freedesktop.org)

XCB API reference, tutorial

libxcb tutorial

Further publications

The X New Developer’s Guide: Xlib and XCB

vteFree and open-source software projects hosted by freedesktop.orgOS componentsSound

PulseAudio

PipeWire

Graphics

Compiz

DRI

Enchant

nouveau

Plymouth

Wayland

X.Org Server

Glamor

Xephyr

Other

Avahi

D-Bus

Flatpak

Kmscon

luit

PackageKit

pkg-config

Systemd

Libraries

AppStream

Cairo

FreeType

Fontconfig

GStreamer

libinput

Mesa 3D

HarfBuzz

Pango

Poppler

Swfdec

Video Acceleration API

XCB

Xft

Frameworks

CppUnit

Open Collaboration Services (OCS)

Telepathy

Meetings

Create Project

Portland Project

vteX Window SystemArchitecture

Core protocol

X Window selection

X Window authorization

X11 color names

X Input Method

Wayland

Extensions

X Image Extension

X keyboard extension

RandR

X Rendering Extension

Shape extension

Shared memory extension

X Display Manager Control Protocol

X video extension

X-Video Motion Compensation

AIGLX

GLX

Multi-Pointer X

Display PostScript

Composite Extension

Xinerama

Componentsand notableimplementationsDisplay servers

X.Org Server

Cygwin/X

X-Win32

X386

XFree86

XDarwin

Xming

Xsgi

Xsun

Xgl

Xephyr

XQuartz

XWayland

Client libraries

Xlib

XCB

X Toolkit Intrinsics

Display managersSession managers

GDM

KDM

SDDM

XDM

LightDM

LXDM

Entrance

WDM

Window managers(comparison)Compositing

Compiz

KWin

Metacity

Mutter

Xfwm

Enlightenment

Stacking

4Dwm

9wm

AfterStep

amiwm

Blackbox

CTWM

cwm

Fluxbox

FLWM

FVWM

IceWM

JWM

Matchbox

mwm

olwm

Openbox

Qvwm

Sawfish

swm

tvtwm

twm

vtwm

WindowLab

Window Maker

wm2

Tiling

awesome

dwm

Ion

ratpoison

wmii

xmonad

StumpWM

larswm

Standards

ICCCM

EWMH

XDS

freedesktop.org

Applications

xcalc

xclock

xedit

xload

xterm

xeyes

Desktop environments (comparison)

vteList of widget toolkitsLow-levelOn AmigaOS

Intuition

On Classic Mac OS, macOS

Macintosh Toolbox

Carbon

On Windows

Windows API

UWP

WinRT

On Unix,under X11

Xlib

XCB

X Toolkit Intrinsics

On BeOS, Haiku

BeOS API

Cross-platformCLI

OpenTK

GDK

Simple DirectMedia Layer

Java

JOGL

LWJGL

On AndroidCLI

Xamarin.Android

High-level, platform-specificOn AmigaOS

BOOPSI

MUI

ReAction GUI

Zune

On Classic Mac OS, macOSObject Pascal

MacApp

Objective-C, Swift

Cocoa

Cocoa Touch

C++

MacApp

PowerPlant

THINK C

CLI

Xamarin.Mac

Xamarin.iOS

On WindowsCLI

Windows Forms

XAML

Windows Presentation Foundation

Windows UI Library

Silverlight

Microsoft XNA

C++

MFC

Active Template Library

Windows Template Library

Object Windows Library

Object Pascal

Visual Component Library

On Unix,under X11

Athena (Xaw)

LessTif

Motif

OLIT

XForms

On Android

Qt for Android

High-level, cross-platformC

Enlightenment Foundation Libraries

GTK

IUP

XForms

XVT

C++

Bedrock

CEGUI

Component Library for Cross Platform

FLTK

FOX toolkit

OpenGL User Interface Library

gtkmm

JUCE

Rogue Wave Views

TnFOX

U++

wxWidgets

Simple and Fast Multimedia Library

Objective-C

GNUstep

CLI

Gtk#

Tao Framework

OpenTK

UIML

MonoGame

Moonlight

Xamarin.Forms

XWT[1][2]

.NET MAUI

Adobe Flash

Apache Flex

MXML

Fyne

Haskell

wxHaskell

Java

Abstract Window Toolkit

FXML

JavaFX

Qt Jambi

Swing

Standard Widget Toolkit

Google Web Toolkit

Lightweight User Interface Toolkit

JavaScript

Dojo Toolkit

Echo

Ext JS

Google Closure Tools

jQuery UI

OpenUI5

Qooxdoo

YUI

Common Lisp

CAPI

CLIM

Common Graphics

Lua

IUP

Pascal

Lazarus Component Library

Object Pascal

Component Library for Cross Platform

fpGUI

IP Pascal

FireMonkey

Perl

Perl/Tk

wxPerl

PHP

PHP-GTK

wxPHP

Python

Tkinter

Kivy

PySide

PyQt

PyGTK

wxPython

Pyjs

Ruby

Shoes

QtRuby

Tcl

Tcl/Tk

XML

GladeXML

Lively Kernel

Extensible Application Markup Language

XUL

shell

Newt

CDK

Dialog

Dart

Flutter

Retrieved from "https://en.wikipedia.org/w/index.php?title=XCB&oldid=1211644569"

Categories: C (programming language) librariesFreedesktop.orgFreedesktop.org librariesSoftware using the MIT licenseX Window SystemHidden categories: Articles with short descriptionShort description is different from WikidataArticles lacking reliable references from November 2009All articles lacking reliable references

This page was last edited on 3 March 2024, at 17:28 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License 4.0;

additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.

About Wikipedia

Disclaimers

Contact Wikipedia

Code of Conduct

Developers

Statistics

Cookie statement

Mobile view

Toggle limited content width

Basic Graphics Programming With The XCB Library

Introduction

The client and server model of the X window system

GUI programming: the asynchronous model

Basic XCB notions

The X Connection

Requests and replies: the Xlib killers

The Graphics Context

Object handles

Memory allocation for XCB structures

Events

Using XCB-based programs

Installation of XCB

Compiling XCB-based programs

Opening and closing the connection to an X server

Checking basic information about a connection

Creating a basic window - the "hello world" program

Drawing in a window

Allocating a Graphics Context

Changing the attributes of a Graphics Context

Drawing primitives: point, line, box, circle,...

X Events

Registering for event types using event masks

Receiving events: writing the events loop

Expose events

Getting user input

Mouse button press and release events

Mouse movement events

Mouse pointer enter and leave events

The keyboard focus

Keyboard press and release events

X events: a complete example

Handling text and fonts

The Font structure

Opening a Font

Assigning a Font to a Graphic Context

Drawing text in a drawable

Complete example

Windows hierarchy

Root, parent and child windows

Events propagation

Interacting with the window manager

Window properties

Setting the window name and icon name

Setting preferred window size(s)

Setting miscellaneous window manager hints

Setting an application's icon

Obeying the delete-window protocol

Simple window operations

Mapping and unmapping a window

Configuring a window

Moving a window around the screen

Resizing a window

Changing windows stacking order: raise and lower

Iconifying and de-iconifying a window

Getting informations about a window

Using colors to paint the rainbow

Color maps

Allocating and freeing Color Maps

Allocating and freeing a color entry

Drawing with a color

X Bitmaps and Pixmaps

What is a X Bitmap ? An X Pixmap ?

Loading a bitmap from a file

Drawing a bitmap in a window

Creating a pixmap

Drawing a pixmap in a window

Freeing a pixmap

Messing with the mouse cursor

Creating and destroying a mouse cursor

Setting a window's mouse cursor

Complete example

Translation of basic Xlib functions and macros

Members of the Display structure

ConnectionNumber

DefaultScreen

QLength

ScreenCount

ServerVendor

ProtocolVersion

ProtocolRevision

VendorRelease

DisplayString

BitmapUnit

BitmapBitOrder

BitmapPad

ImageByteOrder

ScreenOfDisplay related functions

ScreenOfDisplay

DefaultScreenOfDisplay

RootWindow / RootWindowOfScreen

DefaultRootWindow

DefaultVisual / DefaultVisualOfScreen

DefaultGC / DefaultGCOfScreen

BlackPixel / BlackPixelOfScreen

WhitePixel / WhitePixelOfScreen

DisplayWidth / WidthOfScreen

DisplayHeight / HeightOfScreen

DisplayWidthMM / WidthMMOfScreen

DisplayHeightMM / HeightMMOfScreen

DisplayPlanes / DefaultDepth / DefaultDepthOfScreen / PlanesOfScreen

DefaultColormap / DefaultColormapOfScreen

MinCmapsOfScreen

MaxCmapsOfScreen

DoesSaveUnders

DoesBackingStore

EventMaskOfScreen

Miscellaneaous macros

DisplayOfScreen

DisplayCells / CellsOfScreen

Introduction

This tutorial is based on the

Xlib Tutorial

written by Guy Keren. The

author allowed me to take some parts of his text, mainly the text which

deals with the X Windows generality.

This tutorial is intended for people who want to start to program

with the XCB

library. keep in mind that XCB, like the

Xlib

library, isn't what most programmers wanting to write X

applications are looking for. They should use a much higher

level GUI toolkit like Motif,

LessTiff,

GTK,

QT,

EWL,

ETK, or use

Cairo.

However,

we need to start somewhere. More than this, knowing how things

work down below is never a bad idea.

After reading this tutorial, one should be able to write very

simple graphical programs, but not programs with decent user

interfaces. For such programs, one of the previously mentioned

libraries should be used.

But what is XCB? Xlib has been

the standard C binding for the X

Window System protocol for many years now. It is an

excellent piece of work, but there are applications for which it

is not ideal, for example:

Small platforms: Xlib is a large piece of code, and

it's difficult to make it smaller

Latency hiding: Xlib requests requiring a reply are

effectively synchronous: they block until the reply appears,

whether the result is needed immediately or not.

Direct access to the protocol: Xlib does quite a

bit of caching, layering, and similar optimizations. While this

is normally a feature, it makes it difficult to simply emit

specified X protocol requests and process specific

responses.

Threaded applications: While Xlib does attempt to

support multithreading, the API makes this difficult and

error-prone.

New extensions: The Xlib infrastructure provides

limited support for the new creation of X extension client side

code.

For these reasons, among others, XCB, an X C binding, has been

designed to solve the above problems and thus provide a base for

Toolkit implementation.

Direct protocol-level programming.

Lightweight emulation of commonly used portions of the

Xlib API.

The client and server model of the X window system

The X Window System was developed with one major goal:

flexibility. The idea was that the way things look is one thing,

but the way things work is another matter. Thus, the lower

levels provide the tools required to draw windows, handle user

input, allow drawing graphics using colors (or black and white

screens), etc. To this point, a decision was made to separate

the system into two parts. A client that decides what to do, and

a server that actually draws on the screen and reads user input

in order to send it to the client for processing.

This model is the complete opposite of what is used to when

dealing with clients and servers. In our case, the user sits

near the machine controlled by the server, while the client

might be running on a remote machine. The server controls the

screens, mouse and keyboard. A client may connect to the server,

request that it draws a window (or several windows), and ask the

server to send it any input the user sends to these

windows. Thus, several clients may connect to a single X server

(one might be running mail software, one running a WWW

browser, etc). When input is sent by the user to some window,

the server sends a message to the client controlling this window

for processing. The client decides what to do with this input,

and sends the server requests for drawing in the window.

The whole session is carried out using the X message

protocol. This protocol was originally carried over the TCP/IP

protocol suite, allowing the client to run on any machine

connected to the same network that the server is. Later on, the

X servers were extended to allow clients running on the local

machine with more optimized access to the server (note that an X

protocol message may be several hundreds of KB in size), such as

using shared memory, or using Unix domain sockets (a method for

creating a logical channel on a Unix system between two processes).

GUI programming: the asynchronous model

Unlike conventional computer programs, that carry some serial

nature, a GUI program usually uses an asynchronous programming

model, also known as "event-driven programming". This means that

that program mostly sits idle, waiting for events sent by the X

server, and then acts upon these events. An event may say "The

user pressed the 1st button mouse in spot (x,y)", or "The window

you control needs to be redrawn". In order for the program to be

responsive to the user input, as well as to refresh requests, it

needs to handle each event in a rather short period of time

(e.g. less that 200 milliseconds, as a rule of thumb).

This also implies that the program may not perform operations

that might take a long time while handling an event (such as

opening a network connection to some remote server, or

connecting to a database server, or even performing a long file

copy operation). Instead, it needs to perform all these

operations in an asynchronous manner. This may be done by using

various asynchronous models to perform the longish operations,

or by performing them in a different process or thread.

So the way a GUI program looks is something like that:

Perform initialization routines.

Connect to the X server.

Perform X-related initialization.

While not finished:

Receive the next event from the X server.

Handle the event, possibly sending various drawing

requests to the X server.

If the event was a quit message, exit the loop.

Close down the connection to the X server.

Perform cleanup operations.

Basic XCB notions

XCB has been created to eliminate the need for

programs to actually implement the X protocol layer. This

library gives a program a very low-level access to any X

server. Since the protocol is standardized, a client using any

implementation of XCB may talk with any X server (the same

occurs for Xlib, of course). We now give a brief description of

the basic XCB notions. They will be detailed later.

The X Connection

The major notion of using XCB is the X Connection. This is a

structure representing the connection we have open with a

given X server. It hides a queue of messages coming from the

server, and a queue of pending requests that our client

intends to send to the server. In XCB, this structure is named

'xcb_connection_t'. It is analogous to the Xlib Display.

When we open a connection to an X server, the

library returns a pointer to such a structure. Later, we

supply this pointer to any XCB function that should send

messages to the X server or receive messages from this server.

Requests and

replies: the Xlib killers

To ask for information from the X server, we have to make a request

and ask for a reply. With Xlib, these two tasks are

automatically done: Xlib locks the system, sends a request,

waits for a reply from the X server and unlocks. This is

annoying, especially if one makes a lot of requests to the X

server. Indeed, Xlib has to wait for the end of a reply

before asking for the next request (because of the locks that

Xlib sends). For example, here is a time-line of N=4

requests/replies with Xlib, with a round-trip latency

T_round_trip that is 5 times long as the time required

to write or read a request/reply (T_write/T_read):

W-----RW-----RW-----RW-----R

W: Writing request

-: Stalled, waiting for data

R: Reading reply

The total time is N * (T_write + T_round_trip + T_read).

With XCB, we can suppress most of the round-trips as the

requests and the replies are not locked. We usually send a

request, then XCB returns to us a cookie, which is an

identifier. Then, later, we ask for a reply using this

cookie and XCB returns a

pointer to that reply. Hence, with XCB, we can send a lot of

requests, and later in the program, ask for all the replies

when we need them. Here is the time-line for 4

requests/replies when we use this property of XCB:

WWWW--RRRR

The total time is N * T_write + max (0, T_round_trip - (N-1) *

T_write) + N * T_read. Which can be considerably faster than

all those Xlib round-trips.

Here is a program that computes the time to create 500 atoms

with Xlib and XCB. It shows the Xlib way, the bad XCB way

(which is similar to Xlib) and the good XCB way. On my

computer, XCB is 25 times faster than Xlib.

#include

double

get_time(void)

{

struct timeval timev;

gettimeofday(&timev, NULL);

return (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);

}

int

main ()

{

xcb_connection_t *c;

xcb_atom_t *atoms;

xcb_intern_atom_cookie_t *cs;

char **names;

int count;

int i;

double start;

double end;

double diff;

/* Xlib */

Display *disp;

Atom *atoms_x;

double diff_x;

c = xcb_connect (NULL, NULL);

count = 500;

atoms = (xcb_atom_t *)malloc (count * sizeof (atoms));

names = (char **)malloc (count * sizeof (char *));

/* init names */

for (i = 0; i < count; ++i) {

char buf[100];

sprintf (buf, "NAME%d", i);

names[i] = strdup (buf);

}

/* bad use */

start = get_time ();

for (i = 0; i < count; ++i)

atoms[i] = xcb_intern_atom_reply (c,

xcb_intern_atom (c,

strlen(names[i]),

names[i]),

NULL)->atom;

end = get_time ();

diff = end - start;

printf ("bad use time : %f\n", diff);

/* good use */

start = get_time ();

cs = (xcb_intern_atom_cookie_t *) malloc (count * sizeof(xcb_intern_atom_cookie_t));

for(i = 0; i < count; ++i)

cs[i] = xcb_intern_atom (c, 0, strlen(names[i]), names[i]);

for(i = 0; i < count; ++i) {

xcb_intern_atom_reply_t *r;

r = xcb_intern_atom_reply(c, cs[i], 0);

if(r)

atoms[i] = r->atom;

free(r);

}

end = get_time ();

printf ("good use time : %f\n", end - start);

printf ("ratio : %f\n", diff / (end - start));

diff = end - start;

/* free var */

free (atoms);

free (cs);

xcb_disconnect (c);

/* Xlib */

disp = XOpenDisplay (getenv("DISPLAY"));

atoms_x = (Atom *)malloc (count * sizeof (atoms_x));

start = get_time ();

for (i = 0; i < count; ++i)

atoms_x[i] = XInternAtom(disp, names[i], 0);

end = get_time ();

diff_x = end - start;

printf ("Xlib use time : %f\n", diff_x);

printf ("ratio : %f\n", diff_x / diff);

free (atoms_x);

for (i = 0; i < count; ++i)

free (names[i]);

free (names);

XCloseDisplay (disp);

return 0;

}

The Graphic Context

When we perform various drawing operations (graphics, text,

etc), we may specify various options for controlling how the

data will be drawn (what foreground and background colors to

use, how line edges will be connected, what font to use when

drawing some text, etc). In order to avoid the need to supply

hundreds of parameters to each drawing function, a graphical

context structure is used. We set the various drawing options

in this structure, and then we pass a pointer to this

structure to any drawing routines. This is rather handy, as we

often need to perform several drawing requests with the same

options. Thus, we would initialize a graphical context, set

the desired options, and pass this structure to all drawing

functions.

Note that graphic contexts have no client-side structure in

XCB, they're just XIDs. Xlib has a client-side structure

because it caches the GC contents so it can avoid making

redundant requests, but of course XCB doesn't do that.

Events

A structure is used to pass events received from the X

server. XCB supports exactly the events specified in the

protocol (33 events). This structure contains the type

of event received (including a bit for whether it came

from the server or another client), as well as the data associated with the

event (e.g. position on the screen where the event was

generated, mouse button associated with the event, region of

the screen associated with a "redraw" event, etc). The way to

read the event's data depends on the event type.

Using XCB-based programs

Installation of XCB

TODO: These instructions are out of date.

Just reference the main XCB page

so we don't have to maintain these instructions in more than

one place.

To build XCB from source, you need to have installed at

least:

pkgconfig 0.15.0

automake 1.7

autoconf 2.50

check

xsltproc

gperf 3.0.1

You have to checkout in the git repository the following modules:

Xau from xlibs

xcb-proto

xcb

Note that xcb-proto exists only to install header

files, so typing 'make' or 'make all' will produce the message

"Nothing to be done for 'all'". That's normal.

Compiling XCB-based programs

Compiling XCB-based programs requires linking them with the XCB

library. This is easily done thanks to pkgconfig:

gcc -Wall prog.c -o prog `pkg-config --cflags --libs xcb`

Opening and closing the connection to an X server

An X program first needs to open the connection to the X

server. There is a function that opens a connection. It requires

the display name, or NULL. In the latter case, the display name

will be the one in the environment variable DISPLAY.

xcb_connection_t *xcb_connect (const char *displayname,

int *screenp);

The second parameter returns the screen number used for the

connection. The returned structure describes an XCB connection

and is opaque. Here is how the connection can be opened:

#include

int

main ()

{

xcb_connection_t *c;

/* Open the connection to the X server. Use the DISPLAY environment variable as the default display name */

c = xcb_connect (NULL, NULL);

return 0;

}

To close a connection, it suffices to use:

void xcb_disconnect (xcb_connection_t *c);

Comparison Xlib/XCB

XOpenDisplay ()

xcb_connect ()

XCloseDisplay ()

xcb_disconnect ()

Checking basic information about a connection

Once we have opened a connection to an X server, we should check some

basic information about it: what screens it has, what is the

size (width and height) of the screen, how many colors it

supports (black and white ? grey scale ?, 256 colors ? more ?),

and so on. We get such information from the xcb_screen_t

structure:

typedef struct {

xcb_window_t root;

xcb_colormap_t default_colormap;

uint32_t white_pixel;

uint32_t black_pixel;

uint32_t current_input_masks;

uint16_t width_in_pixels;

uint16_t height_in_pixels;

uint16_t width_in_millimeters;

uint16_t height_in_millimeters;

uint16_t min_installed_maps;

uint16_t max_installed_maps;

xcb_visualid_t root_visual;

uint8_t backing_stores;

uint8_t save_unders;

uint8_t root_depth;

uint8_t allowed_depths_len;

} xcb_screen_t;

We could retrieve the first screen of the connection by using the

following function:

xcb_screen_iterator_t xcb_setup_roots_iterator (xcb_setup_t *R);

Here is a small program that shows how to use this function:

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

xcb_screen_iterator_t iter;

/* Open the connection to the X server. Use the DISPLAY environment variable */

c = xcb_connect (NULL, &screen_nbr);

/* Get the screen #screen_nbr */

iter = xcb_setup_roots_iterator (xcb_get_setup (c));

for (; iter.rem; --screen_nbr, xcb_screen_next (&iter))

if (screen_nbr == 0) {

screen = iter.data;

break;

}

printf ("\n");

printf ("Informations of screen %ld:\n", screen->root);

printf (" width.........: %d\n", screen->width_in_pixels);

printf (" height........: %d\n", screen->height_in_pixels);

printf (" white pixel...: %ld\n", screen->white_pixel);

printf (" black pixel...: %ld\n", screen->black_pixel);

printf ("\n");

return 0;

}

Creating a basic window - the "hello world" program

After we got some basic information about our screen, we can

create our first window. In the X Window System, a window is

characterized by an Id. So, in XCB, a window is of type:

typedef uint32_t xcb_window_t;

We first ask for a new Id for our window, with this function:

xcb_window_t xcb_generate_id(xcb_connection_t *c);

Then, XCB supplies the following function to create new windows:

xcb_void_cookie_t xcb_create_window (xcb_connection_t *c, /* Pointer to the xcb_connection_t structure */

uint8_t depth, /* Depth of the screen */

xcb_window_t wid, /* Id of the window */

xcb_window_t parent, /* Id of an existing window that should be the parent of the new window */

int16_t x, /* X position of the top-left corner of the window (in pixels) */

int16_t y, /* Y position of the top-left corner of the window (in pixels) */

uint16_t width, /* Width of the window (in pixels) */

uint16_t height, /* Height of the window (in pixels) */

uint16_t border_width, /* Width of the window's border (in pixels) */

uint16_t _class,

xcb_visualid_t visual,

uint32_t value_mask,

const uint32_t *value_list);

The fact that we created the window does not mean that it will

be drawn on screen. By default, newly created windows are not

mapped on the screen (they are invisible). In order to make our

window visible, we use the function xcb_map_window(), whose

prototype is

xcb_void_cookie_t xcb_map_window (xcb_connection_t *c,

xcb_window_t window);

Finally, here is a small program to create a window of size

150x150 pixels, positioned at the top-left corner of the screen:

#include /* pause() */

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_window_t win;

/* Open the connection to the X server */

c = xcb_connect (NULL, NULL);

/* Get the first screen */

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* Ask for our window's Id */

win = xcb_generate_id(c);

/* Create the window */

xcb_create_window (c, /* Connection */

XCB_COPY_FROM_PARENT, /* depth (same as root)*/

win, /* 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 (c, win);

/* Make sure commands are sent before we pause, so window is shown */

xcb_flush (c);

pause (); /* hold client until Ctrl-C */

return 0;

}

In this code, you see one more function - xcb_flush(), not explained

yet. It is used to flush all the pending requests. More

precisely, there are 2 functions that do such things. The first

one is xcb_flush():

int xcb_flush (xcb_connection_t *c);

This function flushes all pending requests to the X server (much

like the fflush() function is used to

flush standard output). The second function is

xcb_aux_sync():

int xcb_aux_sync (xcb_connection_t *c);

This functions also flushes all pending requests to the X

server, and then waits until the X server finishing processing

these requests. In a normal program, this will not be necessary

(we'll see why when we get to write a normal X program), but for

now, we put it there.

The window that is created by the above code has a non defined

background. This one can be set to a specific color,

thanks to the two last parameters of

xcb_create_window(), which are not

described yet. See the subsections

Configuring a window or

Registering for event types using event masks

for examples on how to use these parameters. In addition, as no

events are handled, you have to make a Ctrl-C to interrupt the

program.

TODO: one should tell what these functions return and

about the generic error

Comparison Xlib/XCB

XCreateWindow ()

xcb_generate_id ()

xcb_create_window ()

Drawing in a window

Drawing in a window can be done using various graphical

functions (drawing pixels, lines, rectangles, etc). In order to

draw in a window, we first need to define various general

drawing parameters (what line width to use, which color to draw

with, etc). This is done using a graphical context.

Allocating a Graphics Context

As we said, a graphical context defines several attributes to

be used with the various drawing functions. For this, we

define a graphical context. We can use more than one graphical

context with a single window, in order to draw in multiple

styles (different colors, different line widths, etc). In XCB,

a Graphics Context is, as a window, characterized by an Id:

typedef uint32_t xcb_gcontext_t;

We first ask the X server to attribute an Id to our graphic

context with this function:

xcb_gcontext_t xcb_generate_id (xcb_connection_t *c);

Then, we set the attributes of the graphic context with this function:

xcb_void_cookie_t xcb_create_gc (xcb_connection_t *c,

xcb_gcontext_t cid,

xcb_drawable_t drawable,

uint32_t value_mask,

const uint32_t *value_list);

We give now an example on how to allocate a graphic context

that specifies that each drawing function that uses it will

draw in foreground with a black color.

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_drawable_t win;

xcb_gcontext_t black;

uint32_t mask;

uint32_t value[1];

/* Open the connection to the X server and get the first screen */

c = xcb_connect (NULL, NULL);

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* Create a black graphic context for drawing in the foreground */

win = screen->root;

black = xcb_generate_id (c);

mask = XCB_GC_FOREGROUND;

value[0] = screen->black_pixel;

xcb_create_gc (c, black, win, mask, value);

return 0;

}

Note should be taken regarding the role of "value_mask" and

"value_list" in the prototype of xcb_create_gc(). Since a

graphic context has many attributes, and since we often just

want to define a few of them, we need to be able to tell the

xcb_create_gc() which attributes we

want to set. This is what the "value_mask" parameter is

for. We then use the "value_list" parameter to specify actual

values for the attribute we defined in "value_mask". Thus, for

each constant used in "value_list", we will use the matching

constant in "value_mask". In this case, we define a graphic

context with one attribute: when drawing (a point, a line,

etc), the foreground color will be black. The rest of the

attributes of this graphic context will be set to their

default values.

See the next Subsection for more details.

Comparison Xlib/XCB

XCreateGC ()

xcb_generate_id ()

xcb_create_gc ()

Changing the attributes of a Graphics Context

Once we have allocated a Graphic Context, we may need to

change its attributes (for example, changing the foreground

color we use to draw a line, or changing the attributes of the

font we use to display strings. See Subsections Drawing with a

color and

Assigning a Font to a Graphic Context).

This is done by using this function:

xcb_void_cookie_t xcb_change_gc (xcb_connection_t *c, /* The XCB Connection */

xcb_gcontext_t gc, /* The Graphic Context */

uint32_t value_mask, /* Components of the Graphic Context that have to be set */

const uint32_t *value_list); /* Value as specified by value_mask */

The value_mask parameter could take

any combination of these masks from the xcb_gc_t enumeration:

XCB_GC_FUNCTION

XCB_GC_PLANE_MASK

XCB_GC_FOREGROUND

XCB_GC_BACKGROUND

XCB_GC_LINE_WIDTH

XCB_GC_LINE_STYLE

XCB_GC_CAP_STYLE

XCB_GC_JOIN_STYLE

XCB_GC_FILL_STYLE

XCB_GC_FILL_RULE

XCB_GC_TILE

XCB_GC_STIPPLE

XCB_GC_TILE_STIPPLE_ORIGIN_X

XCB_GC_TILE_STIPPLE_ORIGIN_Y

XCB_GC_FONT

XCB_GC_SUBWINDOW_MODE

XCB_GC_GRAPHICS_EXPOSURES

XCB_GC_CLIP_ORIGIN_X

XCB_GC_CLIP_ORIGIN_Y

XCB_GC_CLIP_MASK

XCB_GC_DASH_OFFSET

XCB_GC_DASH_LIST

XCB_GC_ARC_MODE

It is possible to set several attributes at the same

time (for example setting the attributes of a font and the

color which will be used to display a string), by OR'ing these

values in value_mask. Then

value_list has to be an array which

lists the value for the respective attributes. These values

must be in the same order as masks listed above. See Subsection

Drawing with a color to have an example.

TODO: set the links of the 3 subsections, once they will

be written :)

TODO: give an example which sets several attributes.

Drawing primitives: point, line, box, circle,...

After we have created a Graphic Context, we can draw on a

window using this Graphic Context, with a set of XCB

functions, collectively called "drawing primitives". Let see

how they are used.

To draw a point, or several points, we use

xcb_void_cookie_t xcb_poly_point (xcb_connection_t *c, /* The connection to the X server */

uint8_t coordinate_mode, /* Coordinate mode, usually set to XCB_COORD_MODE_ORIGIN */

xcb_drawable_t drawable, /* The drawable on which we want to draw the point(s) */

xcb_gcontext_t gc, /* The Graphic Context we use to draw the point(s) */

uint32_t points_len, /* The number of points */

const xcb_point_t *points); /* An array of points */

The coordinate_mode parameter

specifies the coordinate mode. Available values are

XCB_COORD_MODE_ORIGIN

XCB_COORD_MODE_PREVIOUS

If XCB_COORD_MODE_PREVIOUS is used, then all points but the first one

are relative to the immediately previous point.

The xcb_point_t type is just a

structure with two fields (the coordinates of the point):

typedef struct {

int16_t x;

int16_t y;

} xcb_point_t;

You could see an example in xpoints.c. TODO Set the link.

To draw a line, or a polygonal line, we use

xcb_void_cookie_t xcb_poly_line (xcb_connection_t *c, /* The connection to the X server */

uint8_t coordinate_mode, /* Coordinate mode, usually set to XCB_COORD_MODE_ORIGIN */

xcb_drawable_t drawable, /* The drawable on which we want to draw the line(s) */

xcb_gcontext_t gc, /* The Graphic Context we use to draw the line(s) */

uint32_t points_len, /* The number of points in the polygonal line */

const xcb_point_t *points); /* An array of points */

This function will draw the line between the first and the

second points, then the line between the second and the third

points, and so on.

To draw a segment, or several segments, we use

xcb_void_cookie_t xcb_poly_segment (xcb_connection_t *c, /* The connection to the X server */

xcb_drawable_t drawable, /* The drawable on which we want to draw the segment(s) */

xcb_gcontext_t gc, /* The Graphic Context we use to draw the segment(s) */

uint32_t segments_len, /* The number of segments */

const xcb_segment_t *segments); /* An array of segments */

The xcb_segment_t type is just a

structure with four fields (the coordinates of the two points

that define the segment):

typedef struct {

int16_t x1;

int16_t y1;

int16_t x2;

int16_t y2;

} xcb_segment_t;

To draw a rectangle, or several rectangles, we use

xcb_void_cookie_t xcb_poly_rectangle (xcb_connection_t *c, /* The connection to the X server */

xcb_drawable_t drawable, /* The drawable on which we want to draw the rectangle(s) */

xcb_gcontext_t gc, /* The Graphic Context we use to draw the rectangle(s) */

uint32_t rectangles_len, /* The number of rectangles */

const xcb_rectangle_t *rectangles); /* An array of rectangles */

The xcb_rectangle_t type is just a

structure with four fields (the coordinates of the top-left

corner of the rectangle, and its width and height):

typedef struct {

int16_t x;

int16_t y;

uint16_t width;

uint16_t height;

} xcb_rectangle_t;

To draw an elliptical arc, or several elliptical arcs, we use

xcb_void_cookie_t xcb_poly_arc (xcb_connection_t *c, /* The connection to the X server */

xcb_drawable_t drawable, /* The drawable on which we want to draw the arc(s) */

xcb_gcontext_t gc, /* The Graphic Context we use to draw the arc(s) */

uint32_t arcs_len, /* The number of arcs */

const xcb_arc_t *arcs); /* An array of arcs */

The xcb_arc_t type is a structure with

six fields:

typedef struct {

int16_t x; /* Top left x coordinate of the rectangle surrounding the ellipse */

int16_t y; /* Top left y coordinate of the rectangle surrounding the ellipse */

uint16_t width; /* Width of the rectangle surrounding the ellipse */

uint16_t height; /* Height of the rectangle surrounding the ellipse */

int16_t angle1; /* Angle at which the arc begins */

int16_t angle2; /* Angle at which the arc ends */

} xcb_arc_t;

Note: the angles are expressed in units of 1/64 of a degree,

so to have an angle of 90 degrees, starting at 0,

angle1 = 0 and

angle2 = 90 << 6. Positive angles

indicate counterclockwise motion, while negative angles

indicate clockwise motion.

The corresponding function which fill inside the geometrical

object are listed below, without further explanation, as they

are used as the above functions.

To Fill a polygon defined by the points given as arguments ,

we use

xcb_void_cookie_t xcb_fill_poly (xcb_connection_t *c,

xcb_drawable_t drawable,

xcb_gcontext_t gc,

uint8_t shape,

uint8_t coordinate_mode,

uint32_t points_len,

const xcb_point_t *points);

The shape parameter specifies a

shape that helps the server to improve performance. Available

values are

XCB_POLY_SHAPE_COMPLEX

XCB_POLY_SHAPE_NONCONVEX

XCB_POLY_SHAPE_CONVEX

To fill one or several rectangles, we use

xcb_void_cookie_t xcb_poly_fill_rectangle (xcb_connection_t *c,

xcb_drawable_t drawable,

xcb_gcontext_t gc,

uint32_t rectangles_len,

const xcb_rectangle_t *rectangles);

To fill one or several arcs, we use

xcb_void_cookie_t xcb_poly_fill_arc (xcb_connection_t *c,

xcb_drawable_t drawable,

xcb_gcontext_t gc,

uint32_t arcs_len,

const xcb_arc_t *arcs);

To illustrate these functions, here is an example that draws

four points, a polygonal line, two segments, two rectangles

and two arcs. Remark that we use events for the first time, as

an introduction to the next section.

TODO: Use screen->root_depth for depth parameter.

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_drawable_t win;

xcb_gcontext_t foreground;

xcb_generic_event_t *e;

uint32_t mask = 0;

uint32_t values[2];

/* geometric objects */

xcb_point_t points[] = {

{10, 10},

{10, 20},

{20, 10},

{20, 20}};

xcb_point_t polyline[] = {

{50, 10},

{ 5, 20}, /* rest of points are relative */

{25,-20},

{10, 10}};

xcb_segment_t segments[] = {

{100, 10, 140, 30},

{110, 25, 130, 60}};

xcb_rectangle_t rectangles[] = {

{ 10, 50, 40, 20},

{ 80, 50, 10, 40}};

xcb_arc_t arcs[] = {

{10, 100, 60, 40, 0, 90 << 6},

{90, 100, 55, 40, 0, 270 << 6}};

/* Open the connection to the X server */

c = xcb_connect (NULL, NULL);

/* Get the first screen */

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* Create black (foreground) graphic context */

win = screen->root;

foreground = xcb_generate_id (c);

mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;

values[0] = screen->black_pixel;

values[1] = 0;

xcb_create_gc (c, foreground, win, mask, values);

/* Ask for our window's Id */

win = xcb_generate_id(c);

/* Create the window */

mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;

values[0] = screen->white_pixel;

values[1] = XCB_EVENT_MASK_EXPOSURE;

xcb_create_window (c, /* Connection */

XCB_COPY_FROM_PARENT, /* depth */

win, /* 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 */

mask, values); /* masks */

/* Map the window on the screen */

xcb_map_window (c, win);

/* We flush the request */

xcb_flush (c);

while ((e = xcb_wait_for_event (c))) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: {

/* We draw the points */

xcb_poly_point (c, XCB_COORD_MODE_ORIGIN, win, foreground, 4, points);

/* We draw the polygonal line */

xcb_poly_line (c, XCB_COORD_MODE_PREVIOUS, win, foreground, 4, polyline);

/* We draw the segements */

xcb_poly_segment (c, win, foreground, 2, segments);

/* We draw the rectangles */

xcb_poly_rectangle (c, win, foreground, 2, rectangles);

/* We draw the arcs */

xcb_poly_arc (c, win, foreground, 2, arcs);

/* We flush the request */

xcb_flush (c);

break;

}

default: {

/* Unknown event type, ignore it */

break;

}

/* Free the Generic Event */

free (e);

}

return 0;

}

X Events

In an X program, everything is driven by events. Event painting

on the screen is sometimes done as a response to an event (an

Expose event). If part of a program's

window that was hidden, gets exposed (e.g. the window was raised

above other widows), the X server will send an "expose" event to

let the program know it should repaint that part of the

window. User input (key presses, mouse movement, etc) is also

received as a set of events.

Registering for event types using event masks

During the creation of a window, you should give it what kind

of events it wishes to receive. Thus, you may register for

various mouse (also called pointer) events, keyboard events,

expose events, and so on. This is done for optimizing the

server-to-client connection (i.e. why send a program (that

might even be running at the other side of the globe) an event

it is not interested in ?)

In XCB, you use the "value_mask" and "value_list" data in the

xcb_create_window() function to

Expose event when creating a window:

mask = XCB_CW_EVENT_MASK;

valwin[0] = XCB_EVENT_MASK_EXPOSURE;

win = xcb_generate_id (c);

xcb_create_window (c, depth, win, root->root,

0, 0, 150, 150, 10,

XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual,

mask, valwin);

XCB_EVENT_MASK_EXPOSURE is a constant defined

in the xcb_event_mask_t enumeration in the "xproto.h" header file. If we wanted to register for several

event types, we can logically "or" them, as follows:

mask = XCB_CW_EVENT_MASK;

valwin[0] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS;

win = xcb_generate_id (c);

xcb_create_window (c, depth, win, root->root,

0, 0, 150, 150, 10,

XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual,

mask, valwin);

This registers for Expose events as

well as for mouse button presses inside the created

window. You should note that a mask may represent several

event sub-types.

The values that a mask could take are given

by the xcb_cw_t enumeration:

typedef enum {

XCB_CW_BACK_PIXMAP = 1L<<0,

XCB_CW_BACK_PIXEL = 1L<<1,

XCB_CW_BORDER_PIXMAP = 1L<<2,

XCB_CW_BORDER_PIXEL = 1L<<3,

XCB_CW_BIT_GRAVITY = 1L<<4,

XCB_CW_WIN_GRAVITY = 1L<<5,

XCB_CW_BACKING_STORE = 1L<<6,

XCB_CW_BACKING_PLANES = 1L<<7,

XCB_CW_BACKING_PIXEL = 1L<<8,

XCB_CW_OVERRIDE_REDIRECT = 1L<<9,

XCB_CW_SAVE_UNDER = 1L<<10,

XCB_CW_EVENT_MASK = 1L<<11,

XCB_CW_DONT_PROPAGATE = 1L<<12,

XCB_CW_COLORMAP = 1L<<13,

XCB_CW_CURSOR = 1L<<14

} xcb_cw_t;

Note: we must be careful when setting the values of the valwin

parameter, as they have to follow the order the

xcb_cw_t enumeration. Here is an

example:

mask = XCB_CW_EVENT_MASK | XCB_CW_BACK_PIXMAP;

valwin[0] = XCB_NONE; /* for XCB_CW_BACK_PIXMAP (whose value is 1) */

valwin[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS; /* for XCB_CW_EVENT_MASK, whose value (2048) */

/* is greater than the one of XCB_CW_BACK_PIXMAP */

If the window has already been created, we can use the

xcb_change_window_attributes() function to set

the events that the window will receive. The subsection

Configuring a window shows its

prototype. As an example, here is a piece of code that

configures the window to receive the

Expose and

ButtonPress events:

const static uint32_t values[] = { XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS };

/* The connection c and the window win are supposed to be defined */

xcb_change_window_attributes (c, win, XCB_CW_EVENT_MASK, values);

Note: A common bug programmers do is adding code to handle new

event types in their program, while forgetting to add the

masks for these events in the creation of the window. Such a

programmer then should sit down for hours debugging his

program, wondering "Why doesn't my program notice that I

released the button?", only to find that they registered for

button press events but not for button release events.

Receiving events: writing the events loop

After we have registered for the event types we are interested

in, we need to enter a loop of receiving events and handling

them. There are two ways to receive events: a blocking way and

a non-blocking way:

xcb_wait_for_event (xcb_connection_t *c)

is the blocking way. It waits (so blocks...) until an event is

queued in the X server. Then it retrieves it into a newly

allocated structure (it dequeues it from the queue) and returns

it. This structure has to be freed. The function returns

NULL if an error occurs.

xcb_poll_for_event (xcb_connection_t *c, int

*error) is the non-blocking way. It looks at the event

queue and returns (and dequeues too) an existing event into

a newly allocated structure. This structure has to be

freed. It returns NULL if there is

no event. If an error occurs, the parameter error will be filled with the error

status.

There are various ways to write such a loop. We present two

ways to write such a loop, with the two functions above. The

first one uses xcb_wait_for_event_t, which

is similar to an event Xlib loop using only XNextEvent:

xcb_generic_event_t *e;

while ((e = xcb_wait_for_event (c))) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: {

/* Handle the Expose event type */

xcb_expose_event_t *ev = (xcb_expose_event_t *)e;

/* ... */

break;

}

case XCB_BUTTON_PRESS: {

/* Handle the ButtonPress event type */

xcb_button_press_event_t *ev = (xcb_button_press_event_t *)e;

/* ... */

break;

}

default: {

/* Unknown event type, ignore it */

break;

}

/* Free the Generic Event */

free (e);

}

You will certainly want to use xcb_poll_for_event(xcb_connection_t *c, int

*error) if, in Xlib, you use XPending or

XCheckMaskEvent:

while (XPending (display)) {

XEvent ev;

XNextEvent(d, &ev);

/* Manage your event */

}

Such a loop in XCB looks like:

xcb_generic_event_t *ev;

while ((ev = xcb_poll_for_event (conn, 0))) {

/* Manage your event */

}

The events are managed in the same way as with xcb_wait_for_event_t.

Obviously, we will need to give the user some way of

terminating the program. This is usually done by handling a

special "quit" event, as we will soon see.

Comparison Xlib/XCB

XNextEvent ()

xcb_wait_for_event ()

XPending ()

XCheckMaskEvent ()

xcb_poll_for_event ()

Expose events

The Expose event is one of the most

basic (and most used) events an application may receive. It

will be sent to us in one of several cases:

A window that covered part of our window has moved

away, exposing part (or all) of our window.

Our window was raised above other windows.

Our window mapped for the first time.

Our window was de-iconified.

You should note the implicit assumption hidden here: the

contents of our window is lost when it is being obscured

(covered) by either windows. One may wonder why the X server

does not save this contents. The answer is: to save

memory. After all, the number of windows on a display at a

given time may be very large, and storing the contents of all

of them might require a lot of memory. Actually, there is a

way to tell the X server to store the contents of a window in

special cases, as we will see later.

When we get an Expose event, we

should take the event's data from the members of the following

structure:

typedef struct {

uint8_t response_type; /* The type of the event, here it is XCB_EXPOSE */

uint8_t pad0;

uint16_t sequence;

xcb_window_t window; /* The Id of the window that receives the event (in case */

/* our application registered for events on several windows */

uint16_t x; /* The x coordinate of the top-left part of the window that needs to be redrawn */

uint16_t y; /* The y coordinate of the top-left part of the window that needs to be redrawn */

uint16_t width; /* The width of the part of the window that needs to be redrawn */

uint16_t height; /* The height of the part of the window that needs to be redrawn */

uint16_t count;

} xcb_expose_event_t;

Getting user input

User input traditionally comes from two sources: the mouse

and the keyboard. Various event types exist to notify us of

user input (a key being presses on the keyboard, a key being

released on the keyboard, the mouse moving over our window,

the mouse entering (or leaving) our window, and so on.

Mouse button press and release events

The first event type we will deal with is a mouse

button-press (or button-release) event in our window. In

order to register to such an event type, we should add one

(or more) of the following masks when we create our window:

XCB_EVENT_MASK_BUTTON_PRESS: notify us

of any button that was pressed in one of our windows.

XCB_EVENT_MASK_BUTTON_RELEASE: notify us

of any button that was released in one of our windows.

The structure to be checked for in our events loop is the

same for these two events, and is the following:

typedef struct {

uint8_t response_type; /* The type of the event, here it is xcb_button_press_event_t or xcb_button_release_event_t */

xcb_button_t detail;

uint16_t sequence;

xcb_timestamp_t time; /* Time, in milliseconds the event took place in */

xcb_window_t root;

xcb_window_t event;

xcb_window_t child;

int16_t root_x;

int16_t root_y;

int16_t event_x; /* The x coordinate where the mouse has been pressed in the window */

int16_t event_y; /* The y coordinate where the mouse has been pressed in the window */

uint16_t state; /* A mask of the buttons (or keys) during the event */

uint8_t same_screen;

} xcb_button_press_event_t;

typedef xcb_button_press_event_t xcb_button_release_event_t;

The time field may be used to calculate "double-click"

situations by an application (e.g. if the mouse button was

clicked two times in a duration shorter than a given amount

of time, assume this was a double click).

The state field is a mask of the buttons held down during

the event. It is a bitwise OR of any of the following (from the xcb_button_mask_t and

xcb_mod_mask_t enumerations):

XCB_BUTTON_MASK_1

XCB_BUTTON_MASK_2

XCB_BUTTON_MASK_3

XCB_BUTTON_MASK_4

XCB_BUTTON_MASK_5

XCB_MOD_MASK_SHIFT

XCB_MOD_MASK_LOCK

XCB_MOD_MASK_CONTROL

XCB_MOD_MASK_1

XCB_MOD_MASK_2

XCB_MOD_MASK_3

XCB_MOD_MASK_4

XCB_MOD_MASK_5

Their names are self explanatory, where the first 5 refer to

the mouse buttons that are being pressed, while the rest

refer to various "special keys" that are being pressed (Mod1

is usually the 'Alt' key or the 'Meta' key).

TODO: Problem: it seems that the state does not

change when clicking with various buttons.

Mouse movement events

Similar to mouse button press and release events, we also

can be notified of various mouse movement events. These can

be split into two families. One is of mouse pointer

movement while no buttons are pressed, and the second is a

mouse pointer motion while one (or more) of the buttons are

pressed (this is sometimes called "a mouse drag operation",

or just "dragging"). The following event masks may be added

during the creation of our window:

XCB_EVENT_MASK_POINTER_MOTION: events of

the pointer moving in one of the windows controlled by our

application, while no mouse button is held pressed.

XCB_EVENT_MASK_BUTTON_MOTION: Events of

the pointer moving while one or more of the mouse buttons

is held pressed.

XCB_EVENT_MASK_BUTTON_1_MOTION: same as

XCB_EVENT_MASK_BUTTON_MOTION, but only when

the 1st mouse button is held pressed.

XCB_EVENT_MASK_BUTTON_2_MOTION,

XCB_EVENT_MASK_BUTTON_3_MOTION,

XCB_EVENT_MASK_BUTTON_4_MOTION,

XCB_EVENT_MASK_BUTTON_5_MOTION: same as

XCB_EVENT_MASK_BUTTON_1_MOTION, but

respectively for 2nd, 3rd, 4th and 5th mouse button.

The structure to be checked for in our events loop is the

same for these events, and is the following:

typedef struct {

uint8_t response_type; /* The type of the event */

uint8_t detail;

uint16_t sequence;

xcb_timestamp_t time; /* Time, in milliseconds the event took place in */

xcb_window_t root;

xcb_window_t event;

xcb_window_t child;

int16_t root_x;

int16_t root_y;

int16_t event_x; /* The x coordinate of the mouse when the event was generated */

int16_t event_y; /* The y coordinate of the mouse when the event was generated */

uint16_t state; /* A mask of the buttons (or keys) during the event */

uint8_t same_screen;

} xcb_motion_notify_event_t;

Mouse pointer enter and leave events

Another type of event that applications might be interested

in, is a mouse pointer entering a window the program

controls, or leaving such a window. Some programs use these

events to show the user that the application is now in

focus. In order to register for such an event type, we

should add one (or more) of the following masks when we

create our window:

xcb_event_enter_window_t: notify us

when the mouse pointer enters any of our controlled

windows.

xcb_event_leave_window_t: notify us

when the mouse pointer leaves any of our controlled

windows.

The structure to be checked for in our events loop is the

same for these two events, and is the following:

typedef struct {

uint8_t response_type; /* The type of the event */

uint8_t detail;

uint16_t sequence;

xcb_timestamp_t time; /* Time, in milliseconds the event took place in */

xcb_window_t root;

xcb_window_t event;

xcb_window_t child;

int16_t root_x;

int16_t root_y;

int16_t event_x; /* The x coordinate of the mouse when the event was generated */

int16_t event_y; /* The y coordinate of the mouse when the event was generated */

uint16_t state; /* A mask of the buttons (or keys) during the event */

uint8_t mode; /* The number of mouse button that was clicked */

uint8_t same_screen_focus;

} xcb_enter_notify_event_t;

typedef xcb_enter_notify_event_t xcb_leave_notify_event_t;

The keyboard focus

There may be many windows on a screen, but only a single

keyboard attached to them. How does the X server then know

which window should be sent a given keyboard input ? This is

done using the keyboard focus. Only a single window on the

screen may have the keyboard focus at a given time. There

is a XCB function that allows a program to set the keyboard

focus to a given window. The user can usually set the

keyboard focus using the window manager (often by clicking

on the title bar of the desired window). Once our window

has the keyboard focus, every key press or key release will

cause an event to be sent to our program (if it regsitered

for these event types...).

Keyboard press and release events

If a window controlled by our program currently holds the

keyboard focus, it can receive key press and key release

events. So, we should add one (or more) of the following

masks when we create our window:

XCB_EVENT_MASK_KEY_PRESS: notify us when

a key was pressed while any of our controlled windows had

the keyboard focus.

XCB_EVENT_MASK_KEY_RELEASE: notify us

when a key was released while any of our controlled

windows had the keyboard focus.

The structure to be checked for in our events loop is the

same for these two events, and is the following:

typedef struct {

uint8_t response_type; /* The type of the event */

xcb_keycode_t detail;

uint16_t sequence;

xcb_timestamp_t time; /* Time, in milliseconds the event took place in */

xcb_window_t root;

xcb_window_t event;

xcb_window_t child;

int16_t root_x;

int16_t root_y;

int16_t event_x;

int16_t event_y;

uint16_t state;

uint8_t same_screen;

} xcb_key_press_event_t;

typedef xcb_key_press_event_t xcb_key_release_event_t;

The detail field refers to the

physical key on the keyboard.

TODO: Talk about getting the ASCII code from the key code.

X events: a complete example

As an example for handling events, we show a program that

creates a window, enters an events loop and checks for all the

events described above, and writes on the terminal the relevant

characteristics of the event. With this code, it should be

easy to add drawing operations, like those which have been

described above.

#include

void

print_modifiers (uint32_t mask)

{

const char **mod, *mods[] = {

"Shift", "Lock", "Ctrl", "Alt",

"Mod2", "Mod3", "Mod4", "Mod5",

"Button1", "Button2", "Button3", "Button4", "Button5"

};

printf ("Modifier mask: ");

for (mod = mods ; mask; mask >>= 1, mod++)

if (mask & 1)

printf(*mod);

putchar ('\n');

}

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_window_t win;

xcb_generic_event_t *e;

uint32_t mask = 0;

uint32_t values[2];

/* Open the connection to the X server */

c = xcb_connect (NULL, NULL);

/* Get the first screen */

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* Ask for our window's Id */

win = xcb_generate_id (c);

/* Create the window */

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_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION |

XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |

XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE;

xcb_create_window (c, /* Connection */

0, /* depth */

win, /* 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 */

mask, values); /* masks */

/* Map the window on the screen */

xcb_map_window (c, win);

xcb_flush (c);

while ((e = xcb_wait_for_event (c))) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: {

xcb_expose_event_t *ev = (xcb_expose_event_t *)e;

printf ("Window %ld exposed. Region to be redrawn at location (%d,%d), with dimension (%d,%d)\n",

ev->window, ev->x, ev->y, ev->width, ev->height);

break;

}

case XCB_BUTTON_PRESS: {

xcb_button_press_event_t *ev = (xcb_button_press_event_t *)e;

print_modifiers(ev->state);

switch (ev->detail) {

case 4:

printf ("Wheel Button up in window %ld, at coordinates (%d,%d)\n",

ev->event, ev->event_x, ev->event_y);

break;

case 5:

printf ("Wheel Button down in window %ld, at coordinates (%d,%d)\n",

ev->event, ev->event_x, ev->event_y);

break;

default:

printf ("Button %d pressed in window %ld, at coordinates (%d,%d)\n",

ev->detail, ev->event, ev->event_x, ev->event_y);

}

break;

}

case XCB_BUTTON_RELEASE: {

xcb_button_release_event_t *ev = (xcb_button_release_event_t *)e;

print_modifiers(ev->state);

printf ("Button %d released in window %ld, at coordinates (%d,%d)\n",

ev->detail, ev->event, ev->event_x, ev->event_y);

break;

}

case XCB_MOTION_NOTIFY: {

xcb_motion_notify_event_t *ev = (xcb_motion_notify_event_t *)e;

printf ("Mouse moved in window %ld, at coordinates (%d,%d)\n",

ev->event, ev->event_x, ev->event_y);

break;

}

case XCB_ENTER_NOTIFY: {

xcb_enter_notify_event_t *ev = (xcb_enter_notify_event_t *)e;

printf ("Mouse entered window %ld, at coordinates (%d,%d)\n",

ev->event, ev->event_x, ev->event_y);

break;

}

case XCB_LEAVE_NOTIFY: {

xcb_leave_notify_event_t *ev = (xcb_leave_notify_event_t *)e;

printf ("Mouse left window %ld, at coordinates (%d,%d)\n",

ev->event, ev->event_x, ev->event_y);

break;

}

case XCB_KEY_PRESS: {

xcb_key_press_event_t *ev = (xcb_key_press_event_t *)e;

print_modifiers(ev->state);

printf ("Key pressed in window %ld\n",

ev->event);

break;

}

case XCB_KEY_RELEASE: {

xcb_key_release_event_t *ev = (xcb_key_release_event_t *)e;

print_modifiers(ev->state);

printf ("Key released in window %ld\n",

ev->event);

break;

}

default:

/* Unknown event type, ignore it */

printf("Unknown event: %d\n", e->response_type);

break;

}

/* Free the Generic Event */

free (e);

}

return 0;

}

Handling text and fonts

Besides drawing graphics on a window, we often want to draw

text. Text strings have two major properties: the characters to

be drawn and the font with which they are drawn. In order to

draw text, we need to first request the X server to load a

font. We then assign a font to a Graphic Context, and finally, we

draw the text in a window, using the Graphic Context.

The Font structure

In order to support flexible fonts, a font type is

defined. You know what ? It's an Id:

typedef uint32_t xcb_font_t;

It is used to contain information about a font, and is passed

to several functions that handle fonts selection and text drawing.

We ask the X server to attribute an Id to our font with the

function:

xcb_font_t xcb_generate_id (xcb_connection_t *c);

Opening a Font

To open a font, we use the following function:

xcb_void_cookie_t xcb_open_font (xcb_connection_t *c,

xcb_font_t fid,

uint16_t name_len,

const char *name);

The fid parameter is the font Id

defined by xcb_generate_id() (see

above). The name parameter is the

name of the font you want to open. Use the command

xlsfonts in a terminal to know which

are the fonts available on your computer. The parameter

name_len is the length of the name

of the font (given by strlen()).

Assigning a Font to a Graphic Context

Once a font is opened, you have to create a Graphic Context

that will contain the informations about the color of the

foreground and the background used when you draw a text in a

Drawable. Here is an exemple of a Graphic Context that will

allow us to draw an opened font with a black foreground and a

white background:

* c is the connection

* screen is the screen where the window is displayed

* window is the window in which we will draw the text

* font is the opened font

uint32_t value_list[3];

xcb_gcontext_t gc;

uint32_t mask;

gc = xcb_generate_id (c);

mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;

value_list[0] = screen->black_pixel;

value_list[1] = screen->white_pixel;

value_list[2] = font;

xcb_create_gc (c, gc, window, mask, value_list);

/* The font is not needed anymore, so we close it */

xcb_close_font (c, font);

Drawing text in a drawable

To draw a text in a drawable, we use the following function:

xcb_void_cookie_t xcb_image_text_8 (xcb_connection_t *c,

uint8_t string_len,

xcb_drawable_t drawable,

xcb_gcontext_t gc,

int16_t x,

int16_t y,

const char *string);

The string parameter is the text to

draw. The location of the drawing is given by the parameters

x and y.

The base line of the text is exactly the parameter

Complete example

This example draw a text at 10 pixels (for the base line) of

the bottom of a window. Pressing the Esc key exits the program.

#include

#define WIDTH 300

#define HEIGHT 100

static xcb_gc_t gc_font_get (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

const char *font_name);

static void text_draw (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int16_t x1,

int16_t y1,

const char *label);

static void

text_draw (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int16_t x1,

int16_t y1,

const char *label)

{

xcb_void_cookie_t cookie_gc;

xcb_void_cookie_t cookie_text;

xcb_generic_error_t *error;

xcb_gcontext_t gc;

uint8_t length;

length = strlen (label);

gc = gc_font_get(c, screen, window, "7x13");

cookie_text = xcb_image_text_8_checked (c, length, window, gc,

x1,

y1, label);

error = xcb_request_check (c, cookie_text);

if (error) {

fprintf (stderr, "ERROR: can't paste text : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cookie_gc = xcb_free_gc (c, gc);

error = xcb_request_check (c, cookie_gc);

if (error) {

fprintf (stderr, "ERROR: can't free gc : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

static xcb_gc_t

gc_font_get (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

const char *font_name)

{

uint32_t value_list[3];

xcb_void_cookie_t cookie_font;

xcb_void_cookie_t cookie_gc;

xcb_generic_error_t *error;

xcb_font_t font;

xcb_gcontext_t gc;

uint32_t mask;

font = xcb_generate_id (c);

cookie_font = xcb_open_font_checked (c, font,

strlen (font_name),

font_name);

error = xcb_request_check (c, cookie_font);

if (error) {

fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);

xcb_disconnect (c);

return -1;

}

gc = xcb_generate_id (c);

mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;

value_list[0] = screen->black_pixel;

value_list[1] = screen->white_pixel;

value_list[2] = font;

cookie_gc = xcb_create_gc_checked (c, gc, window, mask, value_list);

error = xcb_request_check (c, cookie_gc);

if (error) {

fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cookie_font = xcb_close_font_checked (c, font);

error = xcb_request_check (c, cookie_font);

if (error) {

fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

return gc;

}

int main ()

{

xcb_screen_iterator_t screen_iter;

xcb_connection_t *c;

const xcb_setup_t *setup;

xcb_screen_t *screen;

xcb_generic_event_t *e;

xcb_generic_error_t *error;

xcb_void_cookie_t cookie_window;

xcb_void_cookie_t cookie_map;

xcb_window_t window;

uint32_t mask;

uint32_t values[2];

int screen_number;

/* getting the connection */

c = xcb_connect (NULL, &screen_number);

if (!c) {

fprintf (stderr, "ERROR: can't connect to an X server\n");

return -1;

}

/* getting the current screen */

setup = xcb_get_setup (c);

screen = NULL;

screen_iter = xcb_setup_roots_iterator (setup);

for (; screen_iter.rem != 0; --screen_number, xcb_screen_next (&screen_iter))

if (screen_number == 0)

{

screen = screen_iter.data;

break;

}

if (!screen) {

fprintf (stderr, "ERROR: can't get the current screen\n");

xcb_disconnect (c);

return -1;

}

/* creating the window */

window = xcb_generate_id (c);

mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;

values[0] = screen->white_pixel;

values[1] =

XCB_EVENT_MASK_KEY_RELEASE |

XCB_EVENT_MASK_BUTTON_PRESS |

XCB_EVENT_MASK_EXPOSURE |

XCB_EVENT_MASK_POINTER_MOTION;

cookie_window = xcb_create_window_checked (c,

screen->root_depth,

window, screen->root,

20, 200, WIDTH, HEIGHT,

0, XCB_WINDOW_CLASS_INPUT_OUTPUT,

screen->root_visual,

mask, values);

cookie_map = xcb_map_window_checked (c, window);

/* error managing */

error = xcb_request_check (c, cookie_window);

if (error) {

fprintf (stderr, "ERROR: can't create window : %d\n", error->error_code);

xcb_disconnect (c);

return -1;

}

error = xcb_request_check (c, cookie_map);

if (error) {

fprintf (stderr, "ERROR: can't map window : %d\n", error->error_code);

xcb_disconnect (c);

return -1;

}

xcb_flush(c);

while (1) {

e = xcb_poll_for_event(c);

if (e) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: {

char *text;

text = "Press ESC key to exit...";

text_draw (c, screen, window, 10, HEIGHT - 10, text);

break;

}

case XCB_KEY_RELEASE: {

xcb_key_release_event_t *ev;

ev = (xcb_key_release_event_t *)e;

switch (ev->detail) {

/* ESC */

case 9:

free (e);

xcb_disconnect (c);

return 0;

}

free (e);

}

return 0;

}

Interacting with the window manager

After we have seen how to create windows and draw on them, we

take one step back, and look at how our windows are interacting

with their environment (the full screen and the other

windows). First of all, our application needs to interact with

the window manager. The window manager is responsible to

decorating drawn windows (i.e. adding a frame, an iconify

button, a system menu, a title bar, etc), as well as handling

icons shown when windows are being iconified. It also handles

ordering of windows on the screen, and other administrative

tasks. We need to give it various hints as to how we want it to

treat our application's windows.

Window properties

Many of the parameters communicated to the window manager are

passed using data called "properties". These properties are

attached by the X server to different windows, and are stored

in a format that makes it possible to read them from different

machines that may use different architectures (remember that

an X client program may run on a remote machine).

The property and its type (a string, an integer, etc) are

Id. Their type are xcb_atom_t:

typedef uint32_t xcb_atom_t;

To change the property of a window, we use the following

function:

xcb_void_cookie_t xcb_change_property (xcb_connection_t *c, /* Connection to the X server */

uint8_t mode, /* Property mode */

xcb_window_t window, /* Window */

xcb_atom_t property, /* Property to change */

xcb_atom_t type, /* Type of the property */

uint8_t format, /* Format of the property (8, 16, 32) */

uint32_t data_len, /* Length of the data parameter */

const void *data); /* Data */

The mode parameter coud be one of

the following values (defined in enumeration xcb_prop_mode_t in

the xproto.h header file):

XCB_PROP_MODE_REPLACE

XCB_PROP_MODE_PREPEND

XCB_PROP_MODE_APPEND

Setting the window name and icon name

The first thing we want to do would be to set the name for our

window. This is done using the

xcb_change_property() function. This

name may be used by the window manager as the title of the

window (in the title bar), in a task list, etc. The property

atom to use to set the name of a window is

WM_NAME (and

WM_ICON_NAME for the iconified

window) and its type is STRING. Here

is an example of utilization:

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_window_t win;

char *title = "Hello World !";

char *title_icon = "Hello World ! (iconified)";

/* Open the connection to the X server */

c = xcb_connect (NULL, NULL);

/* Get the first screen */

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* Ask for our window's Id */

win = xcb_generate_id (c);

/* Create the window */

xcb_create_window (c, /* Connection */

0, /* depth */

win, /* window Id */

screen->root, /* parent window */

0, 0, /* x, y */

250, 150, /* width, height */

10, /* border_width */

XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */

screen->root_visual, /* visual */

0, NULL); /* masks, not used */

/* Set the title of the window */

xcb_change_property (c, XCB_PROP_MODE_REPLACE, win,

WM_NAME, STRING, 8,

strlen (title), title);

/* Set the title of the window icon */

xcb_change_property (c, XCB_PROP_MODE_REPLACE, win,

WM_ICON_NAME, STRING, 8,

strlen(title_icon), title_icon);

/* Map the window on the screen */

xcb_map_window (c, win);

xcb_flush (c);

while (1) {}

return 0;

}

Note: the use of the atoms needs our program to be compiled

and linked against xcb_atom, so that we have to use

gcc prog.c -o prog `pkg-config --cflags --libs xcb_atom`

for the program to compile fine.

Simple window operations

One more thing we can do to our window is manipulate them on the

screen (resize them, move them, raise or lower them, iconify

them, and so on). Some window operations functions are supplied

by XCB for this purpose.

Mapping and un-mapping a window

The first pair of operations we can apply on a window is

mapping it, or un-mapping it. Mapping a window causes the

window to appear on the screen, as we have seen in our simple

window program example. Un-mapping it causes it to be removed

from the screen (although the window as a logical entity still

exists). This gives the effect of making a window hidden

(unmapped) and shown again (mapped). For example, if we have a

dialog box window in our program, instead of creating it every

time the user asks to open it, we can create the window once,

in an un-mapped mode, and when the user asks to open it, we

simply map the window on the screen. When the user clicked the

'OK' or 'Cancel' button, we simply un-map the window. This is

much faster than creating and destroying the window, however,

the cost is wasted resources, both on the client side, and on

the X server side.

To map a window, you use the following function:

xcb_void_cookie_t xcb_map_window (xcb_connection_t *c,

xcb_window_t window);

To have a simple example, see the example

above. The mapping operation will cause an

Expose event to be sent to our

application, unless the window is completely covered by other

windows.

Un-mapping a window is also simple. You use the function

xcb_void_cookie_t xcb_unmap_window (xcb_connection_t *c,

xcb_window_t window);

The utilization of this function is the same as

xcb_map_window().

Configuring a window

As we have seen when we have created our first window, in the

X Events subsection, we can set some attributes for the window

(that is, the position, the size, the events the window will

receive, etc). If we want to modify them, but the window is

already created, we can change them by using the following

function:

xcb_void_cookie_t xcb_configure_window (xcb_connection_t *c, /* The connection to the X server*/

xcb_window_t window, /* The window to configure */

uint16_t value_mask, /* The mask */

const uint32_t *value_list); /* The values to set */

We set the value_mask to one or

several mask values that are in the xcb_config_window_t enumeration in the xproto.h header:

XCB_CONFIG_WINDOW_X: new x coordinate of the window's top left corner

XCB_CONFIG_WINDOW_Y: new y coordinate of the window's top left corner

XCB_CONFIG_WINDOW_WIDTH: new width of the window

XCB_CONFIG_WINDOW_HEIGHT: new height of the window

XCB_CONFIG_WINDOW_BORDER_WIDTH: new width of the border of the window

XCB_CONFIG_WINDOW_SIBLING

XCB_CONFIG_WINDOW_STACK_MODE: the new stacking order

We then give to value_mask the new

value. We now describe how to use

xcb_configure_window_t in some useful

situations.

Moving a window around the screen

An operation we might want to do with windows is to move them

to a different location. This can be done like this:

const static uint32_t values[] = { 10, 20 };

/* The connection c and the window win are supposed to be defined */

/* Move the window to coordinates x = 10 and y = 20 */

xcb_configure_window (c, win, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values);

Note that when the window is moved, it might get partially

exposed or partially hidden by other windows, and thus we

might get Expose events due to this

operation.

Resizing a window

Yet another operation we can do is to change the size of a

window. This is done using the following code:

const static uint32_t values[] = { 200, 300 };

/* The connection c and the window win are supposed to be defined */

/* Resize the window to width = 10 and height = 20 */

xcb_configure_window (c, win, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);

We can also combine the move and resize operations using one

single call to xcb_configure_window_t:

const static uint32_t values[] = { 10, 20, 200, 300 };

/* The connection c and the window win are supposed to be defined */

/* Move the window to coordinates x = 10 and y = 20 */

/* and resize the window to width = 10 and height = 20 */

xcb_configure_window (c, win, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);

Changing windows stacking order: raise and lower

Until now, we changed properties of a single window. We'll see

that there are properties that relate to the window and other

windows. One of them is the stacking order. That is, the order

in which the windows are layered on top of each other. The

front-most window is said to be on the top of the stack, while

the back-most window is at the bottom of the stack. Here is

how to manipulate our windows stack order:

const static uint32_t values[] = { XCB_STACK_MODE_ABOVE };

/* The connection c and the window win are supposed to be defined */

/* Move the window on the top of the stack */

xcb_configure_window (c, win, XCB_CONFIG_WINDOW_STACK_MODE, values);

const static uint32_t values[] = { XCB_STACK_MODE_BELOW };

/* The connection c and the window win are supposed to be defined */

/* Move the window on the bottom of the stack */

xcb_configure_window (c, win, XCB_CONFIG_WINDOW_STACK_MODE, values);

Getting information about a window

Just like we can set various attributes of our windows, we can

also ask the X server supply the current values of these

attributes. For example, we can check where a window is

located on the screen, what is its current size, whether it is

mapped or not, etc. The structure that contains some of this

information is

typedef struct {

uint8_t response_type;

uint8_t depth; /* depth of the window */

uint16_t sequence;

uint32_t length;

xcb_window_t root; /* Id of the root window *>

int16_t x; /* X coordinate of the window's location */

int16_t y; /* Y coordinate of the window's location */

uint16_t width; /* Width of the window */

uint16_t height; /* Height of the window */

uint16_t border_width; /* Width of the window's border */

} xcb_get_geometry_reply_t;

XCB fill this structure with two functions:

xcb_get_geometry_cookie_t xcb_get_geometry (xcb_connection_t *c,

xcb_drawable_t drawable);

xcb_get_geometry_reply_t *xcb_get_geometry_reply (xcb_connection_t *c,

xcb_get_geometry_cookie_t cookie,

xcb_generic_error_t **e);

You use them as follows:

xcb_connection_t *c;

xcb_drawable_t win;

xcb_get_geometry_reply_t *geom;

/* You initialize c and win */

geom = xcb_get_geometry_reply (c, xcb_get_geometry (c, win), NULL);

/* Do something with the fields of geom */

free (geom);

Remark that you have to free the structure, as

xcb_get_geometry_reply_t allocates a

newly one.

One problem is that the returned location of the window is

relative to its parent window. This makes these coordinates

rather useless for any window manipulation functions, like

moving it on the screen. In order to overcome this problem, we

need to take a two-step operation. First, we find out the Id

of the parent window of our window. We then translate the

above relative coordinates to the screen coordinates.

To get the Id of the parent window, we need this structure:

typedef struct {

uint8_t response_type;

uint8_t pad0;

uint16_t sequence;

uint32_t length;

xcb_window_t root;

xcb_window_t parent; /* Id of the parent window */

uint16_t children_len;

uint8_t pad1[14];

} xcb_query_tree_reply_t;

To fill this structure, we use these two functions:

xcb_query_tree_cookie_t xcb_query_tree (xcb_connection_t *c,

xcb_window_t window);

xcb_query_tree_reply_t *xcb_query_tree_reply (xcb_connection_t *c,

xcb_query_tree_cookie_t cookie,

xcb_generic_error_t **e);

The translated coordinates will be found in this structure:

typedef struct {

uint8_t response_type;

uint8_t same_screen;

uint16_t sequence;

uint32_t length;

xcb_window_t child;

uint16_t dst_x; /* Translated x coordinate */

uint16_t dst_y; /* Translated y coordinate */

} xcb_translate_coordinates_reply_t;

As usual, we need two functions to fill this structure:

xcb_translate_coordinates_cookie_t xcb_translate_coordinates (xcb_connection_t *c,

xcb_window_t src_window,

xcb_window_t dst_window,

int16_t src_x,

int16_t src_y);

xcb_translate_coordinates_reply_t *xcb_translate_coordinates_reply (xcb_connection_t *c,

xcb_translate_coordinates_cookie_t cookie,

xcb_generic_error_t **e);

We use them as follows:

xcb_connection_t *c;

xcb_drawable_t win;

xcb_get_geometry_reply_t *geom;

xcb_query_tree_reply_t *tree;

xcb_translate_coordinates_reply_t *trans;

/* You initialize c and win */

geom = xcb_get_geometry_reply (c, xcb_get_geometry (c, win), NULL);

if (!geom)

return 0;

tree = xcb_query_tree_reply (c, xcb_query_tree (c, win), NULL);

if (!tree)

return 0;

trans = xcb_translate_coordinates_reply (c,

xcb_translate_coordinates (c,

win,

tree->parent,

geom->x, geom->y),

NULL);

if (!trans)

return 0;

/* the translated coordinates are in trans->dst_x and trans->dst_y */

free (trans);

free (tree);

free (geom);

Of course, as for geom,

tree and

trans have to be freed.

The work is a bit hard, but XCB is a very low-level library.

TODO: the utilization of these functions should be a

prog, which displays the coordinates of the window.

There is another structure that gives informations about our window:

typedef struct {

uint8_t response_type;

uint8_t backing_store;

uint16_t sequence;

uint32_t length;

xcb_visualid_t visual; /* Visual of the window */

uint16_t _class;

uint8_t bit_gravity;

uint8_t win_gravity;

uint32_t backing_planes;

uint32_t backing_pixel;

uint8_t save_under;

uint8_t map_is_installed;

uint8_t map_state; /* Map state of the window */

uint8_t override_redirect;

xcb_colormap_t colormap; /* Colormap of the window */

uint32_t all_event_masks;

uint32_t your_event_mask;

uint16_t do_not_propagate_mask;

} xcb_get_window_attributes_reply_t;

XCB supplies these two functions to fill it:

xcb_get_window_attributes_cookie_t xcb_get_window_attributes (xcb_connection_t *c,

xcb_window_t window);

xcb_get_window_attributes_reply_t *xcb_get_window_attributes_reply (xcb_connection_t *c,

xcb_get_window_attributes_cookie_t cookie,

xcb_generic_error_t **e);

You use them as follows:

xcb_connection_t *c;

xcb_drawable_t win;

xcb_get_window_attributes_reply_t *attr;

/* You initialize c and win */

attr = xcb_get_window_attributes_reply (c, xcb_get_window_attributes (c, win), NULL);

if (!attr)

return 0;

/* Do something with the fields of attr */

free (attr);

As for geom,

attr has to be freed.

Using colors to paint the rainbow

Up until now, all our painting operation were done using black

and white. We will (finally) see now how to draw using colors.

Color maps

In the beginning, there were not enough colors. Screen

controllers could only support a limited number of colors

simultaneously (initially 2, then 4, 16 and 256). Because of

this, an application could not just ask to draw in a "light

purple-red" color, and expect that color to be available. Each

application allocated the colors it needed, and when all the

color entries (4, 16, 256 colors) were in use, the next color

allocation would fail.

Thus, the notion of "a color map" was introduced. A color map

is a table whose size is the same as the number of

simultaneous colors a given screen controller. Each entry

contained the RGB (Red, Green and Blue) values of a different

color (all colors can be drawn using some combination of red,

green and blue). When an application wants to draw on the

screen, it does not specify which color to use. Rather, it

specifies which color entry of some color map to be used

during this drawing. Change the value in this color map entry

and the drawing will use a different color.

In order to be able to draw using colors that got something to

do with what the programmer intended, color map allocation

functions are supplied. You could ask to allocate entry for a

color with a set of RGB values. If one already existed, you

would get its index in the table. If none existed, and the

table was not full, a new cell would be allocated to contain

the given RGB values, and its index returned. If the table was

full, the procedure would fail. You could then ask to get a

color map entry with a color that is closest to the one you

were asking for. This would mean that the actual drawing on

the screen would be done using colors similar to what you

wanted, but not the same.

On today's more modern screens where one runs an X server with

support for 16 million colors, this limitation looks a little

silly, but remember that there are still older computers with

older graphics cards out there. Using color map, support for

these screen becomes transparent to you. On a display

supporting 16 million colors, any color entry allocation

request would succeed. On a display supporting a limited

number of colors, some color allocation requests would return

similar colors. It won't look as good, but your application

would still work.

Allocating and freeing Color Maps

When you draw using XCB, you can choose to use the standard

color map of the screen your window is displayed on, or you

can allocate a new color map and apply it to a window. In the

latter case, each time the mouse moves onto your window, the

screen color map will be replaced by your window's color map,

and you'll see all the other windows on screen change their

colors into something quite bizzare. In fact, this is the

effect you get with X applications that use the "-install"

command line option.

In XCB, a color map is (as often in X) an Id:

typedef uint32_t xcb_colormap_t;

In order to access the screen's default color map, you just

have to retrieve the default_colormap

field of the xcb_screen_t structure

(see Section

Checking basic information about a connection):

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_colormap_t colormap;

/* Open the connection to the X server and get the first screen */

c = xcb_connect (NULL, NULL);

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

colormap = screen->default_colormap;

return 0;

}

This will return the color map used by default on the first

screen (again, remember that an X server may support several

different screens, each of which might have its own resources).

The other option, that of allocating a new colormap, works as

follows. We first ask the X server to give an Id to our color

map, with this function:

xcb_colormap_t xcb_generate_id (xcb_connection_t *c);

Then, we create the color map with

xcb_void_cookie_t xcb_create_colormap (xcb_connection_t *c, /* Pointer to the xcb_connection_t structure */

uint8_t alloc, /* Colormap entries to be allocated (AllocNone or AllocAll) */

xcb_colormap_t mid, /* Id of the color map */

xcb_window_t window, /* Window on whose screen the colormap will be created */

xcb_visualid_t visual); /* Id of the visual supported by the screen */

Here is an example of creation of a new color map:

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_window_t win;

xcb_colormap_t cmap

/* Open the connection to the X server and get the first screen */

c = xcb_connect (NULL, NULL);

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* We create the window win here*/

cmap = xcb_generate_id (c);

xcb_create_colormap (c, XCB_COLORMAP_ALLOC_NONE, cmap, win, screen->root_visual);

return 0;

}

Note that the window parameter is only used to allow the X

server to create the color map for the given screen. We can

then use this color map for any window drawn on the same screen.

To free a color map, it suffices to use this function:

xcb_void_cookie_t xcb_free_colormap (xcb_connection_t *c, /* The connection */

xcb_colormap_t cmap); /* The color map */

Comparison Xlib/XCB

XCreateColormap ()

xcb_generate_id ()

xcb_create_colormap ()

XFreeColormap ()

xcb_free_colormap ()

Allocating and freeing a color entry

Once we got access to some color map, we can start allocating

colors. The informations related to a color are stored in the

following structure:

typedef struct {

uint8_t response_type;

uint8_t pad0;

uint16_t sequence;

uint32_t length;

uint16_t red; /* The red component */

uint16_t green; /* The green component */

uint16_t blue; /* The blue component */

uint8_t pad1[2];

uint32_t pixel; /* The entry in the color map, supplied by the X server */

} xcb_alloc_color_reply_t;

XCB supplies these two functions to fill it:

xcb_alloc_color_cookie_t xcb_alloc_color (xcb_connection_t *c,

xcb_colormap_t cmap,

uint16_t red,

uint16_t green,

uint16_t blue);

xcb_alloc_color_reply_t *xcb_alloc_color_reply (xcb_connection_t *c,

xcb_alloc_color_cookie_t cookie,

xcb_generic_error_t **e);

The fuction xcb_alloc_color() takes the

3 RGB components as parameters (red, green and blue). Here is an

example of using these functions:

#include

int

main ()

{

xcb_connection_t *c;

xcb_screen_t *screen;

xcb_window_t win;

xcb_colormap_t cmap;

xcb_alloc_color_reply_t *rep;

/* Open the connection to the X server and get the first screen */

c = xcb_connect (NULL, NULL);

screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data;

/* We create the window win here*/

cmap = xcb_generate_id (c);

xcb_create_colormap (c, XCB_COLORMAP_ALLOC_NONE, cmap, win, screen->root_visual);

rep = xcb_alloc_color_reply (c, xcb_alloc_color (c, cmap, 65535, 0, 0), NULL);

if (!rep)

return 0;

/* Do something with r->pixel or the components */

free (rep);

return 0;

}

As xcb_alloc_color_reply() allocates

memory, you have to free rep.

TODO: Talk about freeing colors.

X Bitmaps and Pixmaps

One thing many so-called "Multi-Media" applications need to do,

is display images. In the X world, this is done using bitmaps

and pixmaps. We have already seen some usage of them when

setting an icon for our application. Lets study them further,

and see how to draw these images inside a window, along side the

simple graphics and text we have seen so far.

One thing to note before delving further, is that XCB (nor Xlib)

supplies no means of manipulating popular image formats, such as

gif, png, jpeg or tiff. It is up to the programmer (or to higher

level graphics libraries) to translate these image formats into

formats that the X server is familiar with (x bitmaps and x

pixmaps).

What is a X Bitmap? An X Pixmap?

An X bitmap is a two-color image stored in a format specific

to the X window system. When stored in a file, the bitmap data

looks like a C source file. It contains variables defining the

width and the height of the bitmap, an array containing the

bit values of the bitmap (the size of the array is

(width+7)/8*height and the bit and byte order are LSB), and

an optional hot-spot location (that will

be explained later, when discussing mouse cursors).

An X pixmap is a format used to stored images in the memory of

an X server. This format can store both black and white images

(such as x bitmaps) as well as color images. It is the only

image format supported by the X protocol, and any image to be

drawn on screen, should be first translated into this format.

In actuality, an X pixmap can be thought of as a window that

does not appear on the screen. Many graphics operations that

work on windows, will also work on pixmaps. Indeed, the type

of X pixmap in XCB is an Id like a window:

typedef uint32_t xcb_pixmap_t;

Like Xlib, there is no difference between a Drawable, a Window

or a Pixmap:

typedef uint32_t xcb_drawable_t;

in order to avoid confusion between a window and a pixmap. The

operations that will work the same on a window or a pixmap

will require a xcb_drawable_t

Remark: In Xlib, there is no specific difference between a

Drawable, a

Pixmap or a

Window: all are 32 bit long

integer. XCB wraps all these different IDs in structures to

provide some measure of type-safety.

Creating a pixmap

Sometimes we want to create an un-initialized pixmap, so we

can later draw into it. This is useful for image drawing

programs (creating a new empty canvas will cause the creation

of a new pixmap on which the drawing can be stored). It is

also useful when reading various image formats: we load the

image data into memory, create a pixmap on the server, and

then draw the decoded image data onto that pixmap.

To create a new pixmap, we first ask the X server to give an

Id to our pixmap, with this function:

xcb_pixmap_t xcb_generate_id (xcb_connection_t *c);

Then, XCB supplies the following function to create new pixmaps:

xcb_void_cookie_t xcb_create_pixmap (xcb_connection_t *c, /* Pointer to the xcb_connection_t structure */

uint8_t depth, /* Depth of the screen */

xcb_pixmap_t pid, /* Id of the pixmap */

xcb_drawable_t drawable,

uint16_t width, /* Width of the window (in pixels) */

uint16_t height); /* Height of the window (in pixels) */

TODO: Explain the drawable parameter, and give an

example (like xpoints.c)

Drawing a pixmap in a window

Once we got a handle to a pixmap, we can draw it on some

window, using the following function:

xcb_void_cookie_t xcb_copy_area (xcb_connection_t *c, /* Pointer to the xcb_connection_t structure */

xcb_drawable_t src_drawable, /* The Drawable we want to paste */

xcb_drawable_t dst_drawable, /* The Drawable on which we copy the previous Drawable */

xcb_gcontext_t gc, /* A Graphic Context */

int16_t src_x, /* Top left x coordinate of the region we want to copy */

int16_t src_y, /* Top left y coordinate of the region we want to copy */

int16_t dst_x, /* Top left x coordinate of the region where we want to copy */

int16_t dst_y, /* Top left y coordinate of the region where we want to copy */

uint16_t width, /* Width of the region we want to copy */

uint16_t height); /* Height of the region we want to copy */

As you can see, we could copy the whole pixmap, as well as

only a given rectangle of the pixmap. This is useful to

optimize the drawing speed: we could copy only what we have

modified in the pixmap.

One important note should be made: it is possible to

create pixmaps with different depths on the same screen. When

we perform copy operations (a pixmap onto a window, etc), we

should make sure that both source and target have the same

depth. If they have a different depth, the operation would

fail. The exception to this is if we copy a specific bit plane

of the source pixmap using the

xcb_copy_plane_t function. In such an

event, we can copy a specific plane to the target window (in

actuality, setting a specific bit in the color of each pixel

copied). This can be used to generate strange graphic effects

in a window, but that is beyond the scope of this tutorial.

Freeing a pixmap

Finally, when we are done using a given pixmap, we should free

it, in order to free resources of the X server. This is done

using this function:

xcb_void_cookie_t xcb_free_pixmap (xcb_connection_t *c, /* Pointer to the xcb_connection_t structure */

xcb_pixmap_t pixmap); /* A given pixmap */

Of course, after having freed it, we must not try accessing

the pixmap again.

TODO: Give an example, or a link to xpoints.c

Messing with the mouse cursor

It it possible to modify the shape of the mouse pointer (also

called the X pointer) when in certain states, as we otfen see in

programs. For example, a busy application would often display

the sand clock over its main window, to give the user a visual

hint that he should wait. Let's see how we can change the mouse

cursor of our windows.

Creating and destroying a mouse cursor

There are two methods for creating cursors. One of them is by

using a set of predefined cursors, that are supplied by the X

server, the other is by using a user-supplied bitmap.

In the first method, we use a special font named "cursor", and

the function xcb_create_glyph_cursor:

xcb_void_cookie_t xcb_create_glyph_cursor (xcb_connection_t *c,

xcb_cursor_t cid,

xcb_font_t source_font, /* font for the source glyph */

xcb_font_t mask_font, /* font for the mask glyph or XCB_NONE */

uint16_t source_char, /* character glyph for the source */

uint16_t mask_char, /* character glyph for the mask */

uint16_t fore_red, /* red value for the foreground of the source */

uint16_t fore_green, /* green value for the foreground of the source */

uint16_t fore_blue, /* blue value for the foreground of the source */

uint16_t back_red, /* red value for the background of the source */

uint16_t back_green, /* green value for the background of the source */

uint16_t back_blue) /* blue value for the background of the source */

TODO: Describe source_char

and mask_char, for example by giving

an example on how to get the values. There is a list there:

X Font Cursors

So we first open that font (see Loading a Font)

and create the new cursor. As for every X ressource, we have to

ask for an X id with xcb_generate_id

first:

xcb_font_t font;

xcb_cursor_t cursor;

/* The connection is set */

font = xcb_generate_id (conn);

xcb_open_font (conn, font, strlen ("cursor"), "cursor");

cursor = xcb_generate_id (conn);

xcb_create_glyph_cursor (conn, cursor, font, font,

58, 58 + 1,

0, 0, 0,

0, 0, 0);

We have created the cursor "right hand" by specifying 58 to

the source_font argument and 58 + 1

to the mask_font.

The cursor is destroyed by using the function

xcb_void_cookie_t xcb_free_cursor (xcb_connection_t *c,

xcb_cursor_t cursor);

In the second method, we create a new cursor by using a pair

of pixmaps, with depth of one (that is, two colors

pixmaps). One pixmap defines the shape of the cursor, while

the other works as a mask, specifying which pixels of the

cursor will be actually drawn. The rest of the pixels will be

transparent.

TODO: give an example.

Setting a window's mouse cursor

Once the cursor is created, we can modify the cursor of our

window by using xcb_change_window_attributes

and using the XCB_CWCURSOR attribute:

uint32_t mask;

uint32_t value_list;

/* The connection and window are set */

/* The cursor is already created */

mask = XCB_CWCURSOR;

value_list = cursor;

xcb_change_window_attributes (conn, window, mask, &value_list);

Of course, the cursor and the font must be freed.

Complete example

The following example displays a window with a

button. When entering the window, the window cursor is changed

to an arrow. When clicking once on the button, the cursor is

changed to a hand. When clicking again on the button, the

cursor window gets back to the arrow. The Esc key exits the

application.

#include

#define WIDTH 300

#define HEIGHT 150

static xcb_gc_t gc_font_get (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

const char *font_name);

static void button_draw (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int16_t x1,

int16_t y1,

const char *label);

static void text_draw (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int16_t x1,

int16_t y1,

const char *label);

static void cursor_set (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int cursor_id);

static void

button_draw (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int16_t x1,

int16_t y1,

const char *label)

{

xcb_point_t points[5];

xcb_void_cookie_t cookie_gc;

xcb_void_cookie_t cookie_line;

xcb_void_cookie_t cookie_text;

xcb_generic_error_t *error;

xcb_gcontext_t gc;

int16_t width;

int16_t height;

uint8_t length;

int16_t inset;

length = strlen (label);

inset = 2;

gc = gc_font_get(c, screen, window, "7x13");

width = 7 * length + 2 * (inset + 1);

height = 13 + 2 * (inset + 1);

points[0].x = x1;

points[0].y = y1;

points[1].x = x1 + width;

points[1].y = y1;

points[2].x = x1 + width;

points[2].y = y1 - height;

points[3].x = x1;

points[3].y = y1 - height;

points[4].x = x1;

points[4].y = y1;

cookie_line = xcb_poly_line_checked (c, XCB_COORD_MODE_ORIGIN,

window, gc, 5, points);

error = xcb_request_check (c, cookie_line);

if (error) {

fprintf (stderr, "ERROR: can't draw lines : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cookie_text = xcb_image_text_8_checked (c, length, window, gc,

x1 + inset + 1,

y1 - inset - 1, label);

error = xcb_request_check (c, cookie_text);

if (error) {

fprintf (stderr, "ERROR: can't paste text : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cookie_gc = xcb_free_gc (c, gc);

error = xcb_request_check (c, cookie_gc);

if (error) {

fprintf (stderr, "ERROR: can't free gc : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

static void

text_draw (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int16_t x1,

int16_t y1,

const char *label)

{

xcb_void_cookie_t cookie_gc;

xcb_void_cookie_t cookie_text;

xcb_generic_error_t *error;

xcb_gcontext_t gc;

uint8_t length;

length = strlen (label);

gc = gc_font_get(c, screen, window, "7x13");

cookie_text = xcb_image_text_8_checked (c, length, window, gc,

x1,

y1, label);

error = xcb_request_check (c, cookie_text);

if (error) {

fprintf (stderr, "ERROR: can't paste text : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cookie_gc = xcb_free_gc (c, gc);

error = xcb_request_check (c, cookie_gc);

if (error) {

fprintf (stderr, "ERROR: can't free gc : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

static xcb_gc_t

gc_font_get (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

const char *font_name)

{

uint32_t value_list[3];

xcb_void_cookie_t cookie_font;

xcb_void_cookie_t cookie_gc;

xcb_generic_error_t *error;

xcb_font_t font;

xcb_gcontext_t gc;

uint32_t mask;

font = xcb_generate_id (c);

cookie_font = xcb_open_font_checked (c, font,

strlen (font_name),

font_name);

error = xcb_request_check (c, cookie_font);

if (error) {

fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);

xcb_disconnect (c);

return -1;

}

gc = xcb_generate_id (c);

mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;

value_list[0] = screen->black_pixel;

value_list[1] = screen->white_pixel;

value_list[2] = font;

cookie_gc = xcb_create_gc_checked (c, gc, window, mask, value_list);

error = xcb_request_check (c, cookie_gc);

if (error) {

fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cookie_font = xcb_close_font_checked (c, font);

error = xcb_request_check (c, cookie_font);

if (error) {

fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

return gc;

}

static void

cursor_set (xcb_connection_t *c,

xcb_screen_t *screen,

xcb_window_t window,

int cursor_id)

{

uint32_t values_list[3];

xcb_void_cookie_t cookie_font;

xcb_void_cookie_t cookie_gc;

xcb_generic_error_t *error;

xcb_font_t font;

xcb_cursor_t cursor;

xcb_gcontext_t gc;

uint32_t mask;

uint32_t value_list;

font = xcb_generate_id (c);

cookie_font = xcb_open_font_checked (c, font,

strlen ("cursor"),

"cursor");

error = xcb_request_check (c, cookie_font);

if (error) {

fprintf (stderr, "ERROR: can't open font : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

cursor = xcb_generate_id (c);

xcb_create_glyph_cursor (c, cursor, font, font,

cursor_id, cursor_id + 1,

0, 0, 0,

0, 0, 0);

gc = xcb_generate_id (c);

mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;

values_list[0] = screen->black_pixel;

values_list[1] = screen->white_pixel;

values_list[2] = font;

cookie_gc = xcb_create_gc_checked (c, gc, window, mask, values_list);

error = xcb_request_check (c, cookie_gc);

if (error) {

fprintf (stderr, "ERROR: can't create gc : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

mask = XCB_CW_CURSOR;

value_list = cursor;

xcb_change_window_attributes (c, window, mask, &value_list);

xcb_free_cursor (c, cursor);

cookie_font = xcb_close_font_checked (c, font);

error = xcb_request_check (c, cookie_font);

if (error) {

fprintf (stderr, "ERROR: can't close font : %d\n", error->error_code);

xcb_disconnect (c);

exit (-1);

}

int main ()

{

xcb_screen_iterator_t screen_iter;

xcb_connection_t *c;

const xcb_setup_t *setup;

xcb_screen_t *screen;

xcb_generic_event_t *e;

xcb_generic_error_t *error;

xcb_void_cookie_t cookie_window;

xcb_void_cookie_t cookie_map;

xcb_window_t window;

uint32_t mask;

uint32_t values[2];

int screen_number;

uint8_t is_hand = 0;

/* getting the connection */

c = xcb_connect (NULL, &screen_number);

if (!c) {

fprintf (stderr, "ERROR: can't connect to an X server\n");

return -1;

}

/* getting the current screen */

setup = xcb_get_setup (c);

screen = NULL;

screen_iter = xcb_setup_roots_iterator (setup);

for (; screen_iter.rem != 0; --screen_number, xcb_screen_next (&screen_iter))

if (screen_number == 0)

{

screen = screen_iter.data;

break;

}

if (!screen) {

fprintf (stderr, "ERROR: can't get the current screen\n");

xcb_disconnect (c);

return -1;

}

/* creating the window */

window = xcb_generate_id (c);

mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;

values[0] = screen->white_pixel;

values[1] =

XCB_EVENT_MASK_KEY_RELEASE |

XCB_EVENT_MASK_BUTTON_PRESS |

XCB_EVENT_MASK_EXPOSURE |

XCB_EVENT_MASK_POINTER_MOTION;

cookie_window = xcb_create_window_checked (c,

screen->root_depth,

window, screen->root,

20, 200, WIDTH, HEIGHT,

0, XCB_WINDOW_CLASS_INPUT_OUTPUT,

screen->root_visual,

mask, values);

cookie_map = xcb_map_window_checked (c, window);

/* error managing */

error = xcb_request_check (c, cookie_window);

if (error) {

fprintf (stderr, "ERROR: can't create window : %d\n", error->error_code);

xcb_disconnect (c);

return -1;

}

error = xcb_request_check (c, cookie_map);

if (error) {

fprintf (stderr, "ERROR: can't map window : %d\n", error->error_code);

xcb_disconnect (c);

return -1;

}

cursor_set (c, screen, window, 68);

xcb_flush(c);

while (1) {

e = xcb_poll_for_event(c);

if (e) {

switch (e->response_type & ~0x80) {

case XCB_EXPOSE: {

char *text;

text = "click here to change cursor";

button_draw (c, screen, window,

(WIDTH - 7 * strlen(text)) / 2,

(HEIGHT - 16) / 2, text);

text = "Press ESC key to exit...";

text_draw (c, screen, window, 10, HEIGHT - 10, text);

break;

}

case XCB_BUTTON_PRESS: {

xcb_button_press_event_t *ev;

int length;

ev = (xcb_button_press_event_t *)e;

length = strlen ("click here to change cursor");

if ((ev->event_x >= (WIDTH - 7 * length) / 2) &&

(ev->event_x <= ((WIDTH - 7 * length) / 2 + 7 * length + 6)) &&

(ev->event_y >= (HEIGHT - 16) / 2 - 19) &&

(ev->event_y <= ((HEIGHT - 16) / 2)))

is_hand = 1 - is_hand;

is_hand ? cursor_set (c, screen, window, 58) : cursor_set (c, screen, window, 68);

}

case XCB_KEY_RELEASE: {

xcb_key_release_event_t *ev;

ev = (xcb_key_release_event_t *)e;

switch (ev->detail) {

/* ESC */

case 9:

free (e);

xcb_disconnect (c);

return 0;

}

free (e);

}

return 0;

}

Translation of basic Xlib functions and macros

The problem when you want to port an Xlib program to XCB is that

you don't know if the Xlib function that you want to "translate"

is a X Window one or an Xlib macro. In that section, we describe

a way to translate the usual functions or macros that Xlib

provides. It's usually just a member of a structure.

Members of the Display structure

In this section, we look at how to translate the macros that

return some members of the Display

structure. They are obtained by using a function that requires a

xcb_connection_t * or a member of the

xcb_setup_t structure

(via the function xcb_get_setup), or

a function that requires that structure.

ConnectionNumber

This number is the file descriptor that connects the client

to the server. You just have to use that function:

int xcb_get_file_descriptor (xcb_connection_t *c);

DefaultScreen

That number is not stored by XCB. It is returned in the

second parameter of the function xcb_connect.

Hence, you have to store it yourself if you want to use

it. Then, to get the xcb_screen_t

structure, you have to iterate on the screens.

The equivalent function of the Xlib's

ScreenOfDisplay function can be

found below. This is also provided in the

xcb_aux_t library as xcb_aux_get_screen(). OK, here is the

small piece of code to get that number:

xcb_connection_t *c;

int screen_default_nbr;

/* you pass the name of the display you want to xcb_connect_t */

c = xcb_connect (display_name, &screen_default_nbr);

/* screen_default_nbr contains now the number of the default screen */

QLength

Not documented yet.

However, this points out a basic difference in philosophy between

Xlib and XCB. Xlib has several functions for filtering and

manipulating the incoming and outgoing X message queues. XCB

wishes to hide this as much as possible from the user, which

allows for more freedom in implementation strategies.

ScreenCount

You get the count of screens with the functions

xcb_get_setup

and

xcb_setup_roots_iterator

(if you need to iterate):

xcb_connection_t *c;

int screen_count;

/* you init the connection */

screen_count = xcb_setup_roots_iterator (xcb_get_setup (c)).rem;

/* screen_count contains now the count of screens */

If you don't want to iterate over the screens, a better way

to get that number is to use

xcb_setup_roots_length_t:

xcb_connection_t *c;

int screen_count;

/* you init the connection */

screen_count = xcb_setup_roots_length (xcb_get_setup (c));

/* screen_count contains now the count of screens */

ServerVendor

You get the name of the vendor of the server hardware with

the functions xcb_get_setup

and

xcb_setup_vendor. Beware

that, unlike Xlib, the string returned by XCB is not

necessarily null-terminaled:

xcb_connection_t *c;

char *vendor = NULL;

int length;

/* you init the connection */

length = xcb_setup_vendor_length (xcb_get_setup (c));

vendor = (char *)malloc (length + 1);

if (vendor)

memcpy (vendor, xcb_setup_vendor (xcb_get_setup (c)), length);

vendor[length] = '\0';

/* vendor contains now the name of the vendor. Must be freed when not used anymore */

ProtocolVersion

You get the major version of the protocol in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint16_t protocol_major_version;

/* you init the connection */

protocol_major_version = xcb_get_setup (c)->protocol_major_version;

/* protocol_major_version contains now the major version of the protocol */

ProtocolRevision

You get the minor version of the protocol in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint16_t protocol_minor_version;

/* you init the connection */

protocol_minor_version = xcb_get_setup (c)->protocol_minor_version;

/* protocol_minor_version contains now the minor version of the protocol */

VendorRelease

You get the number of the release of the server hardware in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint32_t release_number;

/* you init the connection */

release_number = xcb_get_setup (c)->release_number;

/* release_number contains now the number of the release of the server hardware */

DisplayString

The name of the display is not stored in XCB. You have to

store it by yourself.

BitmapUnit

You get the bitmap scanline unit in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint8_t bitmap_format_scanline_unit;

/* you init the connection */

bitmap_format_scanline_unit = xcb_get_setup (c)->bitmap_format_scanline_unit;

/* bitmap_format_scanline_unit contains now the bitmap scanline unit */

BitmapBitOrder

You get the bitmap bit order in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint8_t bitmap_format_bit_order;

/* you init the connection */

bitmap_format_bit_order = xcb_get_setup (c)->bitmap_format_bit_order;

/* bitmap_format_bit_order contains now the bitmap bit order */

BitmapPad

You get the bitmap scanline pad in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint8_t bitmap_format_scanline_pad;

/* you init the connection */

bitmap_format_scanline_pad = xcb_get_setup (c)->bitmap_format_scanline_pad;

/* bitmap_format_scanline_pad contains now the bitmap scanline pad */

ImageByteOrder

You get the image byte order in the

xcb_setup_t

structure, with the function xcb_get_setup:

xcb_connection_t *c;

uint8_t image_byte_order;

/* you init the connection */

image_byte_order = xcb_get_setup (c)->image_byte_order;

/* image_byte_order contains now the image byte order */

ScreenOfDisplay related functions

in Xlib, ScreenOfDisplay returns a

Screen structure that contains

several characteristics of your screen. XCB has a similar

structure (xcb_screen_t),

but the way to obtain it is a bit different. With

Xlib, you just provide the number of the screen and you grab it

from an array. With XCB, you iterate over all the screens to

obtain the one you want. The complexity of this operation is

O(n). So the best is to store this structure if you use

it often. See screen_of_display just below.

Xlib provides generally two functions to obtain the characteristics

related to the screen. One with the display and the number of

the screen, which calls ScreenOfDisplay,

and the other that uses the Screen structure.

This might be a bit confusing. As mentioned above, with XCB, it

is better to store the xcb_screen_t

structure. Then, you have to read the members of this

structure. That's why the Xlib functions are put by pairs (or

more) as, with XCB, you will use the same code.

ScreenOfDisplay

This function returns the Xlib Screen

structure. With XCB, you iterate over all the screens and

once you get the one you want, you return it:

xcb_screen_t *screen_of_display (xcb_connection_t *c,

int screen)

{

xcb_screen_iterator_t iter;

iter = xcb_setup_roots_iterator (xcb_get_setup (c));

for (; iter.rem; --screen, xcb_screen_next (&iter))

if (screen == 0)

return iter.data;

return NULL;

}

As mentioned above, you might want to store the value

returned by this function.

All the functions below will use the result of that

function, as they just grab a specific member of the

xcb_screen_t structure.

DefaultScreenOfDisplay

It is the default screen that you obtain when you connect to

the X server. It suffices to call the screen_of_display

function above with the connection and the number of the

default screen.

xcb_connection_t *c;

int screen_default_nbr;

xcb_screen_t *default_screen; /* the returned default screen */

/* you pass the name of the display you want to xcb_connect_t */

c = xcb_connect (display_name, &screen_default_nbr);

default_screen = screen_of_display (c, screen_default_nbr);

/* default_screen contains now the default root window, or a NULL window if no screen is found */

RootWindow / RootWindowOfScreen

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

xcb_window_t root_window = { 0 }; /* the returned window */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

root_window = screen->root;

/* root_window contains now the root window, or a NULL window if no screen is found */

DefaultRootWindow

It is the root window of the default screen. So, you call

ScreenOfDisplay with the

default screen number and you get the

root window as above:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_default_nbr;

xcb_window_t root_window = { 0 }; /* the returned root window */

/* you pass the name of the display you want to xcb_connect_t */

c = xcb_connect (display_name, &screen_default_nbr);

screen = screen_of_display (c, screen_default_nbr);

if (screen)

root_window = screen->root;

/* root_window contains now the default root window, or a NULL window if no screen is found */

DefaultVisual / DefaultVisualOfScreen

While a Visual is, in Xlib, a structure, in XCB, there are

two types: xcb_visualid_t, which is

the Id of the visual, and xcb_visualtype_t,

which corresponds to the Xlib Visual. To get the Id of the

visual of a screen, just get the

root_visual

member of a xcb_screen_t:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

xcb_visualid_t root_visual = { 0 }; /* the returned visual Id */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

root_visual = screen->root_visual;

/* root_visual contains now the value of the Id of the visual, or a NULL visual if no screen is found */

To get the xcb_visualtype_t

structure, it's a bit less easy. You have to get the

xcb_screen_t structure that you want,

get its root_visual member,

then iterate over the xcb_depth_ts

and the xcb_visualtype_ts, and compare

the xcb_visualid_t of these xcb_visualtype_ts:

with root_visual:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

xcb_visualid_t root_visual = { 0 };

xcb_visualtype_t *visual_type = NULL; /* the returned visual type */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen) {

xcb_depth_iterator_t depth_iter;

depth_iter = xcb_screen_allowed_depths_iterator (screen);

for (; depth_iter.rem; xcb_depth_next (&depth_iter)) {

xcb_visualtype_iterator_t visual_iter;

visual_iter = xcb_depth_visuals_iterator (depth_iter.data);

for (; visual_iter.rem; xcb_visualtype_next (&visual_iter)) {

if (screen->root_visual == visual_iter.data->visual_id) {

visual_type = visual_iter.data;

break;

}

/* visual_type contains now the visual structure, or a NULL visual structure if no screen is found */

DefaultGC / DefaultGCOfScreen

This default Graphic Context is just a newly created Graphic

Context, associated to the root window of a

xcb_screen_t,

using the black white pixels of that screen:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

xcb_gcontext_t gc = { 0 }; /* the returned default graphic context */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen) {

xcb_drawable_t draw;

uint32_t mask;

uint32_t values[2];

gc = xcb_generate_id (c);

draw = screen->root;

mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND;

values[0] = screen->black_pixel;

values[1] = screen->white_pixel;

xcb_create_gc (c, gc, draw, mask, values);

}

/* gc contains now the default graphic context */

BlackPixel / BlackPixelOfScreen

It is the Id of the black pixel, which is in the structure

of an xcb_screen_t.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t black_pixel = 0; /* the returned black pixel */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

black_pixel = screen->black_pixel;

/* black_pixel contains now the value of the black pixel, or 0 if no screen is found */

WhitePixel / WhitePixelOfScreen

It is the Id of the white pixel, which is in the structure

of an xcb_screen_t.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t white_pixel = 0; /* the returned white pixel */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

white_pixel = screen->white_pixel;

/* white_pixel contains now the value of the white pixel, or 0 if no screen is found */

DisplayWidth / WidthOfScreen

It is the width in pixels of the screen that you want, and

which is in the structure of the corresponding

xcb_screen_t.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t width_in_pixels = 0; /* the returned width in pixels */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

width_in_pixels = screen->width_in_pixels;

/* width_in_pixels contains now the width in pixels, or 0 if no screen is found */

DisplayHeight / HeightOfScreen

It is the height in pixels of the screen that you want, and

which is in the structure of the corresponding

xcb_screen_t.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t height_in_pixels = 0; /* the returned height in pixels */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

height_in_pixels = screen->height_in_pixels;

/* height_in_pixels contains now the height in pixels, or 0 if no screen is found */

DisplayWidthMM / WidthMMOfScreen

It is the width in millimeters of the screen that you want, and

which is in the structure of the corresponding

xcb_screen_t.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t width_in_millimeters = 0; /* the returned width in millimeters */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

width_in_millimeters = screen->width_in_millimeters;

/* width_in_millimeters contains now the width in millimeters, or 0 if no screen is found */

DisplayHeightMM / HeightMMOfScreen

It is the height in millimeters of the screen that you want, and

which is in the structure of the corresponding

xcb_screen_t.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t height_in_millimeters = 0; /* the returned height in millimeters */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

height_in_millimeters = screen->height_in_millimeters;

/* height_in_millimeters contains now the height in millimeters, or 0 if no screen is found */

DisplayPlanes / DefaultDepth / DefaultDepthOfScreen / PlanesOfScreen

It is the depth (in bits) of the root window of the

screen. You get it from the xcb_screen_t structure.

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint8_t root_depth = 0; /* the returned depth of the root window */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

root_depth = screen->root_depth;

/* root_depth contains now the depth of the root window, or 0 if no screen is found */

DefaultColormap / DefaultColormapOfScreen

This is the default colormap of the screen (and not the

(default) colormap of the default screen !). As usual, you

get it from the xcb_screen_t structure:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

xcb_colormap_t default_colormap = { 0 }; /* the returned default colormap */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

default_colormap = screen->default_colormap;

/* default_colormap contains now the default colormap, or a NULL colormap if no screen is found */

MinCmapsOfScreen

You get the minimum installed colormaps in the xcb_screen_t structure:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint16_t min_installed_maps = 0; /* the returned minimum installed colormaps */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

min_installed_maps = screen->min_installed_maps;

/* min_installed_maps contains now the minimum installed colormaps, or 0 if no screen is found */

MaxCmapsOfScreen

You get the maximum installed colormaps in the xcb_screen_t structure:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint16_t max_installed_maps = 0; /* the returned maximum installed colormaps */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

max_installed_maps = screen->max_installed_maps;

/* max_installed_maps contains now the maximum installed colormaps, or 0 if no screen is found */

DoesSaveUnders

You know if save_unders is set,

by looking in the xcb_screen_t structure:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint8_t save_unders = 0; /* the returned value of save_unders */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

save_unders = screen->save_unders;

/* save_unders contains now the value of save_unders, or FALSE if no screen is found */

DoesBackingStore

You know the value of backing_stores,

by looking in the xcb_screen_t structure:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint8_t backing_stores = 0; /* the returned value of backing_stores */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

backing_stores = screen->backing_stores;

/* backing_stores contains now the value of backing_stores, or FALSE if no screen is found */

EventMaskOfScreen

To get the current input masks,

you look in the xcb_screen_t structure:

xcb_connection_t *c;

xcb_screen_t *screen;

int screen_nbr;

uint32_t current_input_masks = 0; /* the returned value of current input masks */

/* you init the connection and screen_nbr */

screen = screen_of_display (c, screen_nbr);

if (screen)

current_input_masks = screen->current_input_masks;

/* current_input_masks contains now the value of the current input masks, or FALSE if no screen is found */

Miscellaneous macros

DisplayOfScreen

in Xlib, the Screen structure

stores its associated Display

structure. This is not the case in the X Window protocol,

hence, it's also not the case in XCB. So you have to store

it by yourself.

DisplayCells / CellsOfScreen

To get the colormap entries,

you look in the xcb_visualtype_t

structure, that you grab like here:

xcb_connection_t *c;

xcb_visualtype_t *visual_type;

uint16_t colormap_entries = 0; /* the returned value of the colormap entries */

/* you init the connection and visual_type */

if (visual_type)

colormap_entries = visual_type->colormap_entries;

/* colormap_entries contains now the value of the colormap entries, or FALSE if no screen is found */

The X New Developer’s Guide: Xlib and XCB

xorg/

guide/

The X New Developer’s Guide: Xlib and XCB

Edit

Page History

Repo Info

Xlib and XCB

Alan Coopersmith

Example: Converting xwininfo from Xlib to XCB

Mixing Xlib & XCB calls

Example: Converting xdpyinfo extension queries to XCB

Extension libraries

API documentation

The two most popular questions about Xlib and XCB may be

"What are they?" and "What's the difference?"

Most programming languages make it awkward for X

applications to spit raw X protocol down the network and

take apart the protocol coming back. Thus, X toolkits and

applications are a lot easier to write if some library

handles these jobs for them, providing an API that fits with

the programming language and environment for connecting to

the X server.

At the bottom level of the X client library stack are Xlib

and XCB, two helper libraries (really sets of libraries)

that provide API for talking to the X server. Xlib and XCB

have different design goals, and were developed in different

periods in the evolution of the X Window System.

Most application developers should call Xlib and XCB

sparingly. Higher level toolkits provide more efficient

programming models, and support features expected in modern

applications, including support for complex

internationalized input and output, accessibility, and

integration with desktop environments. However, sometimes

applications will find themselves needing to make calls to

the raw underlying X11 libraries for operations not

supported by toolkits. An application might need to make

calls to X extension API's not covered in the current

version of the toolkit's programming model. It is also

common for drawing not to be wrapped by toolkit API's. [Yes?

--po8]

The original C-language X11 API is libX11, often referred to

as "Xlib". It was designed to look like a traditional

library API, hiding the fact that calls result in protocol

requests to a server. Calls that don't require a response

from the X server are queued in a buffer to be sent as a

batch of requests to the server. Those that require a

response flush all the buffered requests and then block

until the response is received.

Xlib's mix of synchronous and asynchronous behaviors causes

some problems. Xlib's behaviour is often confusing to new

programmers. Calls appear to work sometimes and not others,

because it is not obvious which calls implicitly flush the

buffer. The asynchronous nature of many calls makes it

difficult to debug problems. When an error is reported, the

stack trace shows the call that was being made when the

error was received and processed, often many calls after the

one that caused the error. Finally, Xlib's synchronous calls

incur avoidable round-trip latency. This latency has a

notable effect on application performance; in particular,

startup times are often greatly increased.

After many years of experience with Xlib, and learning from

it and other protocol interface libraries, a second attempt

was made at defining a C language binding for X11: the "X11

C Binding" layer XCB. XCB makes the client-server nature of

the protocol explicit in its design. The client is in charge

of deciding when to flush the request buffer, when to read

results and when to wait for the server to respond.

For instance, to lookup a window property, the Xlib code is

a single function call:

XGetWindowProperty(dpy, win, atom, 0, 0, False, AnyPropertyType, &type_ret, &format_ret, &num_ret, &bytes_after, &prop_ret);

Xlib generates the request to the X server to retrieve the

property and appends it to its buffer of requests. Since

this is a request that requires a response, Xlib then

flushes the buffer, sending the contents to the X

server. Next, Xlib waits until the X server processes all

the requests preceding the property retrieve request, and

sends the property retrieve reply. Xlib then returns the

reply to the client.

Xlib also provides convenience functions that wrap a

property request. These convenience functions retrieve

specific properties, knowing the details of each property

and how to request and decode it. Examples include

XGetWMName and XGetWMHints. Some of these functions could be

written outside Xlib, but many use Xlib internals in

non-trivial ways and are thus inseparable. [Yes? --po8]

XCB on the other hand, provides functions generated directly

from the protocol descriptions in an "obvious" mechanistic

way. XCB functions map directly onto the protocol, with

separate functions to put requests into the outgoing buffer

and to read results back from the X server asynchronously

later. The XCB version of the above code is:

prop_cookie = xcb_get_property (dpy, False, win, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, 0);

prop_reply = xcb_get_property_reply (dpy, prop_cookie, NULL);

The power of XCB is in allowing those two steps to have as

much code as you want between them. The programmer decides

when to wait for data, instead of being forced to wait for

the data returned by a request at the time the request is

issued.

Example: Converting xwininfo from Xlib to XCB

The program xwininfo is a command-line utility to print

information about windows on an X server. It knows in

advance, from the command line options, most of the data it

needs to request information for each window from the

server. Thus, xwininfo can make its requests all at once,

and then wait for the results to start coming in. When using

the -tree option to walk the window tree, xwininfo can

request the data for all the children of the current window

at once, batching even further. On a local connection on a

single CPU server, this means less context switches between

X client and server. On a multi-core/CPU server, the X

server can process requests on one core while the client is

handling the responses on another core as they become

available, improving performance. On remote connections, the

requests can be grouped into packets closer to the MTU size

of the connection, instead of just sending whatever requests

are in the buffer when a request is made that needs a

response.

Version 1.1 of xwininfo was converted from Xlib to XCB by

Alan Coopersmith. It was tested with a GNOME desktop session

with a few clients. xwininfo was run as "xwininfo -root

-all": this started xwininfo at the root of the window

hierarchy and asked it to traverse the tree, requesting all

the information available for each window along the way. In

this sample session it found 114 windows. (In X, a window is

simply a container for drawing output and receiving

events. X windows are often regions of, or borders around,

the "user windows"). When running locally on a four-core

Intel Nehalem CPU, both versions ran so fast (0.05 seconds

or less) that the difference in time was too small to

accurately measure. To measure remote performance, "ssh -X"

was used to tunnel an X11 connection from California to a

computer in China, and from there back to the workstation in

California, introducing a huge amount of latency. With this

setup, the difference was dramatic between the two:

Xlib: 0.03u 0.02s 8:19.12 0.0%

xcb: 0.00u 0.00s 0:45.26 0.0%

Of course, xwininfo is an unusual X application in a few ways:

xwininfo runs through the requests as fast as it can and

then exits, not waiting for user input (unless you use

the mode where you click on a window to choose it, after

which it runs through as normal). Once they are up and

running, most X applications spend most of their time

waiting for user input, so the overall runtime won't

decrease as much by reducing the time spent

communicating with the X server. However, application

startups are typically dominated by round-trip times,

and so proper use of XCB reduces the huge startup times

of X applications running over high-latency (and even

medium-latency) connections.

xwininfo uses only the core protocol and shape

extension. It does not use the more complex extensions,

such as Render or Xinput, that most modern applications

use. Xinput, XKB, and GLX are especially problematic, as

those have not yet been fully supported in an XCB

release, though support has been worked on through some

Google Summer of Code projects.

xwininfo is small enough that a complete reworking to

use XCB in one shot was feasible. Most applications are

much larger than this. XCB is aimed primarily at new

code and at toolkits: it is designed specifically to

interoperate with existing Xlib applications. Calls to

Xlib and XCB can be mixed, so Xlib applications can be

converted partially or incrementally if desired.

xwininfo used only raw Xlib, without any toolkit. Thus,

it did not have to worry about which X library the

toolkit used.

xwininfo uses only a few of the Xlib helper

functions. This makes it more directly mappable to

XCB. Applications that rely on Xlib's input method

framework, compose key handling or character set

conversion, for example, would be harder to

port. Fortunately, modern toolkits handle most of this

functionality in the toolkit layer anyway.

xwininfo did rely on Xlib helper functions for converting

the window name property from other character sets---the XCB

version currently only works for UTF-8 and Latin-1 window

names. Since most modern toolkits use UTF-8, no one is

likely to notice. Older applications with localized window

names will fail, but there are few of these in use.

Mixing Xlib & XCB calls

As mentioned above, XCB provides a method for incremental

conversion from Xlib to XCB. One can use libX11 to open the

display and pass the Display pointer it returns to existing

code, toolkits, and libraries. To call an XCB function, one

can convert the Display pointer to an xcb_connection_t

pointer for the same connection. This enables calling into

Xlib and XCB from the same application.

Xlib and XCB compatibility was achieved by rebuilding libX11

as a layer on top of libxcb. Xlib and XCB share the same X

server connection and pass control of it back and

forth. That option was introduced in libX11 1.2, and is now

always present (no longer optional) since the 2010 release

of libX11 1.4.

Example: Converting xdpyinfo extension queries to XCB

xdpyinfo is another command-line tool in the standard X

Window System toolset. Like xwininfo, xdpyinfo prints a lot

of information about the X server. xdpyinfo calls many

extensions, and few of its calls block waiting for a

response from the server. If you add the "-queryExt" option,

though, for every extension xdpyinfo calls XQueryExtension

to print which request, event, and error ids are assigned to

that extension in the currently running server. These ids

are dynamically assigned, and vary depending on the set of

extensions enabled in a given server

build/configuration. Thus, the list of extension ids is

critical information to have when debugging X error reports

that reference them. Using "xdpyinfo -queryExt" is

especially needed when reporting an X error message that

comes from a custom error handler like the one in the gtk

toolkit: such error handlers typically omit the extension

information found in the default Xlib error handler, so the

person reading the bug report will be unable to identify the

extension in which the error was encountered.

The Xlib call XQueryExtension takes one extension name at a

time, sends a request to the X server for the id codes for

that extension, and waits for a response so it can return

those ids to the caller. On the Xorg 1.7 server used as the

test system for this conversion, there were 30 active X

extensions, so that's 30 tiny packets sent to the X server,

30 times that the xdpyinfo client blocks in poll() waiting

for a response, and 30 times that the X server goes through

the client handling and request scheduling code before going

back to block again on its own select() loop.

Note: XListExtensions can be used to get a list of available

extensions that can be called with XQueryExtension.

A simple patch to xdpyinfo replaced just that loop of calls

to XQueryExtension with two loops. The first loop called

xcb_query_extension for each extension. When the entire

batch of queries had been issued, a second loop called

xcb_query_extension_reply to start collecting the batched

replies. Gathering system call counts with "truss -c" showed

the expected reduction in a number of system calls made by

the xdpyinfo client:

System call

Xlib

xcb

writev

poll

recv

117

total

237

Over a TCP connection, the switch to XCB for this

transaction reduced both the number of packets and (due to

tcp packet header overhead) the overall amount of data:

Xlib

xcb

TCP packets

TCP bytes

11554

7726

This sort of change is far more feasible than wholesale

conversion to XCB for most applications. Find the hotspots

where the application is waiting for data from the server

and convert those. There are almost always opportunities in

application startup code, when the application is gathering

the information about the X server and session. Converting

just those calls to more efficient sets of XCB calls can

have major performance benefits. Earlier work by X

developers reduced the latency of many applications by

converting repeated calls to XInternAtom with a single call

to fetch multiple atoms at once via XInternAtoms. XCB

permits a generalization of this principle.

Extension libraries

Each new extension to the X11 protocol adds requests that

clients can make to the X server. To allow client software

to utilize these requests, most extensions offer API's built

on top of Xlib or XCB. These API's use the library's

connection marshalling to include their requests in the

stream sent to the X server.

In the early X11 releases, many of the smaller and more

common extensions were grouped into a common library,

libXext. You will find several there today which are still

in use, such as the MIT-SHM Shared Memory extension, the

SHAPE extension for non-rectangular windows, and the SYNC

extension for event synchronization. However, libXext also

includes some API's for extensions no longer found in

current Xorg server releases, such as App-Group and

Low-Bandwidth X (LBX), as well as extensions many apps never

use, such as DPMS for display power management. Since these

extension API's cannot be removed from libXext without

breaking any existing application which may be using them,

the code is stuck in there.

Accordingly, new Xlib extension API's are no longer added to

libXext. Instead a new library utilizing libX11 is created

for each extension. Having a library per extension makes it

easier to evolve the API for that extension, to deprecate an

obsolete extension and to only link it into the clients that

actually need it. Almost all modern extensions have their

own Xlib API library---libXrender for the RENDER extension,

libXcomposite for the COMPOSITE extension, and so on. A

handful of extensions are so core to the protocol

interaction that they are supported directly in libX11

itself, such as BigRequests, XC-MISC, and XKB.

When XCB added its API style to the mix, it followed the

newer style and created a "libxcb"-prefixed library for each

extension---libxcb-composite, libxcb-render, etc. Since XCB

can generates the API code for an extension automatically

from an XML description of the extension protocol, new

extension API's are created by simply adding the extension

description to the xcb-proto package and rebuilding.

Unfortunately, some of the older extensions have complex

protocols that are not easily described in the XML

syntax. Work is ongoing to extend the syntax and code

generator to handle these. The XKB & GLX protocols are

current challenges.

API documentation

To write code using Xlib or XCB, you'll need to know the

details of the library API. Xlib includes man pages for

most functions, providing a good API reference. libXext

includes man pages for some of the extension API's it

includes, but not all of them. Man page coverage is even

more spotty in the individual Xlib-based extension

libraries.

There's also a more complete guide to the Xlib API, and

specifications for many extension API's, in the X.Org online

doc set at http://www.x.org/releases/current/doc/.

For extensions without Xlib-style API documentation, the

calls are usually simple mappings to the protocol

specifications provided in the above-linked doc set.

For XCB, the documentation relies even more heavily on the

protocol specifications. The generated API is an exact

mapping to the X protocol; it translates the C call data

into X protocol encoded packets as straightforwardly as

possible. The connection management and other functions in

the XCB API are documented at

http://xcb.freedesktop.org/XcbApi/. Work is in progress on

adding support to XCB to generate Unix style reference man

pages from the XML protocol descriptions as well, for

developer convenience.

There is also a XCB tutorial, "Basic Graphics Programming

With The XCB Library" at

http://www.x.org/releases/current/doc/libxcb/tutorial/index.html.

Helping us improve our API documentation for either library

stack is always appreciated. See the Documentation chapter

later in this guide for more information.

The X New Developer’s Guide

<< The X Client Ecosystem

Using Extensions >>

Links:

ProgrammingDocumentation

Last edited Sun 14 Jul 2013 05:33:55 PM UTC

XCB: XCB API

XCB

1.12

Main Page

Modules

Data Structures

Files

Data Structures |

Macros |

Typedefs |

Enumerations |

Functions

XCB API

XCB Protocol Implementation.

More...

Data Structures

struct xcb_char2b_t

xcb_char2b_t More...

struct xcb_char2b_iterator_t

xcb_char2b_iterator_t More...

struct xcb_window_iterator_t

xcb_window_iterator_t More...

struct xcb_pixmap_iterator_t

xcb_pixmap_iterator_t More...

struct xcb_cursor_iterator_t

xcb_cursor_iterator_t More...

struct xcb_font_iterator_t

xcb_font_iterator_t More...

struct xcb_gcontext_iterator_t

xcb_gcontext_iterator_t More...

struct xcb_colormap_iterator_t

xcb_colormap_iterator_t More...

struct xcb_atom_iterator_t

xcb_atom_iterator_t More...

struct xcb_drawable_iterator_t

xcb_drawable_iterator_t More...

struct xcb_fontable_iterator_t

xcb_fontable_iterator_t More...

struct xcb_bool32_iterator_t

xcb_bool32_iterator_t More...

struct xcb_visualid_iterator_t

xcb_visualid_iterator_t More...

struct xcb_timestamp_iterator_t

xcb_timestamp_iterator_t More...

struct xcb_keysym_iterator_t

xcb_keysym_iterator_t More...

struct xcb_keycode_iterator_t

xcb_keycode_iterator_t More...

struct xcb_keycode32_iterator_t

xcb_keycode32_iterator_t More...

struct xcb_button_iterator_t

xcb_button_iterator_t More...

struct xcb_point_t

xcb_point_t More...

struct xcb_point_iterator_t

xcb_point_iterator_t More...

struct xcb_rectangle_t

xcb_rectangle_t More...

struct xcb_rectangle_iterator_t

xcb_rectangle_iterator_t More...

struct xcb_arc_t

xcb_arc_t More...

struct xcb_arc_iterator_t

xcb_arc_iterator_t More...

struct xcb_format_t

xcb_format_t More...

struct xcb_format_iterator_t

xcb_format_iterator_t More...

struct xcb_visualtype_t

xcb_visualtype_t More...

struct xcb_visualtype_iterator_t

xcb_visualtype_iterator_t More...

struct xcb_depth_t

xcb_depth_t More...

struct xcb_depth_iterator_t

xcb_depth_iterator_t More...

struct xcb_screen_t

xcb_screen_t More...

struct xcb_screen_iterator_t

xcb_screen_iterator_t More...

struct xcb_setup_request_t

xcb_setup_request_t More...

struct xcb_setup_request_iterator_t

xcb_setup_request_iterator_t More...

struct xcb_setup_failed_t

xcb_setup_failed_t More...

struct xcb_setup_failed_iterator_t

xcb_setup_failed_iterator_t More...

struct xcb_setup_authenticate_t

xcb_setup_authenticate_t More...

struct xcb_setup_authenticate_iterator_t

xcb_setup_authenticate_iterator_t More...

struct xcb_setup_t

xcb_setup_t More...

struct xcb_setup_iterator_t

xcb_setup_iterator_t More...

struct xcb_key_press_event_t

xcb_key_press_event_t More...

struct xcb_button_press_event_t

xcb_button_press_event_t More...

struct xcb_motion_notify_event_t

xcb_motion_notify_event_t More...

struct xcb_enter_notify_event_t

xcb_enter_notify_event_t More...

struct xcb_focus_in_event_t

xcb_focus_in_event_t More...

struct xcb_keymap_notify_event_t

xcb_keymap_notify_event_t More...

struct xcb_expose_event_t

xcb_expose_event_t More...

struct xcb_graphics_exposure_event_t

xcb_graphics_exposure_event_t More...

struct xcb_no_exposure_event_t

xcb_no_exposure_event_t More...

struct xcb_visibility_notify_event_t

xcb_visibility_notify_event_t More...

struct xcb_create_notify_event_t

xcb_create_notify_event_t More...

struct xcb_destroy_notify_event_t

xcb_destroy_notify_event_t More...

struct xcb_unmap_notify_event_t

xcb_unmap_notify_event_t More...

struct xcb_map_notify_event_t

xcb_map_notify_event_t More...

struct xcb_map_request_event_t

xcb_map_request_event_t More...

struct xcb_reparent_notify_event_t

xcb_reparent_notify_event_t More...

struct xcb_configure_notify_event_t

xcb_configure_notify_event_t More...

struct xcb_configure_request_event_t

xcb_configure_request_event_t More...

struct xcb_gravity_notify_event_t

xcb_gravity_notify_event_t More...

struct xcb_resize_request_event_t

xcb_resize_request_event_t More...

struct xcb_circulate_notify_event_t

xcb_circulate_notify_event_t More...

struct xcb_property_notify_event_t

xcb_property_notify_event_t More...

struct xcb_selection_clear_event_t

xcb_selection_clear_event_t More...

struct xcb_selection_request_event_t

xcb_selection_request_event_t More...

struct xcb_selection_notify_event_t

xcb_selection_notify_event_t More...

struct xcb_colormap_notify_event_t

xcb_colormap_notify_event_t More...

union xcb_client_message_data_t

xcb_client_message_data_t More...

struct xcb_client_message_data_iterator_t

xcb_client_message_data_iterator_t More...

struct xcb_client_message_event_t

xcb_client_message_event_t More...

struct xcb_mapping_notify_event_t

xcb_mapping_notify_event_t More...

struct xcb_ge_generic_event_t

xcb_ge_generic_event_t More...

struct xcb_request_error_t

xcb_request_error_t More...

struct xcb_value_error_t

xcb_value_error_t More...

struct xcb_create_window_value_list_t

xcb_create_window_value_list_t More...

struct xcb_create_window_request_t

xcb_create_window_request_t More...

struct xcb_change_window_attributes_value_list_t

xcb_change_window_attributes_value_list_t More...

struct xcb_change_window_attributes_request_t

xcb_change_window_attributes_request_t More...

struct xcb_get_window_attributes_cookie_t

xcb_get_window_attributes_cookie_t More...

struct xcb_get_window_attributes_request_t

xcb_get_window_attributes_request_t More...

struct xcb_get_window_attributes_reply_t

xcb_get_window_attributes_reply_t More...

struct xcb_destroy_window_request_t

xcb_destroy_window_request_t More...

struct xcb_destroy_subwindows_request_t

xcb_destroy_subwindows_request_t More...

struct xcb_change_save_set_request_t

xcb_change_save_set_request_t More...

struct xcb_reparent_window_request_t

xcb_reparent_window_request_t More...

struct xcb_map_window_request_t

xcb_map_window_request_t More...

struct xcb_map_subwindows_request_t

xcb_map_subwindows_request_t More...

struct xcb_unmap_window_request_t

xcb_unmap_window_request_t More...

struct xcb_unmap_subwindows_request_t

xcb_unmap_subwindows_request_t More...

struct xcb_configure_window_value_list_t

xcb_configure_window_value_list_t More...

struct xcb_configure_window_request_t

xcb_configure_window_request_t More...

struct xcb_circulate_window_request_t

xcb_circulate_window_request_t More...

struct xcb_get_geometry_cookie_t

xcb_get_geometry_cookie_t More...

struct xcb_get_geometry_request_t

xcb_get_geometry_request_t More...

struct xcb_get_geometry_reply_t

xcb_get_geometry_reply_t More...

struct xcb_query_tree_cookie_t

xcb_query_tree_cookie_t More...

struct xcb_query_tree_request_t

xcb_query_tree_request_t More...

struct xcb_query_tree_reply_t

xcb_query_tree_reply_t More...

struct xcb_intern_atom_cookie_t

xcb_intern_atom_cookie_t More...

struct xcb_intern_atom_request_t

xcb_intern_atom_request_t More...

struct xcb_intern_atom_reply_t

xcb_intern_atom_reply_t More...

struct xcb_get_atom_name_cookie_t

xcb_get_atom_name_cookie_t More...

struct xcb_get_atom_name_request_t

xcb_get_atom_name_request_t More...

struct xcb_get_atom_name_reply_t

xcb_get_atom_name_reply_t More...

struct xcb_change_property_request_t

xcb_change_property_request_t More...

struct xcb_delete_property_request_t

xcb_delete_property_request_t More...

struct xcb_get_property_cookie_t

xcb_get_property_cookie_t More...

struct xcb_get_property_request_t

xcb_get_property_request_t More...

struct xcb_get_property_reply_t

xcb_get_property_reply_t More...

struct xcb_list_properties_cookie_t

xcb_list_properties_cookie_t More...

struct xcb_list_properties_request_t

xcb_list_properties_request_t More...

struct xcb_list_properties_reply_t

xcb_list_properties_reply_t More...

struct xcb_set_selection_owner_request_t

xcb_set_selection_owner_request_t More...

struct xcb_get_selection_owner_cookie_t

xcb_get_selection_owner_cookie_t More...

struct xcb_get_selection_owner_request_t

xcb_get_selection_owner_request_t More...

struct xcb_get_selection_owner_reply_t

xcb_get_selection_owner_reply_t More...

struct xcb_convert_selection_request_t

xcb_convert_selection_request_t More...

struct xcb_send_event_request_t

xcb_send_event_request_t More...

struct xcb_grab_pointer_cookie_t

xcb_grab_pointer_cookie_t More...

struct xcb_grab_pointer_request_t

xcb_grab_pointer_request_t More...

struct xcb_grab_pointer_reply_t

xcb_grab_pointer_reply_t More...

struct xcb_ungrab_pointer_request_t

xcb_ungrab_pointer_request_t More...

struct xcb_grab_button_request_t

xcb_grab_button_request_t More...

struct xcb_ungrab_button_request_t

xcb_ungrab_button_request_t More...

struct xcb_change_active_pointer_grab_request_t

xcb_change_active_pointer_grab_request_t More...

struct xcb_grab_keyboard_cookie_t

xcb_grab_keyboard_cookie_t More...

struct xcb_grab_keyboard_request_t

xcb_grab_keyboard_request_t More...

struct xcb_grab_keyboard_reply_t

xcb_grab_keyboard_reply_t More...

struct xcb_ungrab_keyboard_request_t

xcb_ungrab_keyboard_request_t More...

struct xcb_grab_key_request_t

xcb_grab_key_request_t More...

struct xcb_ungrab_key_request_t

xcb_ungrab_key_request_t More...

struct xcb_allow_events_request_t

xcb_allow_events_request_t More...

struct xcb_grab_server_request_t

xcb_grab_server_request_t More...

struct xcb_ungrab_server_request_t

xcb_ungrab_server_request_t More...

struct xcb_query_pointer_cookie_t

xcb_query_pointer_cookie_t More...

struct xcb_query_pointer_request_t

xcb_query_pointer_request_t More...

struct xcb_query_pointer_reply_t

xcb_query_pointer_reply_t More...

struct xcb_timecoord_t

xcb_timecoord_t More...

struct xcb_timecoord_iterator_t

xcb_timecoord_iterator_t More...

struct xcb_get_motion_events_cookie_t

xcb_get_motion_events_cookie_t More...

struct xcb_get_motion_events_request_t

xcb_get_motion_events_request_t More...

struct xcb_get_motion_events_reply_t

xcb_get_motion_events_reply_t More...

struct xcb_translate_coordinates_cookie_t

xcb_translate_coordinates_cookie_t More...

struct xcb_translate_coordinates_request_t

xcb_translate_coordinates_request_t More...

struct xcb_translate_coordinates_reply_t

xcb_translate_coordinates_reply_t More...

struct xcb_warp_pointer_request_t

xcb_warp_pointer_request_t More...

struct xcb_set_input_focus_request_t

xcb_set_input_focus_request_t More...

struct xcb_get_input_focus_cookie_t

xcb_get_input_focus_cookie_t More...

struct xcb_get_input_focus_request_t

xcb_get_input_focus_request_t More...

struct xcb_get_input_focus_reply_t

xcb_get_input_focus_reply_t More...

struct xcb_query_keymap_cookie_t

xcb_query_keymap_cookie_t More...

struct xcb_query_keymap_request_t

xcb_query_keymap_request_t More...

struct xcb_query_keymap_reply_t

xcb_query_keymap_reply_t More...

struct xcb_open_font_request_t

xcb_open_font_request_t More...

struct xcb_close_font_request_t

xcb_close_font_request_t More...

struct xcb_fontprop_t

xcb_fontprop_t More...

struct xcb_fontprop_iterator_t

xcb_fontprop_iterator_t More...

struct xcb_charinfo_t

xcb_charinfo_t More...

struct xcb_charinfo_iterator_t

xcb_charinfo_iterator_t More...

struct xcb_query_font_cookie_t

xcb_query_font_cookie_t More...

struct xcb_query_font_request_t

xcb_query_font_request_t More...

struct xcb_query_font_reply_t

xcb_query_font_reply_t More...

struct xcb_query_text_extents_cookie_t

xcb_query_text_extents_cookie_t More...

struct xcb_query_text_extents_request_t

xcb_query_text_extents_request_t More...

struct xcb_query_text_extents_reply_t

xcb_query_text_extents_reply_t More...

struct xcb_str_t

xcb_str_t More...

struct xcb_str_iterator_t

xcb_str_iterator_t More...

struct xcb_list_fonts_cookie_t

xcb_list_fonts_cookie_t More...

struct xcb_list_fonts_request_t

xcb_list_fonts_request_t More...

struct xcb_list_fonts_reply_t

xcb_list_fonts_reply_t More...

struct xcb_list_fonts_with_info_cookie_t

xcb_list_fonts_with_info_cookie_t More...

struct xcb_list_fonts_with_info_request_t

xcb_list_fonts_with_info_request_t More...

struct xcb_list_fonts_with_info_reply_t

xcb_list_fonts_with_info_reply_t More...

struct xcb_set_font_path_request_t

xcb_set_font_path_request_t More...

struct xcb_get_font_path_cookie_t

xcb_get_font_path_cookie_t More...

struct xcb_get_font_path_request_t

xcb_get_font_path_request_t More...

struct xcb_get_font_path_reply_t

xcb_get_font_path_reply_t More...

struct xcb_create_pixmap_request_t

xcb_create_pixmap_request_t More...

struct xcb_free_pixmap_request_t

xcb_free_pixmap_request_t More...

struct xcb_create_gc_value_list_t

xcb_create_gc_value_list_t More...

struct xcb_create_gc_request_t

xcb_create_gc_request_t More...

struct xcb_change_gc_value_list_t

xcb_change_gc_value_list_t More...

struct xcb_change_gc_request_t

xcb_change_gc_request_t More...

struct xcb_copy_gc_request_t

xcb_copy_gc_request_t More...

struct xcb_set_dashes_request_t

xcb_set_dashes_request_t More...

struct xcb_set_clip_rectangles_request_t

xcb_set_clip_rectangles_request_t More...

struct xcb_free_gc_request_t

xcb_free_gc_request_t More...

struct xcb_clear_area_request_t

xcb_clear_area_request_t More...

struct xcb_copy_area_request_t

xcb_copy_area_request_t More...

struct xcb_copy_plane_request_t

xcb_copy_plane_request_t More...

struct xcb_poly_point_request_t

xcb_poly_point_request_t More...

struct xcb_poly_line_request_t

xcb_poly_line_request_t More...

struct xcb_segment_t

xcb_segment_t More...

struct xcb_segment_iterator_t

xcb_segment_iterator_t More...

struct xcb_poly_segment_request_t

xcb_poly_segment_request_t More...

struct xcb_poly_rectangle_request_t

xcb_poly_rectangle_request_t More...

struct xcb_poly_arc_request_t

xcb_poly_arc_request_t More...

struct xcb_fill_poly_request_t

xcb_fill_poly_request_t More...

struct xcb_poly_fill_rectangle_request_t

xcb_poly_fill_rectangle_request_t More...

struct xcb_poly_fill_arc_request_t

xcb_poly_fill_arc_request_t More...

struct xcb_put_image_request_t

xcb_put_image_request_t More...

struct xcb_get_image_cookie_t

xcb_get_image_cookie_t More...

struct xcb_get_image_request_t

xcb_get_image_request_t More...

struct xcb_get_image_reply_t

xcb_get_image_reply_t More...

struct xcb_poly_text_8_request_t

xcb_poly_text_8_request_t More...

struct xcb_poly_text_16_request_t

xcb_poly_text_16_request_t More...

struct xcb_image_text_8_request_t

xcb_image_text_8_request_t More...

struct xcb_image_text_16_request_t

xcb_image_text_16_request_t More...

struct xcb_create_colormap_request_t

xcb_create_colormap_request_t More...

struct xcb_free_colormap_request_t

xcb_free_colormap_request_t More...

struct xcb_copy_colormap_and_free_request_t

xcb_copy_colormap_and_free_request_t More...

struct xcb_install_colormap_request_t

xcb_install_colormap_request_t More...

struct xcb_uninstall_colormap_request_t

xcb_uninstall_colormap_request_t More...

struct xcb_list_installed_colormaps_cookie_t

xcb_list_installed_colormaps_cookie_t More...

struct xcb_list_installed_colormaps_request_t

xcb_list_installed_colormaps_request_t More...

struct xcb_list_installed_colormaps_reply_t

xcb_list_installed_colormaps_reply_t More...

struct xcb_alloc_color_cookie_t

xcb_alloc_color_cookie_t More...

struct xcb_alloc_color_request_t

xcb_alloc_color_request_t More...

struct xcb_alloc_color_reply_t

xcb_alloc_color_reply_t More...

struct xcb_alloc_named_color_cookie_t

xcb_alloc_named_color_cookie_t More...

struct xcb_alloc_named_color_request_t

xcb_alloc_named_color_request_t More...

struct xcb_alloc_named_color_reply_t

xcb_alloc_named_color_reply_t More...

struct xcb_alloc_color_cells_cookie_t

xcb_alloc_color_cells_cookie_t More...

struct xcb_alloc_color_cells_request_t

xcb_alloc_color_cells_request_t More...

struct xcb_alloc_color_cells_reply_t

xcb_alloc_color_cells_reply_t More...

struct xcb_alloc_color_planes_cookie_t

xcb_alloc_color_planes_cookie_t More...

struct xcb_alloc_color_planes_request_t

xcb_alloc_color_planes_request_t More...

struct xcb_alloc_color_planes_reply_t

xcb_alloc_color_planes_reply_t More...

struct xcb_free_colors_request_t

xcb_free_colors_request_t More...

struct xcb_coloritem_t

xcb_coloritem_t More...

struct xcb_coloritem_iterator_t

xcb_coloritem_iterator_t More...

struct xcb_store_colors_request_t

xcb_store_colors_request_t More...

struct xcb_store_named_color_request_t

xcb_store_named_color_request_t More...

struct xcb_rgb_t

xcb_rgb_t More...

struct xcb_rgb_iterator_t

xcb_rgb_iterator_t More...

struct xcb_query_colors_cookie_t

xcb_query_colors_cookie_t More...

struct xcb_query_colors_request_t

xcb_query_colors_request_t More...

struct xcb_query_colors_reply_t

xcb_query_colors_reply_t More...

struct xcb_lookup_color_cookie_t

xcb_lookup_color_cookie_t More...

struct xcb_lookup_color_request_t

xcb_lookup_color_request_t More...

struct xcb_lookup_color_reply_t

xcb_lookup_color_reply_t More...

struct xcb_create_cursor_request_t

xcb_create_cursor_request_t More...

struct xcb_create_glyph_cursor_request_t

xcb_create_glyph_cursor_request_t More...

struct xcb_free_cursor_request_t

xcb_free_cursor_request_t More...

struct xcb_recolor_cursor_request_t

xcb_recolor_cursor_request_t More...

struct xcb_query_best_size_cookie_t

xcb_query_best_size_cookie_t More...

struct xcb_query_best_size_request_t

xcb_query_best_size_request_t More...

struct xcb_query_best_size_reply_t

xcb_query_best_size_reply_t More...

struct xcb_query_extension_cookie_t

xcb_query_extension_cookie_t More...

struct xcb_query_extension_request_t

xcb_query_extension_request_t More...

struct xcb_query_extension_reply_t

xcb_query_extension_reply_t More...

struct xcb_list_extensions_cookie_t

xcb_list_extensions_cookie_t More...

struct xcb_list_extensions_request_t

xcb_list_extensions_request_t More...

struct xcb_list_extensions_reply_t

xcb_list_extensions_reply_t More...

struct xcb_change_keyboard_mapping_request_t

xcb_change_keyboard_mapping_request_t More...

struct xcb_get_keyboard_mapping_cookie_t

xcb_get_keyboard_mapping_cookie_t More...

struct xcb_get_keyboard_mapping_request_t

xcb_get_keyboard_mapping_request_t More...

struct xcb_get_keyboard_mapping_reply_t

xcb_get_keyboard_mapping_reply_t More...

struct xcb_change_keyboard_control_value_list_t

xcb_change_keyboard_control_value_list_t More...

struct xcb_change_keyboard_control_request_t

xcb_change_keyboard_control_request_t More...

struct xcb_get_keyboard_control_cookie_t

xcb_get_keyboard_control_cookie_t More...

struct xcb_get_keyboard_control_request_t

xcb_get_keyboard_control_request_t More...

struct xcb_get_keyboard_control_reply_t

xcb_get_keyboard_control_reply_t More...

struct xcb_bell_request_t

xcb_bell_request_t More...

struct xcb_change_pointer_control_request_t

xcb_change_pointer_control_request_t More...

struct xcb_get_pointer_control_cookie_t

xcb_get_pointer_control_cookie_t More...

struct xcb_get_pointer_control_request_t

xcb_get_pointer_control_request_t More...

struct xcb_get_pointer_control_reply_t

xcb_get_pointer_control_reply_t More...

struct xcb_set_screen_saver_request_t

xcb_set_screen_saver_request_t More...

struct xcb_get_screen_saver_cookie_t

xcb_get_screen_saver_cookie_t More...

struct xcb_get_screen_saver_request_t

xcb_get_screen_saver_request_t More...

struct xcb_get_screen_saver_reply_t

xcb_get_screen_saver_reply_t More...

struct xcb_change_hosts_request_t

xcb_change_hosts_request_t More...

struct xcb_host_t

xcb_host_t More...

struct xcb_host_iterator_t

xcb_host_iterator_t More...

struct xcb_list_hosts_cookie_t

xcb_list_hosts_cookie_t More...

struct xcb_list_hosts_request_t

xcb_list_hosts_request_t More...

struct xcb_list_hosts_reply_t

xcb_list_hosts_reply_t More...

struct xcb_set_access_control_request_t

xcb_set_access_control_request_t More...

struct xcb_set_close_down_mode_request_t

xcb_set_close_down_mode_request_t More...

struct xcb_kill_client_request_t

xcb_kill_client_request_t More...

struct xcb_rotate_properties_request_t

xcb_rotate_properties_request_t More...

struct xcb_force_screen_saver_request_t

xcb_force_screen_saver_request_t More...

struct xcb_set_pointer_mapping_cookie_t

xcb_set_pointer_mapping_cookie_t More...

struct xcb_set_pointer_mapping_request_t

xcb_set_pointer_mapping_request_t More...

struct xcb_set_pointer_mapping_reply_t

xcb_set_pointer_mapping_reply_t More...

struct xcb_get_pointer_mapping_cookie_t

xcb_get_pointer_mapping_cookie_t More...

struct xcb_get_pointer_mapping_request_t

xcb_get_pointer_mapping_request_t More...

struct xcb_get_pointer_mapping_reply_t

xcb_get_pointer_mapping_reply_t More...

struct xcb_set_modifier_mapping_cookie_t

xcb_set_modifier_mapping_cookie_t More...

struct xcb_set_modifier_mapping_request_t

xcb_set_modifier_mapping_request_t More...

struct xcb_set_modifier_mapping_reply_t

xcb_set_modifier_mapping_reply_t More...

struct xcb_get_modifier_mapping_cookie_t

xcb_get_modifier_mapping_cookie_t More...

struct xcb_get_modifier_mapping_request_t

xcb_get_modifier_mapping_request_t More...

struct xcb_get_modifier_mapping_reply_t

xcb_get_modifier_mapping_reply_t More...

struct xcb_no_operation_request_t

xcb_no_operation_request_t More...

Macros

#define XCB_KEY_PRESS 2

#define XCB_KEY_RELEASE 3

#define XCB_BUTTON_PRESS 4

#define XCB_BUTTON_RELEASE 5

#define XCB_MOTION_NOTIFY 6

#define XCB_ENTER_NOTIFY 7

#define XCB_LEAVE_NOTIFY 8

#define XCB_FOCUS_IN 9

#define XCB_FOCUS_OUT 10

#define XCB_KEYMAP_NOTIFY 11

#define XCB_EXPOSE 12

#define XCB_GRAPHICS_EXPOSURE 13

#define XCB_NO_EXPOSURE 14

#define XCB_VISIBILITY_NOTIFY 15

#define XCB_CREATE_NOTIFY 16

#define XCB_DESTROY_NOTIFY 17

#define XCB_UNMAP_NOTIFY 18

#define XCB_MAP_NOTIFY 19

#define XCB_MAP_REQUEST 20

#define XCB_REPARENT_NOTIFY 21

#define XCB_CONFIGURE_NOTIFY 22

#define XCB_CONFIGURE_REQUEST 23

#define XCB_GRAVITY_NOTIFY 24

#define XCB_RESIZE_REQUEST 25

#define XCB_CIRCULATE_NOTIFY 26

#define XCB_CIRCULATE_REQUEST 27

#define XCB_PROPERTY_NOTIFY 28

#define XCB_SELECTION_CLEAR 29

#define XCB_SELECTION_REQUEST 30

#define XCB_SELECTION_NOTIFY 31

#define XCB_COLORMAP_NOTIFY 32

#define XCB_CLIENT_MESSAGE 33

#define XCB_MAPPING_NOTIFY 34

#define XCB_GE_GENERIC 35

#define XCB_REQUEST 1

#define XCB_VALUE 2

#define XCB_WINDOW 3

#define XCB_PIXMAP 4

#define XCB_ATOM 5

#define XCB_CURSOR 6

#define XCB_FONT 7

#define XCB_MATCH 8

#define XCB_DRAWABLE 9

#define XCB_ACCESS 10

#define XCB_ALLOC 11

#define XCB_COLORMAP 12

#define XCB_G_CONTEXT 13

#define XCB_ID_CHOICE 14

#define XCB_NAME 15

#define XCB_LENGTH 16

#define XCB_IMPLEMENTATION 17

#define XCB_CREATE_WINDOW 1

#define XCB_CHANGE_WINDOW_ATTRIBUTES 2

#define XCB_GET_WINDOW_ATTRIBUTES 3

#define XCB_DESTROY_WINDOW 4

#define XCB_DESTROY_SUBWINDOWS 5

#define XCB_CHANGE_SAVE_SET 6

#define XCB_REPARENT_WINDOW 7

#define XCB_MAP_WINDOW 8

#define XCB_MAP_SUBWINDOWS 9

#define XCB_UNMAP_WINDOW 10

#define XCB_UNMAP_SUBWINDOWS 11

#define XCB_CONFIGURE_WINDOW 12

#define XCB_CIRCULATE_WINDOW 13

#define XCB_GET_GEOMETRY 14

#define XCB_QUERY_TREE 15

#define XCB_INTERN_ATOM 16

#define XCB_GET_ATOM_NAME 17

#define XCB_CHANGE_PROPERTY 18

#define XCB_DELETE_PROPERTY 19

#define XCB_GET_PROPERTY 20

#define XCB_LIST_PROPERTIES 21

#define XCB_SET_SELECTION_OWNER 22

#define XCB_GET_SELECTION_OWNER 23

#define XCB_CONVERT_SELECTION 24

#define XCB_SEND_EVENT 25

#define XCB_GRAB_POINTER 26

#define XCB_UNGRAB_POINTER 27

#define XCB_GRAB_BUTTON 28

#define XCB_UNGRAB_BUTTON 29

#define XCB_CHANGE_ACTIVE_POINTER_GRAB 30

#define XCB_GRAB_KEYBOARD 31

#define XCB_UNGRAB_KEYBOARD 32

#define XCB_GRAB_KEY 33

#define XCB_UNGRAB_KEY 34

#define XCB_ALLOW_EVENTS 35

#define XCB_GRAB_SERVER 36

#define XCB_UNGRAB_SERVER 37

#define XCB_QUERY_POINTER 38

#define XCB_GET_MOTION_EVENTS 39

#define XCB_TRANSLATE_COORDINATES 40

#define XCB_WARP_POINTER 41

#define XCB_SET_INPUT_FOCUS 42

#define XCB_GET_INPUT_FOCUS 43

#define XCB_QUERY_KEYMAP 44

#define XCB_OPEN_FONT 45

#define XCB_CLOSE_FONT 46

#define XCB_QUERY_FONT 47

#define XCB_QUERY_TEXT_EXTENTS 48

#define XCB_LIST_FONTS 49

#define XCB_LIST_FONTS_WITH_INFO 50

#define XCB_SET_FONT_PATH 51

#define XCB_GET_FONT_PATH 52

#define XCB_CREATE_PIXMAP 53

#define XCB_FREE_PIXMAP 54

#define XCB_CREATE_GC 55

#define XCB_CHANGE_GC 56

#define XCB_COPY_GC 57

#define XCB_SET_DASHES 58

#define XCB_SET_CLIP_RECTANGLES 59

#define XCB_FREE_GC 60

#define XCB_CLEAR_AREA 61

#define XCB_COPY_AREA 62

#define XCB_COPY_PLANE 63

#define XCB_POLY_POINT 64

#define XCB_POLY_LINE 65

#define XCB_POLY_SEGMENT 66

#define XCB_POLY_RECTANGLE 67

#define XCB_POLY_ARC 68

#define XCB_FILL_POLY 69

#define XCB_POLY_FILL_RECTANGLE 70

#define XCB_POLY_FILL_ARC 71

#define XCB_PUT_IMAGE 72

#define XCB_GET_IMAGE 73

#define XCB_POLY_TEXT_8 74

#define XCB_POLY_TEXT_16 75

#define XCB_IMAGE_TEXT_8 76

#define XCB_IMAGE_TEXT_16 77

#define XCB_CREATE_COLORMAP 78

#define XCB_FREE_COLORMAP 79

#define XCB_COPY_COLORMAP_AND_FREE 80

#define XCB_INSTALL_COLORMAP 81

#define XCB_UNINSTALL_COLORMAP 82

#define XCB_LIST_INSTALLED_COLORMAPS 83

#define XCB_ALLOC_COLOR 84

#define XCB_ALLOC_NAMED_COLOR 85

#define XCB_ALLOC_COLOR_CELLS 86

#define XCB_ALLOC_COLOR_PLANES 87

#define XCB_FREE_COLORS 88

#define XCB_STORE_COLORS 89

#define XCB_STORE_NAMED_COLOR 90

#define XCB_QUERY_COLORS 91

#define XCB_LOOKUP_COLOR 92

#define XCB_CREATE_CURSOR 93

#define XCB_CREATE_GLYPH_CURSOR 94

#define XCB_FREE_CURSOR 95

#define XCB_RECOLOR_CURSOR 96

#define XCB_QUERY_BEST_SIZE 97

#define XCB_QUERY_EXTENSION 98

#define XCB_LIST_EXTENSIONS 99

#define XCB_CHANGE_KEYBOARD_MAPPING 100

#define XCB_GET_KEYBOARD_MAPPING 101

#define XCB_CHANGE_KEYBOARD_CONTROL 102

#define XCB_GET_KEYBOARD_CONTROL 103

#define XCB_BELL 104

#define XCB_CHANGE_POINTER_CONTROL 105

#define XCB_GET_POINTER_CONTROL 106

#define XCB_SET_SCREEN_SAVER 107

#define XCB_GET_SCREEN_SAVER 108

#define XCB_CHANGE_HOSTS 109

#define XCB_LIST_HOSTS 110

#define XCB_SET_ACCESS_CONTROL 111

#define XCB_SET_CLOSE_DOWN_MODE 112

#define XCB_KILL_CLIENT 113

#define XCB_ROTATE_PROPERTIES 114

#define XCB_FORCE_SCREEN_SAVER 115

#define XCB_SET_POINTER_MAPPING 116

#define XCB_GET_POINTER_MAPPING 117

#define XCB_SET_MODIFIER_MAPPING 118

#define XCB_GET_MODIFIER_MAPPING 119

#define XCB_NO_OPERATION 127

Typedefs

typedef struct xcb_char2b_t xcb_char2b_t

xcb_char2b_t

typedef struct xcb_char2b_iterator_t xcb_char2b_iterator_t

xcb_char2b_iterator_t

typedef uint32_t xcb_window_t

typedef struct xcb_window_iterator_t xcb_window_iterator_t

xcb_window_iterator_t

typedef uint32_t xcb_pixmap_t

typedef struct xcb_pixmap_iterator_t xcb_pixmap_iterator_t

xcb_pixmap_iterator_t

typedef uint32_t xcb_cursor_t

typedef struct xcb_cursor_iterator_t xcb_cursor_iterator_t

xcb_cursor_iterator_t

typedef uint32_t xcb_font_t

typedef struct xcb_font_iterator_t xcb_font_iterator_t

xcb_font_iterator_t

typedef uint32_t xcb_gcontext_t

typedef struct xcb_gcontext_iterator_t xcb_gcontext_iterator_t

xcb_gcontext_iterator_t

typedef uint32_t xcb_colormap_t

typedef struct xcb_colormap_iterator_t xcb_colormap_iterator_t

xcb_colormap_iterator_t

typedef uint32_t xcb_atom_t

typedef struct xcb_atom_iterator_t xcb_atom_iterator_t

xcb_atom_iterator_t

typedef uint32_t xcb_drawable_t

typedef struct xcb_drawable_iterator_t xcb_drawable_iterator_t

xcb_drawable_iterator_t

typedef uint32_t xcb_fontable_t

typedef struct xcb_fontable_iterator_t xcb_fontable_iterator_t

xcb_fontable_iterator_t

typedef uint32_t xcb_bool32_t

typedef struct xcb_bool32_iterator_t xcb_bool32_iterator_t

xcb_bool32_iterator_t

typedef uint32_t xcb_visualid_t

typedef struct xcb_visualid_iterator_t xcb_visualid_iterator_t

xcb_visualid_iterator_t

typedef uint32_t xcb_timestamp_t

typedef struct xcb_timestamp_iterator_t xcb_timestamp_iterator_t

xcb_timestamp_iterator_t

typedef uint32_t xcb_keysym_t

typedef struct xcb_keysym_iterator_t xcb_keysym_iterator_t

xcb_keysym_iterator_t

typedef uint8_t xcb_keycode_t

typedef struct xcb_keycode_iterator_t xcb_keycode_iterator_t

xcb_keycode_iterator_t

typedef uint32_t xcb_keycode32_t

typedef struct xcb_keycode32_iterator_t xcb_keycode32_iterator_t

xcb_keycode32_iterator_t

typedef uint8_t xcb_button_t

typedef struct xcb_button_iterator_t xcb_button_iterator_t

xcb_button_iterator_t

typedef struct xcb_point_t xcb_point_t

xcb_point_t

typedef struct xcb_point_iterator_t xcb_point_iterator_t

xcb_point_iterator_t

typedef struct xcb_rectangle_t xcb_rectangle_t

xcb_rectangle_t

typedef struct xcb_rectangle_iterator_t xcb_rectangle_iterator_t

xcb_rectangle_iterator_t

typedef struct xcb_arc_t xcb_arc_t

xcb_arc_t

typedef struct xcb_arc_iterator_t xcb_arc_iterator_t

xcb_arc_iterator_t

typedef struct xcb_format_t xcb_format_t

xcb_format_t

typedef struct xcb_format_iterator_t xcb_format_iterator_t

xcb_format_iterator_t

typedef enum xcb_visual_class_t xcb_visual_class_t

typedef struct xcb_visualtype_t xcb_visualtype_t

xcb_visualtype_t

typedef struct xcb_visualtype_iterator_t xcb_visualtype_iterator_t

xcb_visualtype_iterator_t

typedef struct xcb_depth_t xcb_depth_t

xcb_depth_t

typedef struct xcb_depth_iterator_t xcb_depth_iterator_t

xcb_depth_iterator_t

typedef enum xcb_event_mask_t xcb_event_mask_t

typedef enum xcb_backing_store_t xcb_backing_store_t

typedef struct xcb_screen_t xcb_screen_t

xcb_screen_t

typedef struct xcb_screen_iterator_t xcb_screen_iterator_t

xcb_screen_iterator_t

typedef struct xcb_setup_request_t xcb_setup_request_t

xcb_setup_request_t

typedef struct xcb_setup_request_iterator_t xcb_setup_request_iterator_t

xcb_setup_request_iterator_t

typedef struct xcb_setup_failed_t xcb_setup_failed_t

xcb_setup_failed_t

typedef struct xcb_setup_failed_iterator_t xcb_setup_failed_iterator_t

xcb_setup_failed_iterator_t

typedef struct xcb_setup_authenticate_t xcb_setup_authenticate_t

xcb_setup_authenticate_t

typedef struct xcb_setup_authenticate_iterator_t xcb_setup_authenticate_iterator_t

xcb_setup_authenticate_iterator_t

typedef enum xcb_image_order_t xcb_image_order_t

typedef struct xcb_setup_t xcb_setup_t

xcb_setup_t

typedef struct xcb_setup_iterator_t xcb_setup_iterator_t

xcb_setup_iterator_t

typedef enum xcb_mod_mask_t xcb_mod_mask_t

typedef enum xcb_key_but_mask_t xcb_key_but_mask_t

typedef enum xcb_window_enum_t xcb_window_enum_t

typedef struct xcb_key_press_event_t xcb_key_press_event_t

xcb_key_press_event_t

typedef xcb_key_press_event_t xcb_key_release_event_t

typedef enum xcb_button_mask_t xcb_button_mask_t

typedef struct xcb_button_press_event_t xcb_button_press_event_t

xcb_button_press_event_t

typedef xcb_button_press_event_t xcb_button_release_event_t

typedef enum xcb_motion_t xcb_motion_t

typedef struct xcb_motion_notify_event_t xcb_motion_notify_event_t

xcb_motion_notify_event_t

typedef enum xcb_notify_detail_t xcb_notify_detail_t

typedef enum xcb_notify_mode_t xcb_notify_mode_t

typedef struct xcb_enter_notify_event_t xcb_enter_notify_event_t

xcb_enter_notify_event_t

typedef xcb_enter_notify_event_t xcb_leave_notify_event_t

typedef struct xcb_focus_in_event_t xcb_focus_in_event_t

xcb_focus_in_event_t

typedef xcb_focus_in_event_t xcb_focus_out_event_t

typedef struct xcb_keymap_notify_event_t xcb_keymap_notify_event_t

xcb_keymap_notify_event_t

typedef struct xcb_expose_event_t xcb_expose_event_t

xcb_expose_event_t

typedef struct xcb_graphics_exposure_event_t xcb_graphics_exposure_event_t

xcb_graphics_exposure_event_t

typedef struct xcb_no_exposure_event_t xcb_no_exposure_event_t

xcb_no_exposure_event_t

typedef enum xcb_visibility_t xcb_visibility_t

typedef struct xcb_visibility_notify_event_t xcb_visibility_notify_event_t

xcb_visibility_notify_event_t

typedef struct xcb_create_notify_event_t xcb_create_notify_event_t

xcb_create_notify_event_t

typedef struct xcb_destroy_notify_event_t xcb_destroy_notify_event_t

xcb_destroy_notify_event_t

typedef struct xcb_unmap_notify_event_t xcb_unmap_notify_event_t

xcb_unmap_notify_event_t

typedef struct xcb_map_notify_event_t xcb_map_notify_event_t

xcb_map_notify_event_t

typedef struct xcb_map_request_event_t xcb_map_request_event_t

xcb_map_request_event_t

typedef struct xcb_reparent_notify_event_t xcb_reparent_notify_event_t

xcb_reparent_notify_event_t

typedef struct xcb_configure_notify_event_t xcb_configure_notify_event_t

xcb_configure_notify_event_t

typedef struct xcb_configure_request_event_t xcb_configure_request_event_t

xcb_configure_request_event_t

typedef struct xcb_gravity_notify_event_t xcb_gravity_notify_event_t

xcb_gravity_notify_event_t

typedef struct xcb_resize_request_event_t xcb_resize_request_event_t

xcb_resize_request_event_t

typedef enum xcb_place_t xcb_place_t

typedef struct xcb_circulate_notify_event_t xcb_circulate_notify_event_t

xcb_circulate_notify_event_t

typedef xcb_circulate_notify_event_t xcb_circulate_request_event_t

typedef enum xcb_property_t xcb_property_t

typedef struct xcb_property_notify_event_t xcb_property_notify_event_t

xcb_property_notify_event_t

typedef struct xcb_selection_clear_event_t xcb_selection_clear_event_t

xcb_selection_clear_event_t

typedef enum xcb_time_t xcb_time_t

typedef enum xcb_atom_enum_t xcb_atom_enum_t

typedef struct xcb_selection_request_event_t xcb_selection_request_event_t

xcb_selection_request_event_t

typedef struct xcb_selection_notify_event_t xcb_selection_notify_event_t

xcb_selection_notify_event_t

typedef enum xcb_colormap_state_t xcb_colormap_state_t

typedef enum xcb_colormap_enum_t xcb_colormap_enum_t

typedef struct xcb_colormap_notify_event_t xcb_colormap_notify_event_t

xcb_colormap_notify_event_t

typedef union xcb_client_message_data_t xcb_client_message_data_t

xcb_client_message_data_t

typedef struct xcb_client_message_data_iterator_t xcb_client_message_data_iterator_t

xcb_client_message_data_iterator_t

typedef struct xcb_client_message_event_t xcb_client_message_event_t

xcb_client_message_event_t

typedef enum xcb_mapping_t xcb_mapping_t

typedef struct xcb_mapping_notify_event_t xcb_mapping_notify_event_t

xcb_mapping_notify_event_t

typedef struct xcb_ge_generic_event_t xcb_ge_generic_event_t

xcb_ge_generic_event_t

typedef struct xcb_request_error_t xcb_request_error_t

xcb_request_error_t

typedef struct xcb_value_error_t xcb_value_error_t

xcb_value_error_t

typedef xcb_value_error_t xcb_window_error_t

typedef xcb_value_error_t xcb_pixmap_error_t

typedef xcb_value_error_t xcb_atom_error_t

typedef xcb_value_error_t xcb_cursor_error_t

typedef xcb_value_error_t xcb_font_error_t

typedef xcb_request_error_t xcb_match_error_t

typedef xcb_value_error_t xcb_drawable_error_t

typedef xcb_request_error_t xcb_access_error_t

typedef xcb_request_error_t xcb_alloc_error_t

typedef xcb_value_error_t xcb_colormap_error_t

typedef xcb_value_error_t xcb_g_context_error_t

typedef xcb_value_error_t xcb_id_choice_error_t

typedef xcb_request_error_t xcb_name_error_t

typedef xcb_request_error_t xcb_length_error_t

typedef xcb_request_error_t xcb_implementation_error_t

typedef enum xcb_window_class_t xcb_window_class_t

typedef enum xcb_cw_t xcb_cw_t

typedef enum xcb_back_pixmap_t xcb_back_pixmap_t

typedef enum xcb_gravity_t xcb_gravity_t

typedef struct xcb_create_window_value_list_t xcb_create_window_value_list_t

xcb_create_window_value_list_t

typedef struct xcb_create_window_request_t xcb_create_window_request_t

xcb_create_window_request_t

typedef struct xcb_change_window_attributes_value_list_t xcb_change_window_attributes_value_list_t

xcb_change_window_attributes_value_list_t

typedef struct xcb_change_window_attributes_request_t xcb_change_window_attributes_request_t

xcb_change_window_attributes_request_t

typedef enum xcb_map_state_t xcb_map_state_t

typedef struct xcb_get_window_attributes_cookie_t xcb_get_window_attributes_cookie_t

xcb_get_window_attributes_cookie_t

typedef struct xcb_get_window_attributes_request_t xcb_get_window_attributes_request_t

xcb_get_window_attributes_request_t

typedef struct xcb_get_window_attributes_reply_t xcb_get_window_attributes_reply_t

xcb_get_window_attributes_reply_t

typedef struct xcb_destroy_window_request_t xcb_destroy_window_request_t

xcb_destroy_window_request_t

typedef struct xcb_destroy_subwindows_request_t xcb_destroy_subwindows_request_t

xcb_destroy_subwindows_request_t

typedef enum xcb_set_mode_t xcb_set_mode_t

typedef struct xcb_change_save_set_request_t xcb_change_save_set_request_t

xcb_change_save_set_request_t

typedef struct xcb_reparent_window_request_t xcb_reparent_window_request_t

xcb_reparent_window_request_t

typedef struct xcb_map_window_request_t xcb_map_window_request_t

xcb_map_window_request_t

typedef struct xcb_map_subwindows_request_t xcb_map_subwindows_request_t

xcb_map_subwindows_request_t

typedef struct xcb_unmap_window_request_t xcb_unmap_window_request_t

xcb_unmap_window_request_t

typedef struct xcb_unmap_subwindows_request_t xcb_unmap_subwindows_request_t

xcb_unmap_subwindows_request_t

typedef enum xcb_config_window_t xcb_config_window_t

typedef enum xcb_stack_mode_t xcb_stack_mode_t

typedef struct xcb_configure_window_value_list_t xcb_configure_window_value_list_t

xcb_configure_window_value_list_t

typedef struct xcb_configure_window_request_t xcb_configure_window_request_t

xcb_configure_window_request_t

typedef enum xcb_circulate_t xcb_circulate_t

typedef struct xcb_circulate_window_request_t xcb_circulate_window_request_t

xcb_circulate_window_request_t

typedef struct xcb_get_geometry_cookie_t xcb_get_geometry_cookie_t

xcb_get_geometry_cookie_t

typedef struct xcb_get_geometry_request_t xcb_get_geometry_request_t

xcb_get_geometry_request_t

typedef struct xcb_get_geometry_reply_t xcb_get_geometry_reply_t

xcb_get_geometry_reply_t

typedef struct xcb_query_tree_cookie_t xcb_query_tree_cookie_t

xcb_query_tree_cookie_t

typedef struct xcb_query_tree_request_t xcb_query_tree_request_t

xcb_query_tree_request_t

typedef struct xcb_query_tree_reply_t xcb_query_tree_reply_t

xcb_query_tree_reply_t

typedef struct xcb_intern_atom_cookie_t xcb_intern_atom_cookie_t

xcb_intern_atom_cookie_t

typedef struct xcb_intern_atom_request_t xcb_intern_atom_request_t

xcb_intern_atom_request_t

typedef struct xcb_intern_atom_reply_t xcb_intern_atom_reply_t

xcb_intern_atom_reply_t

typedef struct xcb_get_atom_name_cookie_t xcb_get_atom_name_cookie_t

xcb_get_atom_name_cookie_t

typedef struct xcb_get_atom_name_request_t xcb_get_atom_name_request_t

xcb_get_atom_name_request_t

typedef struct xcb_get_atom_name_reply_t xcb_get_atom_name_reply_t

xcb_get_atom_name_reply_t

typedef enum xcb_prop_mode_t xcb_prop_mode_t

typedef struct xcb_change_property_request_t xcb_change_property_request_t

xcb_change_property_request_t

typedef struct xcb_delete_property_request_t xcb_delete_property_request_t

xcb_delete_property_request_t

typedef enum xcb_get_property_type_t xcb_get_property_type_t

typedef struct xcb_get_property_cookie_t xcb_get_property_cookie_t

xcb_get_property_cookie_t

typedef struct xcb_get_property_request_t xcb_get_property_request_t

xcb_get_property_request_t

typedef struct xcb_get_property_reply_t xcb_get_property_reply_t

xcb_get_property_reply_t

typedef struct xcb_list_properties_cookie_t xcb_list_properties_cookie_t

xcb_list_properties_cookie_t

typedef struct xcb_list_properties_request_t xcb_list_properties_request_t

xcb_list_properties_request_t

typedef struct xcb_list_properties_reply_t xcb_list_properties_reply_t

xcb_list_properties_reply_t

typedef struct xcb_set_selection_owner_request_t xcb_set_selection_owner_request_t

xcb_set_selection_owner_request_t

typedef struct xcb_get_selection_owner_cookie_t xcb_get_selection_owner_cookie_t

xcb_get_selection_owner_cookie_t

typedef struct xcb_get_selection_owner_request_t xcb_get_selection_owner_request_t

xcb_get_selection_owner_request_t

typedef struct xcb_get_selection_owner_reply_t xcb_get_selection_owner_reply_t

xcb_get_selection_owner_reply_t

typedef struct xcb_convert_selection_request_t xcb_convert_selection_request_t

xcb_convert_selection_request_t

typedef enum xcb_send_event_dest_t xcb_send_event_dest_t

typedef struct xcb_send_event_request_t xcb_send_event_request_t

xcb_send_event_request_t

typedef enum xcb_grab_mode_t xcb_grab_mode_t

typedef enum xcb_grab_status_t xcb_grab_status_t

typedef enum xcb_cursor_enum_t xcb_cursor_enum_t

typedef struct xcb_grab_pointer_cookie_t xcb_grab_pointer_cookie_t

xcb_grab_pointer_cookie_t

typedef struct xcb_grab_pointer_request_t xcb_grab_pointer_request_t

xcb_grab_pointer_request_t

typedef struct xcb_grab_pointer_reply_t xcb_grab_pointer_reply_t

xcb_grab_pointer_reply_t

typedef struct xcb_ungrab_pointer_request_t xcb_ungrab_pointer_request_t

xcb_ungrab_pointer_request_t

typedef enum xcb_button_index_t xcb_button_index_t

typedef struct xcb_grab_button_request_t xcb_grab_button_request_t

xcb_grab_button_request_t

typedef struct xcb_ungrab_button_request_t xcb_ungrab_button_request_t

xcb_ungrab_button_request_t

typedef struct xcb_change_active_pointer_grab_request_t xcb_change_active_pointer_grab_request_t

xcb_change_active_pointer_grab_request_t

typedef struct xcb_grab_keyboard_cookie_t xcb_grab_keyboard_cookie_t

xcb_grab_keyboard_cookie_t

typedef struct xcb_grab_keyboard_request_t xcb_grab_keyboard_request_t

xcb_grab_keyboard_request_t

typedef struct xcb_grab_keyboard_reply_t xcb_grab_keyboard_reply_t

xcb_grab_keyboard_reply_t

typedef struct xcb_ungrab_keyboard_request_t xcb_ungrab_keyboard_request_t

xcb_ungrab_keyboard_request_t

typedef enum xcb_grab_t xcb_grab_t

typedef struct xcb_grab_key_request_t xcb_grab_key_request_t

xcb_grab_key_request_t

typedef struct xcb_ungrab_key_request_t xcb_ungrab_key_request_t

xcb_ungrab_key_request_t

typedef enum xcb_allow_t xcb_allow_t

typedef struct xcb_allow_events_request_t xcb_allow_events_request_t

xcb_allow_events_request_t

typedef struct xcb_grab_server_request_t xcb_grab_server_request_t

xcb_grab_server_request_t

typedef struct xcb_ungrab_server_request_t xcb_ungrab_server_request_t

xcb_ungrab_server_request_t

typedef struct xcb_query_pointer_cookie_t xcb_query_pointer_cookie_t

xcb_query_pointer_cookie_t

typedef struct xcb_query_pointer_request_t xcb_query_pointer_request_t

xcb_query_pointer_request_t

typedef struct xcb_query_pointer_reply_t xcb_query_pointer_reply_t

xcb_query_pointer_reply_t

typedef struct xcb_timecoord_t xcb_timecoord_t

xcb_timecoord_t

typedef struct xcb_timecoord_iterator_t xcb_timecoord_iterator_t

xcb_timecoord_iterator_t

typedef struct xcb_get_motion_events_cookie_t xcb_get_motion_events_cookie_t

xcb_get_motion_events_cookie_t

typedef struct xcb_get_motion_events_request_t xcb_get_motion_events_request_t

xcb_get_motion_events_request_t

typedef struct xcb_get_motion_events_reply_t xcb_get_motion_events_reply_t

xcb_get_motion_events_reply_t

typedef struct xcb_translate_coordinates_cookie_t xcb_translate_coordinates_cookie_t

xcb_translate_coordinates_cookie_t

typedef struct xcb_translate_coordinates_request_t xcb_translate_coordinates_request_t

xcb_translate_coordinates_request_t

typedef struct xcb_translate_coordinates_reply_t xcb_translate_coordinates_reply_t

xcb_translate_coordinates_reply_t

typedef struct xcb_warp_pointer_request_t xcb_warp_pointer_request_t

xcb_warp_pointer_request_t

typedef enum xcb_input_focus_t xcb_input_focus_t

typedef struct xcb_set_input_focus_request_t xcb_set_input_focus_request_t

xcb_set_input_focus_request_t

typedef struct xcb_get_input_focus_cookie_t xcb_get_input_focus_cookie_t

xcb_get_input_focus_cookie_t

typedef struct xcb_get_input_focus_request_t xcb_get_input_focus_request_t

xcb_get_input_focus_request_t

typedef struct xcb_get_input_focus_reply_t xcb_get_input_focus_reply_t

xcb_get_input_focus_reply_t

typedef struct xcb_query_keymap_cookie_t xcb_query_keymap_cookie_t

xcb_query_keymap_cookie_t

typedef struct xcb_query_keymap_request_t xcb_query_keymap_request_t

xcb_query_keymap_request_t

typedef struct xcb_query_keymap_reply_t xcb_query_keymap_reply_t

xcb_query_keymap_reply_t

typedef struct xcb_open_font_request_t xcb_open_font_request_t

xcb_open_font_request_t

typedef struct xcb_close_font_request_t xcb_close_font_request_t

xcb_close_font_request_t

typedef enum xcb_font_draw_t xcb_font_draw_t

typedef struct xcb_fontprop_t xcb_fontprop_t

xcb_fontprop_t

typedef struct xcb_fontprop_iterator_t xcb_fontprop_iterator_t

xcb_fontprop_iterator_t

typedef struct xcb_charinfo_t xcb_charinfo_t

xcb_charinfo_t

typedef struct xcb_charinfo_iterator_t xcb_charinfo_iterator_t

xcb_charinfo_iterator_t

typedef struct xcb_query_font_cookie_t xcb_query_font_cookie_t

xcb_query_font_cookie_t

typedef struct xcb_query_font_request_t xcb_query_font_request_t

xcb_query_font_request_t

typedef struct xcb_query_font_reply_t xcb_query_font_reply_t

xcb_query_font_reply_t

typedef struct xcb_query_text_extents_cookie_t xcb_query_text_extents_cookie_t

xcb_query_text_extents_cookie_t

typedef struct xcb_query_text_extents_request_t xcb_query_text_extents_request_t

xcb_query_text_extents_request_t

typedef struct xcb_query_text_extents_reply_t xcb_query_text_extents_reply_t

xcb_query_text_extents_reply_t

typedef struct xcb_str_t xcb_str_t

xcb_str_t

typedef struct xcb_str_iterator_t xcb_str_iterator_t

xcb_str_iterator_t

typedef struct xcb_list_fonts_cookie_t xcb_list_fonts_cookie_t

xcb_list_fonts_cookie_t

typedef struct xcb_list_fonts_request_t xcb_list_fonts_request_t

xcb_list_fonts_request_t

typedef struct xcb_list_fonts_reply_t xcb_list_fonts_reply_t

xcb_list_fonts_reply_t

typedef struct xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info_cookie_t

xcb_list_fonts_with_info_cookie_t

typedef struct xcb_list_fonts_with_info_request_t xcb_list_fonts_with_info_request_t

xcb_list_fonts_with_info_request_t

typedef struct xcb_list_fonts_with_info_reply_t xcb_list_fonts_with_info_reply_t

xcb_list_fonts_with_info_reply_t

typedef struct xcb_set_font_path_request_t xcb_set_font_path_request_t

xcb_set_font_path_request_t

typedef struct xcb_get_font_path_cookie_t xcb_get_font_path_cookie_t

xcb_get_font_path_cookie_t

typedef struct xcb_get_font_path_request_t xcb_get_font_path_request_t

xcb_get_font_path_request_t

typedef struct xcb_get_font_path_reply_t xcb_get_font_path_reply_t

xcb_get_font_path_reply_t

typedef struct xcb_create_pixmap_request_t xcb_create_pixmap_request_t

xcb_create_pixmap_request_t

typedef struct xcb_free_pixmap_request_t xcb_free_pixmap_request_t

xcb_free_pixmap_request_t

typedef enum xcb_gc_t xcb_gc_t

typedef enum xcb_gx_t xcb_gx_t

typedef enum xcb_line_style_t xcb_line_style_t

typedef enum xcb_cap_style_t xcb_cap_style_t

typedef enum xcb_join_style_t xcb_join_style_t

typedef enum xcb_fill_style_t xcb_fill_style_t

typedef enum xcb_fill_rule_t xcb_fill_rule_t

typedef enum xcb_subwindow_mode_t xcb_subwindow_mode_t

typedef enum xcb_arc_mode_t xcb_arc_mode_t

typedef struct xcb_create_gc_value_list_t xcb_create_gc_value_list_t

xcb_create_gc_value_list_t

typedef struct xcb_create_gc_request_t xcb_create_gc_request_t

xcb_create_gc_request_t

typedef struct xcb_change_gc_value_list_t xcb_change_gc_value_list_t

xcb_change_gc_value_list_t

typedef struct xcb_change_gc_request_t xcb_change_gc_request_t

xcb_change_gc_request_t

typedef struct xcb_copy_gc_request_t xcb_copy_gc_request_t

xcb_copy_gc_request_t

typedef struct xcb_set_dashes_request_t xcb_set_dashes_request_t

xcb_set_dashes_request_t

typedef enum xcb_clip_ordering_t xcb_clip_ordering_t

typedef struct xcb_set_clip_rectangles_request_t xcb_set_clip_rectangles_request_t

xcb_set_clip_rectangles_request_t

typedef struct xcb_free_gc_request_t xcb_free_gc_request_t

xcb_free_gc_request_t

typedef struct xcb_clear_area_request_t xcb_clear_area_request_t

xcb_clear_area_request_t

typedef struct xcb_copy_area_request_t xcb_copy_area_request_t

xcb_copy_area_request_t

typedef struct xcb_copy_plane_request_t xcb_copy_plane_request_t

xcb_copy_plane_request_t

typedef enum xcb_coord_mode_t xcb_coord_mode_t

typedef struct xcb_poly_point_request_t xcb_poly_point_request_t

xcb_poly_point_request_t

typedef struct xcb_poly_line_request_t xcb_poly_line_request_t

xcb_poly_line_request_t

typedef struct xcb_segment_t xcb_segment_t

xcb_segment_t

typedef struct xcb_segment_iterator_t xcb_segment_iterator_t

xcb_segment_iterator_t

typedef struct xcb_poly_segment_request_t xcb_poly_segment_request_t

xcb_poly_segment_request_t

typedef struct xcb_poly_rectangle_request_t xcb_poly_rectangle_request_t

xcb_poly_rectangle_request_t

typedef struct xcb_poly_arc_request_t xcb_poly_arc_request_t

xcb_poly_arc_request_t

typedef enum xcb_poly_shape_t xcb_poly_shape_t

typedef struct xcb_fill_poly_request_t xcb_fill_poly_request_t

xcb_fill_poly_request_t

typedef struct xcb_poly_fill_rectangle_request_t xcb_poly_fill_rectangle_request_t

xcb_poly_fill_rectangle_request_t

typedef struct xcb_poly_fill_arc_request_t xcb_poly_fill_arc_request_t

xcb_poly_fill_arc_request_t

typedef enum xcb_image_format_t xcb_image_format_t

typedef struct xcb_put_image_request_t xcb_put_image_request_t

xcb_put_image_request_t

typedef struct xcb_get_image_cookie_t xcb_get_image_cookie_t

xcb_get_image_cookie_t

typedef struct xcb_get_image_request_t xcb_get_image_request_t

xcb_get_image_request_t

typedef struct xcb_get_image_reply_t xcb_get_image_reply_t

xcb_get_image_reply_t

typedef struct xcb_poly_text_8_request_t xcb_poly_text_8_request_t

xcb_poly_text_8_request_t

typedef struct xcb_poly_text_16_request_t xcb_poly_text_16_request_t

xcb_poly_text_16_request_t

typedef struct xcb_image_text_8_request_t xcb_image_text_8_request_t

xcb_image_text_8_request_t

typedef struct xcb_image_text_16_request_t xcb_image_text_16_request_t

xcb_image_text_16_request_t

typedef enum xcb_colormap_alloc_t xcb_colormap_alloc_t

typedef struct xcb_create_colormap_request_t xcb_create_colormap_request_t

xcb_create_colormap_request_t

typedef struct xcb_free_colormap_request_t xcb_free_colormap_request_t

xcb_free_colormap_request_t

typedef struct xcb_copy_colormap_and_free_request_t xcb_copy_colormap_and_free_request_t

xcb_copy_colormap_and_free_request_t

typedef struct xcb_install_colormap_request_t xcb_install_colormap_request_t

xcb_install_colormap_request_t

typedef struct xcb_uninstall_colormap_request_t xcb_uninstall_colormap_request_t

xcb_uninstall_colormap_request_t

typedef struct xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps_cookie_t

xcb_list_installed_colormaps_cookie_t

typedef struct xcb_list_installed_colormaps_request_t xcb_list_installed_colormaps_request_t

xcb_list_installed_colormaps_request_t

typedef struct xcb_list_installed_colormaps_reply_t xcb_list_installed_colormaps_reply_t

xcb_list_installed_colormaps_reply_t

typedef struct xcb_alloc_color_cookie_t xcb_alloc_color_cookie_t

xcb_alloc_color_cookie_t

typedef struct xcb_alloc_color_request_t xcb_alloc_color_request_t

xcb_alloc_color_request_t

typedef struct xcb_alloc_color_reply_t xcb_alloc_color_reply_t

xcb_alloc_color_reply_t

typedef struct xcb_alloc_named_color_cookie_t xcb_alloc_named_color_cookie_t

xcb_alloc_named_color_cookie_t

typedef struct xcb_alloc_named_color_request_t xcb_alloc_named_color_request_t

xcb_alloc_named_color_request_t

typedef struct xcb_alloc_named_color_reply_t xcb_alloc_named_color_reply_t

xcb_alloc_named_color_reply_t

typedef struct xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells_cookie_t

xcb_alloc_color_cells_cookie_t

typedef struct xcb_alloc_color_cells_request_t xcb_alloc_color_cells_request_t

xcb_alloc_color_cells_request_t

typedef struct xcb_alloc_color_cells_reply_t xcb_alloc_color_cells_reply_t

xcb_alloc_color_cells_reply_t

typedef struct xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes_cookie_t

xcb_alloc_color_planes_cookie_t

typedef struct xcb_alloc_color_planes_request_t xcb_alloc_color_planes_request_t

xcb_alloc_color_planes_request_t

typedef struct xcb_alloc_color_planes_reply_t xcb_alloc_color_planes_reply_t

xcb_alloc_color_planes_reply_t

typedef struct xcb_free_colors_request_t xcb_free_colors_request_t

xcb_free_colors_request_t

typedef enum xcb_color_flag_t xcb_color_flag_t

typedef struct xcb_coloritem_t xcb_coloritem_t

xcb_coloritem_t

typedef struct xcb_coloritem_iterator_t xcb_coloritem_iterator_t

xcb_coloritem_iterator_t

typedef struct xcb_store_colors_request_t xcb_store_colors_request_t

xcb_store_colors_request_t

typedef struct xcb_store_named_color_request_t xcb_store_named_color_request_t

xcb_store_named_color_request_t

typedef struct xcb_rgb_t xcb_rgb_t

xcb_rgb_t

typedef struct xcb_rgb_iterator_t xcb_rgb_iterator_t

xcb_rgb_iterator_t

typedef struct xcb_query_colors_cookie_t xcb_query_colors_cookie_t

xcb_query_colors_cookie_t

typedef struct xcb_query_colors_request_t xcb_query_colors_request_t

xcb_query_colors_request_t

typedef struct xcb_query_colors_reply_t xcb_query_colors_reply_t

xcb_query_colors_reply_t

typedef struct xcb_lookup_color_cookie_t xcb_lookup_color_cookie_t

xcb_lookup_color_cookie_t

typedef struct xcb_lookup_color_request_t xcb_lookup_color_request_t

xcb_lookup_color_request_t

typedef struct xcb_lookup_color_reply_t xcb_lookup_color_reply_t

xcb_lookup_color_reply_t

typedef enum xcb_pixmap_enum_t xcb_pixmap_enum_t

typedef struct xcb_create_cursor_request_t xcb_create_cursor_request_t

xcb_create_cursor_request_t

typedef enum xcb_font_enum_t xcb_font_enum_t

typedef struct xcb_create_glyph_cursor_request_t xcb_create_glyph_cursor_request_t

xcb_create_glyph_cursor_request_t

typedef struct xcb_free_cursor_request_t xcb_free_cursor_request_t

xcb_free_cursor_request_t

typedef struct xcb_recolor_cursor_request_t xcb_recolor_cursor_request_t

xcb_recolor_cursor_request_t

typedef enum xcb_query_shape_of_t xcb_query_shape_of_t

typedef struct xcb_query_best_size_cookie_t xcb_query_best_size_cookie_t

xcb_query_best_size_cookie_t

typedef struct xcb_query_best_size_request_t xcb_query_best_size_request_t

xcb_query_best_size_request_t

typedef struct xcb_query_best_size_reply_t xcb_query_best_size_reply_t

xcb_query_best_size_reply_t

typedef struct xcb_query_extension_cookie_t xcb_query_extension_cookie_t

xcb_query_extension_cookie_t

typedef struct xcb_query_extension_request_t xcb_query_extension_request_t

xcb_query_extension_request_t

typedef struct xcb_query_extension_reply_t xcb_query_extension_reply_t

xcb_query_extension_reply_t

typedef struct xcb_list_extensions_cookie_t xcb_list_extensions_cookie_t

xcb_list_extensions_cookie_t

typedef struct xcb_list_extensions_request_t xcb_list_extensions_request_t

xcb_list_extensions_request_t

typedef struct xcb_list_extensions_reply_t xcb_list_extensions_reply_t

xcb_list_extensions_reply_t

typedef struct xcb_change_keyboard_mapping_request_t xcb_change_keyboard_mapping_request_t

xcb_change_keyboard_mapping_request_t

typedef struct xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping_cookie_t

xcb_get_keyboard_mapping_cookie_t

typedef struct xcb_get_keyboard_mapping_request_t xcb_get_keyboard_mapping_request_t

xcb_get_keyboard_mapping_request_t

typedef struct xcb_get_keyboard_mapping_reply_t xcb_get_keyboard_mapping_reply_t

xcb_get_keyboard_mapping_reply_t

typedef enum xcb_kb_t xcb_kb_t

typedef enum xcb_led_mode_t xcb_led_mode_t

typedef enum xcb_auto_repeat_mode_t xcb_auto_repeat_mode_t

typedef struct xcb_change_keyboard_control_value_list_t xcb_change_keyboard_control_value_list_t

xcb_change_keyboard_control_value_list_t

typedef struct xcb_change_keyboard_control_request_t xcb_change_keyboard_control_request_t

xcb_change_keyboard_control_request_t

typedef struct xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control_cookie_t

xcb_get_keyboard_control_cookie_t

typedef struct xcb_get_keyboard_control_request_t xcb_get_keyboard_control_request_t

xcb_get_keyboard_control_request_t

typedef struct xcb_get_keyboard_control_reply_t xcb_get_keyboard_control_reply_t

xcb_get_keyboard_control_reply_t

typedef struct xcb_bell_request_t xcb_bell_request_t

xcb_bell_request_t

typedef struct xcb_change_pointer_control_request_t xcb_change_pointer_control_request_t

xcb_change_pointer_control_request_t

typedef struct xcb_get_pointer_control_cookie_t xcb_get_pointer_control_cookie_t

xcb_get_pointer_control_cookie_t

typedef struct xcb_get_pointer_control_request_t xcb_get_pointer_control_request_t

xcb_get_pointer_control_request_t

typedef struct xcb_get_pointer_control_reply_t xcb_get_pointer_control_reply_t

xcb_get_pointer_control_reply_t

typedef enum xcb_blanking_t xcb_blanking_t

typedef enum xcb_exposures_t xcb_exposures_t

typedef struct xcb_set_screen_saver_request_t xcb_set_screen_saver_request_t

xcb_set_screen_saver_request_t

typedef struct xcb_get_screen_saver_cookie_t xcb_get_screen_saver_cookie_t

xcb_get_screen_saver_cookie_t

typedef struct xcb_get_screen_saver_request_t xcb_get_screen_saver_request_t

xcb_get_screen_saver_request_t

typedef struct xcb_get_screen_saver_reply_t xcb_get_screen_saver_reply_t

xcb_get_screen_saver_reply_t

typedef enum xcb_host_mode_t xcb_host_mode_t

typedef enum xcb_family_t xcb_family_t

typedef struct xcb_change_hosts_request_t xcb_change_hosts_request_t

xcb_change_hosts_request_t

typedef struct xcb_host_t xcb_host_t

xcb_host_t

typedef struct xcb_host_iterator_t xcb_host_iterator_t

xcb_host_iterator_t

typedef struct xcb_list_hosts_cookie_t xcb_list_hosts_cookie_t

xcb_list_hosts_cookie_t

typedef struct xcb_list_hosts_request_t xcb_list_hosts_request_t

xcb_list_hosts_request_t

typedef struct xcb_list_hosts_reply_t xcb_list_hosts_reply_t

xcb_list_hosts_reply_t

typedef enum xcb_access_control_t xcb_access_control_t

typedef struct xcb_set_access_control_request_t xcb_set_access_control_request_t

xcb_set_access_control_request_t

typedef enum xcb_close_down_t xcb_close_down_t

typedef struct xcb_set_close_down_mode_request_t xcb_set_close_down_mode_request_t

xcb_set_close_down_mode_request_t

typedef enum xcb_kill_t xcb_kill_t

typedef struct xcb_kill_client_request_t xcb_kill_client_request_t

xcb_kill_client_request_t

typedef struct xcb_rotate_properties_request_t xcb_rotate_properties_request_t

xcb_rotate_properties_request_t

typedef enum xcb_screen_saver_t xcb_screen_saver_t

typedef struct xcb_force_screen_saver_request_t xcb_force_screen_saver_request_t

xcb_force_screen_saver_request_t

typedef enum xcb_mapping_status_t xcb_mapping_status_t

typedef struct xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping_cookie_t

xcb_set_pointer_mapping_cookie_t

typedef struct xcb_set_pointer_mapping_request_t xcb_set_pointer_mapping_request_t

xcb_set_pointer_mapping_request_t

typedef struct xcb_set_pointer_mapping_reply_t xcb_set_pointer_mapping_reply_t

xcb_set_pointer_mapping_reply_t

typedef struct xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping_cookie_t

xcb_get_pointer_mapping_cookie_t

typedef struct xcb_get_pointer_mapping_request_t xcb_get_pointer_mapping_request_t

xcb_get_pointer_mapping_request_t

typedef struct xcb_get_pointer_mapping_reply_t xcb_get_pointer_mapping_reply_t

xcb_get_pointer_mapping_reply_t

typedef enum xcb_map_index_t xcb_map_index_t

typedef struct xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping_cookie_t

xcb_set_modifier_mapping_cookie_t

typedef struct xcb_set_modifier_mapping_request_t xcb_set_modifier_mapping_request_t

xcb_set_modifier_mapping_request_t

typedef struct xcb_set_modifier_mapping_reply_t xcb_set_modifier_mapping_reply_t

xcb_set_modifier_mapping_reply_t

typedef struct xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping_cookie_t

xcb_get_modifier_mapping_cookie_t

typedef struct xcb_get_modifier_mapping_request_t xcb_get_modifier_mapping_request_t

xcb_get_modifier_mapping_request_t

typedef struct xcb_get_modifier_mapping_reply_t xcb_get_modifier_mapping_reply_t

xcb_get_modifier_mapping_reply_t

typedef struct xcb_no_operation_request_t xcb_no_operation_request_t

xcb_no_operation_request_t

Enumerations

enum xcb_visual_class_t {

XCB_VISUAL_CLASS_STATIC_GRAY = 0,

XCB_VISUAL_CLASS_GRAY_SCALE = 1,

XCB_VISUAL_CLASS_STATIC_COLOR = 2,

XCB_VISUAL_CLASS_PSEUDO_COLOR = 3,

XCB_VISUAL_CLASS_TRUE_COLOR = 4,

XCB_VISUAL_CLASS_DIRECT_COLOR = 5

}

enum xcb_event_mask_t {

XCB_EVENT_MASK_NO_EVENT = 0,

XCB_EVENT_MASK_KEY_PRESS = 1,

XCB_EVENT_MASK_KEY_RELEASE = 2,

XCB_EVENT_MASK_BUTTON_PRESS = 4,

XCB_EVENT_MASK_BUTTON_RELEASE = 8,

XCB_EVENT_MASK_ENTER_WINDOW = 16,

XCB_EVENT_MASK_LEAVE_WINDOW = 32,

XCB_EVENT_MASK_POINTER_MOTION = 64,

XCB_EVENT_MASK_POINTER_MOTION_HINT = 128,

XCB_EVENT_MASK_BUTTON_1_MOTION = 256,

XCB_EVENT_MASK_BUTTON_2_MOTION = 512,

XCB_EVENT_MASK_BUTTON_3_MOTION = 1024,

XCB_EVENT_MASK_BUTTON_4_MOTION = 2048,

XCB_EVENT_MASK_BUTTON_5_MOTION = 4096,

XCB_EVENT_MASK_BUTTON_MOTION = 8192,

XCB_EVENT_MASK_KEYMAP_STATE = 16384,

XCB_EVENT_MASK_EXPOSURE = 32768,

XCB_EVENT_MASK_VISIBILITY_CHANGE = 65536,

XCB_EVENT_MASK_STRUCTURE_NOTIFY = 131072,

XCB_EVENT_MASK_RESIZE_REDIRECT = 262144,

XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY = 524288,

XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT = 1048576,

XCB_EVENT_MASK_FOCUS_CHANGE = 2097152,

XCB_EVENT_MASK_PROPERTY_CHANGE = 4194304,

XCB_EVENT_MASK_COLOR_MAP_CHANGE = 8388608,

XCB_EVENT_MASK_OWNER_GRAB_BUTTON = 16777216

}

enum xcb_backing_store_t { XCB_BACKING_STORE_NOT_USEFUL = 0,

XCB_BACKING_STORE_WHEN_MAPPED = 1,

XCB_BACKING_STORE_ALWAYS = 2

}

enum xcb_image_order_t { XCB_IMAGE_ORDER_LSB_FIRST = 0,

XCB_IMAGE_ORDER_MSB_FIRST = 1

}

enum xcb_mod_mask_t {

XCB_MOD_MASK_SHIFT = 1,

XCB_MOD_MASK_LOCK = 2,

XCB_MOD_MASK_CONTROL = 4,

XCB_MOD_MASK_1 = 8,

XCB_MOD_MASK_2 = 16,

XCB_MOD_MASK_3 = 32,

XCB_MOD_MASK_4 = 64,

XCB_MOD_MASK_5 = 128,

XCB_MOD_MASK_ANY = 32768

}

enum xcb_key_but_mask_t {

XCB_KEY_BUT_MASK_SHIFT = 1,

XCB_KEY_BUT_MASK_LOCK = 2,

XCB_KEY_BUT_MASK_CONTROL = 4,

XCB_KEY_BUT_MASK_MOD_1 = 8,

XCB_KEY_BUT_MASK_MOD_2 = 16,

XCB_KEY_BUT_MASK_MOD_3 = 32,

XCB_KEY_BUT_MASK_MOD_4 = 64,

XCB_KEY_BUT_MASK_MOD_5 = 128,

XCB_KEY_BUT_MASK_BUTTON_1 = 256,

XCB_KEY_BUT_MASK_BUTTON_2 = 512,

XCB_KEY_BUT_MASK_BUTTON_3 = 1024,

XCB_KEY_BUT_MASK_BUTTON_4 = 2048,

XCB_KEY_BUT_MASK_BUTTON_5 = 4096

}

enum xcb_window_enum_t { XCB_WINDOW_NONE = 0

}

enum xcb_button_mask_t {

XCB_BUTTON_MASK_1 = 256,

XCB_BUTTON_MASK_2 = 512,

XCB_BUTTON_MASK_3 = 1024,

XCB_BUTTON_MASK_4 = 2048,

XCB_BUTTON_MASK_5 = 4096,

XCB_BUTTON_MASK_ANY = 32768

}

enum xcb_motion_t { XCB_MOTION_NORMAL = 0,

XCB_MOTION_HINT = 1

}

enum xcb_notify_detail_t {

XCB_NOTIFY_DETAIL_ANCESTOR = 0,

XCB_NOTIFY_DETAIL_VIRTUAL = 1,

XCB_NOTIFY_DETAIL_INFERIOR = 2,

XCB_NOTIFY_DETAIL_NONLINEAR = 3,

XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL = 4,

XCB_NOTIFY_DETAIL_POINTER = 5,

XCB_NOTIFY_DETAIL_POINTER_ROOT = 6,

XCB_NOTIFY_DETAIL_NONE = 7

}

enum xcb_notify_mode_t { XCB_NOTIFY_MODE_NORMAL = 0,

XCB_NOTIFY_MODE_GRAB = 1,

XCB_NOTIFY_MODE_UNGRAB = 2,

XCB_NOTIFY_MODE_WHILE_GRABBED = 3

}

enum xcb_visibility_t { XCB_VISIBILITY_UNOBSCURED = 0,

XCB_VISIBILITY_PARTIALLY_OBSCURED = 1,

XCB_VISIBILITY_FULLY_OBSCURED = 2

}

enum xcb_place_t { XCB_PLACE_ON_TOP = 0,

XCB_PLACE_ON_BOTTOM = 1

}

enum xcb_property_t { XCB_PROPERTY_NEW_VALUE = 0,

XCB_PROPERTY_DELETE = 1

}

enum xcb_time_t { XCB_TIME_CURRENT_TIME = 0

}

enum xcb_atom_enum_t {

XCB_ATOM_NONE = 0,

XCB_ATOM_ANY = 0,

XCB_ATOM_PRIMARY = 1,

XCB_ATOM_SECONDARY = 2,

XCB_ATOM_ARC = 3,

XCB_ATOM_ATOM = 4,

XCB_ATOM_BITMAP = 5,

XCB_ATOM_CARDINAL = 6,

XCB_ATOM_COLORMAP = 7,

XCB_ATOM_CURSOR = 8,

XCB_ATOM_CUT_BUFFER0 = 9,

XCB_ATOM_CUT_BUFFER1 = 10,

XCB_ATOM_CUT_BUFFER2 = 11,

XCB_ATOM_CUT_BUFFER3 = 12,

XCB_ATOM_CUT_BUFFER4 = 13,

XCB_ATOM_CUT_BUFFER5 = 14,

XCB_ATOM_CUT_BUFFER6 = 15,

XCB_ATOM_CUT_BUFFER7 = 16,

XCB_ATOM_DRAWABLE = 17,

XCB_ATOM_FONT = 18,

XCB_ATOM_INTEGER = 19,

XCB_ATOM_PIXMAP = 20,

XCB_ATOM_POINT = 21,

XCB_ATOM_RECTANGLE = 22,

XCB_ATOM_RESOURCE_MANAGER = 23,

XCB_ATOM_RGB_COLOR_MAP = 24,

XCB_ATOM_RGB_BEST_MAP = 25,

XCB_ATOM_RGB_BLUE_MAP = 26,

XCB_ATOM_RGB_DEFAULT_MAP = 27,

XCB_ATOM_RGB_GRAY_MAP = 28,

XCB_ATOM_RGB_GREEN_MAP = 29,

XCB_ATOM_RGB_RED_MAP = 30,

XCB_ATOM_STRING = 31,

XCB_ATOM_VISUALID = 32,

XCB_ATOM_WINDOW = 33,

XCB_ATOM_WM_COMMAND = 34,

XCB_ATOM_WM_HINTS = 35,

XCB_ATOM_WM_CLIENT_MACHINE = 36,

XCB_ATOM_WM_ICON_NAME = 37,

XCB_ATOM_WM_ICON_SIZE = 38,

XCB_ATOM_WM_NAME = 39,

XCB_ATOM_WM_NORMAL_HINTS = 40,

XCB_ATOM_WM_SIZE_HINTS = 41,

XCB_ATOM_WM_ZOOM_HINTS = 42,

XCB_ATOM_MIN_SPACE = 43,

XCB_ATOM_NORM_SPACE = 44,

XCB_ATOM_MAX_SPACE = 45,

XCB_ATOM_END_SPACE = 46,

XCB_ATOM_SUPERSCRIPT_X = 47,

XCB_ATOM_SUPERSCRIPT_Y = 48,

XCB_ATOM_SUBSCRIPT_X = 49,

XCB_ATOM_SUBSCRIPT_Y = 50,

XCB_ATOM_UNDERLINE_POSITION = 51,

XCB_ATOM_UNDERLINE_THICKNESS = 52,

XCB_ATOM_STRIKEOUT_ASCENT = 53,

XCB_ATOM_STRIKEOUT_DESCENT = 54,

XCB_ATOM_ITALIC_ANGLE = 55,

XCB_ATOM_X_HEIGHT = 56,

XCB_ATOM_QUAD_WIDTH = 57,

XCB_ATOM_WEIGHT = 58,

XCB_ATOM_POINT_SIZE = 59,

XCB_ATOM_RESOLUTION = 60,

XCB_ATOM_COPYRIGHT = 61,

XCB_ATOM_NOTICE = 62,

XCB_ATOM_FONT_NAME = 63,

XCB_ATOM_FAMILY_NAME = 64,

XCB_ATOM_FULL_NAME = 65,

XCB_ATOM_CAP_HEIGHT = 66,

XCB_ATOM_WM_CLASS = 67,

XCB_ATOM_WM_TRANSIENT_FOR = 68

}

enum xcb_colormap_state_t { XCB_COLORMAP_STATE_UNINSTALLED = 0,

XCB_COLORMAP_STATE_INSTALLED = 1

}

enum xcb_colormap_enum_t { XCB_COLORMAP_NONE = 0

}

enum xcb_mapping_t { XCB_MAPPING_MODIFIER = 0,

XCB_MAPPING_KEYBOARD = 1,

XCB_MAPPING_POINTER = 2

}

enum xcb_window_class_t { XCB_WINDOW_CLASS_COPY_FROM_PARENT = 0,

XCB_WINDOW_CLASS_INPUT_OUTPUT = 1,

XCB_WINDOW_CLASS_INPUT_ONLY = 2

}

enum xcb_cw_t {

XCB_CW_BACK_PIXMAP = 1,

XCB_CW_BACK_PIXEL = 2,

XCB_CW_BORDER_PIXMAP = 4,

XCB_CW_BORDER_PIXEL = 8,

XCB_CW_BIT_GRAVITY = 16,

XCB_CW_WIN_GRAVITY = 32,

XCB_CW_BACKING_STORE = 64,

XCB_CW_BACKING_PLANES = 128,

XCB_CW_BACKING_PIXEL = 256,

XCB_CW_OVERRIDE_REDIRECT = 512,

XCB_CW_SAVE_UNDER = 1024,

XCB_CW_EVENT_MASK = 2048,

XCB_CW_DONT_PROPAGATE = 4096,

XCB_CW_COLORMAP = 8192,

XCB_CW_CURSOR = 16384

}

enum xcb_back_pixmap_t { XCB_BACK_PIXMAP_NONE = 0,

XCB_BACK_PIXMAP_PARENT_RELATIVE = 1

}

enum xcb_gravity_t {

XCB_GRAVITY_BIT_FORGET = 0,

XCB_GRAVITY_WIN_UNMAP = 0,

XCB_GRAVITY_NORTH_WEST = 1,

XCB_GRAVITY_NORTH = 2,

XCB_GRAVITY_NORTH_EAST = 3,

XCB_GRAVITY_WEST = 4,

XCB_GRAVITY_CENTER = 5,

XCB_GRAVITY_EAST = 6,

XCB_GRAVITY_SOUTH_WEST = 7,

XCB_GRAVITY_SOUTH = 8,

XCB_GRAVITY_SOUTH_EAST = 9,

XCB_GRAVITY_STATIC = 10

}

enum xcb_map_state_t { XCB_MAP_STATE_UNMAPPED = 0,

XCB_MAP_STATE_UNVIEWABLE = 1,

XCB_MAP_STATE_VIEWABLE = 2

}

enum xcb_set_mode_t { XCB_SET_MODE_INSERT = 0,

XCB_SET_MODE_DELETE = 1

}

enum xcb_config_window_t {

XCB_CONFIG_WINDOW_X = 1,

XCB_CONFIG_WINDOW_Y = 2,

XCB_CONFIG_WINDOW_WIDTH = 4,

XCB_CONFIG_WINDOW_HEIGHT = 8,

XCB_CONFIG_WINDOW_BORDER_WIDTH = 16,

XCB_CONFIG_WINDOW_SIBLING = 32,

XCB_CONFIG_WINDOW_STACK_MODE = 64

}

enum xcb_stack_mode_t {

XCB_STACK_MODE_ABOVE = 0,

XCB_STACK_MODE_BELOW = 1,

XCB_STACK_MODE_TOP_IF = 2,

XCB_STACK_MODE_BOTTOM_IF = 3,

XCB_STACK_MODE_OPPOSITE = 4

}

enum xcb_circulate_t { XCB_CIRCULATE_RAISE_LOWEST = 0,

XCB_CIRCULATE_LOWER_HIGHEST = 1

}

enum xcb_prop_mode_t { XCB_PROP_MODE_REPLACE = 0,

XCB_PROP_MODE_PREPEND = 1,

XCB_PROP_MODE_APPEND = 2

}

enum xcb_get_property_type_t { XCB_GET_PROPERTY_TYPE_ANY = 0

}

enum xcb_send_event_dest_t { XCB_SEND_EVENT_DEST_POINTER_WINDOW = 0,

XCB_SEND_EVENT_DEST_ITEM_FOCUS = 1

}

enum xcb_grab_mode_t { XCB_GRAB_MODE_SYNC = 0,

XCB_GRAB_MODE_ASYNC = 1

}

enum xcb_grab_status_t {

XCB_GRAB_STATUS_SUCCESS = 0,

XCB_GRAB_STATUS_ALREADY_GRABBED = 1,

XCB_GRAB_STATUS_INVALID_TIME = 2,

XCB_GRAB_STATUS_NOT_VIEWABLE = 3,

XCB_GRAB_STATUS_FROZEN = 4

}

enum xcb_cursor_enum_t { XCB_CURSOR_NONE = 0

}

enum xcb_button_index_t {

XCB_BUTTON_INDEX_ANY = 0,

XCB_BUTTON_INDEX_1 = 1,

XCB_BUTTON_INDEX_2 = 2,

XCB_BUTTON_INDEX_3 = 3,

XCB_BUTTON_INDEX_4 = 4,

XCB_BUTTON_INDEX_5 = 5

}

enum xcb_grab_t { XCB_GRAB_ANY = 0

}

enum xcb_allow_t {

XCB_ALLOW_ASYNC_POINTER = 0,

XCB_ALLOW_SYNC_POINTER = 1,

XCB_ALLOW_REPLAY_POINTER = 2,

XCB_ALLOW_ASYNC_KEYBOARD = 3,

XCB_ALLOW_SYNC_KEYBOARD = 4,

XCB_ALLOW_REPLAY_KEYBOARD = 5,

XCB_ALLOW_ASYNC_BOTH = 6,

XCB_ALLOW_SYNC_BOTH = 7

}

enum xcb_input_focus_t { XCB_INPUT_FOCUS_NONE = 0,

XCB_INPUT_FOCUS_POINTER_ROOT = 1,

XCB_INPUT_FOCUS_PARENT = 2,

XCB_INPUT_FOCUS_FOLLOW_KEYBOARD = 3

}

enum xcb_font_draw_t { XCB_FONT_DRAW_LEFT_TO_RIGHT = 0,

XCB_FONT_DRAW_RIGHT_TO_LEFT = 1

}

enum xcb_gc_t {

XCB_GC_FUNCTION = 1,

XCB_GC_PLANE_MASK = 2,

XCB_GC_FOREGROUND = 4,

XCB_GC_BACKGROUND = 8,

XCB_GC_LINE_WIDTH = 16,

XCB_GC_LINE_STYLE = 32,

XCB_GC_CAP_STYLE = 64,

XCB_GC_JOIN_STYLE = 128,

XCB_GC_FILL_STYLE = 256,

XCB_GC_FILL_RULE = 512,

XCB_GC_TILE = 1024,

XCB_GC_STIPPLE = 2048,

XCB_GC_TILE_STIPPLE_ORIGIN_X = 4096,

XCB_GC_TILE_STIPPLE_ORIGIN_Y = 8192,

XCB_GC_FONT = 16384,

XCB_GC_SUBWINDOW_MODE = 32768,

XCB_GC_GRAPHICS_EXPOSURES = 65536,

XCB_GC_CLIP_ORIGIN_X = 131072,

XCB_GC_CLIP_ORIGIN_Y = 262144,

XCB_GC_CLIP_MASK = 524288,

XCB_GC_DASH_OFFSET = 1048576,

XCB_GC_DASH_LIST = 2097152,

XCB_GC_ARC_MODE = 4194304

}

enum xcb_gx_t {

XCB_GX_CLEAR = 0,

XCB_GX_AND = 1,

XCB_GX_AND_REVERSE = 2,

XCB_GX_COPY = 3,

XCB_GX_AND_INVERTED = 4,

XCB_GX_NOOP = 5,

XCB_GX_XOR = 6,

XCB_GX_OR = 7,

XCB_GX_NOR = 8,

XCB_GX_EQUIV = 9,

XCB_GX_INVERT = 10,

XCB_GX_OR_REVERSE = 11,

XCB_GX_COPY_INVERTED = 12,

XCB_GX_OR_INVERTED = 13,

XCB_GX_NAND = 14,

XCB_GX_SET = 15

}

enum xcb_line_style_t { XCB_LINE_STYLE_SOLID = 0,

XCB_LINE_STYLE_ON_OFF_DASH = 1,

XCB_LINE_STYLE_DOUBLE_DASH = 2

}

enum xcb_cap_style_t { XCB_CAP_STYLE_NOT_LAST = 0,

XCB_CAP_STYLE_BUTT = 1,

XCB_CAP_STYLE_ROUND = 2,

XCB_CAP_STYLE_PROJECTING = 3

}

enum xcb_join_style_t { XCB_JOIN_STYLE_MITER = 0,

XCB_JOIN_STYLE_ROUND = 1,

XCB_JOIN_STYLE_BEVEL = 2

}

enum xcb_fill_style_t { XCB_FILL_STYLE_SOLID = 0,

XCB_FILL_STYLE_TILED = 1,

XCB_FILL_STYLE_STIPPLED = 2,

XCB_FILL_STYLE_OPAQUE_STIPPLED = 3

}

enum xcb_fill_rule_t { XCB_FILL_RULE_EVEN_ODD = 0,

XCB_FILL_RULE_WINDING = 1

}

enum xcb_subwindow_mode_t { XCB_SUBWINDOW_MODE_CLIP_BY_CHILDREN = 0,

XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS = 1

}

enum xcb_arc_mode_t { XCB_ARC_MODE_CHORD = 0,

XCB_ARC_MODE_PIE_SLICE = 1

}

enum xcb_clip_ordering_t { XCB_CLIP_ORDERING_UNSORTED = 0,

XCB_CLIP_ORDERING_Y_SORTED = 1,

XCB_CLIP_ORDERING_YX_SORTED = 2,

XCB_CLIP_ORDERING_YX_BANDED = 3

}

enum xcb_coord_mode_t { XCB_COORD_MODE_ORIGIN = 0,

XCB_COORD_MODE_PREVIOUS = 1

}

enum xcb_poly_shape_t { XCB_POLY_SHAPE_COMPLEX = 0,

XCB_POLY_SHAPE_NONCONVEX = 1,

XCB_POLY_SHAPE_CONVEX = 2

}

enum xcb_image_format_t { XCB_IMAGE_FORMAT_XY_BITMAP = 0,

XCB_IMAGE_FORMAT_XY_PIXMAP = 1,

XCB_IMAGE_FORMAT_Z_PIXMAP = 2

}

enum xcb_colormap_alloc_t { XCB_COLORMAP_ALLOC_NONE = 0,

XCB_COLORMAP_ALLOC_ALL = 1

}

enum xcb_color_flag_t { XCB_COLOR_FLAG_RED = 1,

XCB_COLOR_FLAG_GREEN = 2,

XCB_COLOR_FLAG_BLUE = 4

}

enum xcb_pixmap_enum_t { XCB_PIXMAP_NONE = 0

}

enum xcb_font_enum_t { XCB_FONT_NONE = 0

}

enum xcb_query_shape_of_t { XCB_QUERY_SHAPE_OF_LARGEST_CURSOR = 0,

XCB_QUERY_SHAPE_OF_FASTEST_TILE = 1,

XCB_QUERY_SHAPE_OF_FASTEST_STIPPLE = 2

}

enum xcb_kb_t {

XCB_KB_KEY_CLICK_PERCENT = 1,

XCB_KB_BELL_PERCENT = 2,

XCB_KB_BELL_PITCH = 4,

XCB_KB_BELL_DURATION = 8,

XCB_KB_LED = 16,

XCB_KB_LED_MODE = 32,

XCB_KB_KEY = 64,

XCB_KB_AUTO_REPEAT_MODE = 128

}

enum xcb_led_mode_t { XCB_LED_MODE_OFF = 0,

XCB_LED_MODE_ON = 1

}

enum xcb_auto_repeat_mode_t { XCB_AUTO_REPEAT_MODE_OFF = 0,

XCB_AUTO_REPEAT_MODE_ON = 1,

XCB_AUTO_REPEAT_MODE_DEFAULT = 2

}

enum xcb_blanking_t { XCB_BLANKING_NOT_PREFERRED = 0,

XCB_BLANKING_PREFERRED = 1,

XCB_BLANKING_DEFAULT = 2

}

enum xcb_exposures_t { XCB_EXPOSURES_NOT_ALLOWED = 0,

XCB_EXPOSURES_ALLOWED = 1,

XCB_EXPOSURES_DEFAULT = 2

}

enum xcb_host_mode_t { XCB_HOST_MODE_INSERT = 0,

XCB_HOST_MODE_DELETE = 1

}

enum xcb_family_t {

XCB_FAMILY_INTERNET = 0,

XCB_FAMILY_DECNET = 1,

XCB_FAMILY_CHAOS = 2,

XCB_FAMILY_SERVER_INTERPRETED = 5,

XCB_FAMILY_INTERNET_6 = 6

}

enum xcb_access_control_t { XCB_ACCESS_CONTROL_DISABLE = 0,

XCB_ACCESS_CONTROL_ENABLE = 1

}

enum xcb_close_down_t { XCB_CLOSE_DOWN_DESTROY_ALL = 0,

XCB_CLOSE_DOWN_RETAIN_PERMANENT = 1,

XCB_CLOSE_DOWN_RETAIN_TEMPORARY = 2

}

enum xcb_kill_t { XCB_KILL_ALL_TEMPORARY = 0

}

enum xcb_screen_saver_t { XCB_SCREEN_SAVER_RESET = 0,

XCB_SCREEN_SAVER_ACTIVE = 1

}

enum xcb_mapping_status_t { XCB_MAPPING_STATUS_SUCCESS = 0,

XCB_MAPPING_STATUS_BUSY = 1,

XCB_MAPPING_STATUS_FAILURE = 2

}

enum xcb_map_index_t {

XCB_MAP_INDEX_SHIFT = 0,

XCB_MAP_INDEX_LOCK = 1,

XCB_MAP_INDEX_CONTROL = 2,

XCB_MAP_INDEX_1 = 3,

XCB_MAP_INDEX_2 = 4,

XCB_MAP_INDEX_3 = 5,

XCB_MAP_INDEX_4 = 6,

XCB_MAP_INDEX_5 = 7

}

Functions

void xcb_char2b_next (xcb_char2b_iterator_t *i)

xcb_generic_iterator_t xcb_char2b_end (xcb_char2b_iterator_t i)

void xcb_window_next (xcb_window_iterator_t *i)

xcb_generic_iterator_t xcb_window_end (xcb_window_iterator_t i)

void xcb_pixmap_next (xcb_pixmap_iterator_t *i)

xcb_generic_iterator_t xcb_pixmap_end (xcb_pixmap_iterator_t i)

void xcb_cursor_next (xcb_cursor_iterator_t *i)

xcb_generic_iterator_t xcb_cursor_end (xcb_cursor_iterator_t i)

void xcb_font_next (xcb_font_iterator_t *i)

xcb_generic_iterator_t xcb_font_end (xcb_font_iterator_t i)

void xcb_gcontext_next (xcb_gcontext_iterator_t *i)

xcb_generic_iterator_t xcb_gcontext_end (xcb_gcontext_iterator_t i)

void xcb_colormap_next (xcb_colormap_iterator_t *i)

xcb_generic_iterator_t xcb_colormap_end (xcb_colormap_iterator_t i)

void xcb_atom_next (xcb_atom_iterator_t *i)

xcb_generic_iterator_t xcb_atom_end (xcb_atom_iterator_t i)

void xcb_drawable_next (xcb_drawable_iterator_t *i)

xcb_generic_iterator_t xcb_drawable_end (xcb_drawable_iterator_t i)

void xcb_fontable_next (xcb_fontable_iterator_t *i)

xcb_generic_iterator_t xcb_fontable_end (xcb_fontable_iterator_t i)

void xcb_bool32_next (xcb_bool32_iterator_t *i)

xcb_generic_iterator_t xcb_bool32_end (xcb_bool32_iterator_t i)

void xcb_visualid_next (xcb_visualid_iterator_t *i)

xcb_generic_iterator_t xcb_visualid_end (xcb_visualid_iterator_t i)

void xcb_timestamp_next (xcb_timestamp_iterator_t *i)

xcb_generic_iterator_t xcb_timestamp_end (xcb_timestamp_iterator_t i)

void xcb_keysym_next (xcb_keysym_iterator_t *i)

xcb_generic_iterator_t xcb_keysym_end (xcb_keysym_iterator_t i)

void xcb_keycode_next (xcb_keycode_iterator_t *i)

xcb_generic_iterator_t xcb_keycode_end (xcb_keycode_iterator_t i)

void xcb_keycode32_next (xcb_keycode32_iterator_t *i)

xcb_generic_iterator_t xcb_keycode32_end (xcb_keycode32_iterator_t i)

void xcb_button_next (xcb_button_iterator_t *i)

xcb_generic_iterator_t xcb_button_end (xcb_button_iterator_t i)

void xcb_point_next (xcb_point_iterator_t *i)

xcb_generic_iterator_t xcb_point_end (xcb_point_iterator_t i)

void xcb_rectangle_next (xcb_rectangle_iterator_t *i)

xcb_generic_iterator_t xcb_rectangle_end (xcb_rectangle_iterator_t i)

void xcb_arc_next (xcb_arc_iterator_t *i)

xcb_generic_iterator_t xcb_arc_end (xcb_arc_iterator_t i)

void xcb_format_next (xcb_format_iterator_t *i)

xcb_generic_iterator_t xcb_format_end (xcb_format_iterator_t i)

void xcb_visualtype_next (xcb_visualtype_iterator_t *i)

xcb_generic_iterator_t xcb_visualtype_end (xcb_visualtype_iterator_t i)

int xcb_depth_sizeof (const void *_buffer)

xcb_visualtype_t * xcb_depth_visuals (const xcb_depth_t *R)

int xcb_depth_visuals_length (const xcb_depth_t *R)

xcb_visualtype_iterator_t xcb_depth_visuals_iterator (const xcb_depth_t *R)

void xcb_depth_next (xcb_depth_iterator_t *i)

xcb_generic_iterator_t xcb_depth_end (xcb_depth_iterator_t i)

int xcb_screen_sizeof (const void *_buffer)

int xcb_screen_allowed_depths_length (const xcb_screen_t *R)

xcb_depth_iterator_t xcb_screen_allowed_depths_iterator (const xcb_screen_t *R)

void xcb_screen_next (xcb_screen_iterator_t *i)

xcb_generic_iterator_t xcb_screen_end (xcb_screen_iterator_t i)

int xcb_setup_request_sizeof (const void *_buffer)

char * xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R)

int xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R)

xcb_generic_iterator_t xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R)

char * xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R)

int xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R)

xcb_generic_iterator_t xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R)

void xcb_setup_request_next (xcb_setup_request_iterator_t *i)

xcb_generic_iterator_t xcb_setup_request_end (xcb_setup_request_iterator_t i)

int xcb_setup_failed_sizeof (const void *_buffer)

char * xcb_setup_failed_reason (const xcb_setup_failed_t *R)

int xcb_setup_failed_reason_length (const xcb_setup_failed_t *R)

xcb_generic_iterator_t xcb_setup_failed_reason_end (const xcb_setup_failed_t *R)

void xcb_setup_failed_next (xcb_setup_failed_iterator_t *i)

xcb_generic_iterator_t xcb_setup_failed_end (xcb_setup_failed_iterator_t i)

int xcb_setup_authenticate_sizeof (const void *_buffer)

char * xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R)

int xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R)

xcb_generic_iterator_t xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R)

void xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i)

xcb_generic_iterator_t xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i)

int xcb_setup_sizeof (const void *_buffer)

char * xcb_setup_vendor (const xcb_setup_t *R)

int xcb_setup_vendor_length (const xcb_setup_t *R)

xcb_generic_iterator_t xcb_setup_vendor_end (const xcb_setup_t *R)

xcb_format_t * xcb_setup_pixmap_formats (const xcb_setup_t *R)

int xcb_setup_pixmap_formats_length (const xcb_setup_t *R)

xcb_format_iterator_t xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R)

int xcb_setup_roots_length (const xcb_setup_t *R)

xcb_screen_iterator_t xcb_setup_roots_iterator (const xcb_setup_t *R)

void xcb_setup_next (xcb_setup_iterator_t *i)

xcb_generic_iterator_t xcb_setup_end (xcb_setup_iterator_t i)

void xcb_client_message_data_next (xcb_client_message_data_iterator_t *i)

xcb_generic_iterator_t xcb_client_message_data_end (xcb_client_message_data_iterator_t i)

int xcb_create_window_value_list_serialize (void **_buffer, uint32_t value_mask, const xcb_create_window_value_list_t *_aux)

int xcb_create_window_value_list_unpack (const void *_buffer, uint32_t value_mask, xcb_create_window_value_list_t *_aux)

int xcb_create_window_value_list_sizeof (const void *_buffer, uint32_t value_mask)

int xcb_create_window_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_create_window_checked (xcb_connection_t *c, uint8_t depth, xcb_window_t wid, xcb_window_t parent, int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t border_width, uint16_t _class, xcb_visualid_t visual, uint32_t value_mask, const void *value_list)

Creates a window. More...

xcb_void_cookie_t xcb_create_window (xcb_connection_t *c, uint8_t depth, xcb_window_t wid, xcb_window_t parent, int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t border_width, uint16_t _class, xcb_visualid_t visual, uint32_t value_mask, const void *value_list)

Creates a window. More...

xcb_void_cookie_t xcb_create_window_aux_checked (xcb_connection_t *c, uint8_t depth, xcb_window_t wid, xcb_window_t parent, int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t border_width, uint16_t _class, xcb_visualid_t visual, uint32_t value_mask, const xcb_create_window_value_list_t *value_list)

Creates a window. More...

xcb_void_cookie_t xcb_create_window_aux (xcb_connection_t *c, uint8_t depth, xcb_window_t wid, xcb_window_t parent, int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t border_width, uint16_t _class, xcb_visualid_t visual, uint32_t value_mask, const xcb_create_window_value_list_t *value_list)

Creates a window. More...

void * xcb_create_window_value_list (const xcb_create_window_request_t *R)

int xcb_change_window_attributes_value_list_serialize (void **_buffer, uint32_t value_mask, const xcb_change_window_attributes_value_list_t *_aux)

int xcb_change_window_attributes_value_list_unpack (const void *_buffer, uint32_t value_mask, xcb_change_window_attributes_value_list_t *_aux)

int xcb_change_window_attributes_value_list_sizeof (const void *_buffer, uint32_t value_mask)

int xcb_change_window_attributes_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_change_window_attributes_checked (xcb_connection_t *c, xcb_window_t window, uint32_t value_mask, const void *value_list)

change window attributes More...

xcb_void_cookie_t xcb_change_window_attributes (xcb_connection_t *c, xcb_window_t window, uint32_t value_mask, const void *value_list)

change window attributes More...

xcb_void_cookie_t xcb_change_window_attributes_aux_checked (xcb_connection_t *c, xcb_window_t window, uint32_t value_mask, const xcb_change_window_attributes_value_list_t *value_list)

change window attributes More...

xcb_void_cookie_t xcb_change_window_attributes_aux (xcb_connection_t *c, xcb_window_t window, uint32_t value_mask, const xcb_change_window_attributes_value_list_t *value_list)

change window attributes More...

void * xcb_change_window_attributes_value_list (const xcb_change_window_attributes_request_t *R)

xcb_get_window_attributes_cookie_t xcb_get_window_attributes (xcb_connection_t *c, xcb_window_t window)

Gets window attributes. More...

xcb_get_window_attributes_cookie_t xcb_get_window_attributes_unchecked (xcb_connection_t *c, xcb_window_t window)

Gets window attributes. More...

xcb_get_window_attributes_reply_t * xcb_get_window_attributes_reply (xcb_connection_t *c, xcb_get_window_attributes_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_destroy_window_checked (xcb_connection_t *c, xcb_window_t window)

Destroys a window. More...

xcb_void_cookie_t xcb_destroy_window (xcb_connection_t *c, xcb_window_t window)

Destroys a window. More...

xcb_void_cookie_t xcb_destroy_subwindows_checked (xcb_connection_t *c, xcb_window_t window)

xcb_void_cookie_t xcb_destroy_subwindows (xcb_connection_t *c, xcb_window_t window)

xcb_void_cookie_t xcb_change_save_set_checked (xcb_connection_t *c, uint8_t mode, xcb_window_t window)

Changes a client's save set. More...

xcb_void_cookie_t xcb_change_save_set (xcb_connection_t *c, uint8_t mode, xcb_window_t window)

Changes a client's save set. More...

xcb_void_cookie_t xcb_reparent_window_checked (xcb_connection_t *c, xcb_window_t window, xcb_window_t parent, int16_t x, int16_t y)

Reparents a window. More...

xcb_void_cookie_t xcb_reparent_window (xcb_connection_t *c, xcb_window_t window, xcb_window_t parent, int16_t x, int16_t y)

Reparents a window. More...

xcb_void_cookie_t xcb_map_window_checked (xcb_connection_t *c, xcb_window_t window)

Makes a window visible. More...

xcb_void_cookie_t xcb_map_window (xcb_connection_t *c, xcb_window_t window)

Makes a window visible. More...

xcb_void_cookie_t xcb_map_subwindows_checked (xcb_connection_t *c, xcb_window_t window)

xcb_void_cookie_t xcb_map_subwindows (xcb_connection_t *c, xcb_window_t window)

xcb_void_cookie_t xcb_unmap_window_checked (xcb_connection_t *c, xcb_window_t window)

Makes a window invisible. More...

xcb_void_cookie_t xcb_unmap_window (xcb_connection_t *c, xcb_window_t window)

Makes a window invisible. More...

xcb_void_cookie_t xcb_unmap_subwindows_checked (xcb_connection_t *c, xcb_window_t window)

xcb_void_cookie_t xcb_unmap_subwindows (xcb_connection_t *c, xcb_window_t window)

int xcb_configure_window_value_list_serialize (void **_buffer, uint16_t value_mask, const xcb_configure_window_value_list_t *_aux)

int xcb_configure_window_value_list_unpack (const void *_buffer, uint16_t value_mask, xcb_configure_window_value_list_t *_aux)

int xcb_configure_window_value_list_sizeof (const void *_buffer, uint16_t value_mask)

int xcb_configure_window_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_configure_window_checked (xcb_connection_t *c, xcb_window_t window, uint16_t value_mask, const void *value_list)

Configures window attributes. More...

xcb_void_cookie_t xcb_configure_window (xcb_connection_t *c, xcb_window_t window, uint16_t value_mask, const void *value_list)

Configures window attributes. More...

xcb_void_cookie_t xcb_configure_window_aux_checked (xcb_connection_t *c, xcb_window_t window, uint16_t value_mask, const xcb_configure_window_value_list_t *value_list)

Configures window attributes. More...

xcb_void_cookie_t xcb_configure_window_aux (xcb_connection_t *c, xcb_window_t window, uint16_t value_mask, const xcb_configure_window_value_list_t *value_list)

Configures window attributes. More...

void * xcb_configure_window_value_list (const xcb_configure_window_request_t *R)

xcb_void_cookie_t xcb_circulate_window_checked (xcb_connection_t *c, uint8_t direction, xcb_window_t window)

Change window stacking order. More...

xcb_void_cookie_t xcb_circulate_window (xcb_connection_t *c, uint8_t direction, xcb_window_t window)

Change window stacking order. More...

xcb_get_geometry_cookie_t xcb_get_geometry (xcb_connection_t *c, xcb_drawable_t drawable)

Get current window geometry. More...

xcb_get_geometry_cookie_t xcb_get_geometry_unchecked (xcb_connection_t *c, xcb_drawable_t drawable)

Get current window geometry. More...

xcb_get_geometry_reply_t * xcb_get_geometry_reply (xcb_connection_t *c, xcb_get_geometry_cookie_t cookie, xcb_generic_error_t **e)

int xcb_query_tree_sizeof (const void *_buffer)

xcb_query_tree_cookie_t xcb_query_tree (xcb_connection_t *c, xcb_window_t window)

query the window tree More...

xcb_query_tree_cookie_t xcb_query_tree_unchecked (xcb_connection_t *c, xcb_window_t window)

query the window tree More...

xcb_window_t * xcb_query_tree_children (const xcb_query_tree_reply_t *R)

int xcb_query_tree_children_length (const xcb_query_tree_reply_t *R)

xcb_generic_iterator_t xcb_query_tree_children_end (const xcb_query_tree_reply_t *R)

xcb_query_tree_reply_t * xcb_query_tree_reply (xcb_connection_t *c, xcb_query_tree_cookie_t cookie, xcb_generic_error_t **e)

int xcb_intern_atom_sizeof (const void *_buffer)

xcb_intern_atom_cookie_t xcb_intern_atom (xcb_connection_t *c, uint8_t only_if_exists, uint16_t name_len, const char *name)

Get atom identifier by name. More...

xcb_intern_atom_cookie_t xcb_intern_atom_unchecked (xcb_connection_t *c, uint8_t only_if_exists, uint16_t name_len, const char *name)

Get atom identifier by name. More...

xcb_intern_atom_reply_t * xcb_intern_atom_reply (xcb_connection_t *c, xcb_intern_atom_cookie_t cookie, xcb_generic_error_t **e)

int xcb_get_atom_name_sizeof (const void *_buffer)

xcb_get_atom_name_cookie_t xcb_get_atom_name (xcb_connection_t *c, xcb_atom_t atom)

xcb_get_atom_name_cookie_t xcb_get_atom_name_unchecked (xcb_connection_t *c, xcb_atom_t atom)

char * xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R)

int xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R)

xcb_generic_iterator_t xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R)

xcb_get_atom_name_reply_t * xcb_get_atom_name_reply (xcb_connection_t *c, xcb_get_atom_name_cookie_t cookie, xcb_generic_error_t **e)

int xcb_change_property_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_change_property_checked (xcb_connection_t *c, uint8_t mode, xcb_window_t window, xcb_atom_t property, xcb_atom_t type, uint8_t format, uint32_t data_len, const void *data)

Changes a window property. More...

xcb_void_cookie_t xcb_change_property (xcb_connection_t *c, uint8_t mode, xcb_window_t window, xcb_atom_t property, xcb_atom_t type, uint8_t format, uint32_t data_len, const void *data)

Changes a window property. More...

void * xcb_change_property_data (const xcb_change_property_request_t *R)

int xcb_change_property_data_length (const xcb_change_property_request_t *R)

xcb_generic_iterator_t xcb_change_property_data_end (const xcb_change_property_request_t *R)

xcb_void_cookie_t xcb_delete_property_checked (xcb_connection_t *c, xcb_window_t window, xcb_atom_t property)

xcb_void_cookie_t xcb_delete_property (xcb_connection_t *c, xcb_window_t window, xcb_atom_t property)

int xcb_get_property_sizeof (const void *_buffer)

xcb_get_property_cookie_t xcb_get_property (xcb_connection_t *c, uint8_t _delete, xcb_window_t window, xcb_atom_t property, xcb_atom_t type, uint32_t long_offset, uint32_t long_length)

Gets a window property. More...

xcb_get_property_cookie_t xcb_get_property_unchecked (xcb_connection_t *c, uint8_t _delete, xcb_window_t window, xcb_atom_t property, xcb_atom_t type, uint32_t long_offset, uint32_t long_length)

Gets a window property. More...

void * xcb_get_property_value (const xcb_get_property_reply_t *R)

int xcb_get_property_value_length (const xcb_get_property_reply_t *R)

xcb_generic_iterator_t xcb_get_property_value_end (const xcb_get_property_reply_t *R)

xcb_get_property_reply_t * xcb_get_property_reply (xcb_connection_t *c, xcb_get_property_cookie_t cookie, xcb_generic_error_t **e)

int xcb_list_properties_sizeof (const void *_buffer)

xcb_list_properties_cookie_t xcb_list_properties (xcb_connection_t *c, xcb_window_t window)

xcb_list_properties_cookie_t xcb_list_properties_unchecked (xcb_connection_t *c, xcb_window_t window)

xcb_atom_t * xcb_list_properties_atoms (const xcb_list_properties_reply_t *R)

int xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R)

xcb_generic_iterator_t xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R)

xcb_list_properties_reply_t * xcb_list_properties_reply (xcb_connection_t *c, xcb_list_properties_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_set_selection_owner_checked (xcb_connection_t *c, xcb_window_t owner, xcb_atom_t selection, xcb_timestamp_t time)

Sets the owner of a selection. More...

xcb_void_cookie_t xcb_set_selection_owner (xcb_connection_t *c, xcb_window_t owner, xcb_atom_t selection, xcb_timestamp_t time)

Sets the owner of a selection. More...

xcb_get_selection_owner_cookie_t xcb_get_selection_owner (xcb_connection_t *c, xcb_atom_t selection)

Gets the owner of a selection. More...

xcb_get_selection_owner_cookie_t xcb_get_selection_owner_unchecked (xcb_connection_t *c, xcb_atom_t selection)

Gets the owner of a selection. More...

xcb_get_selection_owner_reply_t * xcb_get_selection_owner_reply (xcb_connection_t *c, xcb_get_selection_owner_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_convert_selection_checked (xcb_connection_t *c, xcb_window_t requestor, xcb_atom_t selection, xcb_atom_t target, xcb_atom_t property, xcb_timestamp_t time)

xcb_void_cookie_t xcb_convert_selection (xcb_connection_t *c, xcb_window_t requestor, xcb_atom_t selection, xcb_atom_t target, xcb_atom_t property, xcb_timestamp_t time)

xcb_void_cookie_t xcb_send_event_checked (xcb_connection_t *c, uint8_t propagate, xcb_window_t destination, uint32_t event_mask, const char *event)

send an event More...

xcb_void_cookie_t xcb_send_event (xcb_connection_t *c, uint8_t propagate, xcb_window_t destination, uint32_t event_mask, const char *event)

send an event More...

xcb_grab_pointer_cookie_t xcb_grab_pointer (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, uint16_t event_mask, uint8_t pointer_mode, uint8_t keyboard_mode, xcb_window_t confine_to, xcb_cursor_t cursor, xcb_timestamp_t time)

Grab the pointer. More...

xcb_grab_pointer_cookie_t xcb_grab_pointer_unchecked (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, uint16_t event_mask, uint8_t pointer_mode, uint8_t keyboard_mode, xcb_window_t confine_to, xcb_cursor_t cursor, xcb_timestamp_t time)

Grab the pointer. More...

xcb_grab_pointer_reply_t * xcb_grab_pointer_reply (xcb_connection_t *c, xcb_grab_pointer_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_ungrab_pointer_checked (xcb_connection_t *c, xcb_timestamp_t time)

release the pointer More...

xcb_void_cookie_t xcb_ungrab_pointer (xcb_connection_t *c, xcb_timestamp_t time)

release the pointer More...

xcb_void_cookie_t xcb_grab_button_checked (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, uint16_t event_mask, uint8_t pointer_mode, uint8_t keyboard_mode, xcb_window_t confine_to, xcb_cursor_t cursor, uint8_t button, uint16_t modifiers)

Grab pointer button(s) More...

xcb_void_cookie_t xcb_grab_button (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, uint16_t event_mask, uint8_t pointer_mode, uint8_t keyboard_mode, xcb_window_t confine_to, xcb_cursor_t cursor, uint8_t button, uint16_t modifiers)

Grab pointer button(s) More...

xcb_void_cookie_t xcb_ungrab_button_checked (xcb_connection_t *c, uint8_t button, xcb_window_t grab_window, uint16_t modifiers)

xcb_void_cookie_t xcb_ungrab_button (xcb_connection_t *c, uint8_t button, xcb_window_t grab_window, uint16_t modifiers)

xcb_void_cookie_t xcb_change_active_pointer_grab_checked (xcb_connection_t *c, xcb_cursor_t cursor, xcb_timestamp_t time, uint16_t event_mask)

xcb_void_cookie_t xcb_change_active_pointer_grab (xcb_connection_t *c, xcb_cursor_t cursor, xcb_timestamp_t time, uint16_t event_mask)

xcb_grab_keyboard_cookie_t xcb_grab_keyboard (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, xcb_timestamp_t time, uint8_t pointer_mode, uint8_t keyboard_mode)

Grab the keyboard. More...

xcb_grab_keyboard_cookie_t xcb_grab_keyboard_unchecked (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, xcb_timestamp_t time, uint8_t pointer_mode, uint8_t keyboard_mode)

Grab the keyboard. More...

xcb_grab_keyboard_reply_t * xcb_grab_keyboard_reply (xcb_connection_t *c, xcb_grab_keyboard_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_ungrab_keyboard_checked (xcb_connection_t *c, xcb_timestamp_t time)

xcb_void_cookie_t xcb_ungrab_keyboard (xcb_connection_t *c, xcb_timestamp_t time)

xcb_void_cookie_t xcb_grab_key_checked (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, uint16_t modifiers, xcb_keycode_t key, uint8_t pointer_mode, uint8_t keyboard_mode)

Grab keyboard key(s) More...

xcb_void_cookie_t xcb_grab_key (xcb_connection_t *c, uint8_t owner_events, xcb_window_t grab_window, uint16_t modifiers, xcb_keycode_t key, uint8_t pointer_mode, uint8_t keyboard_mode)

Grab keyboard key(s) More...

xcb_void_cookie_t xcb_ungrab_key_checked (xcb_connection_t *c, xcb_keycode_t key, xcb_window_t grab_window, uint16_t modifiers)

release a key combination More...

xcb_void_cookie_t xcb_ungrab_key (xcb_connection_t *c, xcb_keycode_t key, xcb_window_t grab_window, uint16_t modifiers)

release a key combination More...

xcb_void_cookie_t xcb_allow_events_checked (xcb_connection_t *c, uint8_t mode, xcb_timestamp_t time)

release queued events More...

xcb_void_cookie_t xcb_allow_events (xcb_connection_t *c, uint8_t mode, xcb_timestamp_t time)

release queued events More...

xcb_void_cookie_t xcb_grab_server_checked (xcb_connection_t *c)

xcb_void_cookie_t xcb_grab_server (xcb_connection_t *c)

xcb_void_cookie_t xcb_ungrab_server_checked (xcb_connection_t *c)

xcb_void_cookie_t xcb_ungrab_server (xcb_connection_t *c)

xcb_query_pointer_cookie_t xcb_query_pointer (xcb_connection_t *c, xcb_window_t window)

get pointer coordinates More...

xcb_query_pointer_cookie_t xcb_query_pointer_unchecked (xcb_connection_t *c, xcb_window_t window)

get pointer coordinates More...

xcb_query_pointer_reply_t * xcb_query_pointer_reply (xcb_connection_t *c, xcb_query_pointer_cookie_t cookie, xcb_generic_error_t **e)

void xcb_timecoord_next (xcb_timecoord_iterator_t *i)

xcb_generic_iterator_t xcb_timecoord_end (xcb_timecoord_iterator_t i)

int xcb_get_motion_events_sizeof (const void *_buffer)

xcb_get_motion_events_cookie_t xcb_get_motion_events (xcb_connection_t *c, xcb_window_t window, xcb_timestamp_t start, xcb_timestamp_t stop)

xcb_get_motion_events_cookie_t xcb_get_motion_events_unchecked (xcb_connection_t *c, xcb_window_t window, xcb_timestamp_t start, xcb_timestamp_t stop)

xcb_timecoord_t * xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R)

int xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R)

xcb_timecoord_iterator_t xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R)

xcb_get_motion_events_reply_t * xcb_get_motion_events_reply (xcb_connection_t *c, xcb_get_motion_events_cookie_t cookie, xcb_generic_error_t **e)

xcb_translate_coordinates_cookie_t xcb_translate_coordinates (xcb_connection_t *c, xcb_window_t src_window, xcb_window_t dst_window, int16_t src_x, int16_t src_y)

xcb_translate_coordinates_cookie_t xcb_translate_coordinates_unchecked (xcb_connection_t *c, xcb_window_t src_window, xcb_window_t dst_window, int16_t src_x, int16_t src_y)

xcb_translate_coordinates_reply_t * xcb_translate_coordinates_reply (xcb_connection_t *c, xcb_translate_coordinates_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_warp_pointer_checked (xcb_connection_t *c, xcb_window_t src_window, xcb_window_t dst_window, int16_t src_x, int16_t src_y, uint16_t src_width, uint16_t src_height, int16_t dst_x, int16_t dst_y)

move mouse pointer More...

xcb_void_cookie_t xcb_warp_pointer (xcb_connection_t *c, xcb_window_t src_window, xcb_window_t dst_window, int16_t src_x, int16_t src_y, uint16_t src_width, uint16_t src_height, int16_t dst_x, int16_t dst_y)

move mouse pointer More...

xcb_void_cookie_t xcb_set_input_focus_checked (xcb_connection_t *c, uint8_t revert_to, xcb_window_t focus, xcb_timestamp_t time)

Sets input focus. More...

xcb_void_cookie_t xcb_set_input_focus (xcb_connection_t *c, uint8_t revert_to, xcb_window_t focus, xcb_timestamp_t time)

Sets input focus. More...

xcb_get_input_focus_cookie_t xcb_get_input_focus (xcb_connection_t *c)

xcb_get_input_focus_cookie_t xcb_get_input_focus_unchecked (xcb_connection_t *c)

xcb_get_input_focus_reply_t * xcb_get_input_focus_reply (xcb_connection_t *c, xcb_get_input_focus_cookie_t cookie, xcb_generic_error_t **e)

xcb_query_keymap_cookie_t xcb_query_keymap (xcb_connection_t *c)

xcb_query_keymap_cookie_t xcb_query_keymap_unchecked (xcb_connection_t *c)

xcb_query_keymap_reply_t * xcb_query_keymap_reply (xcb_connection_t *c, xcb_query_keymap_cookie_t cookie, xcb_generic_error_t **e)

int xcb_open_font_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_open_font_checked (xcb_connection_t *c, xcb_font_t fid, uint16_t name_len, const char *name)

opens a font More...

xcb_void_cookie_t xcb_open_font (xcb_connection_t *c, xcb_font_t fid, uint16_t name_len, const char *name)

opens a font More...

char * xcb_open_font_name (const xcb_open_font_request_t *R)

int xcb_open_font_name_length (const xcb_open_font_request_t *R)

xcb_generic_iterator_t xcb_open_font_name_end (const xcb_open_font_request_t *R)

xcb_void_cookie_t xcb_close_font_checked (xcb_connection_t *c, xcb_font_t font)

xcb_void_cookie_t xcb_close_font (xcb_connection_t *c, xcb_font_t font)

void xcb_fontprop_next (xcb_fontprop_iterator_t *i)

xcb_generic_iterator_t xcb_fontprop_end (xcb_fontprop_iterator_t i)

void xcb_charinfo_next (xcb_charinfo_iterator_t *i)

xcb_generic_iterator_t xcb_charinfo_end (xcb_charinfo_iterator_t i)

int xcb_query_font_sizeof (const void *_buffer)

xcb_query_font_cookie_t xcb_query_font (xcb_connection_t *c, xcb_fontable_t font)

query font metrics More...

xcb_query_font_cookie_t xcb_query_font_unchecked (xcb_connection_t *c, xcb_fontable_t font)

query font metrics More...

xcb_fontprop_t * xcb_query_font_properties (const xcb_query_font_reply_t *R)

int xcb_query_font_properties_length (const xcb_query_font_reply_t *R)

xcb_fontprop_iterator_t xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R)

xcb_charinfo_t * xcb_query_font_char_infos (const xcb_query_font_reply_t *R)

int xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R)

xcb_charinfo_iterator_t xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R)

xcb_query_font_reply_t * xcb_query_font_reply (xcb_connection_t *c, xcb_query_font_cookie_t cookie, xcb_generic_error_t **e)

int xcb_query_text_extents_sizeof (const void *_buffer, uint32_t string_len)

xcb_query_text_extents_cookie_t xcb_query_text_extents (xcb_connection_t *c, xcb_fontable_t font, uint32_t string_len, const xcb_char2b_t *string)

get text extents More...

xcb_query_text_extents_cookie_t xcb_query_text_extents_unchecked (xcb_connection_t *c, xcb_fontable_t font, uint32_t string_len, const xcb_char2b_t *string)

get text extents More...

xcb_query_text_extents_reply_t * xcb_query_text_extents_reply (xcb_connection_t *c, xcb_query_text_extents_cookie_t cookie, xcb_generic_error_t **e)

int xcb_str_sizeof (const void *_buffer)

char * xcb_str_name (const xcb_str_t *R)

int xcb_str_name_length (const xcb_str_t *R)

xcb_generic_iterator_t xcb_str_name_end (const xcb_str_t *R)

void xcb_str_next (xcb_str_iterator_t *i)

xcb_generic_iterator_t xcb_str_end (xcb_str_iterator_t i)

int xcb_list_fonts_sizeof (const void *_buffer)

xcb_list_fonts_cookie_t xcb_list_fonts (xcb_connection_t *c, uint16_t max_names, uint16_t pattern_len, const char *pattern)

get matching font names More...

xcb_list_fonts_cookie_t xcb_list_fonts_unchecked (xcb_connection_t *c, uint16_t max_names, uint16_t pattern_len, const char *pattern)

get matching font names More...

int xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R)

xcb_str_iterator_t xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R)

xcb_list_fonts_reply_t * xcb_list_fonts_reply (xcb_connection_t *c, xcb_list_fonts_cookie_t cookie, xcb_generic_error_t **e)

int xcb_list_fonts_with_info_sizeof (const void *_buffer)

xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info (xcb_connection_t *c, uint16_t max_names, uint16_t pattern_len, const char *pattern)

get matching font names and information More...

xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info_unchecked (xcb_connection_t *c, uint16_t max_names, uint16_t pattern_len, const char *pattern)

get matching font names and information More...

xcb_fontprop_t * xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R)

int xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R)

xcb_fontprop_iterator_t xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R)

char * xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R)

int xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R)

xcb_generic_iterator_t xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R)

xcb_list_fonts_with_info_reply_t * xcb_list_fonts_with_info_reply (xcb_connection_t *c, xcb_list_fonts_with_info_cookie_t cookie, xcb_generic_error_t **e)

int xcb_set_font_path_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_set_font_path_checked (xcb_connection_t *c, uint16_t font_qty, const xcb_str_t *font)

xcb_void_cookie_t xcb_set_font_path (xcb_connection_t *c, uint16_t font_qty, const xcb_str_t *font)

int xcb_set_font_path_font_length (const xcb_set_font_path_request_t *R)

xcb_str_iterator_t xcb_set_font_path_font_iterator (const xcb_set_font_path_request_t *R)

int xcb_get_font_path_sizeof (const void *_buffer)

xcb_get_font_path_cookie_t xcb_get_font_path (xcb_connection_t *c)

xcb_get_font_path_cookie_t xcb_get_font_path_unchecked (xcb_connection_t *c)

int xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R)

xcb_str_iterator_t xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R)

xcb_get_font_path_reply_t * xcb_get_font_path_reply (xcb_connection_t *c, xcb_get_font_path_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_create_pixmap_checked (xcb_connection_t *c, uint8_t depth, xcb_pixmap_t pid, xcb_drawable_t drawable, uint16_t width, uint16_t height)

Creates a pixmap. More...

xcb_void_cookie_t xcb_create_pixmap (xcb_connection_t *c, uint8_t depth, xcb_pixmap_t pid, xcb_drawable_t drawable, uint16_t width, uint16_t height)

Creates a pixmap. More...

xcb_void_cookie_t xcb_free_pixmap_checked (xcb_connection_t *c, xcb_pixmap_t pixmap)

Destroys a pixmap. More...

xcb_void_cookie_t xcb_free_pixmap (xcb_connection_t *c, xcb_pixmap_t pixmap)

Destroys a pixmap. More...

int xcb_create_gc_value_list_serialize (void **_buffer, uint32_t value_mask, const xcb_create_gc_value_list_t *_aux)

int xcb_create_gc_value_list_unpack (const void *_buffer, uint32_t value_mask, xcb_create_gc_value_list_t *_aux)

int xcb_create_gc_value_list_sizeof (const void *_buffer, uint32_t value_mask)

int xcb_create_gc_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_create_gc_checked (xcb_connection_t *c, xcb_gcontext_t cid, xcb_drawable_t drawable, uint32_t value_mask, const void *value_list)

Creates a graphics context. More...

xcb_void_cookie_t xcb_create_gc (xcb_connection_t *c, xcb_gcontext_t cid, xcb_drawable_t drawable, uint32_t value_mask, const void *value_list)

Creates a graphics context. More...

xcb_void_cookie_t xcb_create_gc_aux_checked (xcb_connection_t *c, xcb_gcontext_t cid, xcb_drawable_t drawable, uint32_t value_mask, const xcb_create_gc_value_list_t *value_list)

Creates a graphics context. More...

xcb_void_cookie_t xcb_create_gc_aux (xcb_connection_t *c, xcb_gcontext_t cid, xcb_drawable_t drawable, uint32_t value_mask, const xcb_create_gc_value_list_t *value_list)

Creates a graphics context. More...

void * xcb_create_gc_value_list (const xcb_create_gc_request_t *R)

int xcb_change_gc_value_list_serialize (void **_buffer, uint32_t value_mask, const xcb_change_gc_value_list_t *_aux)

int xcb_change_gc_value_list_unpack (const void *_buffer, uint32_t value_mask, xcb_change_gc_value_list_t *_aux)

int xcb_change_gc_value_list_sizeof (const void *_buffer, uint32_t value_mask)

int xcb_change_gc_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_change_gc_checked (xcb_connection_t *c, xcb_gcontext_t gc, uint32_t value_mask, const void *value_list)

change graphics context components More...

xcb_void_cookie_t xcb_change_gc (xcb_connection_t *c, xcb_gcontext_t gc, uint32_t value_mask, const void *value_list)

change graphics context components More...

xcb_void_cookie_t xcb_change_gc_aux_checked (xcb_connection_t *c, xcb_gcontext_t gc, uint32_t value_mask, const xcb_change_gc_value_list_t *value_list)

change graphics context components More...

xcb_void_cookie_t xcb_change_gc_aux (xcb_connection_t *c, xcb_gcontext_t gc, uint32_t value_mask, const xcb_change_gc_value_list_t *value_list)

change graphics context components More...

void * xcb_change_gc_value_list (const xcb_change_gc_request_t *R)

xcb_void_cookie_t xcb_copy_gc_checked (xcb_connection_t *c, xcb_gcontext_t src_gc, xcb_gcontext_t dst_gc, uint32_t value_mask)

xcb_void_cookie_t xcb_copy_gc (xcb_connection_t *c, xcb_gcontext_t src_gc, xcb_gcontext_t dst_gc, uint32_t value_mask)

int xcb_set_dashes_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_set_dashes_checked (xcb_connection_t *c, xcb_gcontext_t gc, uint16_t dash_offset, uint16_t dashes_len, const uint8_t *dashes)

xcb_void_cookie_t xcb_set_dashes (xcb_connection_t *c, xcb_gcontext_t gc, uint16_t dash_offset, uint16_t dashes_len, const uint8_t *dashes)

uint8_t * xcb_set_dashes_dashes (const xcb_set_dashes_request_t *R)

int xcb_set_dashes_dashes_length (const xcb_set_dashes_request_t *R)

xcb_generic_iterator_t xcb_set_dashes_dashes_end (const xcb_set_dashes_request_t *R)

int xcb_set_clip_rectangles_sizeof (const void *_buffer, uint32_t rectangles_len)

xcb_void_cookie_t xcb_set_clip_rectangles_checked (xcb_connection_t *c, uint8_t ordering, xcb_gcontext_t gc, int16_t clip_x_origin, int16_t clip_y_origin, uint32_t rectangles_len, const xcb_rectangle_t *rectangles)

xcb_void_cookie_t xcb_set_clip_rectangles (xcb_connection_t *c, uint8_t ordering, xcb_gcontext_t gc, int16_t clip_x_origin, int16_t clip_y_origin, uint32_t rectangles_len, const xcb_rectangle_t *rectangles)

xcb_rectangle_t * xcb_set_clip_rectangles_rectangles (const xcb_set_clip_rectangles_request_t *R)

int xcb_set_clip_rectangles_rectangles_length (const xcb_set_clip_rectangles_request_t *R)

xcb_rectangle_iterator_t xcb_set_clip_rectangles_rectangles_iterator (const xcb_set_clip_rectangles_request_t *R)

xcb_void_cookie_t xcb_free_gc_checked (xcb_connection_t *c, xcb_gcontext_t gc)

Destroys a graphics context. More...

xcb_void_cookie_t xcb_free_gc (xcb_connection_t *c, xcb_gcontext_t gc)

Destroys a graphics context. More...

xcb_void_cookie_t xcb_clear_area_checked (xcb_connection_t *c, uint8_t exposures, xcb_window_t window, int16_t x, int16_t y, uint16_t width, uint16_t height)

xcb_void_cookie_t xcb_clear_area (xcb_connection_t *c, uint8_t exposures, xcb_window_t window, int16_t x, int16_t y, uint16_t width, uint16_t height)

xcb_void_cookie_t xcb_copy_area_checked (xcb_connection_t *c, xcb_drawable_t src_drawable, xcb_drawable_t dst_drawable, xcb_gcontext_t gc, int16_t src_x, int16_t src_y, int16_t dst_x, int16_t dst_y, uint16_t width, uint16_t height)

copy areas More...

xcb_void_cookie_t xcb_copy_area (xcb_connection_t *c, xcb_drawable_t src_drawable, xcb_drawable_t dst_drawable, xcb_gcontext_t gc, int16_t src_x, int16_t src_y, int16_t dst_x, int16_t dst_y, uint16_t width, uint16_t height)

copy areas More...

xcb_void_cookie_t xcb_copy_plane_checked (xcb_connection_t *c, xcb_drawable_t src_drawable, xcb_drawable_t dst_drawable, xcb_gcontext_t gc, int16_t src_x, int16_t src_y, int16_t dst_x, int16_t dst_y, uint16_t width, uint16_t height, uint32_t bit_plane)

xcb_void_cookie_t xcb_copy_plane (xcb_connection_t *c, xcb_drawable_t src_drawable, xcb_drawable_t dst_drawable, xcb_gcontext_t gc, int16_t src_x, int16_t src_y, int16_t dst_x, int16_t dst_y, uint16_t width, uint16_t height, uint32_t bit_plane)

int xcb_poly_point_sizeof (const void *_buffer, uint32_t points_len)

xcb_void_cookie_t xcb_poly_point_checked (xcb_connection_t *c, uint8_t coordinate_mode, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t points_len, const xcb_point_t *points)

xcb_void_cookie_t xcb_poly_point (xcb_connection_t *c, uint8_t coordinate_mode, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t points_len, const xcb_point_t *points)

xcb_point_t * xcb_poly_point_points (const xcb_poly_point_request_t *R)

int xcb_poly_point_points_length (const xcb_poly_point_request_t *R)

xcb_point_iterator_t xcb_poly_point_points_iterator (const xcb_poly_point_request_t *R)

int xcb_poly_line_sizeof (const void *_buffer, uint32_t points_len)

xcb_void_cookie_t xcb_poly_line_checked (xcb_connection_t *c, uint8_t coordinate_mode, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t points_len, const xcb_point_t *points)

draw lines More...

xcb_void_cookie_t xcb_poly_line (xcb_connection_t *c, uint8_t coordinate_mode, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t points_len, const xcb_point_t *points)

draw lines More...

xcb_point_t * xcb_poly_line_points (const xcb_poly_line_request_t *R)

int xcb_poly_line_points_length (const xcb_poly_line_request_t *R)

xcb_point_iterator_t xcb_poly_line_points_iterator (const xcb_poly_line_request_t *R)

void xcb_segment_next (xcb_segment_iterator_t *i)

xcb_generic_iterator_t xcb_segment_end (xcb_segment_iterator_t i)

int xcb_poly_segment_sizeof (const void *_buffer, uint32_t segments_len)

xcb_void_cookie_t xcb_poly_segment_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t segments_len, const xcb_segment_t *segments)

draw lines More...

xcb_void_cookie_t xcb_poly_segment (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t segments_len, const xcb_segment_t *segments)

draw lines More...

xcb_segment_t * xcb_poly_segment_segments (const xcb_poly_segment_request_t *R)

int xcb_poly_segment_segments_length (const xcb_poly_segment_request_t *R)

xcb_segment_iterator_t xcb_poly_segment_segments_iterator (const xcb_poly_segment_request_t *R)

int xcb_poly_rectangle_sizeof (const void *_buffer, uint32_t rectangles_len)

xcb_void_cookie_t xcb_poly_rectangle_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t rectangles_len, const xcb_rectangle_t *rectangles)

xcb_void_cookie_t xcb_poly_rectangle (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t rectangles_len, const xcb_rectangle_t *rectangles)

xcb_rectangle_t * xcb_poly_rectangle_rectangles (const xcb_poly_rectangle_request_t *R)

int xcb_poly_rectangle_rectangles_length (const xcb_poly_rectangle_request_t *R)

xcb_rectangle_iterator_t xcb_poly_rectangle_rectangles_iterator (const xcb_poly_rectangle_request_t *R)

int xcb_poly_arc_sizeof (const void *_buffer, uint32_t arcs_len)

xcb_void_cookie_t xcb_poly_arc_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t arcs_len, const xcb_arc_t *arcs)

xcb_void_cookie_t xcb_poly_arc (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t arcs_len, const xcb_arc_t *arcs)

xcb_arc_t * xcb_poly_arc_arcs (const xcb_poly_arc_request_t *R)

int xcb_poly_arc_arcs_length (const xcb_poly_arc_request_t *R)

xcb_arc_iterator_t xcb_poly_arc_arcs_iterator (const xcb_poly_arc_request_t *R)

int xcb_fill_poly_sizeof (const void *_buffer, uint32_t points_len)

xcb_void_cookie_t xcb_fill_poly_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint8_t shape, uint8_t coordinate_mode, uint32_t points_len, const xcb_point_t *points)

xcb_void_cookie_t xcb_fill_poly (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint8_t shape, uint8_t coordinate_mode, uint32_t points_len, const xcb_point_t *points)

xcb_point_t * xcb_fill_poly_points (const xcb_fill_poly_request_t *R)

int xcb_fill_poly_points_length (const xcb_fill_poly_request_t *R)

xcb_point_iterator_t xcb_fill_poly_points_iterator (const xcb_fill_poly_request_t *R)

int xcb_poly_fill_rectangle_sizeof (const void *_buffer, uint32_t rectangles_len)

xcb_void_cookie_t xcb_poly_fill_rectangle_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t rectangles_len, const xcb_rectangle_t *rectangles)

Fills rectangles. More...

xcb_void_cookie_t xcb_poly_fill_rectangle (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t rectangles_len, const xcb_rectangle_t *rectangles)

Fills rectangles. More...

xcb_rectangle_t * xcb_poly_fill_rectangle_rectangles (const xcb_poly_fill_rectangle_request_t *R)

int xcb_poly_fill_rectangle_rectangles_length (const xcb_poly_fill_rectangle_request_t *R)

xcb_rectangle_iterator_t xcb_poly_fill_rectangle_rectangles_iterator (const xcb_poly_fill_rectangle_request_t *R)

int xcb_poly_fill_arc_sizeof (const void *_buffer, uint32_t arcs_len)

xcb_void_cookie_t xcb_poly_fill_arc_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t arcs_len, const xcb_arc_t *arcs)

xcb_void_cookie_t xcb_poly_fill_arc (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, uint32_t arcs_len, const xcb_arc_t *arcs)

xcb_arc_t * xcb_poly_fill_arc_arcs (const xcb_poly_fill_arc_request_t *R)

int xcb_poly_fill_arc_arcs_length (const xcb_poly_fill_arc_request_t *R)

xcb_arc_iterator_t xcb_poly_fill_arc_arcs_iterator (const xcb_poly_fill_arc_request_t *R)

int xcb_put_image_sizeof (const void *_buffer, uint32_t data_len)

xcb_void_cookie_t xcb_put_image_checked (xcb_connection_t *c, uint8_t format, xcb_drawable_t drawable, xcb_gcontext_t gc, uint16_t width, uint16_t height, int16_t dst_x, int16_t dst_y, uint8_t left_pad, uint8_t depth, uint32_t data_len, const uint8_t *data)

xcb_void_cookie_t xcb_put_image (xcb_connection_t *c, uint8_t format, xcb_drawable_t drawable, xcb_gcontext_t gc, uint16_t width, uint16_t height, int16_t dst_x, int16_t dst_y, uint8_t left_pad, uint8_t depth, uint32_t data_len, const uint8_t *data)

uint8_t * xcb_put_image_data (const xcb_put_image_request_t *R)

int xcb_put_image_data_length (const xcb_put_image_request_t *R)

xcb_generic_iterator_t xcb_put_image_data_end (const xcb_put_image_request_t *R)

int xcb_get_image_sizeof (const void *_buffer)

xcb_get_image_cookie_t xcb_get_image (xcb_connection_t *c, uint8_t format, xcb_drawable_t drawable, int16_t x, int16_t y, uint16_t width, uint16_t height, uint32_t plane_mask)

xcb_get_image_cookie_t xcb_get_image_unchecked (xcb_connection_t *c, uint8_t format, xcb_drawable_t drawable, int16_t x, int16_t y, uint16_t width, uint16_t height, uint32_t plane_mask)

uint8_t * xcb_get_image_data (const xcb_get_image_reply_t *R)

int xcb_get_image_data_length (const xcb_get_image_reply_t *R)

xcb_generic_iterator_t xcb_get_image_data_end (const xcb_get_image_reply_t *R)

xcb_get_image_reply_t * xcb_get_image_reply (xcb_connection_t *c, xcb_get_image_cookie_t cookie, xcb_generic_error_t **e)

int xcb_poly_text_8_sizeof (const void *_buffer, uint32_t items_len)

xcb_void_cookie_t xcb_poly_text_8_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, uint32_t items_len, const uint8_t *items)

xcb_void_cookie_t xcb_poly_text_8 (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, uint32_t items_len, const uint8_t *items)

uint8_t * xcb_poly_text_8_items (const xcb_poly_text_8_request_t *R)

int xcb_poly_text_8_items_length (const xcb_poly_text_8_request_t *R)

xcb_generic_iterator_t xcb_poly_text_8_items_end (const xcb_poly_text_8_request_t *R)

int xcb_poly_text_16_sizeof (const void *_buffer, uint32_t items_len)

xcb_void_cookie_t xcb_poly_text_16_checked (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, uint32_t items_len, const uint8_t *items)

xcb_void_cookie_t xcb_poly_text_16 (xcb_connection_t *c, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, uint32_t items_len, const uint8_t *items)

uint8_t * xcb_poly_text_16_items (const xcb_poly_text_16_request_t *R)

int xcb_poly_text_16_items_length (const xcb_poly_text_16_request_t *R)

xcb_generic_iterator_t xcb_poly_text_16_items_end (const xcb_poly_text_16_request_t *R)

int xcb_image_text_8_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_image_text_8_checked (xcb_connection_t *c, uint8_t string_len, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, const char *string)

Draws text. More...

xcb_void_cookie_t xcb_image_text_8 (xcb_connection_t *c, uint8_t string_len, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, const char *string)

Draws text. More...

char * xcb_image_text_8_string (const xcb_image_text_8_request_t *R)

int xcb_image_text_8_string_length (const xcb_image_text_8_request_t *R)

xcb_generic_iterator_t xcb_image_text_8_string_end (const xcb_image_text_8_request_t *R)

int xcb_image_text_16_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_image_text_16_checked (xcb_connection_t *c, uint8_t string_len, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, const xcb_char2b_t *string)

Draws text. More...

xcb_void_cookie_t xcb_image_text_16 (xcb_connection_t *c, uint8_t string_len, xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y, const xcb_char2b_t *string)

Draws text. More...

xcb_char2b_t * xcb_image_text_16_string (const xcb_image_text_16_request_t *R)

int xcb_image_text_16_string_length (const xcb_image_text_16_request_t *R)

xcb_char2b_iterator_t xcb_image_text_16_string_iterator (const xcb_image_text_16_request_t *R)

xcb_void_cookie_t xcb_create_colormap_checked (xcb_connection_t *c, uint8_t alloc, xcb_colormap_t mid, xcb_window_t window, xcb_visualid_t visual)

xcb_void_cookie_t xcb_create_colormap (xcb_connection_t *c, uint8_t alloc, xcb_colormap_t mid, xcb_window_t window, xcb_visualid_t visual)

xcb_void_cookie_t xcb_free_colormap_checked (xcb_connection_t *c, xcb_colormap_t cmap)

xcb_void_cookie_t xcb_free_colormap (xcb_connection_t *c, xcb_colormap_t cmap)

xcb_void_cookie_t xcb_copy_colormap_and_free_checked (xcb_connection_t *c, xcb_colormap_t mid, xcb_colormap_t src_cmap)

xcb_void_cookie_t xcb_copy_colormap_and_free (xcb_connection_t *c, xcb_colormap_t mid, xcb_colormap_t src_cmap)

xcb_void_cookie_t xcb_install_colormap_checked (xcb_connection_t *c, xcb_colormap_t cmap)

xcb_void_cookie_t xcb_install_colormap (xcb_connection_t *c, xcb_colormap_t cmap)

xcb_void_cookie_t xcb_uninstall_colormap_checked (xcb_connection_t *c, xcb_colormap_t cmap)

xcb_void_cookie_t xcb_uninstall_colormap (xcb_connection_t *c, xcb_colormap_t cmap)

int xcb_list_installed_colormaps_sizeof (const void *_buffer)

xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps (xcb_connection_t *c, xcb_window_t window)

xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps_unchecked (xcb_connection_t *c, xcb_window_t window)

xcb_colormap_t * xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R)

int xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R)

xcb_generic_iterator_t xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R)

xcb_list_installed_colormaps_reply_t * xcb_list_installed_colormaps_reply (xcb_connection_t *c, xcb_list_installed_colormaps_cookie_t cookie, xcb_generic_error_t **e)

xcb_alloc_color_cookie_t xcb_alloc_color (xcb_connection_t *c, xcb_colormap_t cmap, uint16_t red, uint16_t green, uint16_t blue)

Allocate a color. More...

xcb_alloc_color_cookie_t xcb_alloc_color_unchecked (xcb_connection_t *c, xcb_colormap_t cmap, uint16_t red, uint16_t green, uint16_t blue)

Allocate a color. More...

xcb_alloc_color_reply_t * xcb_alloc_color_reply (xcb_connection_t *c, xcb_alloc_color_cookie_t cookie, xcb_generic_error_t **e)

int xcb_alloc_named_color_sizeof (const void *_buffer)

xcb_alloc_named_color_cookie_t xcb_alloc_named_color (xcb_connection_t *c, xcb_colormap_t cmap, uint16_t name_len, const char *name)

xcb_alloc_named_color_cookie_t xcb_alloc_named_color_unchecked (xcb_connection_t *c, xcb_colormap_t cmap, uint16_t name_len, const char *name)

xcb_alloc_named_color_reply_t * xcb_alloc_named_color_reply (xcb_connection_t *c, xcb_alloc_named_color_cookie_t cookie, xcb_generic_error_t **e)

int xcb_alloc_color_cells_sizeof (const void *_buffer)

xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells (xcb_connection_t *c, uint8_t contiguous, xcb_colormap_t cmap, uint16_t colors, uint16_t planes)

xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells_unchecked (xcb_connection_t *c, uint8_t contiguous, xcb_colormap_t cmap, uint16_t colors, uint16_t planes)

uint32_t * xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R)

int xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R)

xcb_generic_iterator_t xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R)

uint32_t * xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R)

int xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R)

xcb_generic_iterator_t xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R)

xcb_alloc_color_cells_reply_t * xcb_alloc_color_cells_reply (xcb_connection_t *c, xcb_alloc_color_cells_cookie_t cookie, xcb_generic_error_t **e)

int xcb_alloc_color_planes_sizeof (const void *_buffer)

xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes (xcb_connection_t *c, uint8_t contiguous, xcb_colormap_t cmap, uint16_t colors, uint16_t reds, uint16_t greens, uint16_t blues)

xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes_unchecked (xcb_connection_t *c, uint8_t contiguous, xcb_colormap_t cmap, uint16_t colors, uint16_t reds, uint16_t greens, uint16_t blues)

uint32_t * xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R)

int xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R)

xcb_generic_iterator_t xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R)

xcb_alloc_color_planes_reply_t * xcb_alloc_color_planes_reply (xcb_connection_t *c, xcb_alloc_color_planes_cookie_t cookie, xcb_generic_error_t **e)

int xcb_free_colors_sizeof (const void *_buffer, uint32_t pixels_len)

xcb_void_cookie_t xcb_free_colors_checked (xcb_connection_t *c, xcb_colormap_t cmap, uint32_t plane_mask, uint32_t pixels_len, const uint32_t *pixels)

xcb_void_cookie_t xcb_free_colors (xcb_connection_t *c, xcb_colormap_t cmap, uint32_t plane_mask, uint32_t pixels_len, const uint32_t *pixels)

uint32_t * xcb_free_colors_pixels (const xcb_free_colors_request_t *R)

int xcb_free_colors_pixels_length (const xcb_free_colors_request_t *R)

xcb_generic_iterator_t xcb_free_colors_pixels_end (const xcb_free_colors_request_t *R)

void xcb_coloritem_next (xcb_coloritem_iterator_t *i)

xcb_generic_iterator_t xcb_coloritem_end (xcb_coloritem_iterator_t i)

int xcb_store_colors_sizeof (const void *_buffer, uint32_t items_len)

xcb_void_cookie_t xcb_store_colors_checked (xcb_connection_t *c, xcb_colormap_t cmap, uint32_t items_len, const xcb_coloritem_t *items)

xcb_void_cookie_t xcb_store_colors (xcb_connection_t *c, xcb_colormap_t cmap, uint32_t items_len, const xcb_coloritem_t *items)

xcb_coloritem_t * xcb_store_colors_items (const xcb_store_colors_request_t *R)

int xcb_store_colors_items_length (const xcb_store_colors_request_t *R)

xcb_coloritem_iterator_t xcb_store_colors_items_iterator (const xcb_store_colors_request_t *R)

int xcb_store_named_color_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_store_named_color_checked (xcb_connection_t *c, uint8_t flags, xcb_colormap_t cmap, uint32_t pixel, uint16_t name_len, const char *name)

xcb_void_cookie_t xcb_store_named_color (xcb_connection_t *c, uint8_t flags, xcb_colormap_t cmap, uint32_t pixel, uint16_t name_len, const char *name)

char * xcb_store_named_color_name (const xcb_store_named_color_request_t *R)

int xcb_store_named_color_name_length (const xcb_store_named_color_request_t *R)

xcb_generic_iterator_t xcb_store_named_color_name_end (const xcb_store_named_color_request_t *R)

void xcb_rgb_next (xcb_rgb_iterator_t *i)

xcb_generic_iterator_t xcb_rgb_end (xcb_rgb_iterator_t i)

int xcb_query_colors_sizeof (const void *_buffer, uint32_t pixels_len)

xcb_query_colors_cookie_t xcb_query_colors (xcb_connection_t *c, xcb_colormap_t cmap, uint32_t pixels_len, const uint32_t *pixels)

xcb_query_colors_cookie_t xcb_query_colors_unchecked (xcb_connection_t *c, xcb_colormap_t cmap, uint32_t pixels_len, const uint32_t *pixels)

xcb_rgb_t * xcb_query_colors_colors (const xcb_query_colors_reply_t *R)

int xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R)

xcb_rgb_iterator_t xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R)

xcb_query_colors_reply_t * xcb_query_colors_reply (xcb_connection_t *c, xcb_query_colors_cookie_t cookie, xcb_generic_error_t **e)

int xcb_lookup_color_sizeof (const void *_buffer)

xcb_lookup_color_cookie_t xcb_lookup_color (xcb_connection_t *c, xcb_colormap_t cmap, uint16_t name_len, const char *name)

xcb_lookup_color_cookie_t xcb_lookup_color_unchecked (xcb_connection_t *c, xcb_colormap_t cmap, uint16_t name_len, const char *name)

xcb_lookup_color_reply_t * xcb_lookup_color_reply (xcb_connection_t *c, xcb_lookup_color_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_create_cursor_checked (xcb_connection_t *c, xcb_cursor_t cid, xcb_pixmap_t source, xcb_pixmap_t mask, uint16_t fore_red, uint16_t fore_green, uint16_t fore_blue, uint16_t back_red, uint16_t back_green, uint16_t back_blue, uint16_t x, uint16_t y)

xcb_void_cookie_t xcb_create_cursor (xcb_connection_t *c, xcb_cursor_t cid, xcb_pixmap_t source, xcb_pixmap_t mask, uint16_t fore_red, uint16_t fore_green, uint16_t fore_blue, uint16_t back_red, uint16_t back_green, uint16_t back_blue, uint16_t x, uint16_t y)

xcb_void_cookie_t xcb_create_glyph_cursor_checked (xcb_connection_t *c, xcb_cursor_t cid, xcb_font_t source_font, xcb_font_t mask_font, uint16_t source_char, uint16_t mask_char, uint16_t fore_red, uint16_t fore_green, uint16_t fore_blue, uint16_t back_red, uint16_t back_green, uint16_t back_blue)

create cursor More...

xcb_void_cookie_t xcb_create_glyph_cursor (xcb_connection_t *c, xcb_cursor_t cid, xcb_font_t source_font, xcb_font_t mask_font, uint16_t source_char, uint16_t mask_char, uint16_t fore_red, uint16_t fore_green, uint16_t fore_blue, uint16_t back_red, uint16_t back_green, uint16_t back_blue)

create cursor More...

xcb_void_cookie_t xcb_free_cursor_checked (xcb_connection_t *c, xcb_cursor_t cursor)

Deletes a cursor. More...

xcb_void_cookie_t xcb_free_cursor (xcb_connection_t *c, xcb_cursor_t cursor)

Deletes a cursor. More...

xcb_void_cookie_t xcb_recolor_cursor_checked (xcb_connection_t *c, xcb_cursor_t cursor, uint16_t fore_red, uint16_t fore_green, uint16_t fore_blue, uint16_t back_red, uint16_t back_green, uint16_t back_blue)

xcb_void_cookie_t xcb_recolor_cursor (xcb_connection_t *c, xcb_cursor_t cursor, uint16_t fore_red, uint16_t fore_green, uint16_t fore_blue, uint16_t back_red, uint16_t back_green, uint16_t back_blue)

xcb_query_best_size_cookie_t xcb_query_best_size (xcb_connection_t *c, uint8_t _class, xcb_drawable_t drawable, uint16_t width, uint16_t height)

xcb_query_best_size_cookie_t xcb_query_best_size_unchecked (xcb_connection_t *c, uint8_t _class, xcb_drawable_t drawable, uint16_t width, uint16_t height)

xcb_query_best_size_reply_t * xcb_query_best_size_reply (xcb_connection_t *c, xcb_query_best_size_cookie_t cookie, xcb_generic_error_t **e)

int xcb_query_extension_sizeof (const void *_buffer)

xcb_query_extension_cookie_t xcb_query_extension (xcb_connection_t *c, uint16_t name_len, const char *name)

check if extension is present More...

xcb_query_extension_cookie_t xcb_query_extension_unchecked (xcb_connection_t *c, uint16_t name_len, const char *name)

check if extension is present More...

xcb_query_extension_reply_t * xcb_query_extension_reply (xcb_connection_t *c, xcb_query_extension_cookie_t cookie, xcb_generic_error_t **e)

int xcb_list_extensions_sizeof (const void *_buffer)

xcb_list_extensions_cookie_t xcb_list_extensions (xcb_connection_t *c)

xcb_list_extensions_cookie_t xcb_list_extensions_unchecked (xcb_connection_t *c)

int xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R)

xcb_str_iterator_t xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R)

xcb_list_extensions_reply_t * xcb_list_extensions_reply (xcb_connection_t *c, xcb_list_extensions_cookie_t cookie, xcb_generic_error_t **e)

int xcb_change_keyboard_mapping_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_change_keyboard_mapping_checked (xcb_connection_t *c, uint8_t keycode_count, xcb_keycode_t first_keycode, uint8_t keysyms_per_keycode, const xcb_keysym_t *keysyms)

xcb_void_cookie_t xcb_change_keyboard_mapping (xcb_connection_t *c, uint8_t keycode_count, xcb_keycode_t first_keycode, uint8_t keysyms_per_keycode, const xcb_keysym_t *keysyms)

xcb_keysym_t * xcb_change_keyboard_mapping_keysyms (const xcb_change_keyboard_mapping_request_t *R)

int xcb_change_keyboard_mapping_keysyms_length (const xcb_change_keyboard_mapping_request_t *R)

xcb_generic_iterator_t xcb_change_keyboard_mapping_keysyms_end (const xcb_change_keyboard_mapping_request_t *R)

int xcb_get_keyboard_mapping_sizeof (const void *_buffer)

xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping (xcb_connection_t *c, xcb_keycode_t first_keycode, uint8_t count)

xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c, xcb_keycode_t first_keycode, uint8_t count)

xcb_keysym_t * xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R)

int xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R)

xcb_generic_iterator_t xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R)

xcb_get_keyboard_mapping_reply_t * xcb_get_keyboard_mapping_reply (xcb_connection_t *c, xcb_get_keyboard_mapping_cookie_t cookie, xcb_generic_error_t **e)

int xcb_change_keyboard_control_value_list_serialize (void **_buffer, uint32_t value_mask, const xcb_change_keyboard_control_value_list_t *_aux)

int xcb_change_keyboard_control_value_list_unpack (const void *_buffer, uint32_t value_mask, xcb_change_keyboard_control_value_list_t *_aux)

int xcb_change_keyboard_control_value_list_sizeof (const void *_buffer, uint32_t value_mask)

int xcb_change_keyboard_control_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_change_keyboard_control_checked (xcb_connection_t *c, uint32_t value_mask, const void *value_list)

xcb_void_cookie_t xcb_change_keyboard_control (xcb_connection_t *c, uint32_t value_mask, const void *value_list)

xcb_void_cookie_t xcb_change_keyboard_control_aux_checked (xcb_connection_t *c, uint32_t value_mask, const xcb_change_keyboard_control_value_list_t *value_list)

xcb_void_cookie_t xcb_change_keyboard_control_aux (xcb_connection_t *c, uint32_t value_mask, const xcb_change_keyboard_control_value_list_t *value_list)

void * xcb_change_keyboard_control_value_list (const xcb_change_keyboard_control_request_t *R)

xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control (xcb_connection_t *c)

xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control_unchecked (xcb_connection_t *c)

xcb_get_keyboard_control_reply_t * xcb_get_keyboard_control_reply (xcb_connection_t *c, xcb_get_keyboard_control_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_bell_checked (xcb_connection_t *c, int8_t percent)

xcb_void_cookie_t xcb_bell (xcb_connection_t *c, int8_t percent)

xcb_void_cookie_t xcb_change_pointer_control_checked (xcb_connection_t *c, int16_t acceleration_numerator, int16_t acceleration_denominator, int16_t threshold, uint8_t do_acceleration, uint8_t do_threshold)

xcb_void_cookie_t xcb_change_pointer_control (xcb_connection_t *c, int16_t acceleration_numerator, int16_t acceleration_denominator, int16_t threshold, uint8_t do_acceleration, uint8_t do_threshold)

xcb_get_pointer_control_cookie_t xcb_get_pointer_control (xcb_connection_t *c)

xcb_get_pointer_control_cookie_t xcb_get_pointer_control_unchecked (xcb_connection_t *c)

xcb_get_pointer_control_reply_t * xcb_get_pointer_control_reply (xcb_connection_t *c, xcb_get_pointer_control_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_set_screen_saver_checked (xcb_connection_t *c, int16_t timeout, int16_t interval, uint8_t prefer_blanking, uint8_t allow_exposures)

xcb_void_cookie_t xcb_set_screen_saver (xcb_connection_t *c, int16_t timeout, int16_t interval, uint8_t prefer_blanking, uint8_t allow_exposures)

xcb_get_screen_saver_cookie_t xcb_get_screen_saver (xcb_connection_t *c)

xcb_get_screen_saver_cookie_t xcb_get_screen_saver_unchecked (xcb_connection_t *c)

xcb_get_screen_saver_reply_t * xcb_get_screen_saver_reply (xcb_connection_t *c, xcb_get_screen_saver_cookie_t cookie, xcb_generic_error_t **e)

int xcb_change_hosts_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_change_hosts_checked (xcb_connection_t *c, uint8_t mode, uint8_t family, uint16_t address_len, const uint8_t *address)

xcb_void_cookie_t xcb_change_hosts (xcb_connection_t *c, uint8_t mode, uint8_t family, uint16_t address_len, const uint8_t *address)

uint8_t * xcb_change_hosts_address (const xcb_change_hosts_request_t *R)

int xcb_change_hosts_address_length (const xcb_change_hosts_request_t *R)

xcb_generic_iterator_t xcb_change_hosts_address_end (const xcb_change_hosts_request_t *R)

int xcb_host_sizeof (const void *_buffer)

uint8_t * xcb_host_address (const xcb_host_t *R)

int xcb_host_address_length (const xcb_host_t *R)

xcb_generic_iterator_t xcb_host_address_end (const xcb_host_t *R)

void xcb_host_next (xcb_host_iterator_t *i)

xcb_generic_iterator_t xcb_host_end (xcb_host_iterator_t i)

int xcb_list_hosts_sizeof (const void *_buffer)

xcb_list_hosts_cookie_t xcb_list_hosts (xcb_connection_t *c)

xcb_list_hosts_cookie_t xcb_list_hosts_unchecked (xcb_connection_t *c)

int xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R)

xcb_host_iterator_t xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R)

xcb_list_hosts_reply_t * xcb_list_hosts_reply (xcb_connection_t *c, xcb_list_hosts_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_set_access_control_checked (xcb_connection_t *c, uint8_t mode)

xcb_void_cookie_t xcb_set_access_control (xcb_connection_t *c, uint8_t mode)

xcb_void_cookie_t xcb_set_close_down_mode_checked (xcb_connection_t *c, uint8_t mode)

xcb_void_cookie_t xcb_set_close_down_mode (xcb_connection_t *c, uint8_t mode)

xcb_void_cookie_t xcb_kill_client_checked (xcb_connection_t *c, uint32_t resource)

kills a client More...

xcb_void_cookie_t xcb_kill_client (xcb_connection_t *c, uint32_t resource)

kills a client More...

int xcb_rotate_properties_sizeof (const void *_buffer)

xcb_void_cookie_t xcb_rotate_properties_checked (xcb_connection_t *c, xcb_window_t window, uint16_t atoms_len, int16_t delta, const xcb_atom_t *atoms)

xcb_void_cookie_t xcb_rotate_properties (xcb_connection_t *c, xcb_window_t window, uint16_t atoms_len, int16_t delta, const xcb_atom_t *atoms)

xcb_atom_t * xcb_rotate_properties_atoms (const xcb_rotate_properties_request_t *R)

int xcb_rotate_properties_atoms_length (const xcb_rotate_properties_request_t *R)

xcb_generic_iterator_t xcb_rotate_properties_atoms_end (const xcb_rotate_properties_request_t *R)

xcb_void_cookie_t xcb_force_screen_saver_checked (xcb_connection_t *c, uint8_t mode)

xcb_void_cookie_t xcb_force_screen_saver (xcb_connection_t *c, uint8_t mode)

int xcb_set_pointer_mapping_sizeof (const void *_buffer)

xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping (xcb_connection_t *c, uint8_t map_len, const uint8_t *map)

xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping_unchecked (xcb_connection_t *c, uint8_t map_len, const uint8_t *map)

xcb_set_pointer_mapping_reply_t * xcb_set_pointer_mapping_reply (xcb_connection_t *c, xcb_set_pointer_mapping_cookie_t cookie, xcb_generic_error_t **e)

int xcb_get_pointer_mapping_sizeof (const void *_buffer)

xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping (xcb_connection_t *c)

xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping_unchecked (xcb_connection_t *c)

uint8_t * xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R)

int xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R)

xcb_generic_iterator_t xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R)

xcb_get_pointer_mapping_reply_t * xcb_get_pointer_mapping_reply (xcb_connection_t *c, xcb_get_pointer_mapping_cookie_t cookie, xcb_generic_error_t **e)

int xcb_set_modifier_mapping_sizeof (const void *_buffer)

xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping (xcb_connection_t *c, uint8_t keycodes_per_modifier, const xcb_keycode_t *keycodes)

xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping_unchecked (xcb_connection_t *c, uint8_t keycodes_per_modifier, const xcb_keycode_t *keycodes)

xcb_set_modifier_mapping_reply_t * xcb_set_modifier_mapping_reply (xcb_connection_t *c, xcb_set_modifier_mapping_cookie_t cookie, xcb_generic_error_t **e)

int xcb_get_modifier_mapping_sizeof (const void *_buffer)

xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping (xcb_connection_t *c)

xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping_unchecked (xcb_connection_t *c)

xcb_keycode_t * xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R)

int xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R)

xcb_generic_iterator_t xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R)

xcb_get_modifier_mapping_reply_t * xcb_get_modifier_mapping_reply (xcb_connection_t *c, xcb_get_modifier_mapping_cookie_t cookie, xcb_generic_error_t **e)

xcb_void_cookie_t xcb_no_operation_checked (xcb_connection_t *c)

xcb_void_cookie_t xcb_no_operation (xcb_connection_t *c)

Detailed Description

XCB Protocol Implementation.

Macro Definition Documentation

#define XCB_ACCESS 10

Opcode for xcb_access.

#define XCB_ALLOC 11

Opcode for xcb_alloc.

#define XCB_ALLOC_COLOR 84

Opcode for xcb_alloc_color.

Referenced by xcb_alloc_color(), and xcb_alloc_color_unchecked().

#define XCB_ALLOC_COLOR_CELLS 86

Opcode for xcb_alloc_color_cells.

Referenced by xcb_alloc_color_cells(), and xcb_alloc_color_cells_unchecked().

#define XCB_ALLOC_COLOR_PLANES 87

Opcode for xcb_alloc_color_planes.

Referenced by xcb_alloc_color_planes(), and xcb_alloc_color_planes_unchecked().

#define XCB_ALLOC_NAMED_COLOR 85

Opcode for xcb_alloc_named_color.

Referenced by xcb_alloc_named_color(), and xcb_alloc_named_color_unchecked().

#define XCB_ALLOW_EVENTS 35

Opcode for xcb_allow_events.

Referenced by xcb_allow_events(), and xcb_allow_events_checked().

#define XCB_ATOM 5

Opcode for xcb_atom.

#define XCB_BELL 104

Opcode for xcb_bell.

Referenced by xcb_bell(), and xcb_bell_checked().

#define XCB_BUTTON_PRESS 4

Opcode for xcb_button_press.

#define XCB_BUTTON_RELEASE 5

Opcode for xcb_button_release.

#define XCB_CHANGE_ACTIVE_POINTER_GRAB 30

Opcode for xcb_change_active_pointer_grab.

Referenced by xcb_change_active_pointer_grab(), and xcb_change_active_pointer_grab_checked().

#define XCB_CHANGE_GC 56

Opcode for xcb_change_gc.

Referenced by xcb_change_gc(), xcb_change_gc_aux(), xcb_change_gc_aux_checked(), and xcb_change_gc_checked().

#define XCB_CHANGE_HOSTS 109

Opcode for xcb_change_hosts.

Referenced by xcb_change_hosts(), and xcb_change_hosts_checked().

#define XCB_CHANGE_KEYBOARD_CONTROL 102

Opcode for xcb_change_keyboard_control.

Referenced by xcb_change_keyboard_control(), xcb_change_keyboard_control_aux(), xcb_change_keyboard_control_aux_checked(), and xcb_change_keyboard_control_checked().

#define XCB_CHANGE_KEYBOARD_MAPPING 100

Opcode for xcb_change_keyboard_mapping.

Referenced by xcb_change_keyboard_mapping(), and xcb_change_keyboard_mapping_checked().

#define XCB_CHANGE_POINTER_CONTROL 105

Opcode for xcb_change_pointer_control.

Referenced by xcb_change_pointer_control(), and xcb_change_pointer_control_checked().

#define XCB_CHANGE_PROPERTY 18

Opcode for xcb_change_property.

Referenced by xcb_change_property(), and xcb_change_property_checked().

#define XCB_CHANGE_SAVE_SET 6

Opcode for xcb_change_save_set.

Referenced by xcb_change_save_set(), and xcb_change_save_set_checked().

#define XCB_CHANGE_WINDOW_ATTRIBUTES 2

Opcode for xcb_change_window_attributes.

Referenced by xcb_change_window_attributes(), xcb_change_window_attributes_aux(), xcb_change_window_attributes_aux_checked(), and xcb_change_window_attributes_checked().

#define XCB_CIRCULATE_NOTIFY 26

Opcode for xcb_circulate_notify.

#define XCB_CIRCULATE_REQUEST 27

Opcode for xcb_circulate_request.

#define XCB_CIRCULATE_WINDOW 13

Opcode for xcb_circulate_window.

Referenced by xcb_circulate_window(), and xcb_circulate_window_checked().

#define XCB_CLEAR_AREA 61

Opcode for xcb_clear_area.

Referenced by xcb_clear_area(), and xcb_clear_area_checked().

#define XCB_CLIENT_MESSAGE 33

Opcode for xcb_client_message.

#define XCB_CLOSE_FONT 46

Opcode for xcb_close_font.

Referenced by xcb_close_font(), and xcb_close_font_checked().

#define XCB_COLORMAP 12

Opcode for xcb_colormap.

#define XCB_COLORMAP_NOTIFY 32

Opcode for xcb_colormap_notify.

#define XCB_CONFIGURE_NOTIFY 22

Opcode for xcb_configure_notify.

#define XCB_CONFIGURE_REQUEST 23

Opcode for xcb_configure_request.

#define XCB_CONFIGURE_WINDOW 12

Opcode for xcb_configure_window.

Referenced by xcb_configure_window(), xcb_configure_window_aux(), xcb_configure_window_aux_checked(), and xcb_configure_window_checked().

#define XCB_CONVERT_SELECTION 24

Opcode for xcb_convert_selection.

Referenced by xcb_convert_selection(), and xcb_convert_selection_checked().

#define XCB_COPY_AREA 62

Opcode for xcb_copy_area.

Referenced by xcb_copy_area(), and xcb_copy_area_checked().

#define XCB_COPY_COLORMAP_AND_FREE 80

Opcode for xcb_copy_colormap_and_free.

Referenced by xcb_copy_colormap_and_free(), and xcb_copy_colormap_and_free_checked().

#define XCB_COPY_GC 57

Opcode for xcb_copy_gc.

Referenced by xcb_copy_gc(), and xcb_copy_gc_checked().

#define XCB_COPY_PLANE 63

Opcode for xcb_copy_plane.

Referenced by xcb_copy_plane(), and xcb_copy_plane_checked().

#define XCB_CREATE_COLORMAP 78

Opcode for xcb_create_colormap.

Referenced by xcb_create_colormap(), and xcb_create_colormap_checked().

#define XCB_CREATE_CURSOR 93

Opcode for xcb_create_cursor.

Referenced by xcb_create_cursor(), and xcb_create_cursor_checked().

#define XCB_CREATE_GC 55

Opcode for xcb_create_gc.

Referenced by xcb_create_gc(), xcb_create_gc_aux(), xcb_create_gc_aux_checked(), and xcb_create_gc_checked().

#define XCB_CREATE_GLYPH_CURSOR 94

Opcode for xcb_create_glyph_cursor.

Referenced by xcb_create_glyph_cursor(), and xcb_create_glyph_cursor_checked().

#define XCB_CREATE_NOTIFY 16

Opcode for xcb_create_notify.

#define XCB_CREATE_PIXMAP 53

Opcode for xcb_create_pixmap.

Referenced by xcb_create_pixmap(), and xcb_create_pixmap_checked().

#define XCB_CREATE_WINDOW 1

Opcode for xcb_create_window.

Referenced by xcb_create_window(), xcb_create_window_aux(), xcb_create_window_aux_checked(), and xcb_create_window_checked().

#define XCB_CURSOR 6

Opcode for xcb_cursor.

#define XCB_DELETE_PROPERTY 19

Opcode for xcb_delete_property.

Referenced by xcb_delete_property(), and xcb_delete_property_checked().

#define XCB_DESTROY_NOTIFY 17

Opcode for xcb_destroy_notify.

#define XCB_DESTROY_SUBWINDOWS 5

Opcode for xcb_destroy_subwindows.

Referenced by xcb_destroy_subwindows(), and xcb_destroy_subwindows_checked().

#define XCB_DESTROY_WINDOW 4

Opcode for xcb_destroy_window.

Referenced by xcb_destroy_window(), and xcb_destroy_window_checked().

#define XCB_DRAWABLE 9

Opcode for xcb_drawable.

#define XCB_ENTER_NOTIFY 7

Opcode for xcb_enter_notify.

#define XCB_EXPOSE 12

Opcode for xcb_expose.

#define XCB_FILL_POLY 69

Opcode for xcb_fill_poly.

Referenced by xcb_fill_poly(), and xcb_fill_poly_checked().

#define XCB_FOCUS_IN 9

Opcode for xcb_focus_in.

#define XCB_FOCUS_OUT 10

Opcode for xcb_focus_out.

#define XCB_FONT 7

Opcode for xcb_font.

#define XCB_FORCE_SCREEN_SAVER 115

Opcode for xcb_force_screen_saver.

Referenced by xcb_force_screen_saver(), and xcb_force_screen_saver_checked().

#define XCB_FREE_COLORMAP 79

Opcode for xcb_free_colormap.

Referenced by xcb_free_colormap(), and xcb_free_colormap_checked().

#define XCB_FREE_COLORS 88

Opcode for xcb_free_colors.

Referenced by xcb_free_colors(), and xcb_free_colors_checked().

#define XCB_FREE_CURSOR 95

Opcode for xcb_free_cursor.

Referenced by xcb_free_cursor(), and xcb_free_cursor_checked().

#define XCB_FREE_GC 60

Opcode for xcb_free_gc.

Referenced by xcb_free_gc(), and xcb_free_gc_checked().

#define XCB_FREE_PIXMAP 54

Opcode for xcb_free_pixmap.

Referenced by xcb_free_pixmap(), and xcb_free_pixmap_checked().

#define XCB_G_CONTEXT 13

Opcode for xcb_g_context.

#define XCB_GE_GENERIC 35

Opcode for xcb_ge_generic.

#define XCB_GET_ATOM_NAME 17

Opcode for xcb_get_atom_name.

Referenced by xcb_get_atom_name(), and xcb_get_atom_name_unchecked().

#define XCB_GET_FONT_PATH 52

Opcode for xcb_get_font_path.

Referenced by xcb_get_font_path(), and xcb_get_font_path_unchecked().

#define XCB_GET_GEOMETRY 14

Opcode for xcb_get_geometry.

Referenced by xcb_get_geometry(), and xcb_get_geometry_unchecked().

#define XCB_GET_IMAGE 73

Opcode for xcb_get_image.

Referenced by xcb_get_image(), and xcb_get_image_unchecked().

#define XCB_GET_INPUT_FOCUS 43

Opcode for xcb_get_input_focus.

Referenced by xcb_get_input_focus(), and xcb_get_input_focus_unchecked().

#define XCB_GET_KEYBOARD_CONTROL 103

Opcode for xcb_get_keyboard_control.

Referenced by xcb_get_keyboard_control(), and xcb_get_keyboard_control_unchecked().

#define XCB_GET_KEYBOARD_MAPPING 101

Opcode for xcb_get_keyboard_mapping.

Referenced by xcb_get_keyboard_mapping(), and xcb_get_keyboard_mapping_unchecked().

#define XCB_GET_MODIFIER_MAPPING 119

Opcode for xcb_get_modifier_mapping.

Referenced by xcb_get_modifier_mapping(), and xcb_get_modifier_mapping_unchecked().

#define XCB_GET_MOTION_EVENTS 39

Opcode for xcb_get_motion_events.

Referenced by xcb_get_motion_events(), and xcb_get_motion_events_unchecked().

#define XCB_GET_POINTER_CONTROL 106

Opcode for xcb_get_pointer_control.

Referenced by xcb_get_pointer_control(), and xcb_get_pointer_control_unchecked().

#define XCB_GET_POINTER_MAPPING 117

Opcode for xcb_get_pointer_mapping.

Referenced by xcb_get_pointer_mapping(), and xcb_get_pointer_mapping_unchecked().

#define XCB_GET_PROPERTY 20

Opcode for xcb_get_property.

Referenced by xcb_get_property(), and xcb_get_property_unchecked().

#define XCB_GET_SCREEN_SAVER 108

Opcode for xcb_get_screen_saver.

Referenced by xcb_get_screen_saver(), and xcb_get_screen_saver_unchecked().

#define XCB_GET_SELECTION_OWNER 23

Opcode for xcb_get_selection_owner.

Referenced by xcb_get_selection_owner(), and xcb_get_selection_owner_unchecked().

#define XCB_GET_WINDOW_ATTRIBUTES 3

Opcode for xcb_get_window_attributes.

Referenced by xcb_get_window_attributes(), and xcb_get_window_attributes_unchecked().

#define XCB_GRAB_BUTTON 28

Opcode for xcb_grab_button.

Referenced by xcb_grab_button(), and xcb_grab_button_checked().

#define XCB_GRAB_KEY 33

Opcode for xcb_grab_key.

Referenced by xcb_grab_key(), and xcb_grab_key_checked().

#define XCB_GRAB_KEYBOARD 31

Opcode for xcb_grab_keyboard.

Referenced by xcb_grab_keyboard(), and xcb_grab_keyboard_unchecked().

#define XCB_GRAB_POINTER 26

Opcode for xcb_grab_pointer.

Referenced by xcb_grab_pointer(), and xcb_grab_pointer_unchecked().

#define XCB_GRAB_SERVER 36

Opcode for xcb_grab_server.

Referenced by xcb_grab_server(), and xcb_grab_server_checked().

#define XCB_GRAPHICS_EXPOSURE 13

Opcode for xcb_graphics_exposure.

#define XCB_GRAVITY_NOTIFY 24

Opcode for xcb_gravity_notify.

#define XCB_ID_CHOICE 14

Opcode for xcb_id_choice.

#define XCB_IMAGE_TEXT_16 77

Opcode for xcb_image_text_16.

Referenced by xcb_image_text_16(), and xcb_image_text_16_checked().

#define XCB_IMAGE_TEXT_8 76

Opcode for xcb_image_text_8.

Referenced by xcb_image_text_8(), and xcb_image_text_8_checked().

#define XCB_IMPLEMENTATION 17

Opcode for xcb_implementation.

#define XCB_INSTALL_COLORMAP 81

Opcode for xcb_install_colormap.

Referenced by xcb_install_colormap(), and xcb_install_colormap_checked().

#define XCB_INTERN_ATOM 16

Opcode for xcb_intern_atom.

Referenced by xcb_intern_atom(), and xcb_intern_atom_unchecked().

#define XCB_KEY_PRESS 2

Opcode for xcb_key_press.

#define XCB_KEY_RELEASE 3

Opcode for xcb_key_release.

#define XCB_KEYMAP_NOTIFY 11

Opcode for xcb_keymap_notify.

#define XCB_KILL_CLIENT 113

Opcode for xcb_kill_client.

Referenced by xcb_kill_client(), and xcb_kill_client_checked().

#define XCB_LEAVE_NOTIFY 8

Opcode for xcb_leave_notify.

#define XCB_LENGTH 16

Opcode for xcb_length.

#define XCB_LIST_EXTENSIONS 99

Opcode for xcb_list_extensions.

Referenced by xcb_list_extensions(), and xcb_list_extensions_unchecked().

#define XCB_LIST_FONTS 49

Opcode for xcb_list_fonts.

Referenced by xcb_list_fonts(), and xcb_list_fonts_unchecked().

#define XCB_LIST_FONTS_WITH_INFO 50

Opcode for xcb_list_fonts_with_info.

Referenced by xcb_list_fonts_with_info(), and xcb_list_fonts_with_info_unchecked().

#define XCB_LIST_HOSTS 110

Opcode for xcb_list_hosts.

Referenced by xcb_list_hosts(), and xcb_list_hosts_unchecked().

#define XCB_LIST_INSTALLED_COLORMAPS 83

Opcode for xcb_list_installed_colormaps.

Referenced by xcb_list_installed_colormaps(), and xcb_list_installed_colormaps_unchecked().

#define XCB_LIST_PROPERTIES 21

Opcode for xcb_list_properties.

Referenced by xcb_list_properties(), and xcb_list_properties_unchecked().

#define XCB_LOOKUP_COLOR 92

Opcode for xcb_lookup_color.

Referenced by xcb_lookup_color(), and xcb_lookup_color_unchecked().

#define XCB_MAP_NOTIFY 19

Opcode for xcb_map_notify.

#define XCB_MAP_REQUEST 20

Opcode for xcb_map_request.

#define XCB_MAP_SUBWINDOWS 9

Opcode for xcb_map_subwindows.

Referenced by xcb_map_subwindows(), and xcb_map_subwindows_checked().

#define XCB_MAP_WINDOW 8

Opcode for xcb_map_window.

Referenced by xcb_map_window(), and xcb_map_window_checked().

#define XCB_MAPPING_NOTIFY 34

Opcode for xcb_mapping_notify.

#define XCB_MATCH 8

Opcode for xcb_match.

#define XCB_MOTION_NOTIFY 6

Opcode for xcb_motion_notify.

#define XCB_NAME 15

Opcode for xcb_name.

#define XCB_NO_EXPOSURE 14

Opcode for xcb_no_exposure.

#define XCB_NO_OPERATION 127

Opcode for xcb_no_operation.

Referenced by xcb_no_operation(), and xcb_no_operation_checked().

#define XCB_OPEN_FONT 45

Opcode for xcb_open_font.

Referenced by xcb_open_font(), and xcb_open_font_checked().

#define XCB_PIXMAP 4

Opcode for xcb_pixmap.

#define XCB_POLY_ARC 68

Opcode for xcb_poly_arc.

Referenced by xcb_poly_arc(), and xcb_poly_arc_checked().

#define XCB_POLY_FILL_ARC 71

Opcode for xcb_poly_fill_arc.

Referenced by xcb_poly_fill_arc(), and xcb_poly_fill_arc_checked().

#define XCB_POLY_FILL_RECTANGLE 70

Opcode for xcb_poly_fill_rectangle.

Referenced by xcb_poly_fill_rectangle(), and xcb_poly_fill_rectangle_checked().

#define XCB_POLY_LINE 65

Opcode for xcb_poly_line.

Referenced by xcb_poly_line(), and xcb_poly_line_checked().

#define XCB_POLY_POINT 64

Opcode for xcb_poly_point.

Referenced by xcb_poly_point(), and xcb_poly_point_checked().

#define XCB_POLY_RECTANGLE 67

Opcode for xcb_poly_rectangle.

Referenced by xcb_poly_rectangle(), and xcb_poly_rectangle_checked().

#define XCB_POLY_SEGMENT 66

Opcode for xcb_poly_segment.

Referenced by xcb_poly_segment(), and xcb_poly_segment_checked().

#define XCB_POLY_TEXT_16 75

Opcode for xcb_poly_text_16.

Referenced by xcb_poly_text_16(), and xcb_poly_text_16_checked().

#define XCB_POLY_TEXT_8 74

Opcode for xcb_poly_text_8.

Referenced by xcb_poly_text_8(), and xcb_poly_text_8_checked().

#define XCB_PROPERTY_NOTIFY 28

Opcode for xcb_property_notify.

#define XCB_PUT_IMAGE 72

Opcode for xcb_put_image.

Referenced by xcb_put_image(), and xcb_put_image_checked().

#define XCB_QUERY_BEST_SIZE 97

Opcode for xcb_query_best_size.

Referenced by xcb_query_best_size(), and xcb_query_best_size_unchecked().

#define XCB_QUERY_COLORS 91

Opcode for xcb_query_colors.

Referenced by xcb_query_colors(), and xcb_query_colors_unchecked().

#define XCB_QUERY_EXTENSION 98

Opcode for xcb_query_extension.

Referenced by xcb_query_extension(), and xcb_query_extension_unchecked().

#define XCB_QUERY_FONT 47

Opcode for xcb_query_font.

Referenced by xcb_query_font(), and xcb_query_font_unchecked().

#define XCB_QUERY_KEYMAP 44

Opcode for xcb_query_keymap.

Referenced by xcb_query_keymap(), and xcb_query_keymap_unchecked().

#define XCB_QUERY_POINTER 38

Opcode for xcb_query_pointer.

Referenced by xcb_query_pointer(), and xcb_query_pointer_unchecked().

#define XCB_QUERY_TEXT_EXTENTS 48

Opcode for xcb_query_text_extents.

Referenced by xcb_query_text_extents(), and xcb_query_text_extents_unchecked().

#define XCB_QUERY_TREE 15

Opcode for xcb_query_tree.

Referenced by xcb_query_tree(), and xcb_query_tree_unchecked().

#define XCB_RECOLOR_CURSOR 96

Opcode for xcb_recolor_cursor.

Referenced by xcb_recolor_cursor(), and xcb_recolor_cursor_checked().

#define XCB_REPARENT_NOTIFY 21

Opcode for xcb_reparent_notify.

#define XCB_REPARENT_WINDOW 7

Opcode for xcb_reparent_window.

Referenced by xcb_reparent_window(), and xcb_reparent_window_checked().

#define XCB_REQUEST 1

Opcode for xcb_request.

#define XCB_RESIZE_REQUEST 25

Opcode for xcb_resize_request.

#define XCB_ROTATE_PROPERTIES 114

Opcode for xcb_rotate_properties.

Referenced by xcb_rotate_properties(), and xcb_rotate_properties_checked().

#define XCB_SELECTION_CLEAR 29

Opcode for xcb_selection_clear.

#define XCB_SELECTION_NOTIFY 31

Opcode for xcb_selection_notify.

#define XCB_SELECTION_REQUEST 30

Opcode for xcb_selection_request.

#define XCB_SEND_EVENT 25

Opcode for xcb_send_event.

Referenced by xcb_send_event(), and xcb_send_event_checked().

#define XCB_SET_ACCESS_CONTROL 111

Opcode for xcb_set_access_control.

Referenced by xcb_set_access_control(), and xcb_set_access_control_checked().

#define XCB_SET_CLIP_RECTANGLES 59

Opcode for xcb_set_clip_rectangles.

Referenced by xcb_set_clip_rectangles(), and xcb_set_clip_rectangles_checked().

#define XCB_SET_CLOSE_DOWN_MODE 112

Opcode for xcb_set_close_down_mode.

Referenced by xcb_set_close_down_mode(), and xcb_set_close_down_mode_checked().

#define XCB_SET_DASHES 58

Opcode for xcb_set_dashes.

Referenced by xcb_set_dashes(), and xcb_set_dashes_checked().

#define XCB_SET_FONT_PATH 51

Opcode for xcb_set_font_path.

Referenced by xcb_set_font_path(), and xcb_set_font_path_checked().

#define XCB_SET_INPUT_FOCUS 42

Opcode for xcb_set_input_focus.

Referenced by xcb_set_input_focus(), and xcb_set_input_focus_checked().

#define XCB_SET_MODIFIER_MAPPING 118

Opcode for xcb_set_modifier_mapping.

Referenced by xcb_set_modifier_mapping(), and xcb_set_modifier_mapping_unchecked().

#define XCB_SET_POINTER_MAPPING 116

Opcode for xcb_set_pointer_mapping.

Referenced by xcb_set_pointer_mapping(), and xcb_set_pointer_mapping_unchecked().

#define XCB_SET_SCREEN_SAVER 107

Opcode for xcb_set_screen_saver.

Referenced by xcb_set_screen_saver(), and xcb_set_screen_saver_checked().

#define XCB_SET_SELECTION_OWNER 22

Opcode for xcb_set_selection_owner.

Referenced by xcb_set_selection_owner(), and xcb_set_selection_owner_checked().

#define XCB_STORE_COLORS 89

Opcode for xcb_store_colors.

Referenced by xcb_store_colors(), and xcb_store_colors_checked().

#define XCB_STORE_NAMED_COLOR 90

Opcode for xcb_store_named_color.

Referenced by xcb_store_named_color(), and xcb_store_named_color_checked().

#define XCB_TRANSLATE_COORDINATES 40

Opcode for xcb_translate_coordinates.

Referenced by xcb_translate_coordinates(), and xcb_translate_coordinates_unchecked().

#define XCB_UNGRAB_BUTTON 29

Opcode for xcb_ungrab_button.

Referenced by xcb_ungrab_button(), and xcb_ungrab_button_checked().

#define XCB_UNGRAB_KEY 34

Opcode for xcb_ungrab_key.

Referenced by xcb_ungrab_key(), and xcb_ungrab_key_checked().

#define XCB_UNGRAB_KEYBOARD 32

Opcode for xcb_ungrab_keyboard.

Referenced by xcb_ungrab_keyboard(), and xcb_ungrab_keyboard_checked().

#define XCB_UNGRAB_POINTER 27

Opcode for xcb_ungrab_pointer.

Referenced by xcb_ungrab_pointer(), and xcb_ungrab_pointer_checked().

#define XCB_UNGRAB_SERVER 37

Opcode for xcb_ungrab_server.

Referenced by xcb_ungrab_server(), and xcb_ungrab_server_checked().

#define XCB_UNINSTALL_COLORMAP 82

Opcode for xcb_uninstall_colormap.

Referenced by xcb_uninstall_colormap(), and xcb_uninstall_colormap_checked().

#define XCB_UNMAP_NOTIFY 18

Opcode for xcb_unmap_notify.

#define XCB_UNMAP_SUBWINDOWS 11

Opcode for xcb_unmap_subwindows.

Referenced by xcb_unmap_subwindows(), and xcb_unmap_subwindows_checked().

#define XCB_UNMAP_WINDOW 10

Opcode for xcb_unmap_window.

Referenced by xcb_unmap_window(), and xcb_unmap_window_checked().

#define XCB_VALUE 2

Opcode for xcb_value.

#define XCB_VISIBILITY_NOTIFY 15

Opcode for xcb_visibility_notify.

#define XCB_WARP_POINTER 41

Opcode for xcb_warp_pointer.

Referenced by xcb_warp_pointer(), and xcb_warp_pointer_checked().

#define XCB_WINDOW 3

Opcode for xcb_window.

Enumeration Type Documentation

enum xcb_allow_t

EnumeratorXCB_ALLOW_ASYNC_POINTER

For AsyncPointer, if the pointer is frozen by the client, pointer event processing continues normally. If the pointer is frozen twice by the client on behalf of two separate grabs, AsyncPointer thaws for both. AsyncPointer has no effect if the pointer is not frozen by the client, but the pointer need not be grabbed by the client.

TODO: rewrite this in more understandable terms.

XCB_ALLOW_SYNC_POINTER

For SyncPointer, if the pointer is frozen and actively grabbed by the client, pointer event processing continues normally until the next ButtonPress or ButtonRelease event is reported to the client, at which time the pointer again appears to freeze. However, if the reported event causes the pointer grab to be released, then the pointer does not freeze. SyncPointer has no effect if the pointer is not frozen by the client or if the pointer is not grabbed by the client.

XCB_ALLOW_REPLAY_POINTER

For ReplayPointer, if the pointer is actively grabbed by the client and is frozen as the result of an event having been sent to the client (either from the activation of a GrabButton or from a previous AllowEvents with mode SyncPointer but not from a GrabPointer), then the pointer grab is released and that event is completely reprocessed, this time ignoring any passive grabs at or above (towards the root) the grab-window of the grab just released. The request has no effect if the pointer is not grabbed by the client or if the pointer is not frozen as the result of an event.

XCB_ALLOW_ASYNC_KEYBOARD

For AsyncKeyboard, if the keyboard is frozen by the client, keyboard event processing continues normally. If the keyboard is frozen twice by the client on behalf of two separate grabs, AsyncKeyboard thaws for both. AsyncKeyboard has no effect if the keyboard is not frozen by the client, but the keyboard need not be grabbed by the client.

XCB_ALLOW_SYNC_KEYBOARD

For SyncKeyboard, if the keyboard is frozen and actively grabbed by the client, keyboard event processing continues normally until the next KeyPress or KeyRelease event is reported to the client, at which time the keyboard again appears to freeze. However, if the reported event causes the keyboard grab to be released, then the keyboard does not freeze. SyncKeyboard has no effect if the keyboard is not frozen by the client or if the keyboard is not grabbed by the client.

XCB_ALLOW_REPLAY_KEYBOARD

For ReplayKeyboard, if the keyboard is actively grabbed by the client and is frozen as the result of an event having been sent to the client (either from the activation of a GrabKey or from a previous AllowEvents with mode SyncKeyboard but not from a GrabKeyboard), then the keyboard grab is released and that event is completely reprocessed, this time ignoring any passive grabs at or above (towards the root) the grab-window of the grab just released. The request has no effect if the keyboard is not grabbed by the client or if the keyboard is not frozen as the result of an event.

XCB_ALLOW_ASYNC_BOTH

For AsyncBoth, if the pointer and the keyboard are frozen by the client, event processing for both devices continues normally. If a device is frozen twice by the client on behalf of two separate grabs, AsyncBoth thaws for both. AsyncBoth has no effect unless both pointer and keyboard are frozen by the client.

XCB_ALLOW_SYNC_BOTH

For SyncBoth, if both pointer and keyboard are frozen by the client, event processing (for both devices) continues normally until the next ButtonPress, ButtonRelease, KeyPress, or KeyRelease event is reported to the client for a grabbed device (button event for the pointer, key event for the keyboard), at which time the devices again appear to freeze. However, if the reported event causes the grab to be released, then the devices do not freeze (but if the other device is still grabbed, then a subsequent event for it will still cause both devices to freeze). SyncBoth has no effect unless both pointer and keyboard are frozen by the client. If the pointer or keyboard is frozen twice by the client on behalf of two separate grabs, SyncBoth thaws for both (but a subsequent freeze for SyncBoth will only freeze each device once).

enum xcb_button_index_t

EnumeratorXCB_BUTTON_INDEX_ANY

Any of the following (or none):

XCB_BUTTON_INDEX_1

The left mouse button.

XCB_BUTTON_INDEX_2

The right mouse button.

XCB_BUTTON_INDEX_3

The middle mouse button.

XCB_BUTTON_INDEX_4

Scroll wheel. TODO: direction?

XCB_BUTTON_INDEX_5

Scroll wheel. TODO: direction?

enum xcb_colormap_state_t

EnumeratorXCB_COLORMAP_STATE_UNINSTALLED

The colormap was uninstalled.

XCB_COLORMAP_STATE_INSTALLED

The colormap was installed.

enum xcb_coord_mode_t

EnumeratorXCB_COORD_MODE_ORIGIN

Treats all coordinates as relative to the origin.

XCB_COORD_MODE_PREVIOUS

Treats all coordinates after the first as relative to the previous coordinate.

enum xcb_cw_t

EnumeratorXCB_CW_BACK_PIXMAP

Overrides the default background-pixmap. The background pixmap and window must have the same root and same depth. Any size pixmap can be used, although some sizes may be faster than others.

If XCB_BACK_PIXMAP_NONE is specified, the window has no defined background. The server may fill the contents with the previous screen contents or with contents of its own choosing.

If XCB_BACK_PIXMAP_PARENT_RELATIVE is specified, the parent's background is used, but the window must have the same depth as the parent (or a Match error results). The parent's background is tracked, and the current version is used each time the window background is required.

XCB_CW_BACK_PIXEL

Overrides BackPixmap. A pixmap of undefined size filled with the specified background pixel is used for the background. Range-checking is not performed, the background pixel is truncated to the appropriate number of bits.

XCB_CW_BORDER_PIXMAP

Overrides the default border-pixmap. The border pixmap and window must have the same root and the same depth. Any size pixmap can be used, although some sizes may be faster than others.

The special value XCB_COPY_FROM_PARENT means the parent's border pixmap is copied (subsequent changes to the parent's border attribute do not affect the child), but the window must have the same depth as the parent.

XCB_CW_BORDER_PIXEL

Overrides BorderPixmap. A pixmap of undefined size filled with the specified border pixel is used for the border. Range checking is not performed on the border-pixel value, it is truncated to the appropriate number of bits.

XCB_CW_BIT_GRAVITY

Defines which region of the window should be retained if the window is resized.

XCB_CW_WIN_GRAVITY

Defines how the window should be repositioned if the parent is resized (see ConfigureWindow).

XCB_CW_BACKING_STORE

A backing-store of WhenMapped advises the server that maintaining contents of obscured regions when the window is mapped would be beneficial. A backing-store of Always advises the server that maintaining contents even when the window is unmapped would be beneficial. In this case, the server may generate an exposure event when the window is created. A value of NotUseful advises the server that maintaining contents is unnecessary, although a server may still choose to maintain contents while the window is mapped. Note that if the server maintains contents, then the server should maintain complete contents not just the region within the parent boundaries, even if the window is larger than its parent. While the server maintains contents, exposure events will not normally be generated, but the server may stop maintaining contents at any time.

XCB_CW_BACKING_PLANES

The backing-planes indicates (with bits set to 1) which bit planes of the window hold dynamic data that must be preserved in backing-stores and during save-unders.

XCB_CW_BACKING_PIXEL

The backing-pixel specifies what value to use in planes not covered by backing-planes. The server is free to save only the specified bit planes in the backing-store or save-under and regenerate the remaining planes with the specified pixel value. Any bits beyond the specified depth of the window in these values are simply ignored.

XCB_CW_OVERRIDE_REDIRECT

The override-redirect specifies whether map and configure requests on this window should override a SubstructureRedirect on the parent, typically to inform a window manager not to tamper with the window.

XCB_CW_SAVE_UNDER

If 1, the server is advised that when this window is mapped, saving the contents of windows it obscures would be beneficial.

XCB_CW_EVENT_MASK

The event-mask defines which events the client is interested in for this window (or for some event types, inferiors of the window).

XCB_CW_DONT_PROPAGATE

The do-not-propagate-mask defines which events should not be propagated to ancestor windows when no client has the event type selected in this window.

XCB_CW_COLORMAP

The colormap specifies the colormap that best reflects the true colors of the window. Servers capable of supporting multiple hardware colormaps may use this information, and window man- agers may use it for InstallColormap requests. The colormap must have the same visual type and root as the window (or a Match error results). If CopyFromParent is specified, the parent's colormap is copied (subsequent changes to the parent's colormap attribute do not affect the child). However, the window must have the same visual type as the parent (or a Match error results), and the parent must not have a colormap of None (or a Match error results). For an explanation of None, see FreeColormap request. The colormap is copied by sharing the colormap object between the child and the parent, not by making a complete copy of the colormap contents.

XCB_CW_CURSOR

If a cursor is specified, it will be used whenever the pointer is in the window. If None is speci- fied, the parent's cursor will be used when the pointer is in the window, and any change in the parent's cursor will cause an immediate change in the displayed cursor.

enum xcb_gc_t

EnumeratorXCB_GC_FUNCTION

TODO: Refer to GX

XCB_GC_PLANE_MASK

In graphics operations, given a source and destination pixel, the result is computed bitwise on corresponding bits of the pixels; that is, a Boolean operation is performed in each bit plane. The plane-mask restricts the operation to a subset of planes, so the result is: ((src FUNC dst) AND plane-mask) OR (dst AND (NOT plane-mask))

XCB_GC_FOREGROUND

Foreground colorpixel.

XCB_GC_BACKGROUND

Background colorpixel.

XCB_GC_LINE_WIDTH

The line-width is measured in pixels and can be greater than or equal to one, a wide line, or the special value zero, a thin line.

XCB_GC_LINE_STYLE

The line-style defines which sections of a line are drawn: Solid The full path of the line is drawn. DoubleDash The full path of the line is drawn, but the even dashes are filled differently than the odd dashes (see fill-style), with Butt cap-style used where even and odd dashes meet. OnOffDash Only the even dashes are drawn, and cap-style applies to all internal ends of the individual dashes (except NotLast is treated as Butt).

XCB_GC_CAP_STYLE

The cap-style defines how the endpoints of a path are drawn: NotLast The result is equivalent to Butt, except that for a line-width of zero the final endpoint is not drawn. Butt The result is square at the endpoint (perpendicular to the slope of the line) with no projection beyond. Round The result is a circular arc with its diameter equal to the line-width, centered on the endpoint; it is equivalent to Butt for line-width zero. Projecting The result is square at the end, but the path continues beyond the endpoint for a distance equal to half the line-width; it is equivalent to Butt for line-width zero.

XCB_GC_JOIN_STYLE

The join-style defines how corners are drawn for wide lines: Miter The outer edges of the two lines extend to meet at an angle. However, if the angle is less than 11 degrees, a Bevel join-style is used instead. Round The result is a circular arc with a diameter equal to the line-width, centered on the joinpoint. Bevel The result is Butt endpoint styles, and then the triangular notch is filled.

XCB_GC_FILL_STYLE

The fill-style defines the contents of the source for line, text, and fill requests. For all text and fill requests (for example, PolyText8, PolyText16, PolyFillRectangle, FillPoly, and PolyFillArc) as well as for line requests with line-style Solid, (for example, PolyLine, PolySegment, PolyRectangle, PolyArc) and for the even dashes for line requests with line-style OnOffDash or DoubleDash: Solid Foreground Tiled Tile OpaqueStippled A tile with the same width and height as stipple but with background everywhere stipple has a zero and with foreground everywhere stipple has a one Stippled Foreground masked by stipple For the odd dashes for line requests with line-style DoubleDash: Solid Background Tiled Same as for even dashes OpaqueStippled Same as for even dashes Stippled Background masked by stipple

XCB_GC_TILE

The tile/stipple represents an infinite two-dimensional plane with the tile/stipple replicated in all dimensions. When that plane is superimposed on the drawable for use in a graphics operation, the upper-left corner of some instance of the tile/stipple is at the coordinates within the drawable specified by the tile/stipple origin. The tile/stipple and clip origins are interpreted relative to the origin of whatever destination drawable is specified in a graphics request. The tile pixmap must have the same root and depth as the gcontext (or a Match error results). The stipple pixmap must have depth one and must have the same root as the gcontext (or a Match error results). For fill-style Stippled (but not fill-style OpaqueStippled), the stipple pattern is tiled in a single plane and acts as an additional clip mask to be ANDed with the clip-mask. Any size pixmap can be used for tiling or stippling, although some sizes may be faster to use than others.

XCB_GC_STIPPLE

XCB_GC_TILE_STIPPLE_ORIGIN_X

TODO

XCB_GC_TILE_STIPPLE_ORIGIN_Y

TODO

XCB_GC_FONT

Which font to use for the ImageText8 and ImageText16 requests.

XCB_GC_SUBWINDOW_MODE

For ClipByChildren, both source and destination windows are additionally clipped by all viewable InputOutput children. For IncludeInferiors, neither source nor destination window is clipped by inferiors. This will result in including subwindow contents in the source and drawing through subwindow boundaries of the destination. The use of IncludeInferiors with a source or destination window of one depth with mapped inferiors of differing depth is not illegal, but the semantics is undefined by the core protocol.

XCB_GC_GRAPHICS_EXPOSURES

Whether ExposureEvents should be generated (1) or not (0).

The default is 1.

XCB_GC_CLIP_ORIGIN_X

TODO

XCB_GC_CLIP_ORIGIN_Y

TODO

XCB_GC_CLIP_MASK

The clip-mask restricts writes to the destination drawable. Only pixels where the clip-mask has bits set to 1 are drawn. Pixels are not drawn outside the area covered by the clip-mask or where the clip-mask has bits set to 0. The clip-mask affects all graphics requests, but it does not clip sources. The clip-mask origin is interpreted relative to the origin of whatever destination drawable is specified in a graphics request. If a pixmap is specified as the clip-mask, it must have depth 1 and have the same root as the gcontext (or a Match error results). If clip-mask is None, then pixels are always drawn, regardless of the clip origin. The clip-mask can also be set with the SetClipRectangles request.

XCB_GC_DASH_OFFSET

TODO

XCB_GC_DASH_LIST

TODO

XCB_GC_ARC_MODE

TODO

enum xcb_grab_mode_t

EnumeratorXCB_GRAB_MODE_SYNC

The state of the keyboard appears to freeze: No further keyboard events are generated by the server until the grabbing client issues a releasing AllowEvents request or until the keyboard grab is released.

XCB_GRAB_MODE_ASYNC

Keyboard event processing continues normally.

enum xcb_input_focus_t

EnumeratorXCB_INPUT_FOCUS_NONE

The focus reverts to XCB_NONE, so no window will have the input focus.

XCB_INPUT_FOCUS_POINTER_ROOT

The focus reverts to XCB_POINTER_ROOT respectively. When the focus reverts, FocusIn and FocusOut events are generated, but the last-focus-change time is not changed.

XCB_INPUT_FOCUS_PARENT

The focus reverts to the parent (or closest viewable ancestor) and the new revert_to value is XCB_INPUT_FOCUS_NONE.

XCB_INPUT_FOCUS_FOLLOW_KEYBOARD

NOT YET DOCUMENTED. Only relevant for the xinput extension.

enum xcb_place_t

EnumeratorXCB_PLACE_ON_TOP

The window is now on top of all siblings.

XCB_PLACE_ON_BOTTOM

The window is now below all siblings.

enum xcb_prop_mode_t

EnumeratorXCB_PROP_MODE_REPLACE

Discard the previous property value and store the new data.

XCB_PROP_MODE_PREPEND

Insert the new data before the beginning of existing data. The format must match existing property value. If the property is undefined, it is treated as defined with the correct type and format with zero-length data.

XCB_PROP_MODE_APPEND

Insert the new data after the beginning of existing data. The format must match existing property value. If the property is undefined, it is treated as defined with the correct type and format with zero-length data.

Function Documentation

xcb_alloc_color_cookie_t xcb_alloc_color

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint16_t

red,

uint16_t

green,

uint16_t

blue

)

Allocate a color.

Parameters

cThe connection

cmapTODO

redThe red value of your color.

greenThe green value of your color.

blueThe blue value of your color.

ReturnsA cookie

Allocates a read-only colormap entry corresponding to the closest RGB value supported by the hardware. If you are using TrueColor, you can take a shortcut and directly calculate the color pixel value to avoid the round trip. But, for example, on 16-bit color setups (VNC), you can easily get the closest supported RGB value to the RGB value you are specifying.

References XCB_ALLOC_COLOR.

xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells

(

xcb_connection_t *

uint8_t

contiguous,

xcb_colormap_t

cmap,

uint16_t

colors,

uint16_t

planes

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_ALLOC_COLOR_CELLS.

xcb_alloc_color_cells_reply_t* xcb_alloc_color_cells_reply

(

xcb_connection_t *

xcb_alloc_color_cells_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_alloc_color_cells_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells_unchecked

(

xcb_connection_t *

uint8_t

contiguous,

xcb_colormap_t

cmap,

uint16_t

colors,

uint16_t

planes

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_ALLOC_COLOR_CELLS.

xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes

(

xcb_connection_t *

uint8_t

contiguous,

xcb_colormap_t

cmap,

uint16_t

colors,

uint16_t

reds,

uint16_t

greens,

uint16_t

blues

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_ALLOC_COLOR_PLANES.

xcb_alloc_color_planes_reply_t* xcb_alloc_color_planes_reply

(

xcb_connection_t *

xcb_alloc_color_planes_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_alloc_color_planes_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes_unchecked

(

xcb_connection_t *

uint8_t

contiguous,

xcb_colormap_t

cmap,

uint16_t

colors,

uint16_t

reds,

uint16_t

greens,

uint16_t

blues

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_ALLOC_COLOR_PLANES.

xcb_alloc_color_reply_t* xcb_alloc_color_reply

(

xcb_connection_t *

xcb_alloc_color_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_alloc_color_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_alloc_color_cookie_t xcb_alloc_color_unchecked

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint16_t

red,

uint16_t

green,

uint16_t

blue

)

Allocate a color.

Parameters

cThe connection

cmapTODO

redThe red value of your color.

greenThe green value of your color.

blueThe blue value of your color.

ReturnsA cookie

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_ALLOC_COLOR.

xcb_alloc_named_color_cookie_t xcb_alloc_named_color

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint16_t

name_len,

const char *

name

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_ALLOC_NAMED_COLOR.

xcb_alloc_named_color_reply_t* xcb_alloc_named_color_reply

(

xcb_connection_t *

xcb_alloc_named_color_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_alloc_named_color_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_alloc_named_color_cookie_t xcb_alloc_named_color_unchecked

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint16_t

name_len,

const char *

name

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_ALLOC_NAMED_COLOR.

xcb_void_cookie_t xcb_allow_events

(

xcb_connection_t *

uint8_t

mode,

xcb_timestamp_t

time

)

release queued events

Parameters

cThe connection

modeA bitmask of xcb_allow_t values.

mode

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

Releases queued events if the client has caused a device (pointer/keyboard) to freeze due to grabbing it actively. This request has no effect if time is earlier than the last-grab time of the most recent active grab for this client or if time is later than the current X server time.

References XCB_ALLOW_EVENTS.

xcb_void_cookie_t xcb_allow_events_checked

(

xcb_connection_t *

uint8_t

mode,

xcb_timestamp_t

time

)

release queued events

Parameters

cThe connection

modeA bitmask of xcb_allow_t values.

mode

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_ALLOW_EVENTS.

xcb_generic_iterator_t xcb_arc_end

(

xcb_arc_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_arc_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_arc_next

(

xcb_arc_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_arc_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_arc_t)

xcb_generic_iterator_t xcb_atom_end

(

xcb_atom_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_atom_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_atom_next

(

xcb_atom_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_atom_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_atom_t)

xcb_void_cookie_t xcb_bell

(

xcb_connection_t *

int8_t

percent

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_BELL.

xcb_void_cookie_t xcb_bell_checked

(

xcb_connection_t *

int8_t

percent

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_BELL.

xcb_generic_iterator_t xcb_bool32_end

(

xcb_bool32_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_bool32_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_bool32_next

(

xcb_bool32_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_bool32_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_bool32_t)

xcb_generic_iterator_t xcb_button_end

(

xcb_button_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_button_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_button_next

(

xcb_button_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_button_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_button_t)

xcb_void_cookie_t xcb_change_active_pointer_grab

(

xcb_connection_t *

xcb_cursor_t

cursor,

xcb_timestamp_t

time,

uint16_t

event_mask

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CHANGE_ACTIVE_POINTER_GRAB.

xcb_void_cookie_t xcb_change_active_pointer_grab_checked

(

xcb_connection_t *

xcb_cursor_t

cursor,

xcb_timestamp_t

time,

uint16_t

event_mask

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_ACTIVE_POINTER_GRAB.

xcb_void_cookie_t xcb_change_gc

(

xcb_connection_t *

xcb_gcontext_t

gc,

uint32_t

value_mask,

const void *

value_list

)

change graphics context components

Parameters

cThe connection

gcThe graphics context to change.

value_maskA bitmask of xcb_gc_t values.

value_mask

value_listValues for each of the components specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the components specified by value_mask for the specified graphics context.

References XCB_CHANGE_GC.

xcb_void_cookie_t xcb_change_gc_aux

(

xcb_connection_t *

xcb_gcontext_t

gc,

uint32_t

value_mask,

const xcb_change_gc_value_list_t *

value_list

)

change graphics context components

Parameters

cThe connection

gcThe graphics context to change.

value_maskA bitmask of xcb_gc_t values.

value_mask

value_listValues for each of the components specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the components specified by value_mask for the specified graphics context.

References XCB_CHANGE_GC.

xcb_void_cookie_t xcb_change_gc_aux_checked

(

xcb_connection_t *

xcb_gcontext_t

gc,

uint32_t

value_mask,

const xcb_change_gc_value_list_t *

value_list

)

change graphics context components

Parameters

cThe connection

gcThe graphics context to change.

value_maskA bitmask of xcb_gc_t values.

value_mask

value_listValues for each of the components specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the components specified by value_mask for the specified graphics context.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_GC.

xcb_void_cookie_t xcb_change_gc_checked

(

xcb_connection_t *

xcb_gcontext_t

gc,

uint32_t

value_mask,

const void *

value_list

)

change graphics context components

Parameters

cThe connection

gcThe graphics context to change.

value_maskA bitmask of xcb_gc_t values.

value_mask

value_listValues for each of the components specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the components specified by value_mask for the specified graphics context.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_GC.

xcb_void_cookie_t xcb_change_hosts

(

xcb_connection_t *

uint8_t

mode,

uint8_t

family,

uint16_t

address_len,

const uint8_t *

address

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_CHANGE_HOSTS.

xcb_void_cookie_t xcb_change_hosts_checked

(

xcb_connection_t *

uint8_t

mode,

uint8_t

family,

uint16_t

address_len,

const uint8_t *

address

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_HOSTS.

xcb_void_cookie_t xcb_change_keyboard_control

(

xcb_connection_t *

uint32_t

value_mask,

const void *

value_list

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CHANGE_KEYBOARD_CONTROL.

xcb_void_cookie_t xcb_change_keyboard_control_aux

(

xcb_connection_t *

uint32_t

value_mask,

const xcb_change_keyboard_control_value_list_t *

value_list

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CHANGE_KEYBOARD_CONTROL.

xcb_void_cookie_t xcb_change_keyboard_control_aux_checked

(

xcb_connection_t *

uint32_t

value_mask,

const xcb_change_keyboard_control_value_list_t *

value_list

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_KEYBOARD_CONTROL.

xcb_void_cookie_t xcb_change_keyboard_control_checked

(

xcb_connection_t *

uint32_t

value_mask,

const void *

value_list

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_KEYBOARD_CONTROL.

xcb_void_cookie_t xcb_change_keyboard_mapping

(

xcb_connection_t *

uint8_t

keycode_count,

xcb_keycode_t

first_keycode,

uint8_t

keysyms_per_keycode,

const xcb_keysym_t *

keysyms

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_CHANGE_KEYBOARD_MAPPING.

xcb_void_cookie_t xcb_change_keyboard_mapping_checked

(

xcb_connection_t *

uint8_t

keycode_count,

xcb_keycode_t

first_keycode,

uint8_t

keysyms_per_keycode,

const xcb_keysym_t *

keysyms

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_KEYBOARD_MAPPING.

xcb_void_cookie_t xcb_change_pointer_control

(

xcb_connection_t *

int16_t

acceleration_numerator,

int16_t

acceleration_denominator,

int16_t

threshold,

uint8_t

do_acceleration,

uint8_t

do_threshold

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CHANGE_POINTER_CONTROL.

xcb_void_cookie_t xcb_change_pointer_control_checked

(

xcb_connection_t *

int16_t

acceleration_numerator,

int16_t

acceleration_denominator,

int16_t

threshold,

uint8_t

do_acceleration,

uint8_t

do_threshold

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_POINTER_CONTROL.

xcb_void_cookie_t xcb_change_property

(

xcb_connection_t *

uint8_t

mode,

xcb_window_t

window,

xcb_atom_t

property,

xcb_atom_t

type,

uint8_t

format,

uint32_t

data_len,

const void *

data

)

Changes a window property.

Parameters

cThe connection

modeA bitmask of xcb_prop_mode_t values.

mode

windowThe window whose property you want to change.

propertyThe property you want to change (an atom).

typeThe type of the property you want to change (an atom).

formatSpecifies whether the data should be viewed as a list of 8-bit, 16-bit or 32-bit quantities. Possible values are 8, 16 and 32. This information allows the X server to correctly perform byte-swap operations as necessary.

data_lenSpecifies the number of elements (see format).

dataThe property data.

ReturnsA cookie

Sets or updates a property on the specified window. Properties are for example the window title (WM_NAME) or its minimum size (WM_NORMAL_HINTS). Protocols such as EWMH also use properties - for example EWMH defines the window title, encoded as UTF-8 string, in the _NET_WM_NAME property.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_CHANGE_PROPERTY.

xcb_void_cookie_t xcb_change_property_checked

(

xcb_connection_t *

uint8_t

mode,

xcb_window_t

window,

xcb_atom_t

property,

xcb_atom_t

type,

uint8_t

format,

uint32_t

data_len,

const void *

data

)

Changes a window property.

Parameters

cThe connection

modeA bitmask of xcb_prop_mode_t values.

mode

windowThe window whose property you want to change.

propertyThe property you want to change (an atom).

typeThe type of the property you want to change (an atom).

data_lenSpecifies the number of elements (see format).

dataThe property data.

ReturnsA cookie

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_PROPERTY.

xcb_void_cookie_t xcb_change_save_set

(

xcb_connection_t *

uint8_t

mode,

xcb_window_t

window

)

Changes a client's save set.

Parameters

cThe connection

modeA bitmask of #xcb_set_mode_t values.

modeInsert to add the specified window to the save set or Delete to delete it from the save set.

windowThe window to add or delete to/from your save set.

ReturnsA cookie

TODO: explain what the save set is for.

This function either adds or removes the specified window to the client's (your application's) save set.

References XCB_CHANGE_SAVE_SET.

xcb_void_cookie_t xcb_change_save_set_checked

(

xcb_connection_t *

uint8_t

mode,

xcb_window_t

window

)

Changes a client's save set.

Parameters

cThe connection

modeA bitmask of #xcb_set_mode_t values.

modeInsert to add the specified window to the save set or Delete to delete it from the save set.

windowThe window to add or delete to/from your save set.

ReturnsA cookie

TODO: explain what the save set is for.

This function either adds or removes the specified window to the client's (your application's) save set.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_SAVE_SET.

xcb_void_cookie_t xcb_change_window_attributes

(

xcb_connection_t *

xcb_window_t

window,

uint32_t

value_mask,

const void *

value_list

)

change window attributes

Parameters

cThe connection

windowThe window to change.

value_maskA bitmask of xcb_cw_t values.

value_mask

value_listValues for each of the attributes specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the attributes specified by value_mask for the specified window.

References XCB_CHANGE_WINDOW_ATTRIBUTES.

xcb_void_cookie_t xcb_change_window_attributes_aux

(

xcb_connection_t *

xcb_window_t

window,

uint32_t

value_mask,

const xcb_change_window_attributes_value_list_t *

value_list

)

change window attributes

Parameters

cThe connection

windowThe window to change.

value_maskA bitmask of xcb_cw_t values.

value_mask

value_listValues for each of the attributes specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the attributes specified by value_mask for the specified window.

References XCB_CHANGE_WINDOW_ATTRIBUTES.

xcb_void_cookie_t xcb_change_window_attributes_aux_checked

(

xcb_connection_t *

xcb_window_t

window,

uint32_t

value_mask,

const xcb_change_window_attributes_value_list_t *

value_list

)

change window attributes

Parameters

cThe connection

windowThe window to change.

value_maskA bitmask of xcb_cw_t values.

value_mask

value_listValues for each of the attributes specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the attributes specified by value_mask for the specified window.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_WINDOW_ATTRIBUTES.

xcb_void_cookie_t xcb_change_window_attributes_checked

(

xcb_connection_t *

xcb_window_t

window,

uint32_t

value_mask,

const void *

value_list

)

change window attributes

Parameters

cThe connection

windowThe window to change.

value_maskA bitmask of xcb_cw_t values.

value_mask

value_listValues for each of the attributes specified in the bitmask value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Changes the attributes specified by value_mask for the specified window.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CHANGE_WINDOW_ATTRIBUTES.

xcb_generic_iterator_t xcb_char2b_end

(

xcb_char2b_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_char2b_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_char2b_next

(

xcb_char2b_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_char2b_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_char2b_t)

xcb_generic_iterator_t xcb_charinfo_end

(

xcb_charinfo_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_charinfo_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_charinfo_next

(

xcb_charinfo_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_charinfo_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_charinfo_t)

xcb_void_cookie_t xcb_circulate_window

(

xcb_connection_t *

uint8_t

direction,

xcb_window_t

window

)

Change window stacking order.

Parameters

cThe connection

directionA bitmask of #xcb_circulate_t values.

direction

windowThe window to raise/lower (depending on direction).

ReturnsA cookie

If direction is XCB_CIRCULATE_RAISE_LOWEST, the lowest mapped child (if any) will be raised to the top of the stack.

If direction is XCB_CIRCULATE_LOWER_HIGHEST, the highest mapped child will be lowered to the bottom of the stack.

References XCB_CIRCULATE_WINDOW.

xcb_void_cookie_t xcb_circulate_window_checked

(

xcb_connection_t *

uint8_t

direction,

xcb_window_t

window

)

Change window stacking order.

Parameters

cThe connection

directionA bitmask of #xcb_circulate_t values.

direction

windowThe window to raise/lower (depending on direction).

ReturnsA cookie

If direction is XCB_CIRCULATE_RAISE_LOWEST, the lowest mapped child (if any) will be raised to the top of the stack.

If direction is XCB_CIRCULATE_LOWER_HIGHEST, the highest mapped child will be lowered to the bottom of the stack.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CIRCULATE_WINDOW.

xcb_void_cookie_t xcb_clear_area

(

xcb_connection_t *

uint8_t

exposures,

xcb_window_t

window,

int16_t

uint16_t

width,

uint16_t

height

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CLEAR_AREA.

xcb_void_cookie_t xcb_clear_area_checked

(

xcb_connection_t *

uint8_t

exposures,

xcb_window_t

window,

int16_t

uint16_t

width,

uint16_t

height

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CLEAR_AREA.

xcb_generic_iterator_t xcb_client_message_data_end

(

xcb_client_message_data_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_client_message_data_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, XCB_CW_BACK_PIXEL, XCB_CW_BACK_PIXMAP, XCB_CW_BACKING_PIXEL, XCB_CW_BACKING_PLANES, XCB_CW_BACKING_STORE, XCB_CW_BIT_GRAVITY, XCB_CW_BORDER_PIXEL, XCB_CW_BORDER_PIXMAP, XCB_CW_COLORMAP, XCB_CW_CURSOR, XCB_CW_DONT_PROPAGATE, XCB_CW_EVENT_MASK, XCB_CW_OVERRIDE_REDIRECT, XCB_CW_SAVE_UNDER, and XCB_CW_WIN_GRAVITY.

void xcb_client_message_data_next

(

xcb_client_message_data_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_client_message_data_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_client_message_data_t)

xcb_void_cookie_t xcb_close_font

(

xcb_connection_t *

xcb_font_t

font

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CLOSE_FONT.

xcb_void_cookie_t xcb_close_font_checked

(

xcb_connection_t *

xcb_font_t

font

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CLOSE_FONT.

xcb_generic_iterator_t xcb_coloritem_end

(

xcb_coloritem_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_coloritem_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_coloritem_next

(

xcb_coloritem_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_coloritem_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_coloritem_t)

xcb_generic_iterator_t xcb_colormap_end

(

xcb_colormap_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_colormap_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_colormap_next

(

xcb_colormap_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_colormap_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_colormap_t)

xcb_void_cookie_t xcb_configure_window

(

xcb_connection_t *

xcb_window_t

window,

uint16_t

value_mask,

const void *

value_list

)

Configures window attributes.

Parameters

cThe connection

windowThe window to configure.

value_maskBitmask of attributes to change.

value_listNew values, corresponding to the attributes in value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Configures a window's size, position, border width and stacking order.

References XCB_CONFIGURE_WINDOW.

xcb_void_cookie_t xcb_configure_window_aux

(

xcb_connection_t *

xcb_window_t

window,

uint16_t

value_mask,

const xcb_configure_window_value_list_t *

value_list

)

Configures window attributes.

Parameters

cThe connection

windowThe window to configure.

value_maskBitmask of attributes to change.

value_listNew values, corresponding to the attributes in value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Configures a window's size, position, border width and stacking order.

References XCB_CONFIGURE_WINDOW.

xcb_void_cookie_t xcb_configure_window_aux_checked

(

xcb_connection_t *

xcb_window_t

window,

uint16_t

value_mask,

const xcb_configure_window_value_list_t *

value_list

)

Configures window attributes.

Parameters

cThe connection

windowThe window to configure.

value_maskBitmask of attributes to change.

value_listNew values, corresponding to the attributes in value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Configures a window's size, position, border width and stacking order.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CONFIGURE_WINDOW.

xcb_void_cookie_t xcb_configure_window_checked

(

xcb_connection_t *

xcb_window_t

window,

uint16_t

value_mask,

const void *

value_list

)

Configures window attributes.

Parameters

cThe connection

windowThe window to configure.

value_maskBitmask of attributes to change.

value_listNew values, corresponding to the attributes in value_mask. The order has to correspond to the order of possible value_mask bits. See the example.

ReturnsA cookie

Configures a window's size, position, border width and stacking order.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CONFIGURE_WINDOW.

xcb_void_cookie_t xcb_convert_selection

(

xcb_connection_t *

xcb_window_t

requestor,

xcb_atom_t

selection,

xcb_atom_t

target,

xcb_atom_t

property,

xcb_timestamp_t

time

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CONVERT_SELECTION.

xcb_void_cookie_t xcb_convert_selection_checked

(

xcb_connection_t *

xcb_window_t

requestor,

xcb_atom_t

selection,

xcb_atom_t

target,

xcb_atom_t

property,

xcb_timestamp_t

time

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CONVERT_SELECTION.

xcb_void_cookie_t xcb_copy_area

(

xcb_connection_t *

xcb_drawable_t

src_drawable,

xcb_drawable_t

dst_drawable,

xcb_gcontext_t

gc,

int16_t

src_x,

int16_t

src_y,

int16_t

dst_x,

int16_t

dst_y,

uint16_t

width,

uint16_t

height

)

copy areas

Parameters

cThe connection

src_drawableThe source drawable (Window or Pixmap).

dst_drawableThe destination drawable (Window or Pixmap).

gcThe graphics context to use.

src_xThe source X coordinate.

src_yThe source Y coordinate.

dst_xThe destination X coordinate.

dst_yThe destination Y coordinate.

widthThe width of the area to copy (in pixels).

heightThe height of the area to copy (in pixels).

ReturnsA cookie

Copies the specified rectangle from src_drawable to dst_drawable.

References XCB_COPY_AREA.

xcb_void_cookie_t xcb_copy_area_checked

(

xcb_connection_t *

xcb_drawable_t

src_drawable,

xcb_drawable_t

dst_drawable,

xcb_gcontext_t

gc,

int16_t

src_x,

int16_t

src_y,

int16_t

dst_x,

int16_t

dst_y,

uint16_t

width,

uint16_t

height

)

copy areas

Parameters

cThe connection

src_drawableThe source drawable (Window or Pixmap).

dst_drawableThe destination drawable (Window or Pixmap).

gcThe graphics context to use.

src_xThe source X coordinate.

src_yThe source Y coordinate.

dst_xThe destination X coordinate.

dst_yThe destination Y coordinate.

widthThe width of the area to copy (in pixels).

heightThe height of the area to copy (in pixels).

ReturnsA cookie

Copies the specified rectangle from src_drawable to dst_drawable.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_COPY_AREA.

xcb_void_cookie_t xcb_copy_colormap_and_free

(

xcb_connection_t *

xcb_colormap_t

mid,

xcb_colormap_t

src_cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_COPY_COLORMAP_AND_FREE.

xcb_void_cookie_t xcb_copy_colormap_and_free_checked

(

xcb_connection_t *

xcb_colormap_t

mid,

xcb_colormap_t

src_cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_COPY_COLORMAP_AND_FREE.

xcb_void_cookie_t xcb_copy_gc

(

xcb_connection_t *

xcb_gcontext_t

src_gc,

xcb_gcontext_t

dst_gc,

uint32_t

value_mask

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_COPY_GC.

xcb_void_cookie_t xcb_copy_gc_checked

(

xcb_connection_t *

xcb_gcontext_t

src_gc,

xcb_gcontext_t

dst_gc,

uint32_t

value_mask

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_COPY_GC.

xcb_void_cookie_t xcb_copy_plane

(

xcb_connection_t *

xcb_drawable_t

src_drawable,

xcb_drawable_t

dst_drawable,

xcb_gcontext_t

gc,

int16_t

src_x,

int16_t

src_y,

int16_t

dst_x,

int16_t

dst_y,

uint16_t

width,

uint16_t

height,

uint32_t

bit_plane

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_COPY_PLANE.

xcb_void_cookie_t xcb_copy_plane_checked

(

xcb_connection_t *

xcb_drawable_t

src_drawable,

xcb_drawable_t

dst_drawable,

xcb_gcontext_t

gc,

int16_t

src_x,

int16_t

src_y,

int16_t

dst_x,

int16_t

dst_y,

uint16_t

width,

uint16_t

height,

uint32_t

bit_plane

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_COPY_PLANE.

xcb_void_cookie_t xcb_create_colormap

(

xcb_connection_t *

uint8_t

alloc,

xcb_colormap_t

mid,

xcb_window_t

window,

xcb_visualid_t

visual

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CREATE_COLORMAP.

xcb_void_cookie_t xcb_create_colormap_checked

(

xcb_connection_t *

uint8_t

alloc,

xcb_colormap_t

mid,

xcb_window_t

window,

xcb_visualid_t

visual

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_COLORMAP.

xcb_void_cookie_t xcb_create_cursor

(

xcb_connection_t *

xcb_cursor_t

cid,

xcb_pixmap_t

source,

xcb_pixmap_t

mask,

uint16_t

fore_red,

uint16_t

fore_green,

uint16_t

fore_blue,

uint16_t

back_red,

uint16_t

back_green,

uint16_t

back_blue,

uint16_t

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_CREATE_CURSOR.

xcb_void_cookie_t xcb_create_cursor_checked

(

xcb_connection_t *

xcb_cursor_t

cid,

xcb_pixmap_t

source,

xcb_pixmap_t

mask,

uint16_t

fore_red,

uint16_t

fore_green,

uint16_t

fore_blue,

uint16_t

back_red,

uint16_t

back_green,

uint16_t

back_blue,

uint16_t

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_CURSOR.

xcb_void_cookie_t xcb_create_gc

(

xcb_connection_t *

xcb_gcontext_t

cid,

xcb_drawable_t

drawable,

uint32_t

value_mask,

const void *

value_list

)

Creates a graphics context.

Parameters

cThe connection

cidThe ID with which you will refer to the graphics context, created by xcb_generate_id.

drawableDrawable to get the root/depth from.

ReturnsA cookie

Creates a graphics context. The graphics context can be used with any drawable that has the same root and depth as the specified drawable.

References XCB_CREATE_GC.

xcb_void_cookie_t xcb_create_gc_aux

(

xcb_connection_t *

xcb_gcontext_t

cid,

xcb_drawable_t

drawable,

uint32_t

value_mask,

const xcb_create_gc_value_list_t *

value_list

)

Creates a graphics context.

Parameters

cThe connection

cidThe ID with which you will refer to the graphics context, created by xcb_generate_id.

drawableDrawable to get the root/depth from.

ReturnsA cookie

Creates a graphics context. The graphics context can be used with any drawable that has the same root and depth as the specified drawable.

References XCB_CREATE_GC, XCB_GC_ARC_MODE, XCB_GC_BACKGROUND, XCB_GC_CAP_STYLE, XCB_GC_CLIP_MASK, XCB_GC_CLIP_ORIGIN_X, XCB_GC_CLIP_ORIGIN_Y, XCB_GC_DASH_LIST, XCB_GC_DASH_OFFSET, XCB_GC_FILL_STYLE, XCB_GC_FONT, XCB_GC_FOREGROUND, XCB_GC_FUNCTION, XCB_GC_GRAPHICS_EXPOSURES, XCB_GC_JOIN_STYLE, XCB_GC_LINE_STYLE, XCB_GC_LINE_WIDTH, XCB_GC_PLANE_MASK, XCB_GC_STIPPLE, XCB_GC_SUBWINDOW_MODE, XCB_GC_TILE, XCB_GC_TILE_STIPPLE_ORIGIN_X, and XCB_GC_TILE_STIPPLE_ORIGIN_Y.

xcb_void_cookie_t xcb_create_gc_aux_checked

(

xcb_connection_t *

xcb_gcontext_t

cid,

xcb_drawable_t

drawable,

uint32_t

value_mask,

const xcb_create_gc_value_list_t *

value_list

)

Creates a graphics context.

Parameters

cThe connection

cidThe ID with which you will refer to the graphics context, created by xcb_generate_id.

drawableDrawable to get the root/depth from.

ReturnsA cookie

Creates a graphics context. The graphics context can be used with any drawable that has the same root and depth as the specified drawable.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_GC.

xcb_void_cookie_t xcb_create_gc_checked

(

xcb_connection_t *

xcb_gcontext_t

cid,

xcb_drawable_t

drawable,

uint32_t

value_mask,

const void *

value_list

)

Creates a graphics context.

Parameters

cThe connection

cidThe ID with which you will refer to the graphics context, created by xcb_generate_id.

drawableDrawable to get the root/depth from.

ReturnsA cookie

Creates a graphics context. The graphics context can be used with any drawable that has the same root and depth as the specified drawable.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_GC.

xcb_void_cookie_t xcb_create_glyph_cursor

(

xcb_connection_t *

xcb_cursor_t

cid,

xcb_font_t

source_font,

xcb_font_t

mask_font,

uint16_t

source_char,

uint16_t

mask_char,

uint16_t

fore_red,

uint16_t

fore_green,

uint16_t

fore_blue,

uint16_t

back_red,

uint16_t

back_green,

uint16_t

back_blue

)

create cursor

Parameters

cThe connection

cidThe ID with which you will refer to the cursor, created by xcb_generate_id.

source_fontIn which font to look for the cursor glyph.

mask_fontIn which font to look for the mask glyph.

source_charThe glyph of source_font to use.

mask_charThe glyph of mask_font to use as a mask: Pixels which are set to 1 define which source pixels are displayed. All pixels which are set to 0 are not displayed.

fore_redThe red value of the foreground color.

fore_greenThe green value of the foreground color.

fore_blueThe blue value of the foreground color.

back_redThe red value of the background color.

back_greenThe green value of the background color.

back_blueThe blue value of the background color.

ReturnsA cookie

Creates a cursor from a font glyph. X provides a set of standard cursor shapes in a special font named cursor. Applications are encouraged to use this interface for their cursors because the font can be customized for the individual display type.

All pixels which are set to 1 in the source will use the foreground color (as specified by fore_red, fore_green and fore_blue). All pixels set to 0 will use the background color (as specified by back_red, back_green and back_blue).

References XCB_CREATE_GLYPH_CURSOR.

xcb_void_cookie_t xcb_create_glyph_cursor_checked

(

xcb_connection_t *

xcb_cursor_t

cid,

xcb_font_t

source_font,

xcb_font_t

mask_font,

uint16_t

source_char,

uint16_t

mask_char,

uint16_t

fore_red,

uint16_t

fore_green,

uint16_t

fore_blue,

uint16_t

back_red,

uint16_t

back_green,

uint16_t

back_blue

)

create cursor

Parameters

cThe connection

cidThe ID with which you will refer to the cursor, created by xcb_generate_id.

source_fontIn which font to look for the cursor glyph.

mask_fontIn which font to look for the mask glyph.

source_charThe glyph of source_font to use.

mask_charThe glyph of mask_font to use as a mask: Pixels which are set to 1 define which source pixels are displayed. All pixels which are set to 0 are not displayed.

fore_redThe red value of the foreground color.

fore_greenThe green value of the foreground color.

fore_blueThe blue value of the foreground color.

back_redThe red value of the background color.

back_greenThe green value of the background color.

back_blueThe blue value of the background color.

ReturnsA cookie

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_GLYPH_CURSOR.

xcb_void_cookie_t xcb_create_pixmap

(

xcb_connection_t *

uint8_t

depth,

xcb_pixmap_t

pid,

xcb_drawable_t

drawable,

uint16_t

width,

uint16_t

height

)

Creates a pixmap.

Parameters

cThe connection

depthTODO

pidThe ID with which you will refer to the new pixmap, created by xcb_generate_id.

drawableDrawable to get the screen from.

widthThe width of the new pixmap.

heightThe height of the new pixmap.

ReturnsA cookie

Creates a pixmap. The pixmap can only be used on the same screen as drawable is on and only with drawables of the same depth.

References XCB_CREATE_PIXMAP.

xcb_void_cookie_t xcb_create_pixmap_checked

(

xcb_connection_t *

uint8_t

depth,

xcb_pixmap_t

pid,

xcb_drawable_t

drawable,

uint16_t

width,

uint16_t

height

)

Creates a pixmap.

Parameters

cThe connection

depthTODO

pidThe ID with which you will refer to the new pixmap, created by xcb_generate_id.

drawableDrawable to get the screen from.

widthThe width of the new pixmap.

heightThe height of the new pixmap.

ReturnsA cookie

Creates a pixmap. The pixmap can only be used on the same screen as drawable is on and only with drawables of the same depth.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_PIXMAP.

xcb_void_cookie_t xcb_create_window

(

xcb_connection_t *

uint8_t

depth,

xcb_window_t

wid,

xcb_window_t

parent,

int16_t

uint16_t

width,

uint16_t

height,

uint16_t

border_width,

uint16_t

_class,

xcb_visualid_t

visual,

uint32_t

value_mask,

const void *

value_list

)

Creates a window.

Parameters

cThe connection

depthSpecifies the new window's depth (TODO: what unit?).

The special value XCB_COPY_FROM_PARENT means the depth is taken from the parent window.

widThe ID with which you will refer to the new window, created by xcb_generate_id.

parentThe parent window of the new window.

xThe X coordinate of the new window.

yThe Y coordinate of the new window.

widthThe width of the new window.

heightThe height of the new window.

border_widthTODO:

Must be zero if the class is InputOnly or a xcb_match_error_t occurs.

_classA bitmask of #xcb_window_class_t values.

_class

visualSpecifies the id for the new window's visual.

The special value XCB_COPY_FROM_PARENT means the visual is taken from the parent window.

value_maskA bitmask of xcb_cw_t values.

ReturnsA cookie

Creates an unmapped window as child of the specified parent window. A CreateNotify event will be generated. The new window is placed on top in the stacking order with respect to siblings.

The coordinate system has the X axis horizontal and the Y axis vertical with the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms of pixels, and coincide with pixel centers. Each window and pixmap has its own coordinate system. For a window, the origin is inside the border at the inside, upper-left corner.

The created window is not yet displayed (mapped), call xcb_map_window to display it.

The created window will initially use the same cursor as its parent.

References XCB_CREATE_WINDOW.

xcb_void_cookie_t xcb_create_window_aux

(

xcb_connection_t *

uint8_t

depth,

xcb_window_t

wid,

xcb_window_t

parent,

int16_t

uint16_t

width,

uint16_t

height,

uint16_t

border_width,

uint16_t

_class,

xcb_visualid_t

visual,

uint32_t

value_mask,

const xcb_create_window_value_list_t *

value_list

)

Creates a window.

Parameters

cThe connection

depthSpecifies the new window's depth (TODO: what unit?).

The special value XCB_COPY_FROM_PARENT means the depth is taken from the parent window.

widThe ID with which you will refer to the new window, created by xcb_generate_id.

parentThe parent window of the new window.

xThe X coordinate of the new window.

yThe Y coordinate of the new window.

widthThe width of the new window.

heightThe height of the new window.

border_widthTODO:

Must be zero if the class is InputOnly or a xcb_match_error_t occurs.

_classA bitmask of #xcb_window_class_t values.

_class

visualSpecifies the id for the new window's visual.

The special value XCB_COPY_FROM_PARENT means the visual is taken from the parent window.

value_maskA bitmask of xcb_cw_t values.

ReturnsA cookie

Creates an unmapped window as child of the specified parent window. A CreateNotify event will be generated. The new window is placed on top in the stacking order with respect to siblings.

The created window is not yet displayed (mapped), call xcb_map_window to display it.

The created window will initially use the same cursor as its parent.

References XCB_CREATE_WINDOW, XCB_CW_BACK_PIXEL, XCB_CW_BACK_PIXMAP, XCB_CW_BACKING_PIXEL, XCB_CW_BACKING_PLANES, XCB_CW_BACKING_STORE, XCB_CW_BIT_GRAVITY, XCB_CW_BORDER_PIXEL, XCB_CW_BORDER_PIXMAP, XCB_CW_COLORMAP, XCB_CW_CURSOR, XCB_CW_DONT_PROPAGATE, XCB_CW_EVENT_MASK, XCB_CW_OVERRIDE_REDIRECT, XCB_CW_SAVE_UNDER, and XCB_CW_WIN_GRAVITY.

xcb_void_cookie_t xcb_create_window_aux_checked

(

xcb_connection_t *

uint8_t

depth,

xcb_window_t

wid,

xcb_window_t

parent,

int16_t

uint16_t

width,

uint16_t

height,

uint16_t

border_width,

uint16_t

_class,

xcb_visualid_t

visual,

uint32_t

value_mask,

const xcb_create_window_value_list_t *

value_list

)

Creates a window.

Parameters

cThe connection

depthSpecifies the new window's depth (TODO: what unit?).

The special value XCB_COPY_FROM_PARENT means the depth is taken from the parent window.

widThe ID with which you will refer to the new window, created by xcb_generate_id.

parentThe parent window of the new window.

xThe X coordinate of the new window.

yThe Y coordinate of the new window.

widthThe width of the new window.

heightThe height of the new window.

border_widthTODO:

Must be zero if the class is InputOnly or a xcb_match_error_t occurs.

_classA bitmask of #xcb_window_class_t values.

_class

visualSpecifies the id for the new window's visual.

The special value XCB_COPY_FROM_PARENT means the visual is taken from the parent window.

value_maskA bitmask of xcb_cw_t values.

ReturnsA cookie

Creates an unmapped window as child of the specified parent window. A CreateNotify event will be generated. The new window is placed on top in the stacking order with respect to siblings.

The created window is not yet displayed (mapped), call xcb_map_window to display it.

The created window will initially use the same cursor as its parent.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_WINDOW.

xcb_void_cookie_t xcb_create_window_checked

(

xcb_connection_t *

uint8_t

depth,

xcb_window_t

wid,

xcb_window_t

parent,

int16_t

uint16_t

width,

uint16_t

height,

uint16_t

border_width,

uint16_t

_class,

xcb_visualid_t

visual,

uint32_t

value_mask,

const void *

value_list

)

Creates a window.

Parameters

cThe connection

depthSpecifies the new window's depth (TODO: what unit?).

The special value XCB_COPY_FROM_PARENT means the depth is taken from the parent window.

widThe ID with which you will refer to the new window, created by xcb_generate_id.

parentThe parent window of the new window.

xThe X coordinate of the new window.

yThe Y coordinate of the new window.

widthThe width of the new window.

heightThe height of the new window.

border_widthTODO:

Must be zero if the class is InputOnly or a xcb_match_error_t occurs.

_classA bitmask of #xcb_window_class_t values.

_class

visualSpecifies the id for the new window's visual.

The special value XCB_COPY_FROM_PARENT means the visual is taken from the parent window.

value_maskA bitmask of xcb_cw_t values.

ReturnsA cookie

Creates an unmapped window as child of the specified parent window. A CreateNotify event will be generated. The new window is placed on top in the stacking order with respect to siblings.

The created window is not yet displayed (mapped), call xcb_map_window to display it.

The created window will initially use the same cursor as its parent.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_CREATE_WINDOW.

xcb_generic_iterator_t xcb_cursor_end

(

xcb_cursor_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_cursor_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_cursor_next

(

xcb_cursor_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_cursor_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_cursor_t)

xcb_void_cookie_t xcb_delete_property

(

xcb_connection_t *

xcb_window_t

window,

xcb_atom_t

property

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_DELETE_PROPERTY.

xcb_void_cookie_t xcb_delete_property_checked

(

xcb_connection_t *

xcb_window_t

window,

xcb_atom_t

property

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_DELETE_PROPERTY.

xcb_generic_iterator_t xcb_depth_end

(

xcb_depth_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_depth_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_depth_next().

void xcb_depth_next

(

xcb_depth_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_depth_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_depth_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_depth_end().

xcb_void_cookie_t xcb_destroy_subwindows

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_DESTROY_SUBWINDOWS.

xcb_void_cookie_t xcb_destroy_subwindows_checked

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_DESTROY_SUBWINDOWS.

xcb_void_cookie_t xcb_destroy_window

(

xcb_connection_t *

xcb_window_t

window

)

Destroys a window.

Parameters

cThe connection

windowThe window to destroy.

ReturnsA cookie

Destroys the specified window and all of its subwindows. A DestroyNotify event is generated for each destroyed window (a DestroyNotify event is first generated for any given window's inferiors). If the window was mapped, it will be automatically unmapped before destroying.

Calling DestroyWindow on the root window will do nothing.

References XCB_DESTROY_WINDOW.

xcb_void_cookie_t xcb_destroy_window_checked

(

xcb_connection_t *

xcb_window_t

window

)

Destroys a window.

Parameters

cThe connection

windowThe window to destroy.

ReturnsA cookie

Calling DestroyWindow on the root window will do nothing.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_DESTROY_WINDOW.

xcb_generic_iterator_t xcb_drawable_end

(

xcb_drawable_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_drawable_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_drawable_next

(

xcb_drawable_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_drawable_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_drawable_t)

xcb_void_cookie_t xcb_fill_poly

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint8_t

shape,

uint8_t

coordinate_mode,

uint32_t

points_len,

const xcb_point_t *

points

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_FILL_POLY.

xcb_void_cookie_t xcb_fill_poly_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint8_t

shape,

uint8_t

coordinate_mode,

uint32_t

points_len,

const xcb_point_t *

points

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FILL_POLY.

xcb_generic_iterator_t xcb_font_end

(

xcb_font_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_font_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_font_next

(

xcb_font_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_font_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_font_t)

xcb_generic_iterator_t xcb_fontable_end

(

xcb_fontable_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_fontable_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_fontable_next

(

xcb_fontable_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_fontable_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_fontable_t)

xcb_generic_iterator_t xcb_fontprop_end

(

xcb_fontprop_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_fontprop_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

Referenced by xcb_list_fonts_with_info_unchecked(), and xcb_query_font_unchecked().

void xcb_fontprop_next

(

xcb_fontprop_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_fontprop_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_fontprop_t)

xcb_void_cookie_t xcb_force_screen_saver

(

xcb_connection_t *

uint8_t

mode

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_FORCE_SCREEN_SAVER.

xcb_void_cookie_t xcb_force_screen_saver_checked

(

xcb_connection_t *

uint8_t

mode

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FORCE_SCREEN_SAVER.

xcb_generic_iterator_t xcb_format_end

(

xcb_format_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_format_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

Referenced by xcb_setup_authenticate_end().

void xcb_format_next

(

xcb_format_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_format_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_format_t)

xcb_void_cookie_t xcb_free_colormap

(

xcb_connection_t *

xcb_colormap_t

cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_FREE_COLORMAP.

xcb_void_cookie_t xcb_free_colormap_checked

(

xcb_connection_t *

xcb_colormap_t

cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FREE_COLORMAP.

xcb_void_cookie_t xcb_free_colors

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint32_t

plane_mask,

uint32_t

pixels_len,

const uint32_t *

pixels

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_FREE_COLORS.

xcb_void_cookie_t xcb_free_colors_checked

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint32_t

plane_mask,

uint32_t

pixels_len,

const uint32_t *

pixels

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FREE_COLORS.

xcb_void_cookie_t xcb_free_cursor

(

xcb_connection_t *

xcb_cursor_t

cursor

)

Deletes a cursor.

Parameters

cThe connection

cursorThe cursor to destroy.

ReturnsA cookie

Deletes the association between the cursor resource ID and the specified cursor. The cursor is freed when no other resource references it.

References XCB_FREE_CURSOR.

xcb_void_cookie_t xcb_free_cursor_checked

(

xcb_connection_t *

xcb_cursor_t

cursor

)

Deletes a cursor.

Parameters

cThe connection

cursorThe cursor to destroy.

ReturnsA cookie

Deletes the association between the cursor resource ID and the specified cursor. The cursor is freed when no other resource references it.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FREE_CURSOR.

xcb_void_cookie_t xcb_free_gc

(

xcb_connection_t *

xcb_gcontext_t

)

Destroys a graphics context.

Parameters

cThe connection

gcThe graphics context to destroy.

ReturnsA cookie

Destroys the specified gc and all associated storage.

References XCB_FREE_GC.

xcb_void_cookie_t xcb_free_gc_checked

(

xcb_connection_t *

xcb_gcontext_t

)

Destroys a graphics context.

Parameters

cThe connection

gcThe graphics context to destroy.

ReturnsA cookie

Destroys the specified gc and all associated storage.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FREE_GC.

xcb_void_cookie_t xcb_free_pixmap

(

xcb_connection_t *

xcb_pixmap_t

pixmap

)

Destroys a pixmap.

Parameters

cThe connection

pixmapThe pixmap to destroy.

ReturnsA cookie

Deletes the association between the pixmap ID and the pixmap. The pixmap storage will be freed when there are no more references to it.

References XCB_FREE_PIXMAP, XCB_GC_ARC_MODE, XCB_GC_BACKGROUND, XCB_GC_CAP_STYLE, XCB_GC_CLIP_MASK, XCB_GC_CLIP_ORIGIN_X, XCB_GC_CLIP_ORIGIN_Y, XCB_GC_DASH_LIST, XCB_GC_DASH_OFFSET, XCB_GC_FILL_STYLE, XCB_GC_FONT, XCB_GC_FOREGROUND, XCB_GC_FUNCTION, XCB_GC_GRAPHICS_EXPOSURES, XCB_GC_JOIN_STYLE, XCB_GC_LINE_STYLE, XCB_GC_LINE_WIDTH, XCB_GC_PLANE_MASK, XCB_GC_STIPPLE, XCB_GC_SUBWINDOW_MODE, XCB_GC_TILE, XCB_GC_TILE_STIPPLE_ORIGIN_X, and XCB_GC_TILE_STIPPLE_ORIGIN_Y.

xcb_void_cookie_t xcb_free_pixmap_checked

(

xcb_connection_t *

xcb_pixmap_t

pixmap

)

Destroys a pixmap.

Parameters

cThe connection

pixmapThe pixmap to destroy.

ReturnsA cookie

Deletes the association between the pixmap ID and the pixmap. The pixmap storage will be freed when there are no more references to it.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_FREE_PIXMAP.

xcb_generic_iterator_t xcb_gcontext_end

(

xcb_gcontext_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_gcontext_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_gcontext_next

(

xcb_gcontext_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_gcontext_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_gcontext_t)

xcb_get_atom_name_cookie_t xcb_get_atom_name

(

xcb_connection_t *

xcb_atom_t

atom

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_ATOM_NAME.

xcb_get_atom_name_reply_t* xcb_get_atom_name_reply

(

xcb_connection_t *

xcb_get_atom_name_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_atom_name_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_atom_name_cookie_t xcb_get_atom_name_unchecked

(

xcb_connection_t *

xcb_atom_t

atom

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_GET_ATOM_NAME.

xcb_get_font_path_cookie_t xcb_get_font_path

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_FONT_PATH.

xcb_get_font_path_reply_t* xcb_get_font_path_reply

(

xcb_connection_t *

xcb_get_font_path_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_font_path_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_font_path_cookie_t xcb_get_font_path_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_FONT_PATH.

xcb_get_geometry_cookie_t xcb_get_geometry

(

xcb_connection_t *

xcb_drawable_t

drawable

)

Get current window geometry.

Parameters

cThe connection

drawableThe drawable (Window or Pixmap) of which the geometry will be received.

ReturnsA cookie

Gets the current geometry of the specified drawable (either Window or Pixmap).

References XCB_GET_GEOMETRY.

xcb_get_geometry_reply_t* xcb_get_geometry_reply

(

xcb_connection_t *

xcb_get_geometry_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_geometry_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_geometry_cookie_t xcb_get_geometry_unchecked

(

xcb_connection_t *

xcb_drawable_t

drawable

)

Get current window geometry.

Parameters

cThe connection

drawableThe drawable (Window or Pixmap) of which the geometry will be received.

ReturnsA cookie

Gets the current geometry of the specified drawable (either Window or Pixmap).

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_GEOMETRY.

xcb_get_image_cookie_t xcb_get_image

(

xcb_connection_t *

uint8_t

format,

xcb_drawable_t

drawable,

int16_t

uint16_t

width,

uint16_t

height,

uint32_t

plane_mask

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_IMAGE.

xcb_get_image_reply_t* xcb_get_image_reply

(

xcb_connection_t *

xcb_get_image_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_image_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_image_cookie_t xcb_get_image_unchecked

(

xcb_connection_t *

uint8_t

format,

xcb_drawable_t

drawable,

int16_t

uint16_t

width,

uint16_t

height,

uint32_t

plane_mask

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_GET_IMAGE.

xcb_get_input_focus_cookie_t xcb_get_input_focus

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_INPUT_FOCUS.

xcb_get_input_focus_reply_t* xcb_get_input_focus_reply

(

xcb_connection_t *

xcb_get_input_focus_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_input_focus_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_input_focus_cookie_t xcb_get_input_focus_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_INPUT_FOCUS.

xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_KEYBOARD_CONTROL.

xcb_get_keyboard_control_reply_t* xcb_get_keyboard_control_reply

(

xcb_connection_t *

xcb_get_keyboard_control_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_keyboard_control_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_KEYBOARD_CONTROL.

xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping

(

xcb_connection_t *

xcb_keycode_t

first_keycode,

uint8_t

count

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_KEYBOARD_MAPPING.

xcb_get_keyboard_mapping_reply_t* xcb_get_keyboard_mapping_reply

(

xcb_connection_t *

xcb_get_keyboard_mapping_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_keyboard_mapping_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping_unchecked

(

xcb_connection_t *

xcb_keycode_t

first_keycode,

uint8_t

count

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_GET_KEYBOARD_MAPPING.

xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_MODIFIER_MAPPING.

xcb_get_modifier_mapping_reply_t* xcb_get_modifier_mapping_reply

(

xcb_connection_t *

xcb_get_modifier_mapping_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_modifier_mapping_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_GET_MODIFIER_MAPPING.

xcb_get_motion_events_cookie_t xcb_get_motion_events

(

xcb_connection_t *

xcb_window_t

window,

xcb_timestamp_t

start,

xcb_timestamp_t

stop

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_MOTION_EVENTS.

xcb_get_motion_events_reply_t* xcb_get_motion_events_reply

(

xcb_connection_t *

xcb_get_motion_events_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_motion_events_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_motion_events_cookie_t xcb_get_motion_events_unchecked

(

xcb_connection_t *

xcb_window_t

window,

xcb_timestamp_t

start,

xcb_timestamp_t

stop

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_MOTION_EVENTS.

xcb_get_pointer_control_cookie_t xcb_get_pointer_control

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_POINTER_CONTROL.

xcb_get_pointer_control_reply_t* xcb_get_pointer_control_reply

(

xcb_connection_t *

xcb_get_pointer_control_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_pointer_control_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_pointer_control_cookie_t xcb_get_pointer_control_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_POINTER_CONTROL.

xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_POINTER_MAPPING.

xcb_get_pointer_mapping_reply_t* xcb_get_pointer_mapping_reply

(

xcb_connection_t *

xcb_get_pointer_mapping_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_pointer_mapping_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_GET_POINTER_MAPPING.

xcb_get_property_cookie_t xcb_get_property

(

xcb_connection_t *

uint8_t

_delete,

xcb_window_t

window,

xcb_atom_t

property,

xcb_atom_t

type,

uint32_t

long_offset,

uint32_t

long_length

)

Gets a window property.

Parameters

cThe connection

_deleteWhether the property should actually be deleted. For deleting a property, the specified type has to match the actual property type.

windowThe window whose property you want to get.

propertyThe property you want to get (an atom).

typeThe type of the property you want to get (an atom).

long_offsetSpecifies the offset (in 32-bit multiples) in the specified property where the data is to be retrieved.

long_lengthSpecifies how many 32-bit multiples of data should be retrieved (e.g. if you set long_length to 4, you will receive 16 bytes of data).

ReturnsA cookie

Gets the specified property from the specified window. Properties are for example the window title (WM_NAME) or its minimum size (WM_NORMAL_HINTS). Protocols such as EWMH also use properties - for example EWMH defines the window title, encoded as UTF-8 string, in the _NET_WM_NAME property.

TODO: talk about type

TODO: talk about delete

TODO: talk about the offset/length thing. what's a valid use case?

References XCB_GET_PROPERTY.

xcb_get_property_reply_t* xcb_get_property_reply

(

xcb_connection_t *

xcb_get_property_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_property_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_property_cookie_t xcb_get_property_unchecked

(

xcb_connection_t *

uint8_t

_delete,

xcb_window_t

window,

xcb_atom_t

property,

xcb_atom_t

type,

uint32_t

long_offset,

uint32_t

long_length

)

Gets a window property.

Parameters

cThe connection

_deleteWhether the property should actually be deleted. For deleting a property, the specified type has to match the actual property type.

windowThe window whose property you want to get.

propertyThe property you want to get (an atom).

typeThe type of the property you want to get (an atom).

long_offsetSpecifies the offset (in 32-bit multiples) in the specified property where the data is to be retrieved.

long_lengthSpecifies how many 32-bit multiples of data should be retrieved (e.g. if you set long_length to 4, you will receive 16 bytes of data).

ReturnsA cookie

TODO: talk about type

TODO: talk about delete

TODO: talk about the offset/length thing. what's a valid use case?

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_GET_PROPERTY.

xcb_get_screen_saver_cookie_t xcb_get_screen_saver

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GET_SCREEN_SAVER.

xcb_get_screen_saver_reply_t* xcb_get_screen_saver_reply

(

xcb_connection_t *

xcb_get_screen_saver_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_screen_saver_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_screen_saver_cookie_t xcb_get_screen_saver_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_SCREEN_SAVER.

xcb_get_selection_owner_cookie_t xcb_get_selection_owner

(

xcb_connection_t *

xcb_atom_t

selection

)

Gets the owner of a selection.

Parameters

cThe connection

selectionThe selection.

ReturnsA cookie

Gets the owner of the specified selection.

TODO: briefly explain what a selection is.

References XCB_GET_SELECTION_OWNER.

xcb_get_selection_owner_reply_t* xcb_get_selection_owner_reply

(

xcb_connection_t *

xcb_get_selection_owner_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_selection_owner_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_selection_owner_cookie_t xcb_get_selection_owner_unchecked

(

xcb_connection_t *

xcb_atom_t

selection

)

Gets the owner of a selection.

Parameters

cThe connection

selectionThe selection.

ReturnsA cookie

Gets the owner of the specified selection.

TODO: briefly explain what a selection is.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_SELECTION_OWNER.

xcb_get_window_attributes_cookie_t xcb_get_window_attributes

(

xcb_connection_t *

xcb_window_t

window

)

Gets window attributes.

Parameters

cThe connection

windowThe window to get the attributes from.

ReturnsA cookie

Gets the current attributes for the specified window.

References XCB_GET_WINDOW_ATTRIBUTES.

xcb_get_window_attributes_reply_t* xcb_get_window_attributes_reply

(

xcb_connection_t *

xcb_get_window_attributes_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_get_window_attributes_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_get_window_attributes_cookie_t xcb_get_window_attributes_unchecked

(

xcb_connection_t *

xcb_window_t

window

)

Gets window attributes.

Parameters

cThe connection

windowThe window to get the attributes from.

ReturnsA cookie

Gets the current attributes for the specified window.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GET_WINDOW_ATTRIBUTES.

xcb_void_cookie_t xcb_grab_button

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

uint16_t

event_mask,

uint8_t

pointer_mode,

uint8_t

keyboard_mode,

xcb_window_t

confine_to,

xcb_cursor_t

cursor,

uint8_t

button,

uint16_t

modifiers

)

Grab pointer button(s)

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

event_maskSpecifies which pointer events are reported to the client.

TODO: which values?

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

confine_toSpecifies the window to confine the pointer in (the user will not be able to move the pointer out of that window).

The special value XCB_NONE means don't confine the pointer.

cursorSpecifies the cursor that should be displayed or XCB_NONE to not change the cursor.

buttonA bitmask of xcb_button_index_t values.

button

modifiersThe modifiers to grab.

Using the special value XCB_MOD_MASK_ANY means grab the pointer with all possible modifier combinations.

ReturnsA cookie

This request establishes a passive grab. The pointer is actively grabbed as described in GrabPointer, the last-pointer-grab time is set to the time at which the button was pressed (as transmitted in the ButtonPress event), and the ButtonPress event is reported if all of the following conditions are true:

The pointer is not grabbed and the specified button is logically pressed when the specified modifier keys are logically down, and no other buttons or modifier keys are logically down.

The grab-window contains the pointer.

The confine-to window (if any) is viewable.

A passive grab on the same button/key combination does not exist on any ancestor of grab-window.

The interpretation of the remaining arguments is the same as for GrabPointer. The active grab is terminated automatically when the logical state of the pointer has all buttons released, independent of the logical state of modifier keys. Note that the logical state of a device (as seen by means of the protocol) may lag the physical state if device event processing is frozen. This request overrides all previous passive grabs by the same client on the same button/key combinations on the same window. A modifier of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all specified modifiers have currently assigned keycodes. A button of AnyButton is equivalent to issuing the request for all possible buttons. Otherwise, it is not required that the button specified currently be assigned to a physical button.

An Access error is generated if some other client has already issued a GrabButton request with the same button/key combination on the same window. When using AnyModifier or AnyButton, the request fails completely (no grabs are established), and an Access error is generated if there is a conflicting grab for any combination. The request has no effect on an active grab.

References XCB_GRAB_BUTTON.

xcb_void_cookie_t xcb_grab_button_checked

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

uint16_t

event_mask,

uint8_t

pointer_mode,

uint8_t

keyboard_mode,

xcb_window_t

confine_to,

xcb_cursor_t

cursor,

uint8_t

button,

uint16_t

modifiers

)

Grab pointer button(s)

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

event_maskSpecifies which pointer events are reported to the client.

TODO: which values?

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

confine_toSpecifies the window to confine the pointer in (the user will not be able to move the pointer out of that window).

The special value XCB_NONE means don't confine the pointer.

cursorSpecifies the cursor that should be displayed or XCB_NONE to not change the cursor.

buttonA bitmask of xcb_button_index_t values.

button

modifiersThe modifiers to grab.

Using the special value XCB_MOD_MASK_ANY means grab the pointer with all possible modifier combinations.

ReturnsA cookie

The pointer is not grabbed and the specified button is logically pressed when the specified modifier keys are logically down, and no other buttons or modifier keys are logically down.

The grab-window contains the pointer.

The confine-to window (if any) is viewable.

A passive grab on the same button/key combination does not exist on any ancestor of grab-window.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_GRAB_BUTTON.

xcb_void_cookie_t xcb_grab_key

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

uint16_t

modifiers,

xcb_keycode_t

key,

uint8_t

pointer_mode,

uint8_t

keyboard_mode

)

Grab keyboard key(s)

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

modifiersThe modifiers to grab.

Using the special value XCB_MOD_MASK_ANY means grab the pointer with all possible modifier combinations.

keyThe keycode of the key to grab.

The special value XCB_GRAB_ANY means grab any key.

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

ReturnsA cookie

Establishes a passive grab on the keyboard. In the future, the keyboard is actively grabbed (as for GrabKeyboard), the last-keyboard-grab time is set to the time at which the key was pressed (as transmitted in the KeyPress event), and the KeyPress event is reported if all of the following conditions are true:

The keyboard is not grabbed and the specified key (which can itself be a modifier key) is logically pressed when the specified modifier keys are logically down, and no other modifier keys are logically down.

Either the grab_window is an ancestor of (or is) the focus window, or the grab_window is a descendant of the focus window and contains the pointer.

A passive grab on the same key combination does not exist on any ancestor of grab_window.

The interpretation of the remaining arguments is as for XGrabKeyboard. The active grab is terminated automatically when the logical state of the keyboard has the specified key released (independent of the logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window.

Note that the logical state of a device (as seen by client applications) may lag the physical state if device event processing is frozen.

A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all modifiers specified have currently assigned KeyCodes. A keycode argument of AnyKey is equivalent to issuing the request for all possible KeyCodes. Otherwise, the specified keycode must be in the range specified by min_keycode and max_keycode in the connection setup, or a BadValue error results.

If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess error results. When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error results (no grabs are established) if there is a conflicting grab for any combination.

References XCB_GRAB_KEY.

xcb_void_cookie_t xcb_grab_key_checked

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

uint16_t

modifiers,

xcb_keycode_t

key,

uint8_t

pointer_mode,

uint8_t

keyboard_mode

)

Grab keyboard key(s)

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

modifiersThe modifiers to grab.

Using the special value XCB_MOD_MASK_ANY means grab the pointer with all possible modifier combinations.

keyThe keycode of the key to grab.

The special value XCB_GRAB_ANY means grab any key.

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

ReturnsA cookie

Either the grab_window is an ancestor of (or is) the focus window, or the grab_window is a descendant of the focus window and contains the pointer.

A passive grab on the same key combination does not exist on any ancestor of grab_window.

Note that the logical state of a device (as seen by client applications) may lag the physical state if device event processing is frozen.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_GRAB_KEY.

xcb_grab_keyboard_cookie_t xcb_grab_keyboard

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

xcb_timestamp_t

time,

uint8_t

pointer_mode,

uint8_t

keyboard_mode

)

Grab the keyboard.

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

ReturnsA cookie

Actively grabs control of the keyboard and generates FocusIn and FocusOut events. Further key events are reported only to the grabbing client.

Any active keyboard grab by this client is overridden. If the keyboard is actively grabbed by some other client, AlreadyGrabbed is returned. If grab_window is not viewable, GrabNotViewable is returned. If the keyboard is frozen by an active grab of another client, GrabFrozen is returned. If the specified time is earlier than the last-keyboard-grab time or later than the current X server time, GrabInvalidTime is returned. Otherwise, the last-keyboard-grab time is set to the specified time.

References XCB_GRAB_KEYBOARD.

xcb_grab_keyboard_reply_t* xcb_grab_keyboard_reply

(

xcb_connection_t *

xcb_grab_keyboard_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_grab_keyboard_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_grab_keyboard_cookie_t xcb_grab_keyboard_unchecked

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

xcb_timestamp_t

time,

uint8_t

pointer_mode,

uint8_t

keyboard_mode

)

Grab the keyboard.

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

ReturnsA cookie

Actively grabs control of the keyboard and generates FocusIn and FocusOut events. Further key events are reported only to the grabbing client.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GRAB_KEYBOARD.

xcb_grab_pointer_cookie_t xcb_grab_pointer

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

uint16_t

event_mask,

uint8_t

pointer_mode,

uint8_t

keyboard_mode,

xcb_window_t

confine_to,

xcb_cursor_t

cursor,

xcb_timestamp_t

time

)

Grab the pointer.

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

event_maskSpecifies which pointer events are reported to the client.

TODO: which values?

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

confine_toSpecifies the window to confine the pointer in (the user will not be able to move the pointer out of that window).

The special value XCB_NONE means don't confine the pointer.

cursorSpecifies the cursor that should be displayed or XCB_NONE to not change the cursor.

timeThe time argument allows you to avoid certain circumstances that come up if applications take a long time to respond or if there are long network delays. Consider a situation where you have two applications, both of which normally grab the pointer when clicked on. If both applications specify the timestamp from the event, the second application may wake up faster and successfully grab the pointer before the first application. The first application then will get an indication that the other application grabbed the pointer before its request was processed.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client.

References XCB_GRAB_POINTER.

xcb_grab_pointer_reply_t* xcb_grab_pointer_reply

(

xcb_connection_t *

xcb_grab_pointer_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_grab_pointer_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_grab_pointer_cookie_t xcb_grab_pointer_unchecked

(

xcb_connection_t *

uint8_t

owner_events,

xcb_window_t

grab_window,

uint16_t

event_mask,

uint8_t

pointer_mode,

uint8_t

keyboard_mode,

xcb_window_t

confine_to,

xcb_cursor_t

cursor,

xcb_timestamp_t

time

)

Grab the pointer.

Parameters

cThe connection

owner_eventsIf 1, the grab_window will still get the pointer events. If 0, events are not reported to the grab_window.

grab_windowSpecifies the window on which the pointer should be grabbed.

event_maskSpecifies which pointer events are reported to the client.

TODO: which values?

pointer_modeA bitmask of xcb_grab_mode_t values.

pointer_mode

keyboard_modeA bitmask of xcb_grab_mode_t values.

keyboard_mode

confine_toSpecifies the window to confine the pointer in (the user will not be able to move the pointer out of that window).

The special value XCB_NONE means don't confine the pointer.

cursorSpecifies the cursor that should be displayed or XCB_NONE to not change the cursor.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_GRAB_POINTER.

xcb_void_cookie_t xcb_grab_server

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_GRAB_SERVER.

xcb_void_cookie_t xcb_grab_server_checked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_GRAB_SERVER.

xcb_generic_iterator_t xcb_host_end

(

xcb_host_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_host_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_host_next().

void xcb_host_next

(

xcb_host_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_host_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_host_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_host_end().

xcb_void_cookie_t xcb_image_text_16

(

xcb_connection_t *

uint8_t

string_len,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

const xcb_char2b_t *

string

)

Draws text.

Parameters

cThe connection

string_lenThe length of the string in characters. Note that this parameter limited by 255 due to using 8 bits!

drawableThe drawable (Window or Pixmap) to draw text on.

gcThe graphics context to use.

The following graphics context components are used: plane-mask, foreground, background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.

xThe x coordinate of the first character, relative to the origin of drawable.

yThe y coordinate of the first character, relative to the origin of drawable.

stringThe string to draw. Only the first 255 characters are relevant due to the data type of string_len. Every character uses 2 bytes (hence the 16 in this request's name).

ReturnsA cookie

Fills the destination rectangle with the background pixel from gc, then paints the text with the foreground pixel from gc. The upper-left corner of the filled rectangle is at [x, y - font-ascent]. The width is overall-width, the height is font-ascent + font-descent. The overall-width, font-ascent and font-descent are as returned by xcb_query_text_extents (TODO).

Note that using X core fonts is deprecated (but still supported) in favor of client-side rendering using Xft.

References XCB_IMAGE_TEXT_16.

xcb_void_cookie_t xcb_image_text_16_checked

(

xcb_connection_t *

uint8_t

string_len,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

const xcb_char2b_t *

string

)

Draws text.

Parameters

cThe connection

string_lenThe length of the string in characters. Note that this parameter limited by 255 due to using 8 bits!

drawableThe drawable (Window or Pixmap) to draw text on.

gcThe graphics context to use.

The following graphics context components are used: plane-mask, foreground, background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.

xThe x coordinate of the first character, relative to the origin of drawable.

yThe y coordinate of the first character, relative to the origin of drawable.

stringThe string to draw. Only the first 255 characters are relevant due to the data type of string_len. Every character uses 2 bytes (hence the 16 in this request's name).

ReturnsA cookie

Note that using X core fonts is deprecated (but still supported) in favor of client-side rendering using Xft.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_IMAGE_TEXT_16.

xcb_void_cookie_t xcb_image_text_8

(

xcb_connection_t *

uint8_t

string_len,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

const char *

string

)

Draws text.

Parameters

cThe connection

string_lenThe length of the string. Note that this parameter limited by 255 due to using 8 bits!

drawableThe drawable (Window or Pixmap) to draw text on.

gcThe graphics context to use.

The following graphics context components are used: plane-mask, foreground, background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.

xThe x coordinate of the first character, relative to the origin of drawable.

yThe y coordinate of the first character, relative to the origin of drawable.

stringThe string to draw. Only the first 255 characters are relevant due to the data type of string_len.

ReturnsA cookie

Note that using X core fonts is deprecated (but still supported) in favor of client-side rendering using Xft.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_IMAGE_TEXT_8.

xcb_void_cookie_t xcb_image_text_8_checked

(

xcb_connection_t *

uint8_t

string_len,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

const char *

string

)

Draws text.

Parameters

cThe connection

string_lenThe length of the string. Note that this parameter limited by 255 due to using 8 bits!

drawableThe drawable (Window or Pixmap) to draw text on.

gcThe graphics context to use.

The following graphics context components are used: plane-mask, foreground, background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.

xThe x coordinate of the first character, relative to the origin of drawable.

yThe y coordinate of the first character, relative to the origin of drawable.

stringThe string to draw. Only the first 255 characters are relevant due to the data type of string_len.

ReturnsA cookie

Note that using X core fonts is deprecated (but still supported) in favor of client-side rendering using Xft.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_IMAGE_TEXT_8.

xcb_void_cookie_t xcb_install_colormap

(

xcb_connection_t *

xcb_colormap_t

cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_INSTALL_COLORMAP.

xcb_void_cookie_t xcb_install_colormap_checked

(

xcb_connection_t *

xcb_colormap_t

cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_INSTALL_COLORMAP.

xcb_intern_atom_cookie_t xcb_intern_atom

(

xcb_connection_t *

uint8_t

only_if_exists,

uint16_t

name_len,

const char *

name

)

Get atom identifier by name.

Parameters

cThe connection

only_if_existsReturn a valid atom id only if the atom already exists.

name_lenThe length of the following name.

nameThe name of the atom.

ReturnsA cookie

Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified name. Atoms are used in protocols like EWMH, for example to store window titles (_NET_WM_NAME atom) as property of a window.

If only_if_exists is 0, the atom will be created if it does not already exist. If only_if_exists is 1, XCB_ATOM_NONE will be returned if the atom does not yet exist.

References XCB_INTERN_ATOM.

xcb_intern_atom_reply_t* xcb_intern_atom_reply

(

xcb_connection_t *

xcb_intern_atom_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_intern_atom_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_intern_atom_cookie_t xcb_intern_atom_unchecked

(

xcb_connection_t *

uint8_t

only_if_exists,

uint16_t

name_len,

const char *

name

)

Get atom identifier by name.

Parameters

cThe connection

only_if_existsReturn a valid atom id only if the atom already exists.

name_lenThe length of the following name.

nameThe name of the atom.

ReturnsA cookie

Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified name. Atoms are used in protocols like EWMH, for example to store window titles (_NET_WM_NAME atom) as property of a window.

If only_if_exists is 0, the atom will be created if it does not already exist. If only_if_exists is 1, XCB_ATOM_NONE will be returned if the atom does not yet exist.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_INTERN_ATOM.

xcb_generic_iterator_t xcb_keycode32_end

(

xcb_keycode32_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_keycode32_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_keycode32_next

(

xcb_keycode32_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_keycode32_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_keycode32_t)

xcb_generic_iterator_t xcb_keycode_end

(

xcb_keycode_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_keycode_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_keycode_next

(

xcb_keycode_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_keycode_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_keycode_t)

xcb_generic_iterator_t xcb_keysym_end

(

xcb_keysym_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_keysym_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_keysym_next

(

xcb_keysym_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_keysym_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_keysym_t)

xcb_void_cookie_t xcb_kill_client

(

xcb_connection_t *

uint32_t

resource

)

kills a client

Parameters

cThe connection

resourceAny resource belonging to the client (for example a Window), used to identify the client connection.

The special value of XCB_KILL_ALL_TEMPORARY, the resources of all clients that have terminated in RetainTemporary (TODO) are destroyed.

ReturnsA cookie

Forces a close down of the client that created the specified resource.

References XCB_KILL_CLIENT.

xcb_void_cookie_t xcb_kill_client_checked

(

xcb_connection_t *

uint32_t

resource

)

kills a client

Parameters

cThe connection

resourceAny resource belonging to the client (for example a Window), used to identify the client connection.

The special value of XCB_KILL_ALL_TEMPORARY, the resources of all clients that have terminated in RetainTemporary (TODO) are destroyed.

ReturnsA cookie

Forces a close down of the client that created the specified resource.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_KILL_CLIENT.

xcb_list_extensions_cookie_t xcb_list_extensions

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_LIST_EXTENSIONS.

xcb_list_extensions_reply_t* xcb_list_extensions_reply

(

xcb_connection_t *

xcb_list_extensions_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_list_extensions_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_list_extensions_cookie_t xcb_list_extensions_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_LIST_EXTENSIONS.

xcb_list_fonts_cookie_t xcb_list_fonts

(

xcb_connection_t *

uint16_t

max_names,

uint16_t

pattern_len,

const char *

pattern

)

get matching font names

Parameters

cThe connection

max_namesThe maximum number of fonts to be returned.

pattern_lenThe length (in bytes) of pattern.

patternA font pattern, for example "-misc-fixed-*".

The asterisk (*) is a wildcard for any number of characters. The question mark (?) is a wildcard for a single character. Use of uppercase or lowercase does not matter.

ReturnsA cookie

Gets a list of available font names which match the given pattern.

References XCB_LIST_FONTS.

xcb_list_fonts_reply_t* xcb_list_fonts_reply

(

xcb_connection_t *

xcb_list_fonts_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_list_fonts_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_list_fonts_cookie_t xcb_list_fonts_unchecked

(

xcb_connection_t *

uint16_t

max_names,

uint16_t

pattern_len,

const char *

pattern

)

get matching font names

Parameters

cThe connection

max_namesThe maximum number of fonts to be returned.

pattern_lenThe length (in bytes) of pattern.

patternA font pattern, for example "-misc-fixed-*".

The asterisk (*) is a wildcard for any number of characters. The question mark (?) is a wildcard for a single character. Use of uppercase or lowercase does not matter.

ReturnsA cookie

Gets a list of available font names which match the given pattern.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_LIST_FONTS.

xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info

(

xcb_connection_t *

uint16_t

max_names,

uint16_t

pattern_len,

const char *

pattern

)

get matching font names and information

Parameters

cThe connection

max_namesThe maximum number of fonts to be returned.

pattern_lenThe length (in bytes) of pattern.

patternA font pattern, for example "-misc-fixed-*".

The asterisk (*) is a wildcard for any number of characters. The question mark (?) is a wildcard for a single character. Use of uppercase or lowercase does not matter.

ReturnsA cookie

Gets a list of available font names which match the given pattern.

References XCB_LIST_FONTS_WITH_INFO.

xcb_list_fonts_with_info_reply_t* xcb_list_fonts_with_info_reply

(

xcb_connection_t *

xcb_list_fonts_with_info_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_list_fonts_with_info_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info_unchecked

(

xcb_connection_t *

uint16_t

max_names,

uint16_t

pattern_len,

const char *

pattern

)

get matching font names and information

Parameters

cThe connection

max_namesThe maximum number of fonts to be returned.

pattern_lenThe length (in bytes) of pattern.

patternA font pattern, for example "-misc-fixed-*".

The asterisk (*) is a wildcard for any number of characters. The question mark (?) is a wildcard for a single character. Use of uppercase or lowercase does not matter.

ReturnsA cookie

Gets a list of available font names which match the given pattern.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, xcb_fontprop_end(), and XCB_LIST_FONTS_WITH_INFO.

xcb_list_hosts_cookie_t xcb_list_hosts

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_LIST_HOSTS.

xcb_list_hosts_reply_t* xcb_list_hosts_reply

(

xcb_connection_t *

xcb_list_hosts_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_list_hosts_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_list_hosts_cookie_t xcb_list_hosts_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_LIST_HOSTS.

xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_LIST_INSTALLED_COLORMAPS.

xcb_list_installed_colormaps_reply_t* xcb_list_installed_colormaps_reply

(

xcb_connection_t *

xcb_list_installed_colormaps_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_list_installed_colormaps_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps_unchecked

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_LIST_INSTALLED_COLORMAPS.

xcb_list_properties_cookie_t xcb_list_properties

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_LIST_PROPERTIES.

xcb_list_properties_reply_t* xcb_list_properties_reply

(

xcb_connection_t *

xcb_list_properties_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_list_properties_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_list_properties_cookie_t xcb_list_properties_unchecked

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_LIST_PROPERTIES.

xcb_lookup_color_cookie_t xcb_lookup_color

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint16_t

name_len,

const char *

name

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_LOOKUP_COLOR.

xcb_lookup_color_reply_t* xcb_lookup_color_reply

(

xcb_connection_t *

xcb_lookup_color_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_lookup_color_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_lookup_color_cookie_t xcb_lookup_color_unchecked

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint16_t

name_len,

const char *

name

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_LOOKUP_COLOR.

xcb_void_cookie_t xcb_map_subwindows

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_MAP_SUBWINDOWS.

xcb_void_cookie_t xcb_map_subwindows_checked

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_MAP_SUBWINDOWS.

xcb_void_cookie_t xcb_map_window

(

xcb_connection_t *

xcb_window_t

window

)

Makes a window visible.

Parameters

cThe connection

windowThe window to make visible.

ReturnsA cookie

Maps the specified window. This means making the window visible (as long as its parent is visible).

This MapWindow request will be translated to a MapRequest request if a window manager is running. The window manager then decides to either map the window or not. Set the override-redirect window attribute to true if you want to bypass this mechanism.

If the window manager decides to map the window (or if no window manager is running), a MapNotify event is generated.

If the window becomes viewable and no earlier contents for it are remembered, the X server tiles the window with its background. If the window's background is undefined, the existing screen contents are not altered, and the X server generates zero or more Expose events.

If the window type is InputOutput, an Expose event will be generated when the window becomes visible. The normal response to an Expose event should be to repaint the window.

References XCB_MAP_WINDOW.

xcb_void_cookie_t xcb_map_window_checked

(

xcb_connection_t *

xcb_window_t

window

)

Makes a window visible.

Parameters

cThe connection

windowThe window to make visible.

ReturnsA cookie

Maps the specified window. This means making the window visible (as long as its parent is visible).

If the window manager decides to map the window (or if no window manager is running), a MapNotify event is generated.

If the window type is InputOutput, an Expose event will be generated when the window becomes visible. The normal response to an Expose event should be to repaint the window.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_MAP_WINDOW.

xcb_void_cookie_t xcb_no_operation

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_NO_OPERATION.

xcb_void_cookie_t xcb_no_operation_checked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_NO_OPERATION.

xcb_void_cookie_t xcb_open_font

(

xcb_connection_t *

xcb_font_t

fid,

uint16_t

name_len,

const char *

name

)

opens a font

Parameters

cThe connection

fidThe ID with which you will refer to the font, created by xcb_generate_id.

name_lenLength (in bytes) of name.

nameA pattern describing an X core font.

ReturnsA cookie

Opens any X core font matching the given name (for example "-misc-fixed-*").

Note that X core fonts are deprecated (but still supported) in favor of client-side rendering using Xft.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_OPEN_FONT.

xcb_void_cookie_t xcb_open_font_checked

(

xcb_connection_t *

xcb_font_t

fid,

uint16_t

name_len,

const char *

name

)

opens a font

Parameters

cThe connection

fidThe ID with which you will refer to the font, created by xcb_generate_id.

name_lenLength (in bytes) of name.

nameA pattern describing an X core font.

ReturnsA cookie

Opens any X core font matching the given name (for example "-misc-fixed-*").

Note that X core fonts are deprecated (but still supported) in favor of client-side rendering using Xft.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_OPEN_FONT.

xcb_generic_iterator_t xcb_pixmap_end

(

xcb_pixmap_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_pixmap_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_pixmap_next

(

xcb_pixmap_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_pixmap_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_pixmap_t)

xcb_generic_iterator_t xcb_point_end

(

xcb_point_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_point_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_point_next

(

xcb_point_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_point_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_point_t)

xcb_void_cookie_t xcb_poly_arc

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

arcs_len,

const xcb_arc_t *

arcs

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_POLY_ARC.

xcb_void_cookie_t xcb_poly_arc_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

arcs_len,

const xcb_arc_t *

arcs

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_ARC.

xcb_void_cookie_t xcb_poly_fill_arc

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

arcs_len,

const xcb_arc_t *

arcs

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_POLY_FILL_ARC.

xcb_void_cookie_t xcb_poly_fill_arc_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

arcs_len,

const xcb_arc_t *

arcs

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_FILL_ARC.

xcb_void_cookie_t xcb_poly_fill_rectangle

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

rectangles_len,

const xcb_rectangle_t *

rectangles

)

Fills rectangles.

Parameters

cThe connection

drawableThe drawable (Window or Pixmap) to draw on.

gcThe graphics context to use.

The following graphics context components are used: function, plane-mask, fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.

The following graphics context mode-dependent components are used: foreground, background, tile, stipple, tile-stipple-x-origin, and tile-stipple-y-origin.

rectangles_lenThe number of xcb_rectangle_t structures in rectangles.

rectanglesThe rectangles to fill.

ReturnsA cookie

Fills the specified rectangle(s) in the order listed in the array. For any given rectangle, each pixel is not drawn more than once. If rectangles intersect, the intersecting pixels are drawn multiple times.

References XCB_POLY_FILL_RECTANGLE.

xcb_void_cookie_t xcb_poly_fill_rectangle_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

rectangles_len,

const xcb_rectangle_t *

rectangles

)

Fills rectangles.

Parameters

cThe connection

drawableThe drawable (Window or Pixmap) to draw on.

gcThe graphics context to use.

The following graphics context components are used: function, plane-mask, fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.

The following graphics context mode-dependent components are used: foreground, background, tile, stipple, tile-stipple-x-origin, and tile-stipple-y-origin.

rectangles_lenThe number of xcb_rectangle_t structures in rectangles.

rectanglesThe rectangles to fill.

ReturnsA cookie

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_FILL_RECTANGLE.

xcb_void_cookie_t xcb_poly_line

(

xcb_connection_t *

uint8_t

coordinate_mode,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

points_len,

const xcb_point_t *

points

)

draw lines

Parameters

cThe connection

coordinate_modeA bitmask of xcb_coord_mode_t values.

coordinate_mode

drawableThe drawable to draw the line(s) on.

gcThe graphics context to use.

points_lenThe number of xcb_point_t structures in points.

pointsAn array of points.

ReturnsA cookie

Draws points_len-1 lines between each pair of points (point[i], point[i+1]) in the points array. The lines are drawn in the order listed in the array. They join correctly at all intermediate points, and if the first and last points coincide, the first and last lines also join correctly. For any given line, a pixel is not drawn more than once. If thin (zero line-width) lines intersect, the intersecting pixels are drawn multiple times. If wide lines intersect, the intersecting pixels are drawn only once, as though the entire request were a single, filled shape.

References XCB_POLY_LINE.

xcb_void_cookie_t xcb_poly_line_checked

(

xcb_connection_t *

uint8_t

coordinate_mode,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

points_len,

const xcb_point_t *

points

)

draw lines

Parameters

cThe connection

coordinate_modeA bitmask of xcb_coord_mode_t values.

coordinate_mode

drawableThe drawable to draw the line(s) on.

gcThe graphics context to use.

points_lenThe number of xcb_point_t structures in points.

pointsAn array of points.

ReturnsA cookie

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_LINE.

xcb_void_cookie_t xcb_poly_point

(

xcb_connection_t *

uint8_t

coordinate_mode,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

points_len,

const xcb_point_t *

points

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_POLY_POINT.

xcb_void_cookie_t xcb_poly_point_checked

(

xcb_connection_t *

uint8_t

coordinate_mode,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

points_len,

const xcb_point_t *

points

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_POINT.

xcb_void_cookie_t xcb_poly_rectangle

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

rectangles_len,

const xcb_rectangle_t *

rectangles

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_POLY_RECTANGLE.

xcb_void_cookie_t xcb_poly_rectangle_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

rectangles_len,

const xcb_rectangle_t *

rectangles

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_RECTANGLE.

xcb_void_cookie_t xcb_poly_segment

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

segments_len,

const xcb_segment_t *

segments

)

draw lines

Parameters

cThe connection

drawableA drawable (Window or Pixmap) to draw on.

gcThe graphics context to use.

TODO: document which attributes of a gc are used

segments_lenThe number of xcb_segment_t structures in segments.

segmentsAn array of xcb_segment_t structures.

ReturnsA cookie

Draws multiple, unconnected lines. For each segment, a line is drawn between (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of xcb_segment_t structures and does not perform joining at coincident endpoints. For any given line, a pixel is not drawn more than once. If lines intersect, the intersecting pixels are drawn multiple times.

TODO: include the xcb_segment_t data structure

TODO: an example

References XCB_POLY_SEGMENT.

xcb_void_cookie_t xcb_poly_segment_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint32_t

segments_len,

const xcb_segment_t *

segments

)

draw lines

Parameters

cThe connection

drawableA drawable (Window or Pixmap) to draw on.

gcThe graphics context to use.

TODO: document which attributes of a gc are used

segments_lenThe number of xcb_segment_t structures in segments.

segmentsAn array of xcb_segment_t structures.

ReturnsA cookie

TODO: include the xcb_segment_t data structure

TODO: an example

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_SEGMENT.

xcb_void_cookie_t xcb_poly_text_16

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

uint32_t

items_len,

const uint8_t *

items

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_POLY_TEXT_16.

xcb_void_cookie_t xcb_poly_text_16_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

uint32_t

items_len,

const uint8_t *

items

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_TEXT_16.

xcb_void_cookie_t xcb_poly_text_8

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

uint32_t

items_len,

const uint8_t *

items

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_POLY_TEXT_8.

xcb_void_cookie_t xcb_poly_text_8_checked

(

xcb_connection_t *

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

int16_t

uint32_t

items_len,

const uint8_t *

items

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_POLY_TEXT_8.

xcb_void_cookie_t xcb_put_image

(

xcb_connection_t *

uint8_t

format,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint16_t

width,

uint16_t

height,

int16_t

dst_x,

int16_t

dst_y,

uint8_t

left_pad,

uint8_t

depth,

uint32_t

data_len,

const uint8_t *

data

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_PUT_IMAGE.

xcb_void_cookie_t xcb_put_image_checked

(

xcb_connection_t *

uint8_t

format,

xcb_drawable_t

drawable,

xcb_gcontext_t

gc,

uint16_t

width,

uint16_t

height,

int16_t

dst_x,

int16_t

dst_y,

uint8_t

left_pad,

uint8_t

depth,

uint32_t

data_len,

const uint8_t *

data

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_PUT_IMAGE.

xcb_query_best_size_cookie_t xcb_query_best_size

(

xcb_connection_t *

uint8_t

_class,

xcb_drawable_t

drawable,

uint16_t

width,

uint16_t

height

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_QUERY_BEST_SIZE.

xcb_query_best_size_reply_t* xcb_query_best_size_reply

(

xcb_connection_t *

xcb_query_best_size_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_best_size_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_query_best_size_cookie_t xcb_query_best_size_unchecked

(

xcb_connection_t *

uint8_t

_class,

xcb_drawable_t

drawable,

uint16_t

width,

uint16_t

height

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_QUERY_BEST_SIZE.

xcb_query_colors_cookie_t xcb_query_colors

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint32_t

pixels_len,

const uint32_t *

pixels

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_QUERY_COLORS.

xcb_query_colors_reply_t* xcb_query_colors_reply

(

xcb_connection_t *

xcb_query_colors_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_colors_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_query_colors_cookie_t xcb_query_colors_unchecked

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint32_t

pixels_len,

const uint32_t *

pixels

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_QUERY_COLORS.

xcb_query_extension_cookie_t xcb_query_extension

(

xcb_connection_t *

uint16_t

name_len,

const char *

name

)

check if extension is present

Parameters

cThe connection

name_lenThe length of name in bytes.

nameThe name of the extension to query, for example "RANDR". This is case sensitive!

ReturnsA cookie

Determines if the specified extension is present on this X11 server.

Every extension has a unique major_opcode to identify requests, the minor opcodes and request formats are extension-specific. If the extension provides events and errors, the first_event and first_error fields in the reply are set accordingly.

There should rarely be a need to use this request directly, XCB provides the xcb_get_extension_data function instead.

References XCB_QUERY_EXTENSION.

xcb_query_extension_reply_t* xcb_query_extension_reply

(

xcb_connection_t *

xcb_query_extension_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_extension_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

Referenced by xcb_get_extension_data().

xcb_query_extension_cookie_t xcb_query_extension_unchecked

(

xcb_connection_t *

uint16_t

name_len,

const char *

name

)

check if extension is present

Parameters

cThe connection

name_lenThe length of name in bytes.

nameThe name of the extension to query, for example "RANDR". This is case sensitive!

ReturnsA cookie

Determines if the specified extension is present on this X11 server.

There should rarely be a need to use this request directly, XCB provides the xcb_get_extension_data function instead.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_QUERY_EXTENSION.

xcb_query_font_cookie_t xcb_query_font

(

xcb_connection_t *

xcb_fontable_t

font

)

query font metrics

Parameters

cThe connection

fontThe fontable (Font or Graphics Context) to query.

ReturnsA cookie

Queries information associated with the font.

References XCB_QUERY_FONT.

xcb_query_font_reply_t* xcb_query_font_reply

(

xcb_connection_t *

xcb_query_font_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_font_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_query_font_cookie_t xcb_query_font_unchecked

(

xcb_connection_t *

xcb_fontable_t

font

)

query font metrics

Parameters

cThe connection

fontThe fontable (Font or Graphics Context) to query.

ReturnsA cookie

Queries information associated with the font.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_fontprop_end(), and XCB_QUERY_FONT.

xcb_query_keymap_cookie_t xcb_query_keymap

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_QUERY_KEYMAP.

xcb_query_keymap_reply_t* xcb_query_keymap_reply

(

xcb_connection_t *

xcb_query_keymap_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_keymap_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_query_keymap_cookie_t xcb_query_keymap_unchecked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_QUERY_KEYMAP.

xcb_query_pointer_cookie_t xcb_query_pointer

(

xcb_connection_t *

xcb_window_t

window

)

get pointer coordinates

Parameters

cThe connection

windowA window to check if the pointer is on the same screen as window (see the same_screen field in the reply).

ReturnsA cookie

Gets the root window the pointer is logically on and the pointer coordinates relative to the root window's origin.

References XCB_QUERY_POINTER.

xcb_query_pointer_reply_t* xcb_query_pointer_reply

(

xcb_connection_t *

xcb_query_pointer_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_pointer_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_query_pointer_cookie_t xcb_query_pointer_unchecked

(

xcb_connection_t *

xcb_window_t

window

)

get pointer coordinates

Parameters

cThe connection

windowA window to check if the pointer is on the same screen as window (see the same_screen field in the reply).

ReturnsA cookie

Gets the root window the pointer is logically on and the pointer coordinates relative to the root window's origin.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_QUERY_POINTER.

xcb_query_text_extents_cookie_t xcb_query_text_extents

(

xcb_connection_t *

xcb_fontable_t

font,

uint32_t

string_len,

const xcb_char2b_t *

string

)

get text extents

Parameters

cThe connection

fontThe font to calculate text extents in. You can also pass a graphics context.

string_lenThe number of characters in string.

stringThe text to get text extents for.

ReturnsA cookie

Query text extents from the X11 server. This request returns the bounding box of the specified 16-bit character string in the specified font or the font contained in the specified graphics context.

font_ascent is set to the maximum of the ascent metrics of all characters in the string. font_descent is set to the maximum of the descent metrics. overall_width is set to the sum of the character-width metrics of all characters in the string. For each character in the string, let W be the sum of the character-width metrics of all characters preceding it in the string. Let L be the left-side-bearing metric of the character plus W. Let R be the right-side-bearing metric of the character plus W. The lbearing member is set to the minimum L of all characters in the string. The rbearing member is set to the maximum R.

For fonts defined with linear indexing rather than 2-byte matrix indexing, each xcb_char2b_t structure is interpreted as a 16-bit number with byte1 as the most significant byte. If the font has no defined default character, undefined characters in the string are taken to have all zero metrics.

Characters with all zero metrics are ignored. If the font has no defined default_char, the undefined characters in the string are also ignored.

References XCB_QUERY_TEXT_EXTENTS.

xcb_query_text_extents_reply_t* xcb_query_text_extents_reply

(

xcb_connection_t *

xcb_query_text_extents_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_text_extents_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

xcb_query_text_extents_cookie_t xcb_query_text_extents_unchecked

(

xcb_connection_t *

xcb_fontable_t

font,

uint32_t

string_len,

const xcb_char2b_t *

string

)

get text extents

Parameters

cThe connection

fontThe font to calculate text extents in. You can also pass a graphics context.

string_lenThe number of characters in string.

stringThe text to get text extents for.

ReturnsA cookie

Query text extents from the X11 server. This request returns the bounding box of the specified 16-bit character string in the specified font or the font contained in the specified graphics context.

Characters with all zero metrics are ignored. If the font has no defined default_char, the undefined characters in the string are also ignored.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_QUERY_TEXT_EXTENTS.

xcb_query_tree_cookie_t xcb_query_tree

(

xcb_connection_t *

xcb_window_t

window

)

query the window tree

Parameters

cThe connection

windowThe window to query.

ReturnsA cookie

Gets the root window ID, parent window ID and list of children windows for the specified window. The children are listed in bottom-to-top stacking order.

References XCB_QUERY_TREE.

xcb_query_tree_reply_t* xcb_query_tree_reply

(

xcb_connection_t *

xcb_query_tree_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_query_tree_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_query_tree_cookie_t xcb_query_tree_unchecked

(

xcb_connection_t *

xcb_window_t

window

)

query the window tree

Parameters

cThe connection

windowThe window to query.

ReturnsA cookie

Gets the root window ID, parent window ID and list of children windows for the specified window. The children are listed in bottom-to-top stacking order.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_QUERY_TREE.

xcb_void_cookie_t xcb_recolor_cursor

(

xcb_connection_t *

xcb_cursor_t

cursor,

uint16_t

fore_red,

uint16_t

fore_green,

uint16_t

fore_blue,

uint16_t

back_red,

uint16_t

back_green,

uint16_t

back_blue

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_RECOLOR_CURSOR.

xcb_void_cookie_t xcb_recolor_cursor_checked

(

xcb_connection_t *

xcb_cursor_t

cursor,

uint16_t

fore_red,

uint16_t

fore_green,

uint16_t

fore_blue,

uint16_t

back_red,

uint16_t

back_green,

uint16_t

back_blue

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_RECOLOR_CURSOR.

xcb_generic_iterator_t xcb_rectangle_end

(

xcb_rectangle_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_rectangle_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_rectangle_next

(

xcb_rectangle_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_rectangle_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_rectangle_t)

xcb_void_cookie_t xcb_reparent_window

(

xcb_connection_t *

xcb_window_t

window,

xcb_window_t

parent,

int16_t

)

Reparents a window.

Parameters

cThe connection

windowThe window to reparent.

parentThe new parent of the window.

xThe X position of the window within its new parent.

yThe Y position of the window within its new parent.

ReturnsA cookie

Makes the specified window a child of the specified parent window. If the window is mapped, it will automatically be unmapped before reparenting and re-mapped after reparenting. The window is placed in the stacking order on top with respect to sibling windows.

After reparenting, a ReparentNotify event is generated.

References XCB_REPARENT_WINDOW.

xcb_void_cookie_t xcb_reparent_window_checked

(

xcb_connection_t *

xcb_window_t

window,

xcb_window_t

parent,

int16_t

)

Reparents a window.

Parameters

cThe connection

windowThe window to reparent.

parentThe new parent of the window.

xThe X position of the window within its new parent.

yThe Y position of the window within its new parent.

ReturnsA cookie

After reparenting, a ReparentNotify event is generated.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_REPARENT_WINDOW.

xcb_generic_iterator_t xcb_rgb_end

(

xcb_rgb_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_rgb_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_rgb_next

(

xcb_rgb_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_rgb_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_rgb_t)

xcb_void_cookie_t xcb_rotate_properties

(

xcb_connection_t *

xcb_window_t

window,

uint16_t

atoms_len,

int16_t

delta,

const xcb_atom_t *

atoms

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_ROTATE_PROPERTIES.

xcb_void_cookie_t xcb_rotate_properties_checked

(

xcb_connection_t *

xcb_window_t

window,

uint16_t

atoms_len,

int16_t

delta,

const xcb_atom_t *

atoms

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_ROTATE_PROPERTIES.

xcb_generic_iterator_t xcb_screen_end

(

xcb_screen_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_screen_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_screen_next().

void xcb_screen_next

(

xcb_screen_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_screen_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_screen_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_screen_end().

xcb_generic_iterator_t xcb_segment_end

(

xcb_segment_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_segment_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_segment_next

(

xcb_segment_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_segment_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_segment_t)

xcb_void_cookie_t xcb_send_event

(

xcb_connection_t *

uint8_t

propagate,

xcb_window_t

destination,

uint32_t

event_mask,

const char *

event

)

send an event

Parameters

cThe connection

propagateIf propagate is true and no clients have selected any event on destination, the destination is replaced with the closest ancestor of destination for which some client has selected a type in event_mask and for which no intervening window has that type in its do-not-propagate-mask. If no such window exists or if the window is an ancestor of the focus window and InputFocus was originally specified as the destination, the event is not sent to any clients. Otherwise, the event is reported to every client selecting on the final destination any of the types specified in event_mask.

destinationThe window to send this event to. Every client which selects any event within event_mask on destination will get the event.

The special value XCB_SEND_EVENT_DEST_POINTER_WINDOW refers to the window that contains the mouse pointer.

The special value XCB_SEND_EVENT_DEST_ITEM_FOCUS refers to the window which has the keyboard focus.

event_maskEvent_mask for determining which clients should receive the specified event. See destination and propagate.

eventThe event to send to the specified destination.

ReturnsA cookie

Identifies the destination window, determines which clients should receive the specified event and ignores any active grabs.

The event must be one of the core events or an event defined by an extension, so that the X server can correctly byte-swap the contents as necessary. The contents of event are otherwise unaltered and unchecked except for the send_event field which is forced to 'true'.

References XCB_SEND_EVENT.

xcb_void_cookie_t xcb_send_event_checked

(

xcb_connection_t *

uint8_t

propagate,

xcb_window_t

destination,

uint32_t

event_mask,

const char *

event

)

send an event

Parameters

cThe connection

destinationThe window to send this event to. Every client which selects any event within event_mask on destination will get the event.

The special value XCB_SEND_EVENT_DEST_POINTER_WINDOW refers to the window that contains the mouse pointer.

The special value XCB_SEND_EVENT_DEST_ITEM_FOCUS refers to the window which has the keyboard focus.

event_maskEvent_mask for determining which clients should receive the specified event. See destination and propagate.

eventThe event to send to the specified destination.

ReturnsA cookie

Identifies the destination window, determines which clients should receive the specified event and ignores any active grabs.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SEND_EVENT.

xcb_void_cookie_t xcb_set_access_control

(

xcb_connection_t *

uint8_t

mode

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_ACCESS_CONTROL.

xcb_void_cookie_t xcb_set_access_control_checked

(

xcb_connection_t *

uint8_t

mode

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_ACCESS_CONTROL.

xcb_void_cookie_t xcb_set_clip_rectangles

(

xcb_connection_t *

uint8_t

ordering,

xcb_gcontext_t

gc,

int16_t

clip_x_origin,

int16_t

clip_y_origin,

uint32_t

rectangles_len,

const xcb_rectangle_t *

rectangles

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_CLIP_RECTANGLES.

xcb_void_cookie_t xcb_set_clip_rectangles_checked

(

xcb_connection_t *

uint8_t

ordering,

xcb_gcontext_t

gc,

int16_t

clip_x_origin,

int16_t

clip_y_origin,

uint32_t

rectangles_len,

const xcb_rectangle_t *

rectangles

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_CLIP_RECTANGLES.

xcb_void_cookie_t xcb_set_close_down_mode

(

xcb_connection_t *

uint8_t

mode

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_CLOSE_DOWN_MODE.

xcb_void_cookie_t xcb_set_close_down_mode_checked

(

xcb_connection_t *

uint8_t

mode

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_CLOSE_DOWN_MODE.

xcb_void_cookie_t xcb_set_dashes

(

xcb_connection_t *

xcb_gcontext_t

gc,

uint16_t

dash_offset,

uint16_t

dashes_len,

const uint8_t *

dashes

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_SET_DASHES.

xcb_void_cookie_t xcb_set_dashes_checked

(

xcb_connection_t *

xcb_gcontext_t

gc,

uint16_t

dash_offset,

uint16_t

dashes_len,

const uint8_t *

dashes

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_DASHES.

xcb_void_cookie_t xcb_set_font_path

(

xcb_connection_t *

uint16_t

font_qty,

const xcb_str_t *

font

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_FONT_PATH.

xcb_void_cookie_t xcb_set_font_path_checked

(

xcb_connection_t *

uint16_t

font_qty,

const xcb_str_t *

font

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_FONT_PATH.

xcb_void_cookie_t xcb_set_input_focus

(

xcb_connection_t *

uint8_t

revert_to,

xcb_window_t

focus,

xcb_timestamp_t

time

)

Sets input focus.

Parameters

cThe connection

revert_toA bitmask of xcb_input_focus_t values.

revert_toSpecifies what happens when the focus window becomes unviewable (if focus is neither XCB_NONE nor XCB_POINTER_ROOT).

focusThe window to focus. All keyboard events will be reported to this window. The window must be viewable (TODO), or a xcb_match_error_t occurs (TODO).

If focus is XCB_NONE (TODO), all keyboard events are discarded until a new focus window is set.

If focus is XCB_POINTER_ROOT (TODO), focus is on the root window of the screen on which the pointer is on currently.

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

Changes the input focus and the last-focus-change time. If the specified time is earlier than the current last-focus-change time, the request is ignored (to avoid race conditions when running X over the network).

A FocusIn and FocusOut event is generated when focus is changed.

References XCB_SET_INPUT_FOCUS.

xcb_void_cookie_t xcb_set_input_focus_checked

(

xcb_connection_t *

uint8_t

revert_to,

xcb_window_t

focus,

xcb_timestamp_t

time

)

Sets input focus.

Parameters

cThe connection

revert_toA bitmask of xcb_input_focus_t values.

revert_toSpecifies what happens when the focus window becomes unviewable (if focus is neither XCB_NONE nor XCB_POINTER_ROOT).

focusThe window to focus. All keyboard events will be reported to this window. The window must be viewable (TODO), or a xcb_match_error_t occurs (TODO).

If focus is XCB_NONE (TODO), all keyboard events are discarded until a new focus window is set.

If focus is XCB_POINTER_ROOT (TODO), focus is on the root window of the screen on which the pointer is on currently.

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

A FocusIn and FocusOut event is generated when focus is changed.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_INPUT_FOCUS.

xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping

(

xcb_connection_t *

uint8_t

keycodes_per_modifier,

const xcb_keycode_t *

keycodes

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_MODIFIER_MAPPING.

xcb_set_modifier_mapping_reply_t* xcb_set_modifier_mapping_reply

(

xcb_connection_t *

xcb_set_modifier_mapping_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_set_modifier_mapping_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping_unchecked

(

xcb_connection_t *

uint8_t

keycodes_per_modifier,

const xcb_keycode_t *

keycodes

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_SET_MODIFIER_MAPPING.

xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping

(

xcb_connection_t *

uint8_t

map_len,

const uint8_t *

map

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_POINTER_MAPPING.

xcb_set_pointer_mapping_reply_t* xcb_set_pointer_mapping_reply

(

xcb_connection_t *

xcb_set_pointer_mapping_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_set_pointer_mapping_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping_unchecked

(

xcb_connection_t *

uint8_t

map_len,

const uint8_t *

map

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_SET_POINTER_MAPPING.

xcb_void_cookie_t xcb_set_screen_saver

(

xcb_connection_t *

int16_t

timeout,

int16_t

interval,

uint8_t

prefer_blanking,

uint8_t

allow_exposures

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_SET_SCREEN_SAVER.

xcb_void_cookie_t xcb_set_screen_saver_checked

(

xcb_connection_t *

int16_t

timeout,

int16_t

interval,

uint8_t

prefer_blanking,

uint8_t

allow_exposures

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_SCREEN_SAVER.

xcb_void_cookie_t xcb_set_selection_owner

(

xcb_connection_t *

xcb_window_t

owner,

xcb_atom_t

selection,

xcb_timestamp_t

time

)

Sets the owner of a selection.

Parameters

cThe connection

ownerThe new owner of the selection.

The special value XCB_NONE means that the selection will have no owner.

selectionThe selection.

timeTimestamp to avoid race conditions when running X over the network.

The selection will not be changed if time is earlier than the current last-change time of the selection or is later than the current X server time. Otherwise, the last-change time is set to the specified time.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

Makes window the owner of the selection selection and updates the last-change time of the specified selection.

TODO: briefly explain what a selection is.

References XCB_SET_SELECTION_OWNER.

xcb_void_cookie_t xcb_set_selection_owner_checked

(

xcb_connection_t *

xcb_window_t

owner,

xcb_atom_t

selection,

xcb_timestamp_t

time

)

Sets the owner of a selection.

Parameters

cThe connection

ownerThe new owner of the selection.

The special value XCB_NONE means that the selection will have no owner.

selectionThe selection.

timeTimestamp to avoid race conditions when running X over the network.

The special value XCB_CURRENT_TIME will be replaced with the current server time.

ReturnsA cookie

Makes window the owner of the selection selection and updates the last-change time of the specified selection.

TODO: briefly explain what a selection is.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_SET_SELECTION_OWNER.

xcb_generic_iterator_t xcb_setup_authenticate_end

(

xcb_setup_authenticate_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_setup_authenticate_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, xcb_format_end(), and xcb_setup_authenticate_next().

void xcb_setup_authenticate_next

(

xcb_setup_authenticate_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_setup_authenticate_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_setup_authenticate_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_setup_authenticate_end().

xcb_generic_iterator_t xcb_setup_end

(

xcb_setup_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_setup_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_setup_next().

xcb_generic_iterator_t xcb_setup_failed_end

(

xcb_setup_failed_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_setup_failed_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_setup_failed_next().

void xcb_setup_failed_next

(

xcb_setup_failed_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_setup_failed_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_setup_failed_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_setup_failed_end().

void xcb_setup_next

(

xcb_setup_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_setup_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_setup_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_setup_end().

xcb_generic_iterator_t xcb_setup_request_end

(

xcb_setup_request_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_setup_request_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_setup_request_next().

void xcb_setup_request_next

(

xcb_setup_request_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_setup_request_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_setup_request_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_setup_request_end().

xcb_void_cookie_t xcb_store_colors

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint32_t

items_len,

const xcb_coloritem_t *

items

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_STORE_COLORS.

xcb_void_cookie_t xcb_store_colors_checked

(

xcb_connection_t *

xcb_colormap_t

cmap,

uint32_t

items_len,

const xcb_coloritem_t *

items

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_STORE_COLORS.

xcb_void_cookie_t xcb_store_named_color

(

xcb_connection_t *

uint8_t

flags,

xcb_colormap_t

cmap,

uint32_t

pixel,

uint16_t

name_len,

const char *

name

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and XCB_STORE_NAMED_COLOR.

xcb_void_cookie_t xcb_store_named_color_checked

(

xcb_connection_t *

uint8_t

flags,

xcb_colormap_t

cmap,

uint32_t

pixel,

uint16_t

name_len,

const char *

name

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_STORE_NAMED_COLOR.

xcb_generic_iterator_t xcb_str_end

(

xcb_str_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_str_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, xcb_generic_iterator_t::rem, and xcb_str_next().

void xcb_str_next

(

xcb_str_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_str_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_str_t)

References xcb_generic_iterator_t::data.

Referenced by xcb_str_end().

xcb_generic_iterator_t xcb_timecoord_end

(

xcb_timecoord_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_timecoord_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_timecoord_next

(

xcb_timecoord_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_timecoord_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_timecoord_t)

xcb_generic_iterator_t xcb_timestamp_end

(

xcb_timestamp_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_timestamp_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_timestamp_next

(

xcb_timestamp_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_timestamp_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_timestamp_t)

xcb_translate_coordinates_cookie_t xcb_translate_coordinates

(

xcb_connection_t *

xcb_window_t

src_window,

xcb_window_t

dst_window,

int16_t

src_x,

int16_t

src_y

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_TRANSLATE_COORDINATES.

xcb_translate_coordinates_reply_t* xcb_translate_coordinates_reply

(

xcb_connection_t *

xcb_translate_coordinates_cookie_t

cookie,

xcb_generic_error_t **

)

Return the reply Parameters

cThe connection

cookieThe cookie

eThe xcb_generic_error_t supplied

Returns the reply of the request asked by

The parameter e supplied to this function must be NULL if xcb_translate_coordinates_unchecked(). is used. Otherwise, it stores the error if any.

The returned value must be freed by the caller using free().

xcb_translate_coordinates_cookie_t xcb_translate_coordinates_unchecked

(

xcb_connection_t *

xcb_window_t

src_window,

xcb_window_t

dst_window,

int16_t

src_x,

int16_t

src_y

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will cause a reply to be generated. Any returned error will be placed in the event queue.

References XCB_TRANSLATE_COORDINATES.

xcb_void_cookie_t xcb_ungrab_button

(

xcb_connection_t *

uint8_t

button,

xcb_window_t

grab_window,

uint16_t

modifiers

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_UNGRAB_BUTTON.

xcb_void_cookie_t xcb_ungrab_button_checked

(

xcb_connection_t *

uint8_t

button,

xcb_window_t

grab_window,

uint16_t

modifiers

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNGRAB_BUTTON.

xcb_void_cookie_t xcb_ungrab_key

(

xcb_connection_t *

xcb_keycode_t

key,

xcb_window_t

grab_window,

uint16_t

modifiers

)

release a key combination

Parameters

cThe connection

keyThe keycode of the specified key combination.

Using the special value XCB_GRAB_ANY means releasing all possible key codes.

grab_windowThe window on which the grabbed key combination will be released.

modifiersThe modifiers of the specified key combination.

Using the special value XCB_MOD_MASK_ANY means releasing the key combination with every possible modifier combination.

ReturnsA cookie

Releases the key combination on grab_window if you grabbed it using xcb_grab_key before.

References XCB_UNGRAB_KEY.

xcb_void_cookie_t xcb_ungrab_key_checked

(

xcb_connection_t *

xcb_keycode_t

key,

xcb_window_t

grab_window,

uint16_t

modifiers

)

release a key combination

Parameters

cThe connection

keyThe keycode of the specified key combination.

Using the special value XCB_GRAB_ANY means releasing all possible key codes.

grab_windowThe window on which the grabbed key combination will be released.

modifiersThe modifiers of the specified key combination.

Using the special value XCB_MOD_MASK_ANY means releasing the key combination with every possible modifier combination.

ReturnsA cookie

Releases the key combination on grab_window if you grabbed it using xcb_grab_key before.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNGRAB_KEY.

xcb_void_cookie_t xcb_ungrab_keyboard

(

xcb_connection_t *

xcb_timestamp_t

time

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_UNGRAB_KEYBOARD.

xcb_void_cookie_t xcb_ungrab_keyboard_checked

(

xcb_connection_t *

xcb_timestamp_t

time

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNGRAB_KEYBOARD.

xcb_void_cookie_t xcb_ungrab_pointer

(

xcb_connection_t *

xcb_timestamp_t

time

)

release the pointer

Parameters

cThe connection

timeTimestamp to avoid race conditions when running X over the network.

The pointer will not be released if time is earlier than the last-pointer-grab time or later than the current X server time.

ReturnsA cookie

Releases the pointer and any queued events if you actively grabbed the pointer before using xcb_grab_pointer, xcb_grab_button or within a normal button press.

EnterNotify and LeaveNotify events are generated.

References XCB_UNGRAB_POINTER.

xcb_void_cookie_t xcb_ungrab_pointer_checked

(

xcb_connection_t *

xcb_timestamp_t

time

)

release the pointer

Parameters

cThe connection

timeTimestamp to avoid race conditions when running X over the network.

The pointer will not be released if time is earlier than the last-pointer-grab time or later than the current X server time.

ReturnsA cookie

Releases the pointer and any queued events if you actively grabbed the pointer before using xcb_grab_pointer, xcb_grab_button or within a normal button press.

EnterNotify and LeaveNotify events are generated.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNGRAB_POINTER.

xcb_void_cookie_t xcb_ungrab_server

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_UNGRAB_SERVER.

xcb_void_cookie_t xcb_ungrab_server_checked

(

xcb_connection_t *

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNGRAB_SERVER.

xcb_void_cookie_t xcb_uninstall_colormap

(

xcb_connection_t *

xcb_colormap_t

cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_UNINSTALL_COLORMAP.

xcb_void_cookie_t xcb_uninstall_colormap_checked

(

xcb_connection_t *

xcb_colormap_t

cmap

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNINSTALL_COLORMAP.

xcb_void_cookie_t xcb_unmap_subwindows

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

References XCB_UNMAP_SUBWINDOWS.

xcb_void_cookie_t xcb_unmap_subwindows_checked

(

xcb_connection_t *

xcb_window_t

window

)

Parameters

cThe connection

ReturnsA cookie

Delivers a request to the X server.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNMAP_SUBWINDOWS.

xcb_void_cookie_t xcb_unmap_window

(

xcb_connection_t *

xcb_window_t

window

)

Makes a window invisible.

Parameters

cThe connection

windowThe window to make invisible.

ReturnsA cookie

Unmaps the specified window. This means making the window invisible (and all its child windows).

Unmapping a window leads to the UnmapNotify event being generated. Also, Expose events are generated for formerly obscured windows.

References XCB_UNMAP_WINDOW.

xcb_void_cookie_t xcb_unmap_window_checked

(

xcb_connection_t *

xcb_window_t

window

)

Makes a window invisible.

Parameters

cThe connection

windowThe window to make invisible.

ReturnsA cookie

Unmaps the specified window. This means making the window invisible (and all its child windows).

Unmapping a window leads to the UnmapNotify event being generated. Also, Expose events are generated for formerly obscured windows.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_UNMAP_WINDOW.

xcb_generic_iterator_t xcb_visualid_end

(

xcb_visualid_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_visualid_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_visualid_next

(

xcb_visualid_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_visualid_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_visualid_t)

xcb_generic_iterator_t xcb_visualtype_end

(

xcb_visualtype_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_visualtype_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_visualtype_next

(

xcb_visualtype_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_visualtype_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_visualtype_t)

xcb_void_cookie_t xcb_warp_pointer

(

xcb_connection_t *

xcb_window_t

src_window,

xcb_window_t

dst_window,

int16_t

src_x,

int16_t

src_y,

uint16_t

src_width,

uint16_t

src_height,

int16_t

dst_x,

int16_t

dst_y

)

move mouse pointer

Parameters

cThe connection

src_windowIf src_window is not XCB_NONE (TODO), the move will only take place if the pointer is inside src_window and within the rectangle specified by (src_x, src_y, src_width, src_height). The rectangle coordinates are relative to src_window.

dst_windowIf dst_window is not XCB_NONE (TODO), the pointer will be moved to the offsets (dst_x, dst_y) relative to dst_window. If dst_window is XCB_NONE (TODO), the pointer will be moved by the offsets (dst_x, dst_y) relative to the current position of the pointer.

ReturnsA cookie

Moves the mouse pointer to the specified position.

If src_window is not XCB_NONE (TODO), the move will only take place if the pointer is inside src_window and within the rectangle specified by (src_x, src_y, src_width, src_height). The rectangle coordinates are relative to src_window.

If dst_window is not XCB_NONE (TODO), the pointer will be moved to the offsets (dst_x, dst_y) relative to dst_window. If dst_window is XCB_NONE (TODO), the pointer will be moved by the offsets (dst_x, dst_y) relative to the current position of the pointer.

References XCB_WARP_POINTER.

xcb_void_cookie_t xcb_warp_pointer_checked

(

xcb_connection_t *

xcb_window_t

src_window,

xcb_window_t

dst_window,

int16_t

src_x,

int16_t

src_y,

uint16_t

src_width,

uint16_t

src_height,

int16_t

dst_x,

int16_t

dst_y

)

move mouse pointer

Parameters

cThe connection

ReturnsA cookie

Moves the mouse pointer to the specified position.

This form can be used only if the request will not cause a reply to be generated. Any returned error will be saved for handling by xcb_request_check().

References XCB_WARP_POINTER.

xcb_generic_iterator_t xcb_window_end

(

xcb_window_iterator_t

Return the iterator pointing to the last element Parameters

iAn xcb_window_iterator_t

ReturnsThe iterator pointing to the last element

Set the current element in the iterator to the last element. The member rem is set to 0. The member data points to the last element.

References xcb_generic_iterator_t::data, xcb_generic_iterator_t::index, and xcb_generic_iterator_t::rem.

void xcb_window_next

(

xcb_window_iterator_t *

Get the next element of the iterator Parameters

iPointer to a xcb_window_iterator_t

Get the next element in the iterator. The member rem is decreased by one. The member data points to the next element. The member index is increased by sizeof(xcb_window_t)

Generated by

1.8.11

Linux XCB_xcb gtk qt-CSDN博客

Linux XCB

最新推荐文章于 2024-03-06 15:27:44 发布

顺其自然~

最新推荐文章于 2024-03-06 15:27:44 发布

阅读量1.7k

点赞数

文章标签：

linux

运维

服务器

本文链接：https://blog.csdn.net/fuhanghang/article/details/130129691

版权

X协议的c语言绑定(XCB： The X protocol C-language Binding) 是一种替代Xlib具有占用空间小，延迟隐藏，直接访问协议，提高线程的支持，和可扩展性。

基本的窗口和绘制（basicwindowsanddrawing）事件（events）文本和字体（fonts）窗口的内容和操作（windowcontextandmanipulation）颜色和像素地图（https://xcb.freedesktop.org/colorsandpixmaps/）鼠标光标（mousecursors）Xlib 到XCB的翻译引导（xlibtoxcbtranslationguide）

介绍

这个手册是用来介绍给想用XCB library进行编程需要的人们。像使用Xlib library来使用XCB，因为不是大多数的编程人员都想要写X的应用程序。而更多的开发者是想使用更高级的GUI 开发工具，如Motif，LessTiff，GTK，Qt，EWL，or ETK 或者更高级的使用library Cairo来进行绘制。虽然，不是所有的XCB的基础都很复杂，了其他一些库的上层的东西也不是坏事。

在读完这个手册之后，一个人可以写简单图形程序而不是好看的图形界面（至少是相对简单的）。在写应用程序之前，这个先前的关于上面库的了解是更有必要的。

什么是XCB，为什么它为存在？

XCB("X C Bing")是一个低级的api给X window server。 XCB是Xlib的一个替代产物，Xlib曾是多年以来标准的C绑定的给X Window System 协议的库。Xlib表现得很优秀，但是对于应用程序来说也有很多不理想的地方，例如：

小平台： Xlib包含在大段的代码，精简起来十分困难延迟隐藏：Xlib需要有效的同步回复：他们会一直阻塞直到获取到结果，不管这个结果是否立即需要直接访问协议：Xlib需要大量的缓存，层和相似的优化。由于这个通性，它很难简单的发出特定的X 协议请求和处理特定的响应线程化应用程序：Xlib尽量会支持多线程，它的api的容错性较差新的扩展：Xlib的底部架构提供了有限的支持给新的X的扩展客户端代码。

XCB被设计用来解决上述的问题，目前已经解决的有：

工具包的实现直接进行协议级的编程轻量级的调用常用的Xlib api.

Xcb 的全称是 X 协议 C 库，它是一种让在 X Window 活动图形框架中的 Linux 中的程序更易于使用。Xcb 是一种为原生 X 协议提供一个高级接口的库。它允许用户使用函数调用，而不是手动构造消息来访问 X 协议。Xcb 的特点是它是轻量级的，低维护，运行速度快。Xcb 使用在链接器中编译的函数库来缩短天生 X 协议消息的小编程意味，它让用户可以不必担心包装 X 协议消息的技术细节。

在开始使用 Xcb 之前，我们需要一种方法来安装它。如果你使用的是 Ubuntu，你可以使用下面的命令来安装：

“`bash

sudo apt-get install libxcb1-dev

安装之后，我们就可以开始使用 Xcb。要想创建图形界面，我们首先需要做的就是创建 xcb 的连接：

```C

xcb_connection_t *conn = xcb_connect(NULL, NULL);

连接建立之后，我们还需要获取窗口：

“`C

xcb_window_t window = xcb_generate_id(conn);

uint32_t value_list[] = {600, 400};

xcb_create_window(conn,

XCB_COPY_FROM_PARENT,

window,

screen->root,

0, 0,

value_list[0], value_list[1],

XCB_WINDOW_CLASS_INPUT_OUTPUT,

screen->root_visual,

0, NULL );

在窗口创建之后，我们需要把它显示在屏幕上：

```C

xcb_map_window(conn, window);

xcb_flush(conn);

经过以上操作，我们就创建了一个空白窗口。现在，如果我们想要把它绘制成我们想要的样子，我们可以使用 Xcb 的一些其他功能。

另一种在 Linux 中开发图形界面的方法是使用 Qt。Qt 是一个开源的 C++ 框架，它的优势在于它的易用性，以及它的强大的图形功能。此外，它还支持跨平台开发，因此也被用作在 Linux 下开发图形界面的工具。

优惠劵

顺其自然~

关注

踩

觉得还不错?

一键收藏

打赏

知道了

Linux XCB

而更多的开发者是想使用更高级的GUI 开发工具，如Motif，LessTiff，GTK，Qt，EWL，or ETK 或者更高级的使用library Cairo来进行绘制。Qt 是一个开源的 C++ 框架，它的优势在于它的易用性，以及它的强大的图形功能。XCB是Xlib的一个替代产物，Xlib曾是多年以来标准的C绑定的给X Window System 协议的库。Xcb 的全称是 X 协议 C 库，它是一种让在 X Window 活动图形框架中的 Linux 中的程序更易于使用。什么是XCB，为什么它为存在？

复制链接

扫一扫

xcb-util-0.4.0-2.el7.x86_64.rpm

11-30

离线安装包，亲测可用

x11 gtk qt gnome kde 之间的区别和联系

weixin_55163060的博客

08-12

1195

x11 gtk qt gnome kde 之间的区别和联系

参与评论

您还未登录，请先

后发表或查看评论

【ARM开发】交叉编译Qt源码之（4）添加xcb支持

console_log的博客

02-16

5163

Debian 9

1、依赖

Qt源码添加xcb支持，依赖xcb-util-wm、xcb-util、xcb-util-image、xcb-util-keysyms、xcb-util-renderutil、libxkbcommon，其中libxkbcommon依赖libxml。

1.1、xcb-util-wm

下载地址：Index of /releases/individual/xcbhttps://www.x.org/releases/individual/xcb/

#解压

tar -zxvf x

XCB tutorial