VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/7.0/X11/Xlibint.h@ 17234

最後變更 在這個檔案從17234是 17234,由 vboxsync 提交於 16 年 前

Additions/x11/x11include: blast! Corrected svn:keywords property on all files as per ​http://linserv.germany/vbox/wiki/SvnKeywords
  • 屬性 svn:eol-style 設為 native
檔案大小: 35.9 KB
行 
1/* $Xorg: Xlibint.h,v 1.5 2001/02/09 02:03:38 xorgcvs Exp $ */
2
3/*
4
5Copyright 1984, 1985, 1987, 1989, 1998 The Open Group
6
7Permission to use, copy, modify, distribute, and sell this software and its
8documentation for any purpose is hereby granted without fee, provided that
9the above copyright notice appear in all copies and that both that
10copyright notice and this permission notice appear in supporting
11documentation.
12
13The above copyright notice and this permission notice shall be included
14in all copies or substantial portions of the Software.
15
16THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
20OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22OTHER DEALINGS IN THE SOFTWARE.
23
24Except as contained in this notice, the name of The Open Group shall
25not be used in advertising or otherwise to promote the sale, use or
26other dealings in this Software without prior written authorization
27from The Open Group.
28
29*/
30/* $XFree86: xc/lib/X11/Xlibint.h,v 3.27 2003/05/27 22:26:26 tsi Exp $ */
31
32#ifndef _XLIBINT_H_
33#define _XLIBINT_H_ 1
34
35/*
36 * Xlibint.h - Header definition and support file for the internal
37 * support routines used by the C subroutine interface
38 * library (Xlib) to the X Window System.
39 *
40 * Warning, there be dragons here....
41 */
42
43#include <X11/Xlib.h>
44#include <X11/Xproto.h> /* to declare xEvent */
45#include <X11/XlibConf.h> /* for configured options like XTHREADS */
46
47#ifdef WIN32
48#define _XFlush _XFlushIt
49#endif
50
51/*
52 * If your BytesReadable correctly detects broken connections, then
53 * you should NOT define XCONN_CHECK_FREQ.
54 */
55#ifndef XCONN_CHECK_FREQ
56#define XCONN_CHECK_FREQ 256
57#endif
58
59struct _XGC
60{
61 XExtData *ext_data; /* hook for extension to hang data */
62 GContext gid; /* protocol ID for graphics context */
63 Bool rects; /* boolean: TRUE if clipmask is list of rectangles */
64 Bool dashes; /* boolean: TRUE if dash-list is really a list */
65 unsigned long dirty;/* cache dirty bits */
66 XGCValues values; /* shadow structure of values */
67};
68
69struct _XDisplay
70{
71 XExtData *ext_data; /* hook for extension to hang data */
72 struct _XFreeFuncs *free_funcs; /* internal free functions */
73 int fd; /* Network socket. */
74 int conn_checker; /* ugly thing used by _XEventsQueued */
75 int proto_major_version;/* maj. version of server's X protocol */
76 int proto_minor_version;/* minor version of server's X protocol */
77 char *vendor; /* vendor of the server hardware */
78 XID resource_base; /* resource ID base */
79 XID resource_mask; /* resource ID mask bits */
80 XID resource_id; /* allocator current ID */
81 int resource_shift; /* allocator shift to correct bits */
82 XID (*resource_alloc)( /* allocator function */
83 struct _XDisplay*
84 );
85 int byte_order; /* screen byte order, LSBFirst, MSBFirst */
86 int bitmap_unit; /* padding and data requirements */
87 int bitmap_pad; /* padding requirements on bitmaps */
88 int bitmap_bit_order; /* LeastSignificant or MostSignificant */
89 int nformats; /* number of pixmap formats in list */
90 ScreenFormat *pixmap_format; /* pixmap format list */
91 int vnumber; /* Xlib's X protocol version number. */
92 int release; /* release of the server */
93 struct _XSQEvent *head, *tail; /* Input event queue. */
94 int qlen; /* Length of input event queue */
95 unsigned long last_request_read; /* seq number of last event read */
96 unsigned long request; /* sequence number of last request. */
97 char *last_req; /* beginning of last request, or dummy */
98 char *buffer; /* Output buffer starting address. */
99 char *bufptr; /* Output buffer index pointer. */
100 char *bufmax; /* Output buffer maximum+1 address. */
101 unsigned max_request_size; /* maximum number 32 bit words in request*/
102 struct _XrmHashBucketRec *db;
103 int (*synchandler)( /* Synchronization handler */
104 struct _XDisplay*
105 );
106 char *display_name; /* "host:display" string used on this connect*/
107 int default_screen; /* default screen for operations */
108 int nscreens; /* number of screens on this server*/
109 Screen *screens; /* pointer to list of screens */
110 unsigned long motion_buffer; /* size of motion buffer */
111 unsigned long flags; /* internal connection flags */
112 int min_keycode; /* minimum defined keycode */
113 int max_keycode; /* maximum defined keycode */
114 KeySym *keysyms; /* This server's keysyms */
115 XModifierKeymap *modifiermap; /* This server's modifier keymap */
116 int keysyms_per_keycode;/* number of rows */
117 char *xdefaults; /* contents of defaults from server */
118 char *scratch_buffer; /* place to hang scratch buffer */
119 unsigned long scratch_length; /* length of scratch buffer */
120 int ext_number; /* extension number on this display */
121 struct _XExten *ext_procs; /* extensions initialized on this display */
122 /*
123 * the following can be fixed size, as the protocol defines how
124 * much address space is available.
125 * While this could be done using the extension vector, there
126 * may be MANY events processed, so a search through the extension
127 * list to find the right procedure for each event might be
128 * expensive if many extensions are being used.
129 */
130 Bool (*event_vec[128])( /* vector for wire to event */
131 Display * /* dpy */,
132 XEvent * /* re */,
133 xEvent * /* event */
134 );
135 Status (*wire_vec[128])( /* vector for event to wire */
136 Display * /* dpy */,
137 XEvent * /* re */,
138 xEvent * /* event */
139 );
140 KeySym lock_meaning; /* for XLookupString */
141 struct _XLockInfo *lock; /* multi-thread state, display lock */
142 struct _XInternalAsync *async_handlers; /* for internal async */
143 unsigned long bigreq_size; /* max size of big requests */
144 struct _XLockPtrs *lock_fns; /* pointers to threads functions */
145 void (*idlist_alloc)( /* XID list allocator function */
146 Display * /* dpy */,
147 XID * /* ids */,
148 int /* count */
149 );
150 /* things above this line should not move, for binary compatibility */
151 struct _XKeytrans *key_bindings; /* for XLookupString */
152 Font cursor_font; /* for XCreateFontCursor */
153 struct _XDisplayAtoms *atoms; /* for XInternAtom */
154 unsigned int mode_switch; /* keyboard group modifiers */
155 unsigned int num_lock; /* keyboard numlock modifiers */
156 struct _XContextDB *context_db; /* context database */
157 Bool (**error_vec)( /* vector for wire to error */
158 Display * /* display */,
159 XErrorEvent * /* he */,
160 xError * /* we */
161 );
162 /*
163 * Xcms information
164 */
165 struct {
166 XPointer defaultCCCs; /* pointer to an array of default XcmsCCC */
167 XPointer clientCmaps; /* pointer to linked list of XcmsCmapRec */
168 XPointer perVisualIntensityMaps;
169 /* linked list of XcmsIntensityMap */
170 } cms;
171 struct _XIMFilter *im_filters;
172 struct _XSQEvent *qfree; /* unallocated event queue elements */
173 unsigned long next_event_serial_num; /* inserted into next queue elt */
174 struct _XExten *flushes; /* Flush hooks */
175 struct _XConnectionInfo *im_fd_info; /* _XRegisterInternalConnection */
176 int im_fd_length; /* number of im_fd_info */
177 struct _XConnWatchInfo *conn_watchers; /* XAddConnectionWatch */
178 int watcher_count; /* number of conn_watchers */
179 XPointer filedes; /* struct pollfd cache for _XWaitForReadable */
180 int (*savedsynchandler)( /* user synchandler when Xlib usurps */
181 Display * /* dpy */
182 );
183 XID resource_max; /* allocator max ID */
184 int xcmisc_opcode; /* major opcode for XC-MISC */
185 struct _XkbInfoRec *xkb_info; /* XKB info */
186 struct _XtransConnInfo *trans_conn; /* transport connection object */
187};
188
189#define XAllocIDs(dpy,ids,n) (*(dpy)->idlist_alloc)(dpy,ids,n)
190
191/*
192 * define the following if you want the Data macro to be a procedure instead
193 */
194#ifdef CRAY
195#define DataRoutineIsProcedure
196#endif /* CRAY */
197
198#ifndef _XEVENT_
199/*
200 * _QEvent datatype for use in input queueing.
201 */
202typedef struct _XSQEvent
203{
204 struct _XSQEvent *next;
205 XEvent event;
206 unsigned long qserial_num; /* so multi-threaded code can find new ones */
207} _XQEvent;
208#endif
209
210#ifdef XTHREADS /* for xReply */
211#define NEED_REPLIES
212#endif
213
214#define NEED_EVENTS
215#define NEED_REPLIES
216#include <X11/Xproto.h>
217#ifdef __sgi
218#define _SGI_MP_SOURCE /* turn this on to get MP safe errno */
219#endif
220#include <errno.h>
221#define _XBCOPYFUNC _Xbcopy
222#include <X11/Xfuncs.h>
223#include <X11/Xosdefs.h>
224
225/* Utek leaves kernel macros around in include files (bleah) */
226#ifdef dirty
227#undef dirty
228#endif
229
230#include <stdlib.h>
231#include <string.h>
232
233#include <X11/Xfuncproto.h>
234
235_XFUNCPROTOBEGIN
236
237/*
238 * The following definitions can be used for locking requests in multi-threaded
239 * address spaces.
240 */
241#ifdef XTHREADS
242/* Author: Stephen Gildea, MIT X Consortium
243 *
244 * declarations for C Threads locking
245 */
246
247typedef struct _LockInfoRec *LockInfoPtr;
248
249/* interfaces for locking.c */
250struct _XLockPtrs {
251 /* used by all, including extensions; do not move */
252 void (*lock_display)(
253 Display *dpy
254#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
255 , char *file
256 , int line
257#endif
258 );
259 void (*unlock_display)(
260 Display *dpy
261#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
262 , char *file
263 , int line
264#endif
265 );
266};
267
268#if defined(WIN32) && !defined(_XLIBINT_)
269#define _XCreateMutex_fn (*_XCreateMutex_fn_p)
270#define _XFreeMutex_fn (*_XFreeMutex_fn_p)
271#define _XLockMutex_fn (*_XLockMutex_fn_p)
272#define _XUnlockMutex_fn (*_XUnlockMutex_fn_p)
273#define _Xglobal_lock (*_Xglobal_lock_p)
274#endif
275
276/* in XlibInt.c */
277extern void (*_XCreateMutex_fn)(
278 LockInfoPtr /* lock */
279);
280extern void (*_XFreeMutex_fn)(
281 LockInfoPtr /* lock */
282);
283extern void (*_XLockMutex_fn)(
284 LockInfoPtr /* lock */
285#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
286 , char * /* file */
287 , int /* line */
288#endif
289);
290extern void (*_XUnlockMutex_fn)(
291 LockInfoPtr /* lock */
292#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
293 , char * /* file */
294 , int /* line */
295#endif
296);
297
298extern LockInfoPtr _Xglobal_lock;
299
300#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
301#define LockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->lock_display)((d),__FILE__,__LINE__)
302#define UnlockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)((d),__FILE__,__LINE__)
303#define _XLockMutex(lock) if (_XLockMutex_fn) (*_XLockMutex_fn)(lock,__FILE__,__LINE__)
304#define _XUnlockMutex(lock) if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock,__FILE__,__LINE__)
305#else
306/* used everywhere, so must be fast if not using threads */
307#define LockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d)
308#define UnlockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)(d)
309#define _XLockMutex(lock) if (_XLockMutex_fn) (*_XLockMutex_fn)(lock)
310#define _XUnlockMutex(lock) if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock)
311#endif
312#define _XCreateMutex(lock) if (_XCreateMutex_fn) (*_XCreateMutex_fn)(lock);
313#define _XFreeMutex(lock) if (_XFreeMutex_fn) (*_XFreeMutex_fn)(lock);
314
315#else /* XTHREADS */
316#define LockDisplay(dis)
317#define _XLockMutex(lock)
318#define _XUnlockMutex(lock)
319#define UnlockDisplay(dis)
320#define _XCreateMutex(lock)
321#define _XFreeMutex(lock)
322#endif
323
324#define Xfree(ptr) free((ptr))
325
326/*
327 * Note that some machines do not return a valid pointer for malloc(0), in
328 * which case we provide an alternate under the control of the
329 * define MALLOC_0_RETURNS_NULL. This is necessary because some
330 * Xlib code expects malloc(0) to return a valid pointer to storage.
331 */
332#ifdef MALLOC_0_RETURNS_NULL
333
334# define Xmalloc(size) malloc(((size) == 0 ? 1 : (size)))
335# define Xrealloc(ptr, size) realloc((ptr), ((size) == 0 ? 1 : (size)))
336# define Xcalloc(nelem, elsize) calloc(((nelem) == 0 ? 1 : (nelem)), (elsize))
337
338#else
339
340# define Xmalloc(size) malloc((size))
341# define Xrealloc(ptr, size) realloc((ptr), (size))
342# define Xcalloc(nelem, elsize) calloc((nelem), (elsize))
343
344#endif
345
346#include <stddef.h>
347
348#define LOCKED 1
349#define UNLOCKED 0
350
351#ifndef BUFSIZE
352#define BUFSIZE 2048 /* X output buffer size. */
353#endif
354#ifndef PTSPERBATCH
355#define PTSPERBATCH 1024 /* point batching */
356#endif
357#ifndef WLNSPERBATCH
358#define WLNSPERBATCH 50 /* wide line batching */
359#endif
360#ifndef ZLNSPERBATCH
361#define ZLNSPERBATCH 1024 /* thin line batching */
362#endif
363#ifndef WRCTSPERBATCH
364#define WRCTSPERBATCH 10 /* wide line rectangle batching */
365#endif
366#ifndef ZRCTSPERBATCH
367#define ZRCTSPERBATCH 256 /* thin line rectangle batching */
368#endif
369#ifndef FRCTSPERBATCH
370#define FRCTSPERBATCH 256 /* filled rectangle batching */
371#endif
372#ifndef FARCSPERBATCH
373#define FARCSPERBATCH 256 /* filled arc batching */
374#endif
375#ifndef CURSORFONT
376#define CURSORFONT "cursor" /* standard cursor fonts */
377#endif
378
379/*
380 * Display flags
381 */
382#define XlibDisplayIOError (1L << 0)
383#define XlibDisplayClosing (1L << 1)
384#define XlibDisplayNoXkb (1L << 2)
385#define XlibDisplayPrivSync (1L << 3)
386#define XlibDisplayProcConni (1L << 4) /* in _XProcessInternalConnection */
387#define XlibDisplayReadEvents (1L << 5) /* in _XReadEvents */
388#define XlibDisplayReply (1L << 5) /* in _XReply */
389#define XlibDisplayWriting (1L << 6) /* in _XFlushInt, _XSend */
390#define XlibDisplayDfltRMDB (1L << 7) /* mark if RM db from XGetDefault */
391
392/*
393 * X Protocol packetizing macros.
394 */
395
396/* Need to start requests on 64 bit word boundaries
397 * on a CRAY computer so add a NoOp (127) if needed.
398 * A character pointer on a CRAY computer will be non-zero
399 * after shifting right 61 bits of it is not pointing to
400 * a word boundary.
401 */
402#ifdef WORD64
403#define WORD64ALIGN if ((long)dpy->bufptr >> 61) {\
404 dpy->last_req = dpy->bufptr;\
405 *(dpy->bufptr) = X_NoOperation;\
406 *(dpy->bufptr+1) = 0;\
407 *(dpy->bufptr+2) = 0;\
408 *(dpy->bufptr+3) = 1;\
409 dpy->request++;\
410 dpy->bufptr += 4;\
411 }
412#else /* else does not require alignment on 64-bit boundaries */
413#define WORD64ALIGN
414#endif /* WORD64 */
415
416
417/*
418 * GetReq - Get the next available X request packet in the buffer and
419 * return it.
420 *
421 * "name" is the name of the request, e.g. CreatePixmap, OpenFont, etc.
422 * "req" is the name of the request pointer.
423 *
424 */
425
426#if !defined(UNIXCPP) || defined(ANSICPP)
427#define GetReq(name, req) \
428 WORD64ALIGN\
429 if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
430 _XFlush(dpy);\
431 req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
432 req->reqType = X_##name;\
433 req->length = (SIZEOF(x##name##Req))>>2;\
434 dpy->bufptr += SIZEOF(x##name##Req);\
435 dpy->request++
436
437#else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
438#define GetReq(name, req) \
439 WORD64ALIGN\
440 if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
441 _XFlush(dpy);\
442 req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
443 req->reqType = X_/**/name;\
444 req->length = (SIZEOF(x/**/name/**/Req))>>2;\
445 dpy->bufptr += SIZEOF(x/**/name/**/Req);\
446 dpy->request++
447#endif
448
449/* GetReqExtra is the same as GetReq, but allocates "n" additional
450 bytes after the request. "n" must be a multiple of 4! */
451
452#if !defined(UNIXCPP) || defined(ANSICPP)
453#define GetReqExtra(name, n, req) \
454 WORD64ALIGN\
455 if ((dpy->bufptr + SIZEOF(x##name##Req) + n) > dpy->bufmax)\
456 _XFlush(dpy);\
457 req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
458 req->reqType = X_##name;\
459 req->length = (SIZEOF(x##name##Req) + n)>>2;\
460 dpy->bufptr += SIZEOF(x##name##Req) + n;\
461 dpy->request++
462#else
463#define GetReqExtra(name, n, req) \
464 WORD64ALIGN\
465 if ((dpy->bufptr + SIZEOF(x/**/name/**/Req) + n) > dpy->bufmax)\
466 _XFlush(dpy);\
467 req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
468 req->reqType = X_/**/name;\
469 req->length = (SIZEOF(x/**/name/**/Req) + n)>>2;\
470 dpy->bufptr += SIZEOF(x/**/name/**/Req) + n;\
471 dpy->request++
472#endif
473
474
475/*
476 * GetResReq is for those requests that have a resource ID
477 * (Window, Pixmap, GContext, etc.) as their single argument.
478 * "rid" is the name of the resource.
479 */
480
481#if !defined(UNIXCPP) || defined(ANSICPP)
482#define GetResReq(name, rid, req) \
483 WORD64ALIGN\
484 if ((dpy->bufptr + SIZEOF(xResourceReq)) > dpy->bufmax)\
485 _XFlush(dpy);\
486 req = (xResourceReq *) (dpy->last_req = dpy->bufptr);\
487 req->reqType = X_##name;\
488 req->length = 2;\
489 req->id = (rid);\
490 dpy->bufptr += SIZEOF(xResourceReq);\
491 dpy->request++
492#else
493#define GetResReq(name, rid, req) \
494 WORD64ALIGN\
495 if ((dpy->bufptr + SIZEOF(xResourceReq)) > dpy->bufmax)\
496 _XFlush(dpy);\
497 req = (xResourceReq *) (dpy->last_req = dpy->bufptr);\
498 req->reqType = X_/**/name;\
499 req->length = 2;\
500 req->id = (rid);\
501 dpy->bufptr += SIZEOF(xResourceReq);\
502 dpy->request++
503#endif
504
505/*
506 * GetEmptyReq is for those requests that have no arguments
507 * at all.
508 */
509#if !defined(UNIXCPP) || defined(ANSICPP)
510#define GetEmptyReq(name, req) \
511 WORD64ALIGN\
512 if ((dpy->bufptr + SIZEOF(xReq)) > dpy->bufmax)\
513 _XFlush(dpy);\
514 req = (xReq *) (dpy->last_req = dpy->bufptr);\
515 req->reqType = X_##name;\
516 req->length = 1;\
517 dpy->bufptr += SIZEOF(xReq);\
518 dpy->request++
519#else
520#define GetEmptyReq(name, req) \
521 WORD64ALIGN\
522 if ((dpy->bufptr + SIZEOF(xReq)) > dpy->bufmax)\
523 _XFlush(dpy);\
524 req = (xReq *) (dpy->last_req = dpy->bufptr);\
525 req->reqType = X_/**/name;\
526 req->length = 1;\
527 dpy->bufptr += SIZEOF(xReq);\
528 dpy->request++
529#endif
530
531#ifdef WORD64
532#define MakeBigReq(req,n) \
533 { \
534 char _BRdat[4]; \
535 unsigned long _BRlen = req->length - 1; \
536 req->length = 0; \
537 memcpy(_BRdat, ((char *)req) + (_BRlen << 2), 4); \
538 memmove(((char *)req) + 8, ((char *)req) + 4, _BRlen << 2); \
539 memcpy(((char *)req) + 4, _BRdat, 4); \
540 Data32(dpy, (long *)&_BRdat, 4); \
541 }
542#else
543#ifdef LONG64
544#define MakeBigReq(req,n) \
545 { \
546 CARD64 _BRdat; \
547 CARD32 _BRlen = req->length - 1; \
548 req->length = 0; \
549 _BRdat = ((CARD32 *)req)[_BRlen]; \
550 memmove(((char *)req) + 8, ((char *)req) + 4, _BRlen << 2); \
551 ((CARD32 *)req)[1] = _BRlen + n + 2; \
552 Data32(dpy, &_BRdat, 4); \
553 }
554#else
555#define MakeBigReq(req,n) \
556 { \
557 CARD32 _BRdat; \
558 CARD32 _BRlen = req->length - 1; \
559 req->length = 0; \
560 _BRdat = ((CARD32 *)req)[_BRlen]; \
561 memmove(((char *)req) + 8, ((char *)req) + 4, _BRlen << 2); \
562 ((CARD32 *)req)[1] = _BRlen + n + 2; \
563 Data32(dpy, &_BRdat, 4); \
564 }
565#endif
566#endif
567
568#define SetReqLen(req,n,badlen) \
569 if ((req->length + n) > (unsigned)65535) { \
570 if (dpy->bigreq_size) { \
571 MakeBigReq(req,n) \
572 } else { \
573 n = badlen; \
574 req->length += n; \
575 } \
576 } else \
577 req->length += n
578
579#define SyncHandle() \
580 if (dpy->synchandler) (*dpy->synchandler)(dpy)
581
582extern void _XFlushGCCache(Display *dpy, GC gc);
583#define FlushGC(dpy, gc) \
584 if ((gc)->dirty) _XFlushGCCache((dpy), (gc))
585/*
586 * Data - Place data in the buffer and pad the end to provide
587 * 32 bit word alignment. Transmit if the buffer fills.
588 *
589 * "dpy" is a pointer to a Display.
590 * "data" is a pinter to a data buffer.
591 * "len" is the length of the data buffer.
592 */
593#ifndef DataRoutineIsProcedure
594#define Data(dpy, data, len) {\
595 if (dpy->bufptr + (len) <= dpy->bufmax) {\
596 memcpy(dpy->bufptr, data, (int)len);\
597 dpy->bufptr += ((len) + 3) & ~3;\
598 } else\
599 _XSend(dpy, data, len);\
600 }
601#endif /* DataRoutineIsProcedure */
602
603
604/* Allocate bytes from the buffer. No padding is done, so if
605 * the length is not a multiple of 4, the caller must be
606 * careful to leave the buffer aligned after sending the
607 * current request.
608 *
609 * "type" is the type of the pointer being assigned to.
610 * "ptr" is the pointer being assigned to.
611 * "n" is the number of bytes to allocate.
612 *
613 * Example:
614 * xTextElt *elt;
615 * BufAlloc (xTextElt *, elt, nbytes)
616 */
617
618#define BufAlloc(type, ptr, n) \
619 if (dpy->bufptr + (n) > dpy->bufmax) \
620 _XFlush (dpy); \
621 ptr = (type) dpy->bufptr; \
622 (void)ptr; \
623 dpy->bufptr += (n);
624
625#ifdef WORD64
626#define Data16(dpy, data, len) _XData16(dpy, (short *)data, len)
627#define Data32(dpy, data, len) _XData32(dpy, (long *)data, len)
628#else
629#define Data16(dpy, data, len) Data((dpy), (char *)(data), (len))
630#define _XRead16Pad(dpy, data, len) _XReadPad((dpy), (char *)(data), (len))
631#define _XRead16(dpy, data, len) _XRead((dpy), (char *)(data), (len))
632#ifdef LONG64
633#define Data32(dpy, data, len) _XData32(dpy, (long *)data, len)
634extern int _XData32(
635 Display *dpy,
636 register long *data,
637 unsigned len
638);
639extern void _XRead32(
640 Display *dpy,
641 register long *data,
642 long len
643);
644#else
645#define Data32(dpy, data, len) Data((dpy), (char *)(data), (len))
646#define _XRead32(dpy, data, len) _XRead((dpy), (char *)(data), (len))
647#endif
648#endif /* not WORD64 */
649
650#define PackData16(dpy,data,len) Data16 (dpy, data, len)
651#define PackData32(dpy,data,len) Data32 (dpy, data, len)
652
653/* Xlib manual is bogus */
654#define PackData(dpy,data,len) PackData16 (dpy, data, len)
655
656#define min(a,b) (((a) < (b)) ? (a) : (b))
657#define max(a,b) (((a) > (b)) ? (a) : (b))
658
659#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
660 (((cs)->rbearing|(cs)->lbearing| \
661 (cs)->ascent|(cs)->descent) == 0))
662
663/*
664 * CI_GET_CHAR_INFO_1D - return the charinfo struct for the indicated 8bit
665 * character. If the character is in the column and exists, then return the
666 * appropriate metrics (note that fonts with common per-character metrics will
667 * return min_bounds). If none of these hold true, try again with the default
668 * char.
669 */
670#define CI_GET_CHAR_INFO_1D(fs,col,def,cs) \
671{ \
672 cs = def; \
673 if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
674 if (fs->per_char == NULL) { \
675 cs = &fs->min_bounds; \
676 } else { \
677 cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
678 if (CI_NONEXISTCHAR(cs)) cs = def; \
679 } \
680 } \
681}
682
683#define CI_GET_DEFAULT_INFO_1D(fs,cs) \
684 CI_GET_CHAR_INFO_1D (fs, fs->default_char, NULL, cs)
685
686
687
688/*
689 * CI_GET_CHAR_INFO_2D - return the charinfo struct for the indicated row and
690 * column. This is used for fonts that have more than row zero.
691 */
692#define CI_GET_CHAR_INFO_2D(fs,row,col,def,cs) \
693{ \
694 cs = def; \
695 if (row >= fs->min_byte1 && row <= fs->max_byte1 && \
696 col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
697 if (fs->per_char == NULL) { \
698 cs = &fs->min_bounds; \
699 } else { \
700 cs = &fs->per_char[((row - fs->min_byte1) * \
701 (fs->max_char_or_byte2 - \
702 fs->min_char_or_byte2 + 1)) + \
703 (col - fs->min_char_or_byte2)]; \
704 if (CI_NONEXISTCHAR(cs)) cs = def; \
705 } \
706 } \
707}
708
709#define CI_GET_DEFAULT_INFO_2D(fs,cs) \
710{ \
711 unsigned int r = (fs->default_char >> 8); \
712 unsigned int c = (fs->default_char & 0xff); \
713 CI_GET_CHAR_INFO_2D (fs, r, c, NULL, cs); \
714}
715
716
717#ifdef MUSTCOPY
718
719/* for when 32-bit alignment is not good enough */
720#define OneDataCard32(dpy,dstaddr,srcvar) \
721 { dpy->bufptr -= 4; Data32 (dpy, (char *) &(srcvar), 4); }
722
723#else
724
725/* srcvar must be a variable for large architecture version */
726#define OneDataCard32(dpy,dstaddr,srcvar) \
727 { *(CARD32 *)(dstaddr) = (srcvar); }
728
729#endif /* MUSTCOPY */
730
731typedef struct _XInternalAsync {
732 struct _XInternalAsync *next;
733 /*
734 * handler arguments:
735 * rep is the generic reply that caused this handler
736 * to be invoked. It must also be passed to _XGetAsyncReply.
737 * buf and len are opaque values that must be passed to
738 * _XGetAsyncReply or _XGetAsyncData.
739 * data is the closure stored in this struct.
740 * The handler returns True iff it handled this reply.
741 */
742 Bool (*handler)(
743 Display* /* dpy */,
744 xReply* /* rep */,
745 char* /* buf */,
746 int /* len */,
747 XPointer /* data */
748 );
749 XPointer data;
750} _XAsyncHandler;
751
752typedef struct _XAsyncEState {
753 unsigned long min_sequence_number;
754 unsigned long max_sequence_number;
755 unsigned char error_code;
756 unsigned char major_opcode;
757 unsigned short minor_opcode;
758 unsigned char last_error_received;
759 int error_count;
760} _XAsyncErrorState;
761
762extern void _XDeqAsyncHandler(Display *dpy, _XAsyncHandler *handler);
763#define DeqAsyncHandler(dpy,handler) { \
764 if (dpy->async_handlers == (handler)) \
765 dpy->async_handlers = (handler)->next; \
766 else \
767 _XDeqAsyncHandler(dpy, handler); \
768 }
769
770typedef void (*FreeFuncType) (
771 Display* /* display */
772);
773
774typedef int (*FreeModmapType) (
775 XModifierKeymap* /* modmap */
776);
777
778/*
779 * This structure is private to the library.
780 */
781typedef struct _XFreeFuncs {
782 FreeFuncType atoms; /* _XFreeAtomTable */
783 FreeModmapType modifiermap; /* XFreeModifierMap */
784 FreeFuncType key_bindings; /* _XFreeKeyBindings */
785 FreeFuncType context_db; /* _XFreeContextDB */
786 FreeFuncType defaultCCCs; /* _XcmsFreeDefaultCCCs */
787 FreeFuncType clientCmaps; /* _XcmsFreeClientCmaps */
788 FreeFuncType intensityMaps; /* _XcmsFreeIntensityMaps */
789 FreeFuncType im_filters; /* _XFreeIMFilters */
790 FreeFuncType xkb; /* _XkbFreeInfo */
791} _XFreeFuncRec;
792
793/* types for InitExt.c */
794typedef int (*CreateGCType) (
795 Display* /* display */,
796 GC /* gc */,
797 XExtCodes* /* codes */
798);
799
800typedef int (*CopyGCType)(
801 Display* /* display */,
802 GC /* gc */,
803 XExtCodes* /* codes */
804);
805
806typedef int (*FlushGCType) (
807 Display* /* display */,
808 GC /* gc */,
809 XExtCodes* /* codes */
810);
811
812typedef int (*FreeGCType) (
813 Display* /* display */,
814 GC /* gc */,
815 XExtCodes* /* codes */
816);
817
818typedef int (*CreateFontType) (
819 Display* /* display */,
820 XFontStruct* /* fs */,
821 XExtCodes* /* codes */
822);
823
824typedef int (*FreeFontType) (
825 Display* /* display */,
826 XFontStruct* /* fs */,
827 XExtCodes* /* codes */
828);
829
830typedef int (*CloseDisplayType) (
831 Display* /* display */,
832 XExtCodes* /* codes */
833);
834
835typedef int (*ErrorType) (
836 Display* /* display */,
837 xError* /* err */,
838 XExtCodes* /* codes */,
839 int* /* ret_code */
840);
841
842typedef char* (*ErrorStringType) (
843 Display* /* display */,
844 int /* code */,
845 XExtCodes* /* codes */,
846 char* /* buffer */,
847 int /* nbytes */
848);
849
850typedef void (*PrintErrorType)(
851 Display* /* display */,
852 XErrorEvent* /* ev */,
853 void* /* fp */
854);
855
856typedef void (*BeforeFlushType)(
857 Display* /* display */,
858 XExtCodes* /* codes */,
859 _Xconst char* /* data */,
860 long /* len */
861);
862
863/*
864 * This structure is private to the library.
865 */
866typedef struct _XExten { /* private to extension mechanism */
867 struct _XExten *next; /* next in list */
868 XExtCodes codes; /* public information, all extension told */
869 CreateGCType create_GC; /* routine to call when GC created */
870 CopyGCType copy_GC; /* routine to call when GC copied */
871 FlushGCType flush_GC; /* routine to call when GC flushed */
872 FreeGCType free_GC; /* routine to call when GC freed */
873 CreateFontType create_Font; /* routine to call when Font created */
874 FreeFontType free_Font; /* routine to call when Font freed */
875 CloseDisplayType close_display; /* routine to call when connection closed */
876 ErrorType error; /* who to call when an error occurs */
877 ErrorStringType error_string; /* routine to supply error string */
878 char *name; /* name of this extension */
879 PrintErrorType error_values; /* routine to supply error values */
880 BeforeFlushType before_flush; /* routine to call when sending data */
881 struct _XExten *next_flush; /* next in list of those with flushes */
882} _XExtension;
883
884/* extension hooks */
885
886#ifdef DataRoutineIsProcedure
887extern void Data(Display *dpy, char *data, long len);
888#endif
889extern int _XError(
890 Display* /* dpy */,
891 xError* /* rep */
892);
893extern int _XIOError(
894 Display* /* dpy */
895);
896extern int (*_XIOErrorFunction)(
897 Display* /* dpy */
898);
899extern int (*_XErrorFunction)(
900 Display* /* dpy */,
901 XErrorEvent* /* error_event */
902);
903extern void _XEatData(
904 Display* /* dpy */,
905 unsigned long /* n */
906);
907extern char *_XAllocScratch(
908 Display* /* dpy */,
909 unsigned long /* nbytes */
910);
911extern char *_XAllocTemp(
912 Display* /* dpy */,
913 unsigned long /* nbytes */
914);
915extern void _XFreeTemp(
916 Display* /* dpy */,
917 char* /* buf */,
918 unsigned long /* nbytes */
919);
920extern Visual *_XVIDtoVisual(
921 Display* /* dpy */,
922 VisualID /* id */
923);
924extern unsigned long _XSetLastRequestRead(
925 Display* /* dpy */,
926 xGenericReply* /* rep */
927);
928extern int _XGetHostname(
929 char* /* buf */,
930 int /* maxlen */
931);
932extern Screen *_XScreenOfWindow(
933 Display* /* dpy */,
934 Window /* w */
935);
936extern Bool _XAsyncErrorHandler(
937 Display* /* dpy */,
938 xReply* /* rep */,
939 char* /* buf */,
940 int /* len */,
941 XPointer /* data */
942);
943extern char *_XGetAsyncReply(
944 Display* /* dpy */,
945 char* /* replbuf */,
946 xReply* /* rep */,
947 char* /* buf */,
948 int /* len */,
949 int /* extra */,
950 Bool /* discard */
951);
952extern void _XGetAsyncData(
953 Display* /* dpy */,
954 char * /* data */,
955 char * /* buf */,
956 int /* len */,
957 int /* skip */,
958 int /* datalen */,
959 int /* discardtotal */
960);
961extern void _XFlush(
962 Display* /* dpy */
963);
964extern int _XEventsQueued(
965 Display* /* dpy */,
966 int /* mode */
967);
968extern void _XReadEvents(
969 Display* /* dpy */
970);
971extern int _XRead(
972 Display* /* dpy */,
973 char* /* data */,
974 long /* size */
975);
976extern void _XReadPad(
977 Display* /* dpy */,
978 char* /* data */,
979 long /* size */
980);
981extern void _XSend(
982 Display* /* dpy */,
983 _Xconst char* /* data */,
984 long /* size */
985);
986extern Status _XReply(
987 Display* /* dpy */,
988 xReply* /* rep */,
989 int /* extra */,
990 Bool /* discard */
991);
992extern void _XEnq(
993 Display* /* dpy */,
994 xEvent* /* event */
995);
996extern void _XDeq(
997 Display* /* dpy */,
998 _XQEvent* /* prev */,
999 _XQEvent* /* qelt */
1000);
1001
1002extern Bool _XUnknownWireEvent(
1003 Display* /* dpy */,
1004 XEvent* /* re */,
1005 xEvent* /* event */
1006);
1007extern Status _XUnknownNativeEvent(
1008 Display* /* dpy */,
1009 XEvent* /* re */,
1010 xEvent* /* event */
1011);
1012
1013extern Bool _XWireToEvent(Display *dpy, XEvent *re, xEvent *event);
1014extern Bool _XDefaultWireError(Display *display, XErrorEvent *he, xError *we);
1015extern Bool _XPollfdCacheInit(Display *dpy);
1016extern void _XPollfdCacheAdd(Display *dpy, int fd);
1017extern void _XPollfdCacheDel(Display *dpy, int fd);
1018extern XID _XAllocID(Display *dpy);
1019extern void _XAllocIDs(Display *dpy, XID *ids, int count);
1020
1021extern int _XFreeExtData(
1022 XExtData* /* extension */
1023);
1024
1025extern int (*XESetCreateGC(
1026 Display* /* display */,
1027 int /* extension */,
1028 int (*) (
1029 Display* /* display */,
1030 GC /* gc */,
1031 XExtCodes* /* codes */
1032 ) /* proc */
1033))(
1034 Display*, GC, XExtCodes*
1035);
1036
1037extern int (*XESetCopyGC(
1038 Display* /* display */,
1039 int /* extension */,
1040 int (*) (
1041 Display* /* display */,
1042 GC /* gc */,
1043 XExtCodes* /* codes */
1044 ) /* proc */
1045))(
1046 Display*, GC, XExtCodes*
1047);
1048
1049extern int (*XESetFlushGC(
1050 Display* /* display */,
1051 int /* extension */,
1052 int (*) (
1053 Display* /* display */,
1054 GC /* gc */,
1055 XExtCodes* /* codes */
1056 ) /* proc */
1057))(
1058 Display*, GC, XExtCodes*
1059);
1060
1061extern int (*XESetFreeGC(
1062 Display* /* display */,
1063 int /* extension */,
1064 int (*) (
1065 Display* /* display */,
1066 GC /* gc */,
1067 XExtCodes* /* codes */
1068 ) /* proc */
1069))(
1070 Display*, GC, XExtCodes*
1071);
1072
1073extern int (*XESetCreateFont(
1074 Display* /* display */,
1075 int /* extension */,
1076 int (*) (
1077 Display* /* display */,
1078 XFontStruct* /* fs */,
1079 XExtCodes* /* codes */
1080 ) /* proc */
1081))(
1082 Display*, XFontStruct*, XExtCodes*
1083);
1084
1085extern int (*XESetFreeFont(
1086 Display* /* display */,
1087 int /* extension */,
1088 int (*) (
1089 Display* /* display */,
1090 XFontStruct* /* fs */,
1091 XExtCodes* /* codes */
1092 ) /* proc */
1093))(
1094 Display*, XFontStruct*, XExtCodes*
1095);
1096
1097extern int (*XESetCloseDisplay(
1098 Display* /* display */,
1099 int /* extension */,
1100 int (*) (
1101 Display* /* display */,
1102 XExtCodes* /* codes */
1103 ) /* proc */
1104))(
1105 Display*, XExtCodes*
1106);
1107
1108extern int (*XESetError(
1109 Display* /* display */,
1110 int /* extension */,
1111 int (*) (
1112 Display* /* display */,
1113 xError* /* err */,
1114 XExtCodes* /* codes */,
1115 int* /* ret_code */
1116 ) /* proc */
1117))(
1118 Display*, xError*, XExtCodes*, int*
1119);
1120
1121extern char* (*XESetErrorString(
1122 Display* /* display */,
1123 int /* extension */,
1124 char* (*) (
1125 Display* /* display */,
1126 int /* code */,
1127 XExtCodes* /* codes */,
1128 char* /* buffer */,
1129 int /* nbytes */
1130 ) /* proc */
1131))(
1132 Display*, int, XExtCodes*, char*, int
1133);
1134
1135extern void (*XESetPrintErrorValues (
1136 Display* /* display */,
1137 int /* extension */,
1138 void (*)(
1139 Display* /* display */,
1140 XErrorEvent* /* ev */,
1141 void* /* fp */
1142 ) /* proc */
1143))(
1144 Display*, XErrorEvent*, void*
1145);
1146
1147extern Bool (*XESetWireToEvent(
1148 Display* /* display */,
1149 int /* event_number */,
1150 Bool (*) (
1151 Display* /* display */,
1152 XEvent* /* re */,
1153 xEvent* /* event */
1154 ) /* proc */
1155))(
1156 Display*, XEvent*, xEvent*
1157);
1158
1159extern Status (*XESetEventToWire(
1160 Display* /* display */,
1161 int /* event_number */,
1162 Status (*) (
1163 Display* /* display */,
1164 XEvent* /* re */,
1165 xEvent* /* event */
1166 ) /* proc */
1167))(
1168 Display*, XEvent*, xEvent*
1169);
1170
1171extern Bool (*XESetWireToError(
1172 Display* /* display */,
1173 int /* error_number */,
1174 Bool (*) (
1175 Display* /* display */,
1176 XErrorEvent* /* he */,
1177 xError* /* we */
1178 ) /* proc */
1179))(
1180 Display*, XErrorEvent*, xError*
1181);
1182
1183extern void (*XESetBeforeFlush(
1184 Display* /* display */,
1185 int /* error_number */,
1186 void (*) (
1187 Display* /* display */,
1188 XExtCodes* /* codes */,
1189 _Xconst char* /* data */,
1190 long /* len */
1191 ) /* proc */
1192))(
1193 Display*, XExtCodes*, _Xconst char*, long
1194);
1195
1196/* internal connections for IMs */
1197
1198typedef void (*_XInternalConnectionProc)(
1199 Display* /* dpy */,
1200 int /* fd */,
1201 XPointer /* call_data */
1202);
1203
1204
1205extern Status _XRegisterInternalConnection(
1206 Display* /* dpy */,
1207 int /* fd */,
1208 _XInternalConnectionProc /* callback */,
1209 XPointer /* call_data */
1210);
1211
1212extern void _XUnregisterInternalConnection(
1213 Display* /* dpy */,
1214 int /* fd */
1215);
1216
1217/* Display structure has pointers to these */
1218
1219struct _XConnectionInfo { /* info from _XRegisterInternalConnection */
1220 int fd;
1221 _XInternalConnectionProc read_callback;
1222 XPointer call_data;
1223 XPointer *watch_data; /* set/used by XConnectionWatchProc */
1224 struct _XConnectionInfo *next;
1225};
1226
1227struct _XConnWatchInfo { /* info from XAddConnectionWatch */
1228 XConnectionWatchProc fn;
1229 XPointer client_data;
1230 struct _XConnWatchInfo *next;
1231};
1232
1233#ifdef __UNIXOS2__
1234extern char* __XOS2RedirRoot(
1235 char*
1236);
1237#endif
1238
1239extern int _XTextHeight(
1240 XFontStruct* /* font_struct */,
1241 _Xconst char* /* string */,
1242 int /* count */
1243);
1244
1245extern int _XTextHeight16(
1246 XFontStruct* /* font_struct */,
1247 _Xconst XChar2b* /* string */,
1248 int /* count */
1249);
1250
1251#if defined(WIN32)
1252
1253extern int _XOpenFile(
1254 _Xconst char* /* path */,
1255 int /* flags */
1256);
1257
1258extern void* _XFopenFile(
1259 _Xconst char* /* path */,
1260 _Xconst char* /* mode */
1261);
1262
1263extern int _XAccessFile(
1264 _Xconst char* /* path */
1265);
1266#else
1267#define _XOpenFile(path,flags) open(path,flags)
1268#define _XFopenFile(path,mode) fopen(path,mode)
1269#endif
1270
1271/* EvToWire.c */
1272extern Status _XEventToWire(Display *dpy, XEvent *re, xEvent *event);
1273
1274extern int _XF86LoadQueryLocaleFont(
1275 Display* /* dpy */,
1276 _Xconst char* /* name*/,
1277 XFontStruct** /* xfp*/,
1278 Font* /* fidp */
1279);
1280
1281extern void _XProcessWindowAttributes (
1282 register Display *dpy,
1283 xChangeWindowAttributesReq *req,
1284 register unsigned long valuemask,
1285 register XSetWindowAttributes *attributes);
1286
1287extern int _XDefaultError(
1288 Display *dpy,
1289 XErrorEvent *event);
1290
1291extern int _XDefaultIOError(
1292 Display *dpy);
1293
1294extern void _XSetClipRectangles (
1295 register Display *dpy,
1296 GC gc,
1297 int clip_x_origin, int clip_y_origin,
1298 XRectangle *rectangles,
1299 int n,
1300 int ordering);
1301
1302Status _XGetWindowAttributes(
1303 register Display *dpy,
1304 Window w,
1305 XWindowAttributes *attr);
1306
1307int _XPutBackEvent (
1308 register Display *dpy,
1309 register XEvent *event);
1310
1311_XFUNCPROTOEND
1312
1313#endif /* _XLIBINT_H_ */
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette