xcb_aux.h   xcb_aux.h 
#ifndef __XCB_AUX_H__ #ifndef __XCB_AUX_H__
#define __XCB_AUX_H__ #define __XCB_AUX_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
uint8_t xcb_aux_get_depth (xcb_connection_t *c, uint8_t xcb_aux_get_depth (xcb_connection_t *c,
xcb_screen_t *screen); xcb_screen_t *screen);
uint8_t xcb_aux_get_depth_of_visual (xcb_screen_t *screen,
xcb_visualid_t id);
xcb_screen_t *xcb_aux_get_screen (xcb_connection_t *c, xcb_screen_t *xcb_aux_get_screen (xcb_connection_t *c,
int screen); int screen);
xcb_visualtype_t *xcb_aux_get_visualtype (xcb_connection_t *c, xcb_visualtype_t *xcb_aux_get_visualtype (xcb_connection_t *c,
int screen, int screen,
xcb_visualid_t vid); xcb_visualid_t vid);
xcb_visualtype_t *
xcb_aux_find_visual_by_id (xcb_screen_t *screen,
xcb_visualid_t id);
xcb_visualtype_t *
xcb_aux_find_visual_by_attrs (xcb_screen_t *screen,
int8_t class,
int8_t depth);
void xcb_aux_sync (xcb_connection_t *c); void xcb_aux_sync (xcb_connection_t *c);
/* less error prone to use structs instead of value lists */ /* less error prone to use structs instead of value lists */
#define _XCB_AUX_OFFSETOF(paramsp, param) \
((void*)(&((paramsp)->param))-(void*)(paramsp))
#define XCB_AUX_ADD_PARAM(maskp, paramsp, param, value) \
((*(maskp)|=1<<(_XCB_AUX_OFFSETOF((paramsp),param)/sizeof(uint32_t))),
\
((paramsp)->param=(value)))
typedef struct { typedef struct {
uint32_t back_pixmap; uint32_t back_pixmap;
uint32_t back_pixel; uint32_t back_pixel;
uint32_t border_pixmap; uint32_t border_pixmap;
uint32_t border_pixel; uint32_t border_pixel;
uint32_t bit_gravity; uint32_t bit_gravity;
uint32_t win_gravity; uint32_t win_gravity;
uint32_t backing_store; uint32_t backing_store;
uint32_t backing_planes; uint32_t backing_planes;
uint32_t backing_pixel; uint32_t backing_pixel;
skipping to change at line 56 skipping to change at line 75
int16_t y, int16_t y,
uint16_t width, uint16_t width,
uint16_t height, uint16_t height,
uint16_t border_width, uint16_t border_width,
uint16_t _class, uint16_t _class,
xcb_visualid_t visual, xcb_visualid_t visual,
uint32_t mask, uint32_t mask,
const xcb_params_cw_t *params); const xcb_params_cw_t *params);
xcb_void_cookie_t xcb_void_cookie_t
xcb_aux_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 mask,
const xcb_params_cw_t *params);
xcb_void_cookie_t
xcb_aux_change_window_attributes (xcb_connection_t *c, xcb_aux_change_window_attributes (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
uint32_t mask, uint32_t mask,
const xcb_params_cw_t *params); const xcb_params_cw_t *params);
typedef struct { typedef struct {
int32_t x; int32_t x;
int32_t y; int32_t y;
uint32_t width; uint32_t width;
uint32_t height; uint32_t height;
skipping to change at line 90 skipping to change at line 124
uint32_t foreground; uint32_t foreground;
uint32_t background; uint32_t background;
uint32_t line_width; uint32_t line_width;
uint32_t line_style; uint32_t line_style;
uint32_t cap_style; uint32_t cap_style;
uint32_t join_style; uint32_t join_style;
uint32_t fill_style; uint32_t fill_style;
uint32_t fill_rule; uint32_t fill_rule;
uint32_t tile; uint32_t tile;
uint32_t stipple; uint32_t stipple;
uint32_t tile_stipple_originX; uint32_t tile_stipple_origin_x;
uint32_t tile_stipple_originY; uint32_t tile_stipple_origin_y;
uint32_t font; uint32_t font;
uint32_t subwindow_mode; uint32_t subwindow_mode;
uint32_t graphics_exposures; uint32_t graphics_exposures;
uint32_t clip_originX; uint32_t clip_originX;
uint32_t clip_originY; uint32_t clip_originY;
uint32_t mask; uint32_t mask;
uint32_t dash_offset; uint32_t dash_offset;
uint32_t dash_list; uint32_t dash_list;
uint32_t arc_mode; uint32_t arc_mode;
} xcb_params_gc_t; } xcb_params_gc_t;
xcb_void_cookie_t xcb_void_cookie_t
xcb_aux_create_gc (xcb_connection_t *c, xcb_aux_create_gc (xcb_connection_t *c,
xcb_gcontext_t cid, xcb_gcontext_t cid,
xcb_drawable_t drawable, xcb_drawable_t drawable,
uint32_t mask, uint32_t mask,
const xcb_params_gc_t *params); const xcb_params_gc_t *params);
xcb_void_cookie_t xcb_void_cookie_t
xcb_aux_create_gc_checked (xcb_connection_t *c,
xcb_gcontext_t gid,
xcb_drawable_t drawable,
uint32_t mask,
const xcb_params_gc_t *params);
xcb_void_cookie_t
xcb_aux_change_gc (xcb_connection_t *c, xcb_aux_change_gc (xcb_connection_t *c,
xcb_gcontext_t gc, xcb_gcontext_t gc,
uint32_t mask, uint32_t mask,
const xcb_params_gc_t *params); const xcb_params_gc_t *params);
xcb_void_cookie_t
xcb_aux_change_gc_checked (xcb_connection_t *c,
xcb_gcontext_t gc,
uint32_t mask,
const xcb_params_gc_t *params);
typedef struct { typedef struct {
uint32_t key_click_percent; uint32_t key_click_percent;
uint32_t bell_percent; uint32_t bell_percent;
uint32_t bell_pitch; uint32_t bell_pitch;
uint32_t bell_duration; uint32_t bell_duration;
uint32_t led; uint32_t led;
uint32_t led_mode; uint32_t led_mode;
uint32_t key; uint32_t key;
uint32_t auto_repeat_mode; uint32_t auto_repeat_mode;
} xcb_params_keyboard_t; } xcb_params_keyboard_t;
xcb_void_cookie_t xcb_void_cookie_t
xcb_aux_change_keyboard_control (xcb_connection_t *c, xcb_aux_change_keyboard_control (xcb_connection_t *c,
uint32_t mask, uint32_t mask,
const xcb_params_keyboard_t *params); const xcb_params_keyboard_t *params);
int
xcb_aux_parse_color(char *color_name,
uint16_t *red, uint16_t *green, uint16_t *blue);
xcb_void_cookie_t
xcb_aux_set_line_attributes_checked (xcb_connection_t *dpy,
xcb_gcontext_t gc,
uint16_t linewidth,
int32_t linestyle,
int32_t capstyle,
int32_t joinstyle);
xcb_void_cookie_t
xcb_aux_clear_window(xcb_connection_t * dpy,
xcb_window_t w);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __XCB_AUX_H__ */ #endif /* __XCB_AUX_H__ */
 End of changes. 8 change blocks. 
2 lines changed or deleted 64 lines changed or added


 xcb_event.h   xcb_event.h 
#ifndef __XCB_EVENTS_H__ #ifndef __XCB_EVENTS_H__
#define __XCB_EVENTS_H__ #define __XCB_EVENTS_H__
#include <xcb/xcb.h> #include <xcb/xcb.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef struct event_handlers event_handlers_t; typedef struct xcb_event_handlers_t xcb_event_handlers_t;
event_handlers_t *alloc_event_handlers(xcb_connection_t *c); xcb_event_handlers_t *xcb_alloc_event_handlers(xcb_connection_t *c);
void free_event_handlers(event_handlers_t *evenths); void xcb_free_event_handlers(xcb_event_handlers_t *evenths);
xcb_connection_t *get_xcb_connection(event_handlers_t *evenths); xcb_connection_t *xcb_get_xcb_connection(xcb_event_handlers_t *evenths);
void xcb_wait_for_event_loop(xcb_event_handlers_t *evenths);
void xcb_poll_for_event_loop(xcb_event_handlers_t *evenths);
int xcb_handle_event(xcb_event_handlers_t *evenths, xcb_generic_event_t *ev
ent);
void event_loop(event_handlers_t *evenths); typedef int (*xcb_generic_event_handler_t)(void *data, xcb_connection_t *c,
xcb_generic_event_t *event);
typedef int (*xcb_generic_error_handler_t)(void *data, xcb_connection_t *c,
xcb_generic_error_t *error);
typedef int (*generic_event_handler)(void *data, xcb_connection_t *c, xcb_g void xcb_set_event_handler(xcb_event_handlers_t *evenths, int event, xcb_ge
eneric_event_t *event); neric_event_handler_t handler, void *data);
typedef int (*generic_error_handler)(void *data, xcb_connection_t *c, xcb_g void xcb_set_error_handler(xcb_event_handlers_t *evenths, int error, xcb_ge
eneric_error_t *error); neric_error_handler_t handler, void *data);
void set_event_handler(event_handlers_t *evenths, int event, generic_event_
handler handler, void *data);
void set_error_handler(event_handlers_t *evenths, int error, generic_error_
handler handler, void *data);
#define MAKE_HANDLER(cls,lkind, ukind) \ #define MAKE_HANDLER(cls,lkind, ukind) \
static inline void set_##lkind##_##cls##_handler(event_handlers_t *evenths, int (*handler)(void *, xcb_connection_t *, xcb_##lkind##_##cls##_t *), voi d *data) \ static inline void set_##lkind##_##cls##_handler(xcb_event_handlers_t *even ths, int (*handler)(void *, xcb_connection_t *, xcb_##lkind##_##cls##_t *), void *data) \
{ \ { \
set_##cls##_handler(evenths, XCB_##ukind, (generic_event_handler) ha ndler, data); \ xcb_set_##cls##_handler(evenths, XCB_##ukind, (xcb_generic_event_han dler_t) handler, data); \
} }
MAKE_HANDLER(event, key_press, KEY_PRESS) MAKE_HANDLER(event, key_press, KEY_PRESS)
MAKE_HANDLER(event, key_release, KEY_RELEASE) MAKE_HANDLER(event, key_release, KEY_RELEASE)
MAKE_HANDLER(event, button_press, BUTTON_PRESS) MAKE_HANDLER(event, button_press, BUTTON_PRESS)
MAKE_HANDLER(event, button_release, BUTTON_RELEASE) MAKE_HANDLER(event, button_release, BUTTON_RELEASE)
MAKE_HANDLER(event, motion_notify, MOTION_NOTIFY) MAKE_HANDLER(event, motion_notify, MOTION_NOTIFY)
MAKE_HANDLER(event, enter_notify, ENTER_NOTIFY) MAKE_HANDLER(event, enter_notify, ENTER_NOTIFY)
MAKE_HANDLER(event, leave_notify, LEAVE_NOTIFY) MAKE_HANDLER(event, leave_notify, LEAVE_NOTIFY)
MAKE_HANDLER(event, focus_in, FOCUS_IN) MAKE_HANDLER(event, focus_in, FOCUS_IN)
 End of changes. 5 change blocks. 
16 lines changed or deleted 19 lines changed or added


 xcb_icccm.h   xcb_icccm.h 
skipping to change at line 13 skipping to change at line 13
#include <xcb/xcb.h> #include <xcb/xcb.h>
#include "xcb_property.h" #include "xcb_property.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* WM_NAME */ /* WM_NAME */
void set_wm_name (xcb_connection_t *c, void xcb_set_wm_name_checked (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
xcb_atom_t encoding, xcb_atom_t encoding,
uint32_t name_len, uint32_t name_len,
const char *name); const char *name);
int get_wm_name (xcb_connection_t *c, void xcb_set_wm_name (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
uint8_t *format, xcb_atom_t encoding,
xcb_atom_t *encoding, uint32_t name_len,
uint32_t *name_len, const char *name);
char **name);
int xcb_get_wm_name (xcb_connection_t *c,
void watch_wm_name (property_handlers_t *prophs, xcb_window_t window,
uint32_t long_len, uint8_t *format,
generic_property_handler handler, xcb_atom_t *encoding,
void *data); uint32_t *name_len,
char **name);
void xcb_watch_wm_name (xcb_property_handlers_t *prophs,
uint32_t long_len,
xcb_generic_property_handler_t handler,
void *data);
/* WM_ICON_NAME */ /* WM_ICON_NAME */
void set_wm_icon_name (xcb_connection_t *c, void xcb_set_wm_icon_name_checked (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
xcb_atom_t encoding, xcb_atom_t encoding,
uint32_t name_len, uint32_t name_len,
const char *name); const char *name);
int get_wm_icon_name (xcb_connection_t *c, void xcb_set_wm_icon_name (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
uint8_t *format, xcb_atom_t encoding,
xcb_atom_t *encoding, uint32_t name_len,
uint32_t *name_len, const char *name);
char **name);
int xcb_get_wm_icon_name (xcb_connection_t *c,
void watch_wm_icon_name (property_handlers_t *prophs, xcb_window_t window,
uint32_t long_len, uint8_t *format,
generic_property_handler handler, xcb_atom_t *encoding,
void *data); uint32_t *name_len,
char **name);
void xcb_watch_wm_icon_name (xcb_property_handlers_t *prophs,
uint32_t long_len,
xcb_generic_property_handler_t handler,
void *data);
/* WM_CLIENT_MACHINE */ /* WM_CLIENT_MACHINE */
void set_wm_client_machine (xcb_connection_t *c, void xcb_set_wm_client_machine_checked (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
xcb_atom_t encoding, xcb_atom_t encoding,
uint32_t name_len, uint32_t name_len,
const char *name); const char *name);
int get_wm_client_machine (xcb_connection_t *c, void xcb_set_wm_client_machine (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
uint8_t *format, xcb_atom_t encoding,
xcb_atom_t *encoding, uint32_t name_len,
uint32_t *name_len, const char *name);
char **name);
int xcb_get_wm_client_machine (xcb_connection_t *c,
void watch_wm_client_machine (property_handlers_t *prophs, xcb_window_t window,
uint32_t long_len, uint8_t *format,
generic_property_handler handler, xcb_atom_t *encoding,
void *data); uint32_t *name_len,
char **name);
void xcb_watch_wm_client_machine (xcb_property_handlers_t *prophs,
uint32_t long_len,
xcb_generic_property_handler_t handler,
void *data);
/* WM_TRANSIENT_FOR */
int xcb_get_wm_transient_for (xcb_connection_t *c,
xcb_window_t window,
xcb_window_t *prop_win);
/* WM_SIZE_HINTS */ /* WM_SIZE_HINTS */
typedef struct size_hints_t size_hints_t; typedef enum {
XCB_SIZE_US_POSITION_HINT = 1 << 0,
size_hints_t *alloc_size_hints (); XCB_SIZE_US_SIZE_HINT = 1 << 1,
XCB_SIZE_P_POSITION_HINT = 1 << 2,
void free_size_hints (size_hints_t *hints); XCB_SIZE_P_SIZE_HINT = 1 << 3,
XCB_SIZE_P_MIN_SIZE_HINT = 1 << 4,
void size_hints_get_position (size_hints_t *hints, XCB_SIZE_P_MAX_SIZE_HINT = 1 << 5,
int32_t *x, XCB_SIZE_P_RESIZE_INC_HINT = 1 << 6,
int32_t *y); XCB_SIZE_P_ASPECT_HINT = 1 << 7,
void size_hints_get_size (size_hints_t *hints, XCB_SIZE_BASE_SIZE_HINT = 1 << 8,
int32_t *width, XCB_SIZE_P_WIN_GRAVITY_HINT = 1 << 9
int32_t *height); } xcb_size_hints_flags_t;
void size_hints_get_min_size (size_hints_t *hints,
int32_t *min_width, typedef struct xcb_size_hints_t xcb_size_hints_t;
int32_t *min_height);
void size_hints_get_max_size (size_hints_t *hints, xcb_size_hints_t *xcb_alloc_size_hints ();
int32_t *max_width,
int32_t *max_height); void xcb_free_size_hints (xcb_size_hints_t *hints);
void size_hints_get_increase (size_hints_t *hints,
int32_t *width_inc, void xcb_size_hints_get_position (xcb_size_hints_t *hints,
int32_t *height_inc); int32_t *x,
void size_hints_get_min_aspect (size_hints_t *hints, int32_t *y);
int32_t *min_aspect_num, void xcb_size_hints_get_size (xcb_size_hints_t *hints,
int32_t *min_aspect_den); int32_t *width,
void size_hints_get_max_aspect (size_hints_t *hints, int32_t *height);
int32_t *max_aspect_num, void xcb_size_hints_get_min_size (xcb_size_hints_t *hints,
int32_t *max_aspect_den); int32_t *min_width,
void size_hints_get_base_size (size_hints_t *hints, int32_t *min_height);
int32_t *base_width, void xcb_size_hints_get_max_size (xcb_size_hints_t *hints,
int32_t *base_height); int32_t *max_width,
uint32_t size_hints_get_win_gravity (size_hints_t *hints); int32_t *max_height);
void xcb_size_hints_get_increase (xcb_size_hints_t *hints,
uint8_t size_hints_is_us_position (size_hints_t *hints); int32_t *width_inc,
uint8_t size_hints_is_us_size (size_hints_t *hints); int32_t *height_inc);
uint8_t size_hints_is_p_position (size_hints_t *hints); void xcb_size_hints_get_min_aspect (xcb_size_hints_t *hints,
uint8_t size_hints_is_p_size (size_hints_t *hints); int32_t *min_aspect_num,
uint8_t size_hints_is_p_min_size (size_hints_t *hints); int32_t *min_aspect_den)
uint8_t size_hints_is_p_max_size (size_hints_t *hints); ;
uint8_t size_hints_is_p_resize_inc (size_hints_t *hints); void xcb_size_hints_get_max_aspect (xcb_size_hints_t *hints,
uint8_t size_hints_is_p_aspect (size_hints_t *hints); int32_t *max_aspect_num,
uint8_t size_hints_is_p_base_size (size_hints_t *hints); int32_t *max_aspect_den)
uint8_t size_hints_is_p_win_gravity (size_hints_t *hints); ;
void xcb_size_hints_get_base_size (xcb_size_hints_t *hints,
void size_hints_set_flag_none (size_hints_t *hints); int32_t *base_width,
void size_hints_set_flag_us_position (size_hints_t *hints); int32_t *base_height);
void size_hints_set_flag_us_size (size_hints_t *hints); uint32_t xcb_size_hints_get_win_gravity (xcb_size_hints_t *hints);
void size_hints_set_flag_p_position (size_hints_t *hints);
void size_hints_set_flag_p_size (size_hints_t *hints); uint32_t xcb_size_hints_get_flags (xcb_size_hints_t *hints);
void size_hints_set_flag_p_min_size (size_hints_t *hints);
void size_hints_set_flag_p_max_size (size_hints_t *hints); void xcb_size_hints_set_flags (xcb_size_hints_t *hints,
void size_hints_set_flag_p_resize_inc (size_hints_t *hints); uint32_t flags);
void size_hints_set_flag_p_aspect (size_hints_t *hints);
void size_hints_set_flag_p_base_size (size_hints_t *hints); void xcb_size_hints_set_position (xcb_size_hints_t *hints,
void size_hints_set_flag_p_win_gravity (size_hints_t *hints); int user_specified,
int32_t x,
void size_hints_set_position (size_hints_t *hints, int32_t y);
int user_specified,
int32_t x, void xcb_size_hints_set_size (xcb_size_hints_t *hints,
int32_t y); int user_specified,
int32_t width,
void size_hints_set_size (size_hints_t *hints, int32_t height);
int user_specified,
int32_t width, void xcb_size_hints_set_min_size (xcb_size_hints_t *hints,
int32_t height); int32_t min_width,
int32_t min_height);
void size_hints_set_min_size (size_hints_t *hints,
int32_t min_width, void xcb_size_hints_set_max_size (xcb_size_hints_t *hints,
int32_t min_height); int32_t max_width,
int32_t max_height);
void size_hints_set_max_size (size_hints_t *hints,
int32_t max_width, void xcb_size_hints_set_resize_inc (xcb_size_hints_t *hints,
int32_t max_height); int32_t width_inc,
int32_t height_inc);
void size_hints_set_resize_inc (size_hints_t *hints,
int32_t width_inc, void xcb_size_hints_set_aspect (xcb_size_hints_t *hints,
int32_t height_inc); int32_t min_aspect_num,
int32_t min_aspect_den,
void size_hints_set_aspect (size_hints_t *hints, int32_t max_aspect_num,
int32_t min_aspect_num, int32_t max_aspect_den)
int32_t min_aspect_den, ;
int32_t max_aspect_num,
int32_t max_aspect_den); void xcb_size_hints_set_base_size (xcb_size_hints_t *hints,
int32_t base_width,
void size_hints_set_base_size (size_hints_t *hints, int32_t base_height);
int32_t base_width,
int32_t base_height); void xcb_size_hints_set_win_gravity (xcb_size_hints_t *hints,
uint8_t win_gravity);
void size_hints_set_win_gravity (size_hints_t *hints,
uint8_t win_gravity); void xcb_set_wm_size_hints_checked (xcb_connection_t *c,
xcb_window_t window,
void set_wm_size_hints (xcb_connection_t *c, xcb_atom_t property,
xcb_window_t window, xcb_size_hints_t *hints);
xcb_atom_t property,
size_hints_t *hints); void xcb_set_wm_size_hints (xcb_connection_t *c,
xcb_window_t window,
int get_wm_size_hints (xcb_connection_t *c, xcb_atom_t property,
xcb_window_t window, xcb_size_hints_t *hints);
xcb_atom_t property,
size_hints_t *hints, xcb_size_hints_t *xcb_get_wm_size_hints (xcb_connection_t *c,
long *supplied); xcb_window_t window,
xcb_atom_t property,
long *supplied);
/* WM_NORMAL_HINTS */ /* WM_NORMAL_HINTS */
void set_wm_normal_hints (xcb_connection_t *c, void xcb_set_wm_normal_hints_checked (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
size_hints_t *hints); xcb_size_hints_t *hints);
int get_wm_normal_hints (xcb_connection_t *c, void xcb_set_wm_normal_hints (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
size_hints_t *hints, xcb_size_hints_t *hints);
long *supplied);
xcb_size_hints_t *xcb_get_wm_normal_hints (xcb_connection_t *c,
xcb_window_t window,
long *supplied);
/* WM_HINTS */ /* WM_HINTS */
typedef struct wm_hints_t wm_hints_t; typedef struct xcb_wm_hints_t xcb_wm_hints_t;
#define NumWMHintsElements 9 /* number of elements in this structure */ #define XCB_NUM_WM_HINTS_ELEMENTS 9 /* number of elements in this structure
*/
typedef enum { typedef enum {
xcb_wm_withdrawn_state_t = 0, XCB_WM_WITHDRAWN_STATE = 0,
xcb_wm_normal_state_t = 1, XCB_WM_NORMAL_STATE = 1,
xcb_wm_iconic_state_t = 3 XCB_WM_ICONIC_STATE = 3
} xcb_wm_state_t; } xcb_wm_state_t;
wm_hints_t *alloc_wm_hints(); typedef enum {
XCB_WM_INPUT_HINT = (1L << 0),
uint8_t wm_hints_get_input (wm_hints_t *hints); XCB_WM_STATE_HINT = (1L << 1),
xcb_pixmap_t wm_hints_get_icon_pixmap (wm_hints_t *hints); XCB_WM_ICON_PIXMAP_HINT = (1L << 2),
xcb_pixmap_t wm_hints_get_icon_mask (wm_hints_t *hints); XCB_WM_ICON_WINDOW_HINT = (1L << 3),
xcb_window_t wm_hints_get_icon_window (wm_hints_t *hints); XCB_WM_ICON_POSITION_HINT = (1L << 4),
xcb_window_t wm_hints_get_window_group (wm_hints_t *hints); XCB_WM_ICON_MASK_HINT = (1L << 5),
XCB_WM_WINDOW_GROUP_HINT = (1L << 6),
uint8_t wm_hints_is_input_hint (wm_hints_t *hints); XCB_WM_X_URGENCY_HINT = (1L << 8)
uint8_t wm_hints_is_state_hint (wm_hints_t *hints); } xcb_wm_t;
uint8_t wm_hints_is_icon_pixmap_hint (wm_hints_t *hints);
uint8_t wm_hints_is_icon_window_hint (wm_hints_t *hints); #define XCB_WM_ALL_HINTS (XCB_WM_INPUT_HINT | XCB_WM_STATE_HINT
uint8_t wm_hints_is_icon_position_hint (wm_hints_t *hints); | XCB_WM_ICON_PIXMAP_HINT | \
uint8_t wm_hints_is_icon_mask_hint (wm_hints_t *hints); XCB_WM_ICON_WINDOW_HINT | XCB_WM_ICON_POSITION_HI
uint8_t wm_hints_is_window_group_hint (wm_hints_t *hints); NT | XCB_WM_ICON_MASK_HINT | \
uint8_t wm_hints_is_xu_hint (wm_hints_t *hints); XCB_WM_WINDOW_GROUP_HINT)
uint8_t wm_hints_state_is_withdrawn (wm_hints_t *hints); xcb_wm_hints_t *xcb_alloc_wm_hints();
uint8_t wm_hints_state_is_normal (wm_hints_t *hints); void xcb_free_wm_hints (xcb_wm_hints_t *hints);
uint8_t wm_hints_state_is_iconic (wm_hints_t *hints);
uint8_t xcb_wm_hints_get_input (xcb_wm_hints_t *hints);
void wm_hints_set_input (wm_hints_t *hints, uint8_t input); xcb_pixmap_t xcb_wm_hints_get_icon_pixmap (xcb_wm_hints_t *hints);
void wm_hints_set_iconic (wm_hints_t *hints); xcb_pixmap_t xcb_wm_hints_get_icon_mask (xcb_wm_hints_t *hints);
void wm_hints_set_normal (wm_hints_t *hints); xcb_window_t xcb_wm_hints_get_icon_window (xcb_wm_hints_t *hints);
void wm_hints_set_withdrawn (wm_hints_t *hints); xcb_window_t xcb_wm_hints_get_window_group (xcb_wm_hints_t *hints);
void wm_hints_set_none (wm_hints_t *hints); uint32_t xcb_wm_hints_get_urgency (xcb_wm_hints_t *hints);
void wm_hints_set_urgent (wm_hints_t *hints);
void wm_hints_set_icon_pixmap (wm_hints_t *hints, xcb_pixmap_t icon_pixmap uint32_t xcb_wm_hints_get_flags(xcb_wm_hints_t *hints);
); void xcb_wm_hints_set_flags(xcb_wm_hints_t *hints, uint32_t flags);
void wm_hints_set_icon_mask (wm_hints_t *hints, xcb_pixmap_t icon_mask); uint32_t xcb_wm_hints_get_initial_state(xcb_wm_hints_t *hints);
void wm_hints_set_icon_window (wm_hints_t *hints, xcb_window_t icon_window
); void xcb_wm_hints_set_input (xcb_wm_hints_t *hints, uint8_t input);
void wm_hints_set_window_group (wm_hints_t *hints, xcb_window_t window_grou void xcb_wm_hints_set_iconic (xcb_wm_hints_t *hints);
p); void xcb_wm_hints_set_normal (xcb_wm_hints_t *hints);
void xcb_wm_hints_set_withdrawn (xcb_wm_hints_t *hints);
void set_wm_hints (xcb_connection_t *c, void xcb_wm_hints_set_none (xcb_wm_hints_t *hints);
xcb_window_t window, void xcb_wm_hints_set_icon_pixmap (xcb_wm_hints_t *hints, xcb_pixmap_t ico
wm_hints_t *hints); n_pixmap);
void xcb_wm_hints_set_icon_mask (xcb_wm_hints_t *hints, xcb_pixmap_t ico
n_mask);
void xcb_wm_hints_set_icon_window (xcb_wm_hints_t *hints, xcb_window_t ico
n_window);
void xcb_wm_hints_set_window_group (xcb_wm_hints_t *hints, xcb_window_t win
dow_group);
void xcb_wm_hints_set_urgency (xcb_wm_hints_t *hints);
void xcb_set_wm_hints_checked (xcb_connection_t *c,
xcb_window_t window,
xcb_wm_hints_t *hints);
void xcb_set_wm_hints (xcb_connection_t *c,
xcb_window_t window,
xcb_wm_hints_t *hints);
wm_hints_t *get_wm_hints (xcb_connection_t *c, xcb_wm_hints_t *xcb_get_wm_hints (xcb_connection_t *c,
xcb_window_t window); xcb_window_t window);
/* WM_PROTOCOLS */ /* WM_PROTOCOLS */
void set_wm_protocols (xcb_connection_t *c, void xcb_set_wm_protocols_checked (xcb_connection_t *c,
xcb_window_t window, xcb_window_t window,
uint32_t list_len, uint32_t list_len,
xcb_atom_t *list); xcb_atom_t *list);
int get_wm_protocols (xcb_connection_t *c,
xcb_window_t window, void xcb_set_wm_protocols (xcb_connection_t *c,
uint32_t *list_len, xcb_window_t window,
xcb_atom_t **list); uint32_t list_len,
xcb_atom_t *list);
int xcb_get_wm_protocols (xcb_connection_t *c,
xcb_window_t window,
uint32_t *list_len,
xcb_atom_t **list);
#define HAS_DISCRIMINATED_NAME 0 #define HAS_DISCRIMINATED_NAME 0
#if HAS_DISCRIMINATED_NAME #if HAS_DISCRIMINATED_NAME
char *discriminated_atom_name_by_screen (const char *base, uint8_t screen ); char *discriminated_atom_name_by_screen (const char *base, uint8_t screen );
char *discriminated_atom_name_by_resource (const char *base, uint32_t resou rce); char *discriminated_atom_name_by_resource (const char *base, uint32_t resou rce);
char *discriminated_atom_name_unique (const char *base, uint32_t id); char *discriminated_atom_name_unique (const char *base, uint32_t id);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
 End of changes. 10 change blocks. 
212 lines changed or deleted 262 lines changed or added


 xcb_image.h   xcb_image.h 
#ifndef __XCB_IMAGE_H__ #ifndef __XCB_IMAGE_H__
#define __XCB_IMAGE_H__ #define __XCB_IMAGE_H__
/* Copyright (C) 2007 Bart Massey
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"
),
* to deal in the Software without restriction, including without limitatio
n
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE
* AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWAR
E.
*
* Except as contained in this notice, the names of the authors or their
* institutions shall not be used in advertising or otherwise to promote th
e
* sale, use or other dealings in this Software without prior written
* authorization from the authors.
*/
#include <xcb/xcb.h> #include <xcb/xcb.h>
#include <xcb/shm.h> #include <xcb/shm.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
* @defgroup xcb__image_t XCB Image Functions * @defgroup xcb__image_t XCB Image Functions
* *
* Functions used to create and manipulate images. * These are functions used to create and manipulate X images.
*
* The X image format we use is specific to this software,
* which is probably a bug; it represents an intermediate
* position between the wire format used by the X GetImage
* and PutImage requests and standard formats like PBM. An
* image consists of a header of type @ref xcb_image_t
* describing the properties of the image, together with a
* pointer to the image data itself.
*
* X wire images come in three formats. An xy-bitmap is a
* bit-packed format that will be expanded to a two-color
* pixmap using a GC when sent over the wire by PutImage.
* An xy-pixmap is one or more bit-planes, each in the same
* format as xy-bitmap. A z-pixmap is a more conventional
* pixmap representation, with each pixel packed into a
* word. Pixmaps are sent and received over the wire only
* to/from drawables of their depth.
*
* Each X server defines, for each depth and format,
* properties of images in that format that are sent and
* received on the wire. We refer to this as a "native"
* image for a given X server. It is not uncommon to want
* to work with non-native images on the client side, or to
* convert between the native images of different servers.
*
* This library provides several things. Facilities for
* creating and destroying images are, of course, provided.
* Wrappers for xcb_get_image() and xcb_put_image() are
* provided; these utilize the image header to simplify the
* interface. Routines for getting and putting image pixels
* are provided: both a generic form that works with
* arbitrary images, and fastpath forms for some common
* cases. Conversion routines are provided for X images;
* these routines have been fairly well optimized for the
* common cases, and should run fast even on older hardware.
* A routine analogous to Xlib's XCreate*FromBitmapData() is
* provided for creating X images from xbm-format data; this
* routine is in this library only because it is a trivial
* use case for the library.
* *
* @{ * @{
*/ */
typedef struct xcb_image_t xcb_image_t; typedef struct xcb_image_t xcb_image_t;
/** /**
* @struct xcb_image_t * @struct xcb_image_t
* A structure that describes an xcb_image_t. * A structure that describes an xcb_image_t.
*/ */
struct xcb_image_t struct xcb_image_t
{ {
uint16_t width; uint16_t width; /**< Width in pixels, excluding pads etc. */
uint16_t height; uint16_t height; /**< Height in pixels. */
unsigned int xoffset; xcb_image_format_t format; /**< Format. */
uint8_t format; uint8_t scanline_pad; /**< Right pad in bits. Valid pads
uint8_t *data; * are 8, 16, 32.
uint8_t image_byte_order; */
uint8_t bitmap_format_scanline_unit; uint8_t depth; /**< Depth in bits. Valid depths
uint8_t bitmap_format_bit_order; * are 1, 4, 8, 16, 24 for z format,
uint8_t bitmap_format_scanline_pad; * 1 for xy-bitmap-format, anything
uint8_t depth; * for xy-pixmap-format.
uint32_t bytes_per_line; */
uint8_t bits_per_pixel; uint8_t bpp; /**< Storage per pixel in bits.
* Must be >= depth. Valid bpp
* are 1, 4, 8, 16, 24, 32 for z
* format, 1 for xy-bitmap format,
* anything for xy-pixmap-format.
*/
uint8_t unit; /**< Scanline unit in bits for
* xy formats and for bpp == 1,
* in which case valid scanline
* units are 8, 16, 32. Otherwise,
* will be max(8, bpp). Must be >= bpp.
*/
uint32_t plane_mask; /**< When format is
* xy-pixmap and depth >
* 1, this says which
* planes are "valid" in
* some vague sense.
* Currently used only
* by xcb_image_get/put_pixel(),
* and set only by
* xcb_image_get().
*/
xcb_image_order_t byte_order; /**< Component byte order
* for z-pixmap, byte
* order of scanline unit
* for xy-bitmap and
* xy-pixmap. Nybble
* order for z-pixmap
* when bpp == 4.
*/
xcb_image_order_t bit_order; /**< Bit order of
* scanline unit for
* xy-bitmap and
* xy-pixmap.
*/
uint32_t stride; /**< Bytes per image row.
* Computable from other
* data, but cached for
* convenience/performance.
*/
uint32_t size; /**< Size of image data in bytes.
* Computable from other
* data, but cached for
* convenience/performance.
*/
void * base; /**< Malloced block of storage that
* will be freed by
* @ref xcb_image_destroy() if non-null.
*/
uint8_t * data; /**< The actual image. */
}; };
typedef struct xcb_shm_segment_info_t xcb_shm_segment_info_t; typedef struct xcb_shm_segment_info_t xcb_shm_segment_info_t;
/** /**
* @struct xcb_shm_segment_info_t * @struct xcb_shm_segment_info_t
* A structure that stores the informations needed by the MIT Shm * A structure that stores the informations needed by the MIT Shm
* Extension. * Extension.
*/ */
struct xcb_shm_segment_info_t struct xcb_shm_segment_info_t
{ {
xcb_shm_seg_t shmseg; xcb_shm_seg_t shmseg;
uint32_t shmid; uint32_t shmid;
uint8_t *shmaddr; uint8_t *shmaddr;
}; };
/** /**
* Create a new Image. * Update the cached data of an image.
* @param conn The connection to the X server. * @param image The image.
* @param depth The depth of the image. *
* @param format The format of the image. You can pass XYBitmap, * An image's size and stride, among other things, are
* XYPixmap, or ZPixmap. * cached in its structure. This function recomputes those
* @param offset The number of pixels to ignore at the beginning of * cached values for the given image.
* the scanline. * @ingroup xcb__image_t
* @param data The image data. */
void
xcb_image_annotate (xcb_image_t *image);
/**
* Create a new image.
* @param width The width of the image, in pixels. * @param width The width of the image, in pixels.
* @param height The height of the image, in pixels. * @param height The height of the image, in pixels.
* @param xpad The quantum of a scanline (8, 16, or 32). * @param format The format of the image.
* @param bytes_per_line The number of bytes in the client image * @param xpad The scanline pad of the image.
* between the start of one scanline and the start of the next. * @param depth The depth of the image.
* @param bpp The depth of the image storage.
* @param unit The unit of image representation, in bits.
* @param byte_order The byte order of the image.
* @param bit_order The bit order of the image.
* @param base The base address of malloced image data.
* @param bytes The size in bytes of the storage pointed to by base.
* If base == 0 and bytes == ~0 and data == 0 on
* entry, no storage will be auto-allocated.
* @param data The image data. If data is null and bytes != ~0, then
* an attempt will be made to fill in data; from
* base if it is non-null (and bytes is large enough), else
* by mallocing sufficient storage and filling in base.
* @return The new image. * @return The new image.
* *
* This function allocates the memory needed for an xcb_image_t structure * This function allocates the memory needed for an @ref xcb_image_t struct
* for the specified connection but does not allocate space for the image ure
* itself. It initializes the structure byte-order, bit-order, and * with the given properties. See the description of xcb_image_t for detai
* bitmap-unit values from the connection and returns a pointer to the ls.
* xcb_image_t structure. * This function initializes and returns a pointer to the
* * xcb_image_t structure. It may try to allocate or reserve data for the
* The @p offset parameter permits the rapid displaying of the image * structure, depending on how @p base, @p bytes and @p data are set.
* without requiring each scanline to be shifted into position. *
* * The image must be destroyed with xcb_image_destroy().
* The image must be destroyed with @ref xcb_image_destroy_t. * @ingroup xcb__image_t
* @ingroup xcb__image_t */
*/ xcb_image_t *
xcb_image_t *xcb_image_create (xcb_connection_t *conn, xcb_image_create (uint16_t width,
uint8_t depth, uint16_t height,
uint8_t format, xcb_image_format_t format,
unsigned int offset, uint8_t xpad,
uint8_t *data, uint8_t depth,
uint16_t width, uint8_t bpp,
uint16_t height, uint8_t unit,
uint8_t xpad, xcb_image_order_t byte_order,
uint32_t bytes_per_line); xcb_image_order_t bit_order,
void * base,
uint32_t bytes,
uint8_t * data);
/** /**
* Initialize an Image. * Create a new image in connection-native format.
* @param image The image to be destroyed. * @param c The connection.
* @return 1 if the operation has succeeded. * @param width The width of the image, in pixels.
* @param height The height of the image, in pixels.
* @param format The format of the image.
* @param depth The depth of the image.
* @param base The base address of malloced image data.
* @param bytes The size in bytes of the storage pointed to by base.
* If base == 0 and bytes == ~0 and data == 0 on
* entry, no storage will be auto-allocated.
* @param data The image data. If data is null and bytes != ~0, then
* an attempt will be made to fill in data; from
* base if it is non-null (and bytes is large enough), else
* by mallocing sufficient storage and filling in base.
* @return The new image.
* *
* This function initializes the image structure. * This function calls @ref xcb_image_create() with the given
* @ingroup xcb__image_t * properties, and with the remaining properties chosen
*/ * according to the "native format" with the given
int xcb_image_init (xcb_image_t *image); * properties on the current connection.
*
* It is usual to use this rather
* than calling xcb_image_create() directly.
* @ingroup xcb__image_t
*/
xcb_image_t *
xcb_image_create_native (xcb_connection_t * c,
uint16_t width,
uint16_t height,
xcb_image_format_t format,
uint8_t depth,
void * base,
uint32_t bytes,
uint8_t * data);
/** /**
* Destroy an Image. * Destroy an image.
* @param image The image to be destroyed. * @param image The image to be destroyed.
* @return 1 if the operation has succeeded.
* *
* This function deallocates both the memory associated with the @p image * This function frees the memory associated with the @p image
* parameter and its data. * parameter. If its base pointer is non-null, it frees
* that also.
* @ingroup xcb__image_t * @ingroup xcb__image_t
*/ */
int xcb_image_destroy (xcb_image_t *image); void
xcb_image_destroy (xcb_image_t *image);
#define XCB_ALL_PLANES ((uint32_t)~0L)
/** /**
* Return a pointer to a xcb_image_t. * Get an image from the X server.
* @param conn The connection to the X server. * @param conn The connection to the X server.
* @param draw The draw you get the image from. * @param draw The drawable to get the image from.
* @param x The x coordinate, which are relative to the origin of the * @param x The x coordinate in pixels, relative to the origin of the
* drawable and define the upper-left corner of the rectangle. * drawable and defining the upper-left corner of the rectangle.
* @param y The y coordinate, which are relative to the origin of the * @param y The y coordinate in pixels, relative to the origin of the
* drawable and define the upper-left corner of the rectangle. * drawable and defining the upper-left corner of the rectangle.
* @param width The width of the subimage, in pixels. * @param width The width of the subimage in pixels.
* @param height The height of the subimage, in pixels. * @param height The height of the subimage in pixels.
* @param plane_mask The plane mask (can be xcb_all_planes_t). * @param plane_mask The plane mask. See the protocol document for details
* @param format The format of the image. You can pass XYBitmap, .
* XYPixmap, or ZPixmap. * @param format The format of the image.
* @return The subimage of @p draw defined by @p x, @p y, @p w, @p h. * @return The subimage of @p draw defined by @p x, @p y, @p w, @p h.
* *
* This function returns a subimage of @p draw defined by @p x, @p y,
* @p w, @p h. The depth of the image is the one of the drawable @p * This function returns a new image taken from the
* draw, except when getting a subset of the plane in @c XYPixmap * given drawable @p draw.
* format. * The image will be in connection native format. If the @p format
* * is xy-bitmap and the @p plane_mask masks bit planes out, those
* If a problem occurs, the functons returns @c NULL. * bit planes will be made part of the returned image anyway,
* @ingroup xcb__image_t * by zero-filling them; this will require a fresh memory allocation
*/ * and some copying. Otherwise, the resulting image will use the
xcb_image_t *xcb_image_get (xcb_connection_t *conn, * xcb_get_image_reply() record as its backing store.
xcb_drawable_t draw, *
int16_t x, * If a problem occurs, the function returns null.
int16_t y, * @ingroup xcb__image_t
uint16_t width, */
uint16_t height, xcb_image_t *
uint32_t plane_mask, xcb_image_get (xcb_connection_t * conn,
uint8_t format); xcb_drawable_t draw,
int16_t x,
/* Not implemented. Should be ? */ int16_t y,
xcb_image_t xcb_image_subimage_get (xcb_connection_t *conn, uint16_t width,
xcb_drawable_t draw, uint16_t height,
int x, uint32_t plane_mask,
int y, xcb_image_format_t format);
unsigned int width,
unsigned int height,
unsigned long plane_mask,
uint8_t format,
xcb_image_t *dest_im,
int dest_x,
int dest_y);
/** /**
* Put the data of an xcb_image_t onto a drawable. * Put an image onto the X server.
* @param conn The connection to the X server. * @param conn The connection to the X server.
* @param draw The draw you get the image from. * @param draw The draw you get the image from.
* @param gc The graphic context. * @param gc The graphic context.
* @param image The image you want to combine with the rectangle. * @param image The image you want to combine with the rectangle.
* @param x_offset The offset in x from the left edge of the image
* defined by the xcb_image_t structure.
* @param y_offset The offset in y from the left edge of the image
* defined by the xcb_image_t structure.
* @param x The x coordinate, which is relative to the origin of the * @param x The x coordinate, which is relative to the origin of the
* drawable and defines the x coordinate of the upper-left corner of the * drawable and defines the x coordinate of the upper-left corner of the
* rectangle. * rectangle.
* @param y The y coordinate, which is relative to the origin of the * @param y The y coordinate, which is relative to the origin of the
* drawable and defines the x coordinate of the upper-left corner of * drawable and defines the x coordinate of the upper-left corner of
* the rectangle. * the rectangle.
* @param width The width of the subimage, in pixels. * @param left_pad Notionally shift an xy-bitmap or xy-pixmap image
* @param height The height of the subimage, in pixels. * to the right some small amount, for some reason. XXX Not clear
* @return 1 is no problems occurs. * this is currently supported correctly.
* @return The cookie returned by xcb_put_image().
*
* This function combines an image with a rectangle of the
* specified drawable @p draw. The image must be in native
* format for the connection. The image is drawn at the
* specified location in the drawable. For the xy-bitmap
* format, the foreground pixel in @p gc defines the source
* for the one bits in the image, and the background pixel
* defines the source for the zero bits. For xy-pixmap and
* z-pixmap formats, the depth of the image must match the
* depth of the drawable; the gc is ignored.
* *
* This function combines an image with a rectangle of the specified * @ingroup xcb__image_t
* drawable. The section of the image defined by the @p x, @p y, */
* @p width, and @p height arguments is drawn on the specified part of xcb_void_cookie_t
* the drawable. The foreground pixel in @p gc defines the source for xcb_image_put (xcb_connection_t * conn,
* the one bits in the image, and the background pixel defines the xcb_drawable_t draw,
* source for the zero bits. For XYPixmap and ZPixmap formats, the xcb_gcontext_t gc,
* depth of the image must match the depth of the drawable. xcb_image_t * image,
* int16_t x,
* If a problem occurs, the functons returns @c NULL. int16_t y,
* @ingroup xcb__image_t uint8_t left_pad);
*/
int xcb_image_put (xcb_connection_t *conn, /**
xcb_drawable_t draw, * Check image for or convert image to native format.
xcb_gcontext_t gc, * @param c The connection to the X server.
xcb_image_t *image, * @param image The image.
int16_t x_offset, * @param convert If 0, just check the image for native format.
int16_t y_offset, * Otherwise, actually convert it.
int16_t x, * @return Null if the image is not in native format and can or will not
int16_t y, * be converted. Otherwise, the native format image.
uint16_t width, *
uint16_t height); * Each X display has its own "native format" for images of a given
* format and depth. This function either checks whether the given
* @p image is in native format for the given connection @p c, or
* actually tries to convert the image to native format, depending
* on whether @p convert is true or false.
*
* When @p convert is true, and the image is not in native format
* but can be converted, it will be, and a pointer to the new image
* will be returned. The image passed in will be unharmed in this
* case; it is the caller's responsibility to check that the returned
* pointer is different and to dispose of the old image if desired.
* @ingroup xcb__image_t
*/
xcb_image_t *
xcb_image_native (xcb_connection_t * c,
xcb_image_t * image,
int convert);
/** /**
* Put a pixel in a image * Put a pixel to an image.
* @param image The image. * @param image The image.
* @param x The x coordinate of the pixel. * @param x The x coordinate of the pixel.
* @param y The y coordinate of the pixel. * @param y The y coordinate of the pixel.
* @param pixel The new pixel value. * @param pixel The new pixel value.
* @return 1 if the operation has succeeded.
* *
* This function overwrites the pixel in the named image with the * This function overwrites the pixel in the given @p image with the
* specified @p pixel value. The input pixel value must be in normalized * specified @p pixel value (in client format). The image must contain the
* format (that is, the least-significant byte of the long is the @p x
* least-significant byte of the pixel). The image must contain the @p x * and @p y coordinates, as no clipping is done. This function honors
* and @p y coordinates. * the plane-mask for xy-pixmap images.
* @ingroup xcb__image_t * @ingroup xcb__image_t
*/ */
int xcb_image_put_pixel (xcb_image_t *image, void
int x, xcb_image_put_pixel (xcb_image_t *image,
int y, uint32_t x,
uint32_t pixel); uint32_t y,
uint32_t pixel);
/** /**
* Get a pixel in a image * Get a pixel from an image.
* @param image The image. * @param image The image.
* @param x The x coordinate of the pixel. * @param x The x coordinate of the pixel.
* @param y The y coordinate of the pixel. * @param y The y coordinate of the pixel.
* @return The pixel value. * @return The pixel value.
* *
* This function returns the specified pixel from the named image. The * This function retrieves a pixel from the given @p image.
* pixel value is returned in normalized format (that is, the * The image must contain the @p x
* least-significant byte of the long is the least-significant byte of * and @p y coordinates, as no clipping is done. This function honors
* the pixel). The image must contain the @p x and @p y coordinates. * the plane-mask for xy-pixmap images.
* @ingroup xcb__image_t * @ingroup xcb__image_t
*/ */
uint32_t xcb_image_get_pixel (xcb_image_t *image, uint32_t
int x, xcb_image_get_pixel (xcb_image_t *image,
int y); uint32_t x,
uint32_t y);
/**
* Convert an image to a new format.
* @param src Source image.
* @param dst Destination image.
* @return The @p dst image, or null on error.
*
* This function tries to convert the image data of the @p
* src image to the format implied by the @p dst image,
* overwriting the current destination image data.
* The source and destination must have the same
* width, height, and depth. When the source and destination
* are already the same format, a simple copy is done. Otherwise,
* when the destination has the same bits-per-pixel/scanline-unit
* as the source, an optimized copy routine (thanks to Keith Packard)
* is used for the conversion. Otherwise, the copy is done the
* slow, slow way with @ref xcb_image_get_pixel() and
* @ref xcb_image_put_pixel() calls.
* @ingroup xcb__image_t
*/
xcb_image_t *
xcb_image_convert (xcb_image_t * src,
xcb_image_t * dst);
/**
* Extract a subimage of an image.
* @param image Source image.
* @param x X coordinate of subimage.
* @param y Y coordinate of subimage.
* @param width Width of subimage.
* @param height Height of subimage.
* @param base Base of memory allocation.
* @param bytes Size of base allocation.
* @param data Memory allocation.
* @return The subimage, or null on error.
*
* Given an image, this function extracts the subimage at the
* given coordinates. The requested subimage must be entirely
* contained in the source @p image. The resulting image will have the sam
e
* general image parameters as the source image. The @p base, @p bytes,
* and @p data arguments are passed to @ref xcb_create_image() unaltered
* to create the destination image---see its documentation for details.
*
* @ingroup xcb__image_t
*/
xcb_image_t *
xcb_image_subimage(xcb_image_t * image,
uint32_t x,
uint32_t y,
uint32_t width,
uint32_t height,
void * base,
uint32_t bytes,
uint8_t * data);
/* /*
* Shm stuff * Shm stuff
*/ */
/** /**
* Create an xcb_image_t to be used with the MIT Shm Extension
* @param conn The connection to the X server.
* @param depth The depth of the image.
* @param format The format of the image. You can pass XYBitmap,
* XYPixmap, or ZPixmap.
* @param data The image data.
* @param width The width of the image, in pixels.
* @param height The height of the image, in pixels.
* @return The new image.
*
* This function allocates the memory needed for an xcb_image_t structure
* for the specified display but does not allocate space for the image
* itself.
*
* The image must be destroyed with @ref xcb_image_shm_destroy_t.
*
* @ingroup xcb__image_t
*/
xcb_image_t *xcb_image_shm_create (xcb_connection_t *conn,
uint8_t depth,
uint8_t format,
uint8_t *data,
uint16_t width,
uint16_t height);
/**
* Destroy an Image created by xcb_image_shm_create_t.
* @param image The image to be destroyed.
* @return 1 if the operation has succeeded.
*
* This function deallocates both the memory associated with the @p image
* parameter and its data.
* @ingroup xcb__image_t
*/
int xcb_image_shm_destroy (xcb_image_t *image);
/**
* Put the data of an xcb_image_t onto a drawable using the MIT Shm * Put the data of an xcb_image_t onto a drawable using the MIT Shm
* Extension. * Extension.
* @param conn The connection to the X server. * @param conn The connection to the X server.
* @param draw The draw you get the image from. * @param draw The draw you get the image from.
* @param gc The graphic context. * @param gc The graphic context.
* @param image The image you want to combine with the rectangle. * @param image The image you want to combine with the rectangle.
* @param shminfo A @ref xcb_shm_segment_info_t structure. * @param shminfo A @ref xcb_shm_segment_info_t structure.
* @param x The offset in x from the left edge of the image * @param src_x The offset in x from the left edge of the image
* defined by the xcb_image_t structure. * defined by the xcb_image_t structure.
* @param y The offset in y from the left edge of the image * @param src_y The offset in y from the left edge of the image
* defined by the xcb_image_t structure. * defined by the xcb_image_t structure.
* @param dest_x The x coordinate, which is relative to the origin of the * @param dest_x The x coordinate, which is relative to the origin of the
* drawable and defines the x coordinate of the upper-left corner of the * drawable and defines the x coordinate of the upper-left corner of the
* rectangle. * rectangle.
* @param dest_y The y coordinate, which is relative to the origin of the * @param dest_y The y coordinate, which is relative to the origin of the
* drawable and defines the x coordinate of the upper-left corner of * drawable and defines the x coordinate of the upper-left corner of
* the rectangle. * the rectangle.
* @param width The width of the subimage, in pixels. * @param src_width The width of the subimage, in pixels.
* @param height The height of the subimage, in pixels. * @param src_height The height of the subimage, in pixels.
* @param send_event Indicates whether or not a completion event * @param send_event Indicates whether or not a completion event
* should occur when the image write is complete. * should occur when the image write is complete.
* @return 1 is no problems occurs. * @return 1 is no problems occurs.
* *
* This function combines an image in memory with a shape of the * This function combines an image in memory with a shape of the
* specified drawable. The section of the image defined by the @p x, @p y, * specified drawable. The section of the image defined by the @p x, @p y,
* @p width, and @p height arguments is drawn on the specified part of * @p width, and @p height arguments is drawn on the specified part of
* the drawable. If XYBitmap format is used, the depth must be * the drawable. If XYBitmap format is used, the depth must be
* one, or a``BadMatch'' error results. The foreground pixel in the * one, or a``BadMatch'' error results. The foreground pixel in the
* Graphic Context @p gc defines the source for the one bits in the * Graphic Context @p gc defines the source for the one bits in the
* image, and the background pixel defines the source for the zero * image, and the background pixel defines the source for the zero
* bits. For XYPixmap and ZPixmap, the depth must match the depth of * bits. For XYPixmap and ZPixmap, the depth must match the depth of
* the drawable, or a ``BadMatch'' error results. * the drawable, or a ``BadMatch'' error results.
* *
* If a problem occurs, the functons returns @c 0. Otherwise, it * If a problem occurs, the functons returns @c 0. Otherwise, it
* returns @c 1. * returns @c 1.
* @ingroup xcb__image_t * @ingroup xcb__image_t
*/ */
int xcb_image_shm_put (xcb_connection_t *conn, xcb_image_t *
xcb_drawable_t draw, xcb_image_shm_put (xcb_connection_t * conn,
xcb_gcontext_t gc, xcb_drawable_t draw,
xcb_image_t *image, xcb_gcontext_t gc,
xcb_shm_segment_info_t shminfo, xcb_image_t * image,
int16_t x, xcb_shm_segment_info_t shminfo,
int16_t y, int16_t src_x,
int16_t dest_x, int16_t src_y,
int16_t dest_y, int16_t dest_x,
uint16_t width, int16_t dest_y,
uint16_t height, uint16_t src_width,
uint8_t send_event); uint16_t src_height,
uint8_t send_event);
/** /**
* Read image data into a shared memory xcb_image_t. * Read image data into a shared memory xcb_image_t.
* @param conn The connection to the X server. * @param conn The connection to the X server.
* @param draw The draw you get the image from. * @param draw The draw you get the image from.
* @param image The image you want to combine with the rectangle. * @param image The image you want to combine with the rectangle.
* @param shminfo A @ref xcb_shm_segment_info_t structure. * @param shminfo A @ref xcb_shm_segment_info_t structure.
* @param x The x coordinate, which are relative to the origin of the * @param x The x coordinate, which are relative to the origin of the
* drawable and define the upper-left corner of the rectangle. * drawable and define the upper-left corner of the rectangle.
* @param y The y coordinate, which are relative to the origin of the * @param y The y coordinate, which are relative to the origin of the
skipping to change at line 355 skipping to change at line 544
* This function reads image data into a shared memory xcb_image_t where * This function reads image data into a shared memory xcb_image_t where
* @p conn is the connection to the X server, @p draw is the source * @p conn is the connection to the X server, @p draw is the source
* drawable, @p image is the destination xcb_image_t, @p x and @p y are off sets * drawable, @p image is the destination xcb_image_t, @p x and @p y are off sets
* within the drawable, and @p plane_mask defines which planes are to be * within the drawable, and @p plane_mask defines which planes are to be
* read. * read.
* *
* If a problem occurs, the functons returns @c 0. It returns 1 * If a problem occurs, the functons returns @c 0. It returns 1
* otherwise. * otherwise.
* @ingroup xcb__image_t * @ingroup xcb__image_t
*/ */
int xcb_image_shm_get (xcb_connection_t *conn, int xcb_image_shm_get (xcb_connection_t * conn,
xcb_drawable_t draw, xcb_drawable_t draw,
xcb_image_t *image, xcb_image_t * image,
xcb_shm_segment_info_t shminfo, xcb_shm_segment_info_t shminfo,
int16_t x, int16_t x,
int16_t y, int16_t y,
uint32_t plane_mask); uint32_t plane_mask);
/**
* Create an image from user-supplied bitmap data.
* @param data Image data in packed bitmap format.
* @param width Width in bits of image data.
* @param height Height in bits of image data.
* @return The image constructed from the image data, or 0 on error.
*
* This function creates an image from the user-supplied
* bitmap @p data. The bitmap data is assumed to be in
* xbm format (i.e., 8-bit scanline unit, LSB-first, 8-bit pad).
* @ingroup xcb__image_t
*/
xcb_image_t *
xcb_image_create_from_bitmap_data (uint8_t * data,
uint32_t width,
uint32_t height);
/**
* Create a pixmap from user-supplied bitmap data.
* @param display The connection to the X server.
* @param d The parent drawable for the pixmap.
* @param data Image data in packed bitmap format.
* @param width Width in bits of image data.
* @param height Height in bits of image data.
* @param depth Depth of the desired pixmap.
* @param fg Pixel for one-bits of pixmaps with depth larger than one.
* @param bg Pixel for zero-bits of pixmaps with depth larger than one.
* @param gcp If this pointer is non-null, the GC created to
* fill in the pixmap is stored here; it will have its foreground
* and background set to the supplied value. Otherwise, the GC
* will be freed.
* @return The pixmap constructed from the image data, or 0 on error.
*
* This function creates a pixmap from the user-supplied
* bitmap @p data. The bitmap data is assumed to be in
* xbm format (i.e., 8-bit scanline unit, LSB-first, 8-bit pad).
* If @p depth is greater than 1, the
* bitmap will be expanded to a pixmap using the given
* foreground and background pixels @p fg and @p bg.
* @ingroup xcb__image_t
*/
xcb_pixmap_t
xcb_create_pixmap_from_bitmap_data (xcb_connection_t * display,
xcb_drawable_t d,
uint8_t * data,
uint32_t width,
uint32_t height,
uint32_t depth,
uint32_t fg,
uint32_t bg,
xcb_gcontext_t * gcp);
/** /**
* @} * @}
*/ */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __XCB_IMAGE_H__ */ #endif /* __XCB_IMAGE_H__ */
 End of changes. 31 change blocks. 
209 lines changed or deleted 463 lines changed or added


 xcb_property.h   xcb_property.h 
#ifndef __XCB_PROP_H__ #ifndef __XCB_PROP_H__
#define __XCB_PROP_H__ #define __XCB_PROP_H__
#include "xcb_event.h" #include "xcb_event.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
xcb_get_property_cookie_t get_any_property(xcb_connection_t *c, uint8_t del , xcb_window_t window, xcb_atom_t name, uint32_t long_len); xcb_get_property_cookie_t xcb_get_any_property(xcb_connection_t *c, uint8_t del, xcb_window_t window, xcb_atom_t name, uint32_t long_len);
typedef struct property_handlers property_handlers_t; typedef struct xcb_property_handlers xcb_property_handlers_t;
property_handlers_t *alloc_property_handlers(event_handlers_t *evenths); xcb_property_handlers_t *xcb_alloc_property_handlers(xcb_event_handlers_t *
void free_property_handlers(property_handlers_t *prophs); evenths);
event_handlers_t *get_property_event_handlers(property_handlers_t *prophs); void xcb_free_property_handlers(xcb_property_handlers_t *prophs);
xcb_event_handlers_t *xcb_get_property_event_handlers(xcb_property_handlers
_t *prophs);
typedef int (*generic_property_handler)(void *data, xcb_connection_t *c, ui nt8_t state, xcb_window_t window, xcb_atom_t atom, xcb_get_property_reply_t *property); typedef int (*xcb_generic_property_handler_t)(void *data, xcb_connection_t *c, uint8_t state, xcb_window_t window, xcb_atom_t atom, xcb_get_property_r eply_t *property);
int set_property_handler(property_handlers_t *prophs, xcb_atom_t name, uint int xcb_set_property_handler(xcb_property_handlers_t *prophs, xcb_atom_t na
32_t long_len, generic_property_handler handler, void *data); me, uint32_t long_len, xcb_generic_property_handler_t handler, void *data);
int set_default_property_handler(property_handlers_t *prophs, uint32_t long int xcb_set_default_property_handler(xcb_property_handlers_t *prophs, uint3
_len, generic_property_handler handler, void *data); 2_t long_len, xcb_generic_property_handler_t handler, void *data);
int property_changed(property_handlers_t *prophs, uint8_t state, xcb_window _t window, xcb_atom_t atom); int xcb_property_changed(xcb_property_handlers_t *prophs, uint8_t state, xc b_window_t window, xcb_atom_t atom);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __XCB_PROP_H__ */ #endif /* __XCB_PROP_H__ */
 End of changes. 6 change blocks. 
11 lines changed or deleted 13 lines changed or added


 xcb_wm.h   xcb_wm.h 
skipping to change at line 32 skipping to change at line 32
} client_window_t; } client_window_t;
typedef struct { typedef struct {
enum tag_t tag; enum tag_t tag;
union { union {
xcb_get_window_attributes_cookie_t cookie; xcb_get_window_attributes_cookie_t cookie;
uint8_t override_redirect; uint8_t override_redirect;
} u; } u;
} window_attributes_t; } window_attributes_t;
void manage_window(property_handlers_t *prophs, xcb_connection_t *c, xcb_wi ndow_t window, window_attributes_t wa); void manage_window(xcb_property_handlers_t *prophs, xcb_connection_t *c, xc b_window_t window, window_attributes_t wa);
int handle_map_notify_event(void *prophs, xcb_connection_t *c, xcb_map_noti fy_event_t *e); int handle_map_notify_event(void *prophs, xcb_connection_t *c, xcb_map_noti fy_event_t *e);
int handle_unmap_notify_event(void *data, xcb_connection_t *c, xcb_unmap_no tify_event_t *e); int handle_unmap_notify_event(void *data, xcb_connection_t *c, xcb_unmap_no tify_event_t *e);
void manage_existing_windows(xcb_connection_t *c, property_handlers_t *prop hs, xcb_window_t root); void manage_existing_windows(xcb_connection_t *c, xcb_property_handlers_t * prophs, xcb_window_t root);
typedef struct table_t table_t; typedef struct table_t table_t;
table_t *alloc_table(); table_t *alloc_table();
void free_table(table_t *table); void free_table(table_t *table);
int table_put(table_t *table, uint32_t key, void *value); int table_put(table_t *table, uint32_t key, void *value);
void *table_get(table_t *table, uint32_t key); void *table_get(table_t *table, uint32_t key);
void *table_remove(table_t *table, uint32_t key); void *table_remove(table_t *table, uint32_t key);
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/