XSERVER 解读01

#define _GNU_SOURCE 1

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <time.h>
#include <ctype.h>
#include <stdarg.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/stat.h>
#include <sys/epoll.h>
#include <sys/mman.h>

#include <X11/X.h>
#include <X11/keysymdef.h>
#include <X11/Xmd.h>
#include <X11/Xos.h>            /* for unistd.h  */
#include <X11/Xproto.h>
#include <X11/fonts/font.h>
#include <X11/fonts/fontstruct.h>
#include <X11/fonts/libxfont2.h>
#include <X11/Xosdefs.h>
#include <X11/Xfuncproto.h>
#include <X11/Xdefs.h>
#include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h>
#include <X11/extensions/XKB.h>
#include <X11/extensions/XKBproto.h>
#include <X11/extensions/randr.h>
#include <pixman.h>

#define MAP_LENGTH	MAX_BUTTONS
#define DOWN_LENGTH	(MAX_BUTTONS/8)
#define MAX_VALUATORS 36
#define MAX_VALUATOR_EVENTS 6
#define MAX_BUTTONS 256         /* completely arbitrarily chosen */
#define MAXFORMATS	8
#define MAXDEVICES	40      /* input devices */
#define GPU_SCREEN_OFFSET 256
#define MAX_HSYNC 8
#define MAX_VREFRESH 8
#define MAXCLOCKS   128
#define MAXCLIENTS	2048
#define PATH_MAX 1024
#define LOCK_DIR "/tmp"
#define LOCK_TMP_PREFIX "/.tX"
#define LOCK_PREFIX "/.X"
#define LOCK_SUFFIX "-lock"
#define DEFAULT_SCREEN_SAVER_TIME (10 * (60 * 1000))
#define DEFAULT_SCREEN_SAVER_INTERVAL (10 * (60 * 1000))
#define DEFAULT_SCREEN_SAVER_BLANKING PreferBlanking
#define DEFAULT_SCREEN_SAVER_EXPOSURES AllowExposures
#define DEFAULT_LOGDIR "/var/log"
/* Path to configuration file. */
#define XF86CONFIGFILE "xorg.conf"

/* Path to configuration file. */
#define XCONFIGFILE "xorg.conf"

/* Name of configuration directory. */
#define XCONFIGDIR "xorg.conf.d"

/* Path to loadable modules. */
#define DEFAULT_MODULE_PATH "/usr/lib/xorg/modules"

/* Path to installed libraries. */
#define DEFAULT_LIBRARY_PATH "/usr/lib/x86_64-linux-gnu"

/* Default log location */
#define DEFAULT_LOGDIR "/var/log"

/* Default logfile prefix */
#define DEFAULT_LOGPREFIX "Xorg."

/* Default XDG_DATA dir under HOME */
#define DEFAULT_XDG_DATA_HOME ".local/share"

/* Default log dir under XDG_DATA_HOME */
#define DEFAULT_XDG_DATA_HOME_LOGDIR "xorg"

typedef enum _LogParameter {
    XLOG_FLUSH,
    XLOG_SYNC,
    XLOG_VERBOSITY,
    XLOG_FILE_VERBOSITY
} LogParameter;

/* Flags for log messages. */
typedef enum {
    X_PROBED,                   /* Value was probed */
    X_CONFIG,                   /* Value was given in the config file */
    X_DEFAULT,                  /* Value is a default */
    X_CMDLINE,                  /* Value was given on the command line */
    X_NOTICE,                   /* Notice */
    X_ERROR,                    /* Error message */
    X_WARNING,                  /* Warning message */
    X_INFO,                     /* Informational message */
    X_NONE,                     /* No prefix */
    X_NOT_IMPLEMENTED,          /* Not implemented */
    X_DEBUG,                    /* Debug message */
    X_UNKNOWN = -1              /* unknown -- this must always be last */
} MessageType;

typedef enum {
    DAC_BPP8 = 0,
    DAC_BPP16,
    DAC_BPP24,
    DAC_BPP32,
    MAXDACSPEEDS
} DacSpeedIndex;

typedef enum {
    MODE_OK = 0,                /* Mode OK */
    MODE_HSYNC,                 /* hsync out of range */
    MODE_VSYNC,                 /* vsync out of range */
    MODE_H_ILLEGAL,             /* mode has illegal horizontal timings */
    MODE_V_ILLEGAL,             /* mode has illegal horizontal timings */
    MODE_BAD_WIDTH,             /* requires an unsupported linepitch */
    MODE_NOMODE,                /* no mode with a matching name */
    MODE_NO_INTERLACE,          /* interlaced mode not supported */
    MODE_NO_DBLESCAN,           /* doublescan mode not supported */
    MODE_NO_VSCAN,              /* multiscan mode not supported */
    MODE_MEM,                   /* insufficient video memory */
    MODE_VIRTUAL_X,             /* mode width too large for specified virtual size */
    MODE_VIRTUAL_Y,             /* mode height too large for specified virtual size */
    MODE_MEM_VIRT,              /* insufficient video memory given virtual size */
    MODE_NOCLOCK,               /* no fixed clock available */
    MODE_CLOCK_HIGH,            /* clock required is too high */
    MODE_CLOCK_LOW,             /* clock required is too low */
    MODE_CLOCK_RANGE,           /* clock/mode isn't in a ClockRange */
    MODE_BAD_HVALUE,            /* horizontal timing was out of range */
    MODE_BAD_VVALUE,            /* vertical timing was out of range */
    MODE_BAD_VSCAN,             /* VScan value out of range */
    MODE_HSYNC_NARROW,          /* horizontal sync too narrow */
    MODE_HSYNC_WIDE,            /* horizontal sync too wide */
    MODE_HBLANK_NARROW,         /* horizontal blanking too narrow */
    MODE_HBLANK_WIDE,           /* horizontal blanking too wide */
    MODE_VSYNC_NARROW,          /* vertical sync too narrow */
    MODE_VSYNC_WIDE,            /* vertical sync too wide */
    MODE_VBLANK_NARROW,         /* vertical blanking too narrow */
    MODE_VBLANK_WIDE,           /* vertical blanking too wide */
    MODE_PANEL,                 /* exceeds panel dimensions */
    MODE_INTERLACE_WIDTH,       /* width too large for interlaced mode */
    MODE_ONE_WIDTH,             /* only one width is supported */
    MODE_ONE_HEIGHT,            /* only one height is supported */
    MODE_ONE_SIZE,              /* only one resolution is supported */
    MODE_NO_REDUCED,            /* monitor doesn't accept reduced blanking */
    MODE_BANDWIDTH,             /* mode requires too much memory bandwidth */
    MODE_BAD = -2,              /* unspecified reason */
    MODE_ERROR = -1             /* error condition */
} ModeStatus;

typedef enum {
    PosObsolete = -1,
    PosAbsolute = 0,
    PosRightOf,
    PosLeftOf,
    PosAbove,
    PosBelow,
    PosRelative
} PositionType;

typedef enum {
    /* XSELinux uses the same private keys for numerous objects */
    PRIVATE_XSELINUX,

    /* Otherwise, you get a private in just the requested structure
     */
    /* These can have objects created before all of the keys are registered */
    PRIVATE_SCREEN,
    PRIVATE_EXTENSION,
    PRIVATE_COLORMAP,
    PRIVATE_DEVICE,

    /* These cannot have any objects before all relevant keys are registered */
    PRIVATE_CLIENT,
    PRIVATE_PROPERTY,
    PRIVATE_SELECTION,
    PRIVATE_WINDOW,
    PRIVATE_PIXMAP,
    PRIVATE_GC,
    PRIVATE_CURSOR,
    PRIVATE_CURSOR_BITS,

    /* extension privates */
    PRIVATE_GLYPH,
    PRIVATE_GLYPHSET,
    PRIVATE_PICTURE,
    PRIVATE_SYNC_FENCE,

    /* last private type */
    PRIVATE_LAST,
} DevPrivateType;

typedef enum { VTOther, VTStack, VTMove, VTUnmap, VTMap, VTBroken } VTKind;

enum InputLevel {
    CORE = 1,
    XI = 2,
    XI2 = 3,
};

enum EventType {
    ET_KeyPress = 2,
    ET_KeyRelease,
    ET_ButtonPress,
    ET_ButtonRelease,
    ET_Motion,
    ET_TouchBegin,
    ET_TouchUpdate,
    ET_TouchEnd,
    ET_TouchOwnership,
    ET_Enter,
    ET_Leave,
    ET_FocusIn,
    ET_FocusOut,
    ET_ProximityIn,
    ET_ProximityOut,
    ET_DeviceChanged,
    ET_Hierarchy,
    ET_DGAEvent,
    ET_RawKeyPress,
    ET_RawKeyRelease,
    ET_RawButtonPress,
    ET_RawButtonRelease,
    ET_RawMotion,
    ET_RawTouchBegin,
    ET_RawTouchUpdate,
    ET_RawTouchEnd,
    ET_XQuartz,
    ET_BarrierHit,
    ET_BarrierLeave,
    ET_Internal = 0xFF          /* First byte */
};

enum DeviceEventSource {
  EVENT_SOURCE_NORMAL = 0, /**< Default: from a user action (e.g. key press) */
  EVENT_SOURCE_FOCUS, /**< Keys or buttons previously down on focus-in */
};

typedef struct _OsTimerRec *OsTimerPtr;
typedef struct pixman_box16 BoxRec;
typedef struct pixman_region16_data RegDataRec, *RegDataPtr;
typedef struct pixman_region16 RegionRec, *RegionPtr;
typedef int HWEventQueueType;
typedef struct _CallbackList *CallbackListPtr;
typedef void (*CallbackProcPtr) (CallbackListPtr *, void *, void *);
typedef void (*ServerBlockHandlerProcPtr) (void *blockData,void *timeout);
typedef void (*ServerWakeupHandlerProcPtr) (void *blockData,int result);
typedef void (*busfault_notify_ptr) (void *context);
typedef CARD32 (*OsTimerCallback) (OsTimerPtr timer,CARD32 time,void *arg);

struct xorg_list {
    struct xorg_list *next, *prev;
};

typedef struct _CallbackRec 
{
    CallbackProcPtr proc;
    void *data;
    int deleted;                      //Xdefs.h
    struct _CallbackRec *next;
} CallbackRec, *CallbackPtr;

typedef struct _CallbackList 
{
    int inCallback;
    int deleted;
    int numDeleted;
    CallbackPtr list;
} CallbackListRec;

typedef struct _BlockHandler 
{
    ServerBlockHandlerProcPtr BlockHandler;
    ServerWakeupHandlerProcPtr WakeupHandler;
    void *blockData;
    int deleted;
} BlockHandlerRec, *BlockHandlerPtr;

typedef struct {
    float hi, lo;
} range;

typedef struct {
    CARD32 red, green, blue;
} rgb;

typedef struct {
    float red, green, blue;
} Gamma;

typedef struct _DisplayModeRec {
    struct _DisplayModeRec *prev;
    struct _DisplayModeRec *next;
    const char *name;           /* identifier for the mode */
    ModeStatus status;
    int type;

    /* These are the values that the user sees/provides */
    int Clock;                  /* pixel clock freq (kHz) */
    int HDisplay;               /* horizontal timing */
    int HSyncStart;
    int HSyncEnd;
    int HTotal;
    int HSkew;
    int VDisplay;               /* vertical timing */
    int VSyncStart;
    int VSyncEnd;
    int VTotal;
    int VScan;
    int Flags;

    /* These are the values the hardware uses */
    int ClockIndex;
    int SynthClock;             /* Actual clock freq to
                                 * be programmed  (kHz) */
    int CrtcHDisplay;
    int CrtcHBlankStart;
    int CrtcHSyncStart;
    int CrtcHSyncEnd;
    int CrtcHBlankEnd;
    int CrtcHTotal;
    int CrtcHSkew;
    int CrtcVDisplay;
    int CrtcVBlankStart;
    int CrtcVSyncStart;
    int CrtcVSyncEnd;
    int CrtcVBlankEnd;
    int CrtcVTotal;
    int CrtcHAdjusted;
    int CrtcVAdjusted;
    int PrivSize;
    INT32 *Private;
    int PrivFlags;

    float HSync, VRefresh;
} DisplayModeRec, *DisplayModePtr;


typedef struct {
    const char *id;
    const char *vendor;
    const char *model;
    int nHsync;
    range hsync[MAX_HSYNC];
    int nVrefresh;
    range vrefresh[MAX_VREFRESH];
    DisplayModePtr Modes;       /* Start of the monitor's mode list */
    DisplayModePtr Last;        /* End of the monitor's mode list */
    Gamma gamma;                /* Gamma of the monitor */
    int widthmm;
    int heightmm;
    void *options;
    void *DDC;
    Bool reducedblanking;       /* Allow CVT reduced blanking modes? */
    int maxPixClock;            /* in kHz, like mode->Clock */
} MonRec, *MonPtr;


typedef struct {
    const char *identifier;
    const char *vendor;
    const char *board;
    const char *chipset;
    const char *ramdac;
    const char *driver;
    struct _confscreenrec *myScreenSection;
    int claimed;
    int dacSpeeds[MAXDACSPEEDS];
    int numclocks;
    int clock[MAXCLOCKS];
    const char *clockchip;
    const char *busID;
    int active;
    int inUse;
    int videoRam;
    unsigned long MemBase;      /* Frame buffer base address */
    unsigned long IOBase;
    int chipID;
    int chipRev;
    void *options;
    int irq;
    int screen;                 /* For multi-CRTC cards */
} GDevRec, *GDevPtr;

typedef struct {
    int frameX0;
    int frameY0;
    int virtualX;
    int virtualY;
    int depth;
    int fbbpp;
    rgb weight;
    rgb blackColour;
    rgb whiteColour;
    int defaultVisual;
    const char **modes;
    void *options;
} DispRec, *DispPtr;

typedef struct _confxvportrec {
    const char *identifier;
    void *options;
} confXvPortRec, *confXvPortPtr;

typedef struct _confxvadaptrec {
    const char *identifier;
    int numports;
    confXvPortPtr ports;
    void *options;
} confXvAdaptorRec, *confXvAdaptorPtr;

#define MAX_GPUDEVICES 4
typedef struct _confscreenrec {
    const char *id;
    int screennum;
    int defaultdepth;
    int defaultbpp;
    int defaultfbbpp;
    MonPtr monitor;
    GDevPtr device;
    int numdisplays;
    DispPtr displays;
    int numxvadaptors;
    confXvAdaptorPtr xvadaptors;
    void *options;

    int num_gpu_devices;
    GDevPtr gpu_devices[MAX_GPUDEVICES];
} confScreenRec, *confScreenPtr;

typedef struct _screenlayoutrec {
    confScreenPtr screen;
    const char *topname;
    confScreenPtr top;
    const char *bottomname;
    confScreenPtr bottom;
    const char *leftname;
    confScreenPtr left;
    const char *rightname;
    confScreenPtr right;
    PositionType where;
    int x;
    int y;
    const char *refname;
    confScreenPtr refscreen;
} screenLayoutRec, *screenLayoutPtr;

typedef struct _InputInfoRec InputInfoRec;
typedef struct _DeviceIntRec *DeviceIntPtr;
typedef struct _InputOption *XF86OptionPtr;

typedef union _InternalEvent InternalEvent;
typedef int (*DeviceProc) (DeviceIntPtr /*device */ ,int /*what */ );
typedef void (*ProcessInputProc) (InternalEvent * /*event */ ,DeviceIntPtr /*device */ );
typedef int (*DeviceHandleProc) (DeviceIntPtr /*device */ ,void *        /*data */);
typedef void (*DeviceUnwrapProc) (DeviceIntPtr /*device */ , DeviceHandleProc /*proc */ ,void *        /*data */);

typedef struct _DeviceRec {
    void *devicePrivate;
    ProcessInputProc processInputProc;  /* current */
    ProcessInputProc realInputProc;     /* deliver */
    ProcessInputProc enqueueInputProc;  /* enqueue */
    int on;                    /* used by DDX to keep state */
} DeviceRec, *DevicePtr;

typedef struct _TimeStamp {
    CARD32 months;              /* really ~49.7 days */
    CARD32 milliseconds;
} TimeStamp;

typedef uint32_t ATOM;
typedef struct _GC *GCPtr;
typedef struct _Pixmap *PixmapPtr;
typedef struct _GCOps *GCOpsPtr;
typedef struct _PixmapFormat *PixmapFormatPtr;
typedef struct _Visual *VisualPtr;
typedef struct _Depth *DepthPtr;
typedef struct _Screen *ScreenPtr;
typedef struct _GrabRec *GrabPtr;
typedef struct _Window *WindowPtr;
typedef struct _Private PrivateRec, *PrivatePtr;
typedef struct _Screen *ScreenPtr;
typedef struct _Drawable *DrawablePtr;
typedef xPoint DDXPointRec;
typedef struct _xPoint *DDXPointPtr;
typedef struct pixman_box16 *BoxPtr;
typedef struct _xEvent *xEventPtr;
typedef struct _xRectangle *xRectanglePtr;
typedef struct _Cursor *CursorPtr;
typedef CARD32 Pixel;
typedef struct _CMEntry *EntryPtr;
typedef struct _CursorMetric *CursorMetricPtr;
typedef struct _SpriteRec *SpritePtr;
typedef struct _ColormapRec *ColormapPtr;
typedef struct _xPoint *DDXPointPtr;
typedef struct _Property *PropertyPtr;
typedef struct _DeviceEvent DeviceEvent;
typedef struct _Drawable {
    unsigned char type;         /* DRAWABLE_<type> */
    unsigned char class;        /* specific to type */
    unsigned char depth;
    unsigned char bitsPerPixel;
    XID id;                     /* resource id */
    short x;                    /* window: screen absolute, pixmap: 0 */
    short y;                    /* window: screen absolute, pixmap: 0 */
    unsigned short width;
    unsigned short height;
    ScreenPtr pScreen;
    unsigned long serialNumber;
} DrawableRec;

typedef union _DevUnion {
    void *ptr;
    long val;
    unsigned long uval;
    void *(*fptr) (void);
} DevUnion;

typedef struct _Pixmap {
    DrawableRec drawable;
    PrivateRec *devPrivates;
    int refcnt;
    int devKind;                /* This is the pitch of the pixmap, typically width*bpp/8. */
    DevUnion devPrivate;        /* When !NULL, devPrivate.ptr points to the raw pixel data. */
#ifdef COMPOSITE
    short screen_x;
    short screen_y;
#endif
    unsigned usage_hint;        /* see CREATE_PIXMAP_USAGE_* */

    PixmapPtr master_pixmap;    /* pointer to master copy of pixmap for pixmap sharing */
} PixmapRec;

typedef union _PixUnion {
    PixmapPtr pixmap;
    unsigned long pixel;
} PixUnion;

typedef struct {
    int x, y;
    ScreenPtr pScreen;
} HotSpot;

typedef struct _SpriteRec {
    CursorPtr current;
    BoxRec hotLimits;           /* logical constraints of hot spot */
    Bool confined;              /* confined to screen */
    RegionPtr hotShape;         /* additional logical shape constraint */
    BoxRec physLimits;          /* physical constraints of hot spot */
    WindowPtr win;              /* window of logical position */
    HotSpot hot;                /* logical pointer position */
    HotSpot hotPhys;            /* physical pointer position */
#ifdef PANORAMIX
    ScreenPtr screen;           /* all others are in Screen 0 coordinates */
    RegionRec Reg1;             /* Region 1 for confining motion */
    RegionRec Reg2;             /* Region 2 for confining virtual motion */
    WindowPtr windows[MAXSCREENS];
    WindowPtr confineWin;       /* confine window */
#endif
    /* The window trace information is used at dix/events.c to avoid having
     * to compute all the windows between the root and the current pointer
     * window each time a button or key goes down. The grabs on each of those
     * windows must be checked.
     * spriteTraces should only be used at dix/events.c! */
    WindowPtr *spriteTrace;
    int spriteTraceSize;
    int spriteTraceGood;

    /* Due to delays between event generation and event processing, it is
     * possible that the pointer has crossed screen boundaries between the
     * time in which it begins generating events and the time when
     * those events are processed.
     *
     * pEnqueueScreen: screen the pointer was on when the event was generated
     * pDequeueScreen: screen the pointer was on when the event is processed
     */
    ScreenPtr pEnqueueScreen;
    ScreenPtr pDequeueScreen;

} SpriteRec;

typedef struct {
    unsigned short red, green, blue;
} LOCO;

typedef struct {
    unsigned short color;
    short refcnt;
} SHAREDCOLOR;

typedef struct {
    SHAREDCOLOR *red, *green, *blue;
} SHCO;

/* color map entry */
typedef struct _CMEntry {
    union {
        LOCO local;
        SHCO shco;
    } co;
    short refcnt;
    Bool fShared;
} Entry;

typedef struct _ColormapRec {
    VisualPtr pVisual;
    short class;                /* PseudoColor or DirectColor */
    XID mid;                    /* client's name for colormap */
    ScreenPtr pScreen;          /* screen map is associated with */
    short flags;                /* 1 = IsDefault
                                 * 2 = AllAllocated */
    int freeRed;
    int freeGreen;
    int freeBlue;
    int *numPixelsRed;
    int *numPixelsGreen;
    int *numPixelsBlue;
    Pixel **clientPixelsRed;
    Pixel **clientPixelsGreen;
    Pixel **clientPixelsBlue;
    Entry *red;
    Entry *green;
    Entry *blue;
    PrivateRec *devPrivates;
} ColormapRec;

typedef unsigned long Leds;
typedef struct {
    int click, bell, bell_pitch, bell_duration;
    int autoRepeat;
    unsigned char autoRepeats[32];
    Leds leds;
    unsigned char id;
} KeybdCtrl;

typedef struct {
    int num, den, threshold;
    unsigned char id;
} PtrCtrl;

typedef struct {
    int max_symbols, num_symbols_supported;
    int num_symbols_displayed;
    KeySym *symbols_supported;
    KeySym *symbols_displayed;
    unsigned char id;
} StringCtrl;

typedef struct {
    Leds led_values;
    Mask led_mask;
    unsigned char id;
} LedCtrl;

typedef struct {
    int percent, pitch, duration;
    unsigned char id;
} BellCtrl;

typedef struct _GCFuncs {
    void (*ValidateGC) (GCPtr /*pGC */ ,unsigned long /*stateChanges */ , DrawablePtr /*pDrawable */ );

    void (*ChangeGC) (GCPtr /*pGC */ ,unsigned long /*mask */ );

    void (*CopyGC) (GCPtr /*pGCSrc */ ,unsigned long /*mask */ , GCPtr /*pGCDst */ );

    void (*DestroyGC) (GCPtr /*pGC */ );

    void (*ChangeClip) (GCPtr pGC,int type,void *pvalue,int nrects);

    void (*DestroyClip) (GCPtr /*pGC */ );

    void (*CopyClip) (GCPtr /*pgcDst */ , GCPtr /*pgcSrc */ );
} GCFuncs;

typedef struct _GCOps {
    void (*FillSpans) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*nInit */ ,DDXPointPtr /*pptInit */ , int * /*pwidthInit */ ,int /*fSorted */ );

    void (*SetSpans) (DrawablePtr /*pDrawable */ , GCPtr /*pGC */ , char * /*psrc */ ,DDXPointPtr /*ppt */ ,int * /*pwidth */ ,int /*nspans */ ,int /*fSorted */ );

    void (*PutImage) (DrawablePtr /*pDrawable */ , GCPtr /*pGC */ ,int /*depth */ , int /*x */ ,int /*y */ ,int /*w */ , int /*h */ , int /*leftPad */ ,int /*format */ ,char * /*pBits */ );

    RegionPtr (*CopyArea) (DrawablePtr /*pSrc */ ,DrawablePtr /*pDst */ ,GCPtr /*pGC */ ,int /*srcx */ ,int /*srcy */ ,int /*w */ ,int /*h */ ,int /*dstx */ ,int /*dsty */ );

    RegionPtr (*CopyPlane) (DrawablePtr /*pSrcDrawable */ ,DrawablePtr /*pDstDrawable */ ,GCPtr /*pGC */ ,int /*srcx */ ,int /*srcy */ , int /*width */ , int /*height */ , int /*dstx */ , int /*dsty */ , unsigned long /*bitPlane */ );
    void (*PolyPoint) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*mode */ ,int /*npt */ ,DDXPointPtr /*pptInit */ );

    void (*Polylines) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*mode */ ,int /*npt */ ,DDXPointPtr /*pptInit */ );

    void (*PolySegment) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ , int /*nseg */ ,xSegment * /*pSegs */ );

    void (*PolyRectangle) (DrawablePtr /*pDrawable */ , GCPtr /*pGC */ ,int /*nrects */ , xRectangle * /*pRects */ );

    void (*PolyArc) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*narcs */ ,xArc * /*parcs */ );

    void (*FillPolygon) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*shape */ ,int /*mode */ ,int /*count */ ,DDXPointPtr /*pPts */ );

    void (*PolyFillRect) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*nrectFill */ ,xRectangle * /*prectInit */ );

    void (*PolyFillArc) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*narcs */ ,xArc * /*parcs */ );

    int (*PolyText8) (DrawablePtr /*pDrawable */ , GCPtr /*pGC */ ,int /*x */ ,int /*y */ ,int /*count */ ,char * /*chars */ );

    int (*PolyText16) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*x */ ,int /*y */ ,int /*count */ ,unsigned short * /*chars */ );

    void (*ImageText8) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*x */ ,int /*y */ ,int /*count */ ,char * /*chars */ );

    void (*ImageText16) (DrawablePtr /*pDrawable */ ,GCPtr /*pGC */ ,int /*x */ ,int /*y */ ,int /*count */ ,unsigned sh