Xwindow 相关结构

/*
 * This file generated automatically from xcb_types.xml by c-client.xsl using XSLT.
 * Edit at your peril.
 */

#ifndef __XCB_TYPES_H
#define __XCB_TYPES_H

#include "xcb.h"

typedef struct {
    CARD8 byte1;
    CARD8 byte2;
} XCBCHAR2B;

typedef struct {
    XCBCHAR2B *data;
    int        rem;
    int        index;
} XCBCHAR2BIter;

typedef struct {
    CARD32 xid;
} XCBWINDOW;

typedef struct {
    XCBWINDOW *data;
    int        rem;
    int        index;
} XCBWINDOWIter;

typedef struct {
    CARD32 xid;
} XCBPIXMAP;

typedef struct {
    XCBPIXMAP *data;
    int        rem;
    int        index;
} XCBPIXMAPIter;

typedef struct {
    CARD32 xid;
} XCBCURSOR;

typedef struct {
    XCBCURSOR *data;
    int        rem;
    int        index;
} XCBCURSORIter;

typedef struct {
    CARD32 xid;
} XCBFONT;

typedef struct {
    XCBFONT *data;
    int      rem;
    int      index;
} XCBFONTIter;

typedef struct {
    CARD32 xid;
} XCBGCONTEXT;

typedef struct {
    XCBGCONTEXT *data;
    int          rem;
    int          index;
} XCBGCONTEXTIter;

typedef struct {
    CARD32 xid;
} XCBCOLORMAP;

typedef struct {
    XCBCOLORMAP *data;
    int          rem;
    int          index;
} XCBCOLORMAPIter;

typedef struct {
    CARD32 xid;
} XCBATOM;

typedef struct {
    XCBATOM *data;
    int      rem;
    int      index;
} XCBATOMIter;

typedef union {
    XCBWINDOW window;
    XCBPIXMAP pixmap;
} XCBDRAWABLE;

typedef struct {
    XCBDRAWABLE *data;
    int          rem;
    int          index;
} XCBDRAWABLEIter;

typedef union {
    XCBFONT     font;
    XCBGCONTEXT gcontext;
} XCBFONTABLE;

typedef struct {
    XCBFONTABLE *data;
    int          rem;
    int          index;
} XCBFONTABLEIter;

typedef struct {
    CARD32 id;
} XCBVISUALID;

typedef struct {
    XCBVISUALID *data;
    int          rem;
    int          index;
} XCBVISUALIDIter;

typedef struct {
    CARD32 id;
} XCBTIMESTAMP;

typedef struct {
    XCBTIMESTAMP *data;
    int           rem;
    int           index;
} XCBTIMESTAMPIter;

typedef struct {
    CARD32 id;
} XCBKEYSYM;

typedef struct {
    XCBKEYSYM *data;
    int        rem;
    int        index;
} XCBKEYSYMIter;

typedef struct {
    CARD8 id;
} XCBKEYCODE;

typedef struct {
    XCBKEYCODE *data;
    int         rem;
    int         index;
} XCBKEYCODEIter;

typedef struct {
    CARD8 id;
} XCBBUTTON;

typedef struct {
    XCBBUTTON *data;
    int        rem;
    int        index;
} XCBBUTTONIter;

typedef struct {
    INT16 x;
    INT16 y;
} XCBPOINT;

typedef struct {
    XCBPOINT *data;
    int       rem;
    int       index;
} XCBPOINTIter;

typedef struct {
    INT16  x;
    INT16  y;
    CARD16 width;
    CARD16 height;
} XCBRECTANGLE;

typedef struct {
    XCBRECTANGLE *data;
    int           rem;
    int           index;
} XCBRECTANGLEIter;

typedef struct {
    INT16  x;
    INT16  y;
    CARD16 width;
    CARD16 height;
    INT16  angle1;
    INT16  angle2;
} XCBARC;

typedef struct {
    XCBARC *data;
    int     rem;
    int     index;
} XCBARCIter;

typedef struct {
    CARD8 depth;
    CARD8 bits_per_pixel;
    CARD8 scanline_pad;
    CARD8 pad0[5];
} XCBFORMAT;

typedef struct {
    XCBFORMAT *data;
    int        rem;
    int        index;
} XCBFORMATIter;

typedef struct {
    XCBVISUALID visual_id;
    CARD8       _class;
    CARD8       bits_per_rgb_value;
    CARD16      colormap_entries;
    CARD32      red_mask;
    CARD32      green_mask;
    CARD32      blue_mask;
    CARD8       pad0[4];
} XCBVISUALTYPE;

typedef struct {
    XCBVISUALTYPE *data;
    int            rem;
    int            index;
} XCBVISUALTYPEIter;

typedef struct {
    CARD8  depth;
    CARD8  pad0;
    CARD16 visuals_len;
    CARD8  pad1[4];
} XCBDEPTH;

typedef struct {
    XCBDEPTH *data;
    int       rem;
    int       index;
} XCBDEPTHIter;

typedef struct {
    XCBWINDOW   root;
    XCBCOLORMAP default_colormap;
    CARD32      white_pixel;
    CARD32      black_pixel;
    CARD32      current_input_masks;
    CARD16      width_in_pixels;
    CARD16      height_in_pixels;
    CARD16      width_in_millimeters;
    CARD16      height_in_millimeters;
    CARD16      min_installed_maps;
    CARD16      max_installed_maps;
    XCBVISUALID root_visual;
    BYTE        backing_stores;
    BOOL        save_unders;
    CARD8       root_depth;
    CARD8       allowed_depths_len;
} XCBSCREEN;

typedef struct {
    XCBSCREEN *data;
    int        rem;
    int        index;
} XCBSCREENIter;

typedef struct {
    CARD8  byte_order;
    CARD8  pad0;
    CARD16 protocol_major_version;
    CARD16 protocol_minor_version;
    CARD16 authorization_protocol_name_len;
    CARD16 authorization_protocol_data_len;
} XCBSetupReq;

typedef struct {
    XCBSetupReq *data;
    int          rem;
    int          index;
} XCBSetupReqIter;

typedef struct {
    CARD8  status;
    CARD8  reason_len;
    CARD16 protocol_major_version;
    CARD16 protocol_minor_version;
    CARD16 length;
} XCBSetupFailed;

typedef struct {
    XCBSetupFailed *data;
    int             rem;
    int             index;
} XCBSetupFailedIter;

typedef struct {
    CARD8  status;
    CARD8  pad0[5];
    CARD16 length;
} XCBSetupAuthenticate;

typedef struct {
    XCBSetupAuthenticate *data;
    int                   rem;
    int                   index;
} XCBSetupAuthenticateIter;

typedef struct {
    CARD8      status;
    CARD8      pad0;
    CARD16     protocol_major_version;
    CARD16     protocol_minor_version;
    CARD16     length;
    CARD32     release_number;
    CARD32     resource_id_base;
    CARD32     resource_id_mask;
    CARD32     motion_buffer_size;
    CARD16     vendor_len;
    CARD16     maximum_request_length;
    CARD8      roots_len;
    CARD8      pixmap_formats_len;
    CARD8      image_byte_order;
    CARD8      bitmap_format_bit_order;
    CARD8      bitmap_format_scanline_unit;
    CARD8      bitmap_format_scanline_pad;
    XCBKEYCODE min_keycode;
    XCBKEYCODE max_keycode;
    CARD8      pad1[4];
} XCBSetup;

typedef struct {
    XCBSetup *data;
    int       rem;
    int       index;
} XCBSetupIter;

void
XCBCHAR2BNext (XCBCHAR2BIter *i);

XCBGenericIter
XCBCHAR2BEnd (XCBCHAR2BIter i);

void
XCBWINDOWNext (XCBWINDOWIter *i);

XCBGenericIter
XCBWINDOWEnd (XCBWINDOWIter i);

XCBWINDOW
XCBWINDOWNew (XCBConnection *c);

void
XCBPIXMAPNext (XCBPIXMAPIter *i);

XCBGenericIter
XCBPIXMAPEnd (XCBPIXMAPIter i);

XCBPIXMAP
XCBPIXMAPNew (XCBConnection *c);

void
XCBCURSORNext (XCBCURSORIter *i);

XCBGenericIter
XCBCURSOREnd (XCBCURSORIter i);

XCBCURSOR
XCBCURSORNew (XCBConnection *c);

void
XCBFONTNext (XCBFONTIter *i);

XCBGenericIter
XCBFONTEnd (XCBFONTIter i);

XCBFONT
XCBFONTNew (XCBConnection *c);

void
XCBGCONTEXTNext (XCBGCONTEXTIter *i);

XCBGenericIter
XCBGCONTEXTEnd (XCBGCONTEXTIter i);

XCBGCONTEXT
XCBGCONTEXTNew (XCBConnection *c);

void
XCBCOLORMAPNext (XCBCOLORMAPIter *i);

XCBGenericIter
XCBCOLORMAPEnd (XCBCOLORMAPIter i);

XCBCOLORMAP
XCBCOLORMAPNew (XCBConnection *c);

void
XCBATOMNext (XCBATOMIter *i);

XCBGenericIter
XCBATOMEnd (XCBATOMIter i);

XCBATOM
XCBATOMNew (XCBConnection *c);

void
XCBDRAWABLENext (XCBDRAWABLEIter *i);

XCBGenericIter
XCBDRAWABLEEnd (XCBDRAWABLEIter i);

void
XCBFONTABLENext (XCBFONTABLEIter *i);

XCBGenericIter
XCBFONTABLEEnd (XCBFONTABLEIter i);

void
XCBVISUALIDNext (XCBVISUALIDIter *i);

XCBGenericIter
XCBVISUALIDEnd (XCBVISUALIDIter i);

void
XCBTIMESTAMPNext (XCBTIMESTAMPIter *i);

XCBGenericIter
XCBTIMESTAMPEnd (XCBTIMESTAMPIter i);

void
XCBKEYSYMNext (XCBKEYSYMIter *i);

XCBGenericIter
XCBKEYSYMEnd (XCBKEYSYMIter i);

void
XCBKEYCODENext (XCBKEYCODEIter *i);

XCBGenericIter
XCBKEYCODEEnd (XCBKEYCODEIter i);

void
XCBBUTTONNext (XCBBUTTONIter *i);

XCBGenericIter
XCBBUTTONEnd (XCBBUTTONIter i);

void
XCBPOINTNext (XCBPOINTIter *i);

XCBGenericIter
XCBPOINTEnd (XCBPOINTIter i);

void
XCBRECTANGLENext (XCBRECTANGLEIter *i);

XCBGenericIter
XCBRECTANGLEEnd (XCBRECTANGLEIter i);

void
XCBARCNext (XCBARCIter *i);

XCBGenericIter
XCBARCEnd (XCBARCIter i);

void
XCBFORMATNext (XCBFORMATIter *i);

XCBGenericIter
XCBFORMATEnd (XCBFORMATIter i);

void
XCBVISUALTYPENext (XCBVISUALTYPEIter *i);

XCBGenericIter
XCBVISUALTYPEEnd (XCBVISUALTYPEIter i);

XCBVISUALTYPE *
XCBDEPTHVisuals (const XCBDEPTH *R);

int
XCBDEPTHVisualsLength (const XCBDEPTH *R);

XCBVISUALTYPEIter
XCBDEPTHVisualsIter (const XCBDEPTH *R);

void
XCBDEPTHNext (XCBDEPTHIter *i);

XCBGenericIter
XCBDEPTHEnd (XCBDEPTHIter i);

int
XCBSCREENAllowedDepthsLength (const XCBSCREEN *R);

XCBDEPTHIter
XCBSCREENAllowedDepthsIter (const XCBSCREEN *R);

void
XCBSCREENNext (XCBSCREENIter *i);

XCBGenericIter
XCBSCREENEnd (XCBSCREENIter i);

char *
XCBSetupReqAuthorizationProtocolName (const XCBSetupReq *R);

int
XCBSetupReqAuthorizationProtocolNameLength (const XCBSetupReq *R);

XCBGenericIter
XCBSetupReqAuthorizationProtocolNameEnd (const XCBSetupReq *R);

char *
XCBSetupReqAuthorizationProtocolData (const XCBSetupReq *R);

int
XCBSetupReqAuthorizationProtocolDataLength (const XCBSetupReq *R);

XCBGenericIter
XCBSetupReqAuthorizationProtocolDataEnd (const XCBSetupReq *R);

void
XCBSetupReqNext (XCBSetupReqIter *i);

XCBGenericIter
XCBSetupReqEnd (XCBSetupReqIter i);

char *
XCBSetupFailedReason (const XCBSetupFailed *R);

int
XCBSetupFailedReasonLength (const XCBSetupFailed *R);

XCBGenericIter
XCBSetupFailedReasonEnd (const XCBSetupFailed *R);

void
XCBSetupFailedNext (XCBSetupFailedIter *i);

XCBGenericIter
XCBSetupFailedEnd (XCBSetupFailedIter i);

char *
XCBSetupAuthenticateReason (const XCBSetupAuthenticate *R);

int
XCBSetupAuthenticateReasonLength (const XCBSetupAuthenticate *R);

XCBGenericIter
XCBSetupAuthenticateReasonEnd (const XCBSetupAuthenticate *R);

void
XCBSetupAuthenticateNext (XCBSetupAuthenticateIter *i);

XCBGenericIter
XCBSetupAuthenticateEnd (XCBSetupAuthenticateIter i);

char *
XCBSetupVendor (const XCBSetup *R);

int
XCBSetupVendorLength (const XCBSetup *R);

XCBGenericIter
XCBSetupVendorEnd (const XCBSetup *R);

XCBFORMAT *
XCBSetupPixmapFormats (const XCBSetup *R);

int
XCBSetupPixmapFormatsLength (const XCBSetup *R);

XCBFORMATIter
XCBSetupPixmapFormatsIter (const XCBSetup *R);

int
XCBSetupRootsLength (const XCBSetup *R);

XCBSCREENIter
XCBSetupRootsIter (const XCBSetup *R);

void
XCBSetupNext (XCBSetupIter *i);

XCBGenericIter
XCBSetupEnd (XCBSetupIter i);


#endif