root/trunk/X11/Xlib.d

/*  Xlib binding for D language
    Copyright 2007 TEISSIER Sylvere sligor(at)free.fr
    version 0.1 2007/08/29
    This binding is an alpha release and need to be more tested
    
    This file is free software, please read COPYING file for more informations
*/

/* This file is binding from:
 $XdotOrg: lib/X11/include/X11/Xlib.h,v 1.6 2005-11-08 06:33:25 jkj Exp $ 
 $Xorg: Xlib.h,v 1.6 2001/02/09 02:03:38 xorgcvs Exp $
*/


module std.c.linux.X11.Xlib;
public import std.c.linux.X11.X;

const int XlibSpecificationRelease=6;
version = X_HAVE_UTF8_STRING;

typedef void* XPointer;
typedef int Status ;
enum Bool:int{False,True}; //xlib boolean is int type, D bool is only byte
enum QueueMode{QueuedAlready,QueuedAfterReading,QueuedAfterFlush};

/+
TODO Nested struc or union verify
+/

int     ConnectionNumber(Display *dpy)  {return dpy.fd;}
Window  RootWindow(Display *dpy,int scr)    {return ScreenOfDisplay(dpy,scr).root;}
int     DefaultScreen(Display *dpy)         {return dpy.default_screen;}
Window  DefaultRootWindow(Display *dpy)     {return ScreenOfDisplay(dpy,DefaultScreen(dpy)).root;}
Visual* DefaultVisual(Display *dpy,int scr) {return ScreenOfDisplay(dpy,scr).root_visual;}
GC      DefaultGC(Display *dpy,int scr)     {return ScreenOfDisplay(dpy,scr).default_gc;}
uint    BlackPixel(Display *dpy,int scr)    {return ScreenOfDisplay(dpy,scr).black_pixel;}
uint    WhitePixel(Display *dpy,int scr)    {return ScreenOfDisplay(dpy,scr).white_pixel;}
uint    AllPlanes()                         {return 0xFFFFFFFF;}
int     QLength(Display *dpy)               {return dpy.qlen;}
int     DisplayWidth(Display *dpy,int scr)  {return ScreenOfDisplay(dpy,scr).width;}
int     DisplayHeight(Display *dpy,int scr) {return ScreenOfDisplay(dpy,scr).height;}
int     DisplayWidthMM(Display *dpy,int scr){return ScreenOfDisplay(dpy,scr).mwidth;}
int     DisplayHeightMM(Display *dpy,int scr){return ScreenOfDisplay(dpy,scr).mheight;}
int     DisplayPlanes(Display *dpy,int scr) {return ScreenOfDisplay(dpy,scr).root_depth;}
int     DisplayCells(Display *dpy,int scr)  {return DefaultVisual(dpy,scr).map_entries;}
int     ScreenCount(Display *dpy)           {return dpy.nscreens;}
char*   ServerVendor(Display *dpy)          {return dpy.vendor;}
int     ProtocolVersion(Display *dpy)       {return dpy.proto_major_version;}
int     ProtocolRevision(Display *dpy)      {return dpy.proto_minor_version;}
int     VendorRelease(Display *dpy)             {return dpy.release;}
char*   DisplayString(Display *dpy)             {return dpy.display_name;}
int     DefaultDepth(Display *dpy,int scr)  {return ScreenOfDisplay(dpy,scr).root_depth;}
Colormap DefaultColormap(Display *dpy,int scr){return ScreenOfDisplay(dpy,scr).cmap;}
int     BitmapUnit(Display *dpy)            {return dpy.bitmap_unit;}
int     BitmapBitOrder(Display *dpy)        {return dpy.bitmap_bit_order;}
int     BitmapPad(Display *dpy)             {return dpy.bitmap_pad;}
int     ImageByteOrder(Display *dpy)        {return dpy.byte_order;} 
uint    NextRequest(Display *dpy)           {return dpy.request + 1;}

uint    LastKnownRequestProcessed(Display *dpy) {return dpy.last_request_read;}

/* macros for screen oriented applications (toolkit) */
Screen* ScreenOfDisplay(Display *dpy,int scr)   {return &dpy.screens[scr];}
Screen* DefaultScreenOfDisplay(Display *dpy) {return ScreenOfDisplay(dpy,DefaultScreen(dpy));}
Display* DisplayOfScreen(Screen s)          {return s.display;}
Window  RootWindowOfScreen(Screen s)        {return s.root;}
uint    BlackPixelOfScreen(Screen s)        {return s.black_pixel;}
uint    WhitePixelOfScreen(Screen s)        {return s.white_pixel;}
Colormap DefaultColormapOfScreen(Screen s)  {return s.cmap;}
int     DefaultDepthOfScreen(Screen s)      {return s.root_depth;}
GC      DefaultGCOfScreen(Screen s)     {return s.default_gc;}
Visual* DefaultVisualOfScreen(Screen s) {return s.root_visual;}
int     WidthOfScreen(Screen s)         {return s.width;}
int     HeightOfScreen(Screen s)        {return s.height;}
int     WidthMMOfScreen(Screen s)       {return s.mwidth;}
int     HeightMMOfScreen(Screen s)      {return s.mheight;}
int     PlanesOfScreen(Screen s)        {return s.root_depth;}
int     CellsOfScreen(Screen s)         {return DefaultVisualOfScreen(s).map_entries;}
int     MinCmapsOfScreen(Screen s)      {return s.min_maps;}
int     MaxCmapsOfScreen(Screen s)      {return s.max_maps;}
Bool    DoesSaveUnders(Screen s)        {return s.save_unders;}
int     DoesBackingStore(Screen s)      {return s.backing_store;}
int     EventMaskOfScreen(Screen s)     {return s.root_input_mask;}



/*
 * Extensions need a way to hang private data on some structures.
 */
struct XExtData 
{
    int number;     /* number returned by XRegisterExtension */
    XExtData *next;     /* next item on list of data for structure */
    int function(XExtData *extension) free_private; /* called to free private storage */
    XPointer private_data;  /* data private to this extension. */
};

/*
 * This file contains structures used by the extension mechanism.
 */
struct XExtCodes
{                       /* public to extension, cannot be changed */
    int extension;      /* extension number */
    int major_opcode;   /* major op-code assigned by server */
    int first_event;    /* first event number for the extension */
    int first_error;    /* first error number for the extension */
};

/*
 * Data structure for retrieving info about pixmap formats.
 */

struct XPixmapFormatValues
{
    int depth;
    int bits_per_pixel;
    int scanline_pad;
};

struct XGCValues
{
    GraphicFunction function_;      /* logical operation*/
    uint plane_mask;                /* plane mask */
    uint foreground;                /* foreground pixel */
    uint background;                /* background pixel */
    int line_width;                 /* line width */
    LineStyle line_style;           /* LineSolid, LineOnOffDash, LineDoubleDash */
    CapStyle cap_style;             /* CapNotLast, CapButt, CapRound, CapProjecting */
    LineStyle join_style;           /* JoinMiter, JoinRound, JoinBevel */
    FillStyle fill_style;           /* FillSolid, FillTiled,FillStippled, FillOpaeueStippled */
    FillRule fill_rule;             /* EvenOddRule, WindingRule */
    ArcMode arc_mode;               /* ArcChord, ArcPieSlice */
    Pixmap tile;                    /* tile pixmap for tiling operations */
    Pixmap stipple;             /* stipple 1 plane pixmap for stipping */
    int ts_x_origin;                /* offset for tile or stipple operations */
    int ts_y_origin;
    Font font;                      /* default text font for text operations */
    SubwindowMode subwindow_mode;   /* ClipByChildren, IncludeInferiors */
    Bool graphics_exposures;        /* Boolean, should exposures be generated */
    int clip_x_origin;              /* origin for clipping */
    int clip_y_origin;
    Pixmap clip_mask;               /* bitmap clipping; other calls for rects */
    int dash_offset;                /* patterned/dashed line information */
    byte dashes;
};

typedef void* GC;

/*
 * Visual structure; contains information about colormapping possible.
 */
struct Visual
{
    XExtData *ext_data; /* hook for extension to hang data */
    VisualID visualid;  /* visual id of this visual */
    int class_;         /* class of screen (monochrome, etc.) */
    uint red_mask, green_mask, blue_mask;   /* mask values */
    int bits_per_rgb;   /* log base 2 of distinct color values */
    int map_entries;    /* color map entries */
} ;

/*
 * Depth structure; contains information for each possible depth.
 */ 
struct Depth
{
    int depth;      /* this depth (Z) of the depth */
    int nvisuals;       /* number of Visual types at this depth */
    Visual *visuals;    /* list of visuals possible at this depth */
};

alias Display XDisplay;

struct Screen{
    XExtData *ext_data;     /* hook for extension to hang data */
    XDisplay *display;      /* back pointer to display structure */
    Window root;            /* Root window id. */
    int width, height;      /* width and height of screen */
    int mwidth, mheight;    /* width and height of  in millimeters */
    int ndepths;            /* number of depths possible */
    Depth *depths;          /* list of allowable depths on the screen */
    int root_depth;         /* bits per pixel */
    Visual *root_visual;    /* root visual */
    GC default_gc;          /* GC for the root root visual */
    Colormap cmap;          /* default color map */
    uint white_pixel;
    uint black_pixel;       /* White and Black pixel values */
    int max_maps, min_maps; /* max and min color maps */
    int backing_store;      /* Never, WhenMapped, Always */
    Bool save_unders;   
    int root_input_mask;    /* initial root input mask */
};

/*
 * Format structure; describes ZFormat data the screen will understand.
 */
struct ScreenFormat
{
    XExtData *ext_data; /* hook for extension to hang data */
    int depth;          /* depth of this image format */
    int bits_per_pixel; /* bits/pixel at this depth */
    int scanline_pad;   /* scanline must padded to this multiple */
};

/*
 * Data structure for setting window attributes.
 */
struct  XSetWindowAttributes
{
    Pixmap background_pixmap;   /* background or None or ParentRelative */
    uint background_pixel;      /* background pixel */
    Pixmap border_pixmap;       /* border of the window */
    uint border_pixel;          /* border pixel value */
    BitGravity bit_gravity;     /* one of bit gravity values */
    BitGravity win_gravity;     /* one of the window gravity values */
    BackingStoreHint backing_store;     /* NotUseful, WhenMapped, Always */
    uint backing_planes;        /* planes to be preseved if possible */
    uint backing_pixel;         /* value to use in restoring planes */
    Bool save_under;            /* should bits under be saved? (popups) */
    long event_mask;            /* set of events that should be saved */
    long do_not_propagate_mask;/* set of events that should not propagate */
    Bool override_redirect;     /* Boolean value for override-redirect */
    Colormap colormap;          /* color map to be associated with window */
    Cursor cursor;              /* cursor to be displayed (or None) */
};

struct XWindowAttributes
{
    int x, y;                   /* location of window */
    int width, height;          /* width and height of window */
    int border_width;           /* border width of window */
    int depth;                  /* depth of window */
    Visual *visual;             /* the associated visual structure */
    Window root;                /* root of screen containing window */
    WindowClass class_;         /* InputOutput, InputOnly*/
    BitGravity bit_gravity;     /* one of bit gravity values */
    BitGravity win_gravity;     /* one of the window gravity values */
    BackingStoreHint backing_store; /* NotUseful, WhenMapped, Always */
    uint backing_planes;        /* planes to be preserved if possible */
    uint backing_pixel; /* value to be used when restoring planes */
    Bool save_under;            /* Boolean, should bits under be saved? */
    Colormap colormap;          /* color map to be associated with window */
    Bool map_installed;     /* Boolean, is color map currently installed*/
    MapState map_state;     /* IsUnmapped, IsUnviewable, IsViewable */
    EventMask all_event_masks;  /* set of events all people have interest in*/
    EventMask your_event_mask;  /* my event mask */
    EventMask do_not_propagate_mask; /* set of events that should not propagate */
    Bool override_redirect;     /* Boolean value for override-redirect */
    Screen *screen;             /* back pointer to correct screen */
};

/*
 * Data structure for host setting; getting routines.
 *
 */

struct XHostAddress
{
    ProtocolFamlily family; /* for example FamilyInternet */
    int length;                 /* length of address, in bytes */
    void *address;              /* pointer to where to find the bytes */
};

/*
 * Data structure for ServerFamilyInterpreted addresses in host routines
 */
struct XServerInterpretedAddress
{
    int typelength;     /* length of type string, in bytes */
    int valuelength;    /* length of value string, in bytes */
    void *type;         /* pointer to where to find the type string */
    void *value;        /* pointer to where to find the address */
};

/*
 * Data structure for "image" data, used by image manipulation routines.
 */
struct XImage
{
    int width, height;          /* size of image */
    int xoffset;                /* number of pixels offset in X direction */
    ImageFormat format;     /* XYBitmap, XYPixmap, ZPixmap */
    void *data;                 /* pointer to image data */
    ByteOrder byte_order;       /* data byte order, LSBFirst, MSBFirst */
    int bitmap_unit;            /* quant. of scanline 8, 16, 32 */
    int bitmap_bit_order;       /* LSBFirst, MSBFirst */
    int bitmap_pad;         /* 8, 16, 32 either XY or ZPixmap */
    int depth;                  /* depth of image */
    int bytes_per_line;         /* accelarator to next line */
    int bits_per_pixel;         /* bits per pixel (ZPixmap) */
    uint red_mask;  /* bits in z arrangment */
    uint green_mask;
    uint blue_mask;
    XPointer obdata;            /* hook for the object routines to hang on */
    struct f {              /* image manipulation routines */
        XImage* function(
            XDisplay*           /* display */,
            Visual*             /* visual */,
            uint                /* depth */,
            int                 /* format */,
            int                 /* offset */,
            byte*               /* data */,
            uint                /* width */,
            uint                /* height */,
            int                 /* bitmap_pad */,
            int                 /* bytes_per_line */) create_image;
        int  function(XImage *)destroy_image;
        uint function(XImage *, int, int)get_pixel;
        int  function(XImage *, int, int, uint)put_pixel;
        XImage function(XImage *, int, int, uint, uint)sub_image;
        int function(XImage *, int)add_pixel;
    };
};

/* 
 * Data structure for XReconfigureWindow
 */
struct XWindowChanges{
    int x, y;
    int width, height;
    int border_width;
    Window sibling;
    WindowStackingMethod stack_mode;
};

/*
 * Data structure used by color operations
 */
struct XColor
{
    uint pixel;
    ushort red, green, blue;
    StoreColor flags;  /* do_red, do_green, do_blue */
    byte pad;
};

/* 
 * Data structures for graphics operations.  On most machines, these are
 * congruent with the wire protocol structures, so reformatting the data
 * can be avoided on these architectures.
 */
struct XSegment
{
    short x1, y1, x2, y2;
};

struct XPoint
{
    short x, y;
};
    
struct XRectangle
{
    short x, y;
    ushort width, height;
};
    
struct XArc
{
    short x, y;
    ushort width, height;
    short angle1, angle2;
};


/* Data structure for XChangeKeyboardControl */

struct XKeyboardControl
{
    int key_click_percent;
    int bell_percent;
    int bell_pitch;
    int bell_duration;
    int led;
    LedMode led_mode;
    int key;
    AutoRepeatMode auto_repeat_mode;   /* On, Off, Default */
};

/* Data structure for XGetKeyboardControl */

struct XKeyboardState
{
    int key_click_percent;
    int bell_percent;
    uint bell_pitch, bell_duration;
    uint led_mask;
    int global_auto_repeat;
    byte auto_repeats[32];
};

struct XTimeCoord
{
    Time time;
    short x, y;
};

/* Data structure for X{Set,Get}ModifierMapping */

struct XModifierKeymap
{
    int max_keypermod;  /* The server's max # of keys per modifier */
    KeyCode *modifiermap;   /* An 8 by max_keypermod array of modifiers */
};


/+ todo Verify Here+/
/*
 * Display datatype maintaining display specific data.
 * The contents of this structure are implementation dependent.
 * A Display should be treated as opaque by application code.
 */

struct _XPrivate{}      /* Forward declare before use for C++ */
struct _XrmHashBucketRec{}

struct Display
{
    XExtData *ext_data; /* hook for extension to hang data */
    _XPrivate *private1;
    int fd;         /* Network socket. */
    int private2;
    int proto_major_version;/* major version of server's X protocol */
    int proto_minor_version;/* minor version of servers X protocol */
    char *vendor;       /* vendor of the server hardware */
    XID private3;
    XID private4;
    XID private5;
    int private6;
    XID function(Display*)resource_alloc;/* allocator function */
    ByteOrder byte_order;       /* screen byte order, LSBFirst, MSBFirst */
    int bitmap_unit;    /* padding and data requirements */
    int bitmap_pad;     /* padding requirements on bitmaps */
    ByteOrder bitmap_bit_order; /* LeastSignificant or MostSignificant */
    int nformats;       /* number of pixmap formats in list */
    ScreenFormat *pixmap_format;    /* pixmap format list */
    int private8;
    int release;        /* release of the server */
    _XPrivate *private9;
    _XPrivate *private10;
    int qlen;       /* Length of input event queue */
    uint last_request_read; /* seq number of last event read */
    uint request;   /* sequence number of last request. */
    XPointer private11;
    XPointer private12;
    XPointer private13;
    XPointer private14;
    uint max_request_size; /* maximum number 32 bit words in request*/
    _XrmHashBucketRec *db;
    int function  (Display*)private15;
    char *display_name; /* "host:display" string used on this connect*/
    int default_screen; /* default screen for operations */
    int nscreens;       /* number of screens on this server*/
    Screen *screens;    /* pointer to list of screens */
    uint motion_buffer; /* size of motion buffer */
    uint private16;
    int min_keycode;    /* minimum defined keycode */
    int max_keycode;    /* maximum defined keycode */
    XPointer private17;
    XPointer private18;
    int private19;
    byte *xdefaults;    /* contents of defaults from server */
    /* there is more to this structure, but it is private to Xlib */
}

typedef Display *_XPrivDisplay;
struct XrmHashBucketRec{};


/*
 * Definitions of specific events.
 */
struct XKeyEvent
{
    int type;           /* of event */
    uint serial;        /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;          /* "event" window it is reported relative to */
    Window root;            /* root window that the event occurred on */
    Window subwindow;   /* child window */
    Time time;      /* milliseconds */
    int x, y;       /* pointer x, y coordinates in event window */
    int x_root, y_root; /* coordinates relative to root */
    KeyOrButtonMask state;  /* key or button mask */
    uint keycode;   /* detail */
    Bool same_screen;   /* same screen flag */
};
typedef XKeyEvent XKeyPressedEvent;
typedef XKeyEvent XKeyReleasedEvent;

struct XButtonEvent
{
    int type;       /* of event */
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;          /* "event" window it is reported relative to */
    Window root;            /* root window that the event occurred on */
    Window subwindow;   /* child window */
    Time time;      /* milliseconds */
    int x, y;       /* pointer x, y coordinates in event window */
    int x_root, y_root; /* coordinates relative to root */
    KeyOrButtonMask state;  /* key or button mask */
    uint button;    /* detail */
    Bool same_screen;   /* same screen flag */
};
typedef XButtonEvent XButtonPressedEvent;
typedef XButtonEvent XButtonReleasedEvent;

struct XMotionEvent{
    int type;       /* of event */
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;          /* "event" window reported relative to */
    Window root;            /* root window that the event occurred on */
    Window subwindow;   /* child window */
    Time time;      /* milliseconds */
    int x, y;       /* pointer x, y coordinates in event window */
    int x_root, y_root; /* coordinates relative to root */
    KeyOrButtonMask state;  /* key or button mask */
    byte is_hint;       /* detail */
    Bool same_screen;   /* same screen flag */
};
typedef XMotionEvent XPointerMovedEvent;

struct XCrossingEvent{
    int type;       /* of event */
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;          /* "event" window reported relative to */
    Window root;            /* root window that the event occurred on */
    Window subwindow;   /* child window */
    Time time;      /* milliseconds */
    int x, y;       /* pointer x, y coordinates in event window */
    int x_root, y_root; /* coordinates relative to root */
    NotifyModes mode;       /* NotifyNormal, NotifyGrab, NotifyUngrab */
    NotifyDetail detail;
    /*
     * NotifyAncestor, NotifyVirtual, NotifyInferior, 
     * NotifyNonlinear,NotifyNonlinearVirtual
     */
    Bool same_screen;   /* same screen flag */
    Bool focus;     /* Boolean focus */
    KeyOrButtonMask state;  /* key or button mask */
};
typedef XCrossingEvent XEnterWindowEvent;
typedef XCrossingEvent XLeaveWindowEvent;

struct XFocusChangeEvent{
    int type;       /* FocusIn or FocusOut */
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;      /* window of event */
    NotifyModes mode;       /* NotifyNormal, NotifyWhileGrabbed,
                   NotifyGrab, NotifyUngrab */
    NotifyDetail detail;
    /*
     * NotifyAncestor, NotifyVirtual, NotifyInferior, 
     * NotifyNonlinear,NotifyNonlinearVirtual, NotifyPointer,
     * NotifyPointerRoot, NotifyDetailNone 
     */
};
typedef XFocusChangeEvent XFocusInEvent;
typedef XFocusChangeEvent XFocusOutEvent;

/* generated on EnterWindow and FocusIn  when KeyMapState selected */
struct XKeymapEvent
{
    int type;
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;
    byte key_vector[32];
};  

struct XExposeEvent
{
    int type;
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Window window;
    int x, y;
    int width, height;
    int count;      /* if non-zero, at least this many more */
};

struct XGraphicsExposeEvent{
    int type;
    uint serial;    /* # of last request processed by server */
    Bool send_event;    /* true if this came from a SendEvent request */
    Display *display;   /* Display the event was read from */
    Drawable drawable;
    int x, y;
    int width, height;
    int count;      /* if non-zero, at least this many more */
    int major_code;     /* core is CopyArea or CopyPlane */
    int minor_code;     /* not defined in the core */
};

struct XNoExposeEvent{
    int