Xlibint.h@ 17236

Last change on this file since 17236 was 17236, checked in by vboxsync, 16 years ago
Additions/x11/x11include: blast! Reverted r43555 and r43556
Property svn:eol-style set to `native`
File size: 35.9 KB

Line
1	/* $Xorg: Xlibint.h,v 1.5 2001/02/09 02:03:38 xorgcvs Exp $ */
2
3	/*
4
5	Copyright 1984, 1985, 1987, 1989, 1998 The Open Group
6
7	Permission to use, copy, modify, distribute, and sell this software and its
8	documentation for any purpose is hereby granted without fee, provided that
9	the above copyright notice appear in all copies and that both that
10	copyright notice and this permission notice appear in supporting
11	documentation.
12
13	The above copyright notice and this permission notice shall be included
14	in all copies or substantial portions of the Software.
15
16	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19	IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
20	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22	OTHER DEALINGS IN THE SOFTWARE.
23
24	Except as contained in this notice, the name of The Open Group shall
25	not be used in advertising or otherwise to promote the sale, use or
26	other dealings in this Software without prior written authorization
27	from 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
59	struct _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
69	struct _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	*/
202	typedef 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
247	typedef struct _LockInfoRec *LockInfoPtr;
248
249	/* interfaces for locking.c */
250	struct _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 */
277	extern void (*_XCreateMutex_fn)(
278	LockInfoPtr /* lock */
279	);
280	extern void (*_XFreeMutex_fn)(
281	LockInfoPtr /* lock */
282	);
283	extern void (*_XLockMutex_fn)(
284	LockInfoPtr /* lock */
285	#if defined(XTHREADS_WARN) \|\| defined(XTHREADS_FILE_LINE)
286	, char * /* file */
287	, int /* line */
288	#endif
289	);
290	extern 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
298	extern 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
582	extern 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)
634	extern int _XData32(
635	Display *dpy,
636	register long *data,
637	unsigned len
638	);
639	extern 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
731	typedef 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
752	typedef 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
762	extern 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
770	typedef void (*FreeFuncType) (
771	Display* /* display */
772	);
773
774	typedef int (*FreeModmapType) (
775	XModifierKeymap* /* modmap */
776	);
777
778	/*
779	* This structure is private to the library.
780	*/
781	typedef 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 */
794	typedef int (*CreateGCType) (
795	Display* /* display */,
796	GC /* gc */,
797	XExtCodes* /* codes */
798	);
799
800	typedef int (*CopyGCType)(
801	Display* /* display */,
802	GC /* gc */,
803	XExtCodes* /* codes */
804	);
805
806	typedef int (*FlushGCType) (
807	Display* /* display */,
808	GC /* gc */,
809	XExtCodes* /* codes */
810	);
811
812	typedef int (*FreeGCType) (
813	Display* /* display */,
814	GC /* gc */,
815	XExtCodes* /* codes */
816	);
817
818	typedef int (*CreateFontType) (
819	Display* /* display */,
820	XFontStruct* /* fs */,
821	XExtCodes* /* codes */
822	);
823
824	typedef int (*FreeFontType) (
825	Display* /* display */,
826	XFontStruct* /* fs */,
827	XExtCodes* /* codes */
828	);
829
830	typedef int (*CloseDisplayType) (
831	Display* /* display */,
832	XExtCodes* /* codes */
833	);
834
835	typedef int (*ErrorType) (
836	Display* /* display */,
837	xError* /* err */,
838	XExtCodes* /* codes */,
839	int* /* ret_code */
840	);
841
842	typedef char* (*ErrorStringType) (
843	Display* /* display */,
844	int /* code */,
845	XExtCodes* /* codes */,
846	char* /* buffer */,
847	int /* nbytes */
848	);
849
850	typedef void (*PrintErrorType)(
851	Display* /* display */,
852	XErrorEvent* /* ev */,
853	void* /* fp */
854	);
855
856	typedef 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	*/
866	typedef 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
887	extern void Data(Display dpy, char data, long len);
888	#endif
889	extern int _XError(
890	Display* /* dpy */,
891	xError* /* rep */
892	);
893	extern int _XIOError(
894	Display* /* dpy */
895	);
896	extern int (*_XIOErrorFunction)(
897	Display* /* dpy */
898	);
899	extern int (*_XErrorFunction)(
900	Display* /* dpy */,
901	XErrorEvent* /* error_event */
902	);
903	extern void _XEatData(
904	Display* /* dpy */,
905	unsigned long /* n */
906	);
907	extern char *_XAllocScratch(
908	Display* /* dpy */,
909	unsigned long /* nbytes */
910	);
911	extern char *_XAllocTemp(
912	Display* /* dpy */,
913	unsigned long /* nbytes */
914	);
915	extern void _XFreeTemp(
916	Display* /* dpy */,
917	char* /* buf */,
918	unsigned long /* nbytes */
919	);
920	extern Visual *_XVIDtoVisual(
921	Display* /* dpy */,
922	VisualID /* id */
923	);
924	extern unsigned long _XSetLastRequestRead(
925	Display* /* dpy */,
926	xGenericReply* /* rep */
927	);
928	extern int _XGetHostname(
929	char* /* buf */,
930	int /* maxlen */
931	);
932	extern Screen *_XScreenOfWindow(
933	Display* /* dpy */,
934	Window /* w */
935	);
936	extern Bool _XAsyncErrorHandler(
937	Display* /* dpy */,
938	xReply* /* rep */,
939	char* /* buf */,
940	int /* len */,
941	XPointer /* data */
942	);
943	extern char *_XGetAsyncReply(
944	Display* /* dpy */,
945	char* /* replbuf */,
946	xReply* /* rep */,
947	char* /* buf */,
948	int /* len */,
949	int /* extra */,
950	Bool /* discard */
951	);
952	extern void _XGetAsyncData(
953	Display* /* dpy */,
954	char * /* data */,
955	char * /* buf */,
956	int /* len */,
957	int /* skip */,
958	int /* datalen */,
959	int /* discardtotal */
960	);
961	extern void _XFlush(
962	Display* /* dpy */
963	);
964	extern int _XEventsQueued(
965	Display* /* dpy */,
966	int /* mode */
967	);
968	extern void _XReadEvents(
969	Display* /* dpy */
970	);
971	extern int _XRead(
972	Display* /* dpy */,
973	char* /* data */,
974	long /* size */
975	);
976	extern void _XReadPad(
977	Display* /* dpy */,
978	char* /* data */,
979	long /* size */
980	);
981	extern void _XSend(
982	Display* /* dpy */,
983	_Xconst char* /* data */,
984	long /* size */
985	);
986	extern Status _XReply(
987	Display* /* dpy */,
988	xReply* /* rep */,
989	int /* extra */,
990	Bool /* discard */
991	);
992	extern void _XEnq(
993	Display* /* dpy */,
994	xEvent* /* event */
995	);
996	extern void _XDeq(
997	Display* /* dpy */,
998	_XQEvent* /* prev */,
999	_XQEvent* /* qelt */
1000	);
1001
1002	extern Bool _XUnknownWireEvent(
1003	Display* /* dpy */,
1004	XEvent* /* re */,
1005	xEvent* /* event */
1006	);
1007	extern Status _XUnknownNativeEvent(
1008	Display* /* dpy */,
1009	XEvent* /* re */,
1010	xEvent* /* event */
1011	);
1012
1013	extern Bool _XWireToEvent(Display dpy, XEvent re, xEvent *event);
1014	extern Bool _XDefaultWireError(Display display, XErrorEvent he, xError *we);
1015	extern Bool _XPollfdCacheInit(Display *dpy);
1016	extern void _XPollfdCacheAdd(Display *dpy, int fd);
1017	extern void _XPollfdCacheDel(Display *dpy, int fd);
1018	extern XID _XAllocID(Display *dpy);
1019	extern void _XAllocIDs(Display dpy, XID ids, int count);
1020
1021	extern int _XFreeExtData(
1022	XExtData* /* extension */
1023	);
1024
1025	extern 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
1037	extern 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
1049	extern 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
1061	extern 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
1073	extern 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
1085	extern 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
1097	extern int (*XESetCloseDisplay(
1098	Display* /* display */,
1099	int /* extension */,
1100	int (*) (
1101	Display* /* display */,
1102	XExtCodes* /* codes */
1103	) /* proc */
1104	))(
1105	Display, XExtCodes
1106	);
1107
1108	extern 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
1121	extern 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
1135	extern 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
1147	extern 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
1159	extern 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
1171	extern 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
1183	extern 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
1198	typedef void (*_XInternalConnectionProc)(
1199	Display* /* dpy */,
1200	int /* fd */,
1201	XPointer /* call_data */
1202	);
1203
1204
1205	extern Status _XRegisterInternalConnection(
1206	Display* /* dpy */,
1207	int /* fd */,
1208	_XInternalConnectionProc /* callback */,
1209	XPointer /* call_data */
1210	);
1211
1212	extern void _XUnregisterInternalConnection(
1213	Display* /* dpy */,
1214	int /* fd */
1215	);
1216
1217	/* Display structure has pointers to these */
1218
1219	struct _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
1227	struct _XConnWatchInfo { /* info from XAddConnectionWatch */
1228	XConnectionWatchProc fn;
1229	XPointer client_data;
1230	struct _XConnWatchInfo *next;
1231	};
1232
1233	#ifdef __UNIXOS2__
1234	extern char* __XOS2RedirRoot(
1235	char*
1236	);
1237	#endif
1238
1239	extern int _XTextHeight(
1240	XFontStruct* /* font_struct */,
1241	_Xconst char* /* string */,
1242	int /* count */
1243	);
1244
1245	extern int _XTextHeight16(
1246	XFontStruct* /* font_struct */,
1247	_Xconst XChar2b* /* string */,
1248	int /* count */
1249	);
1250
1251	#if defined(WIN32)
1252
1253	extern int _XOpenFile(
1254	_Xconst char* /* path */,
1255	int /* flags */
1256	);
1257
1258	extern void* _XFopenFile(
1259	_Xconst char* /* path */,
1260	_Xconst char* /* mode */
1261	);
1262
1263	extern 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 */
1272	extern Status _XEventToWire(Display dpy, XEvent re, xEvent *event);
1273
1274	extern int _XF86LoadQueryLocaleFont(
1275	Display* /* dpy */,
1276	_Xconst char* /* name*/,
1277	XFontStruct** /* xfp*/,
1278	Font* /* fidp */
1279	);
1280
1281	extern void _XProcessWindowAttributes (
1282	register Display *dpy,
1283	xChangeWindowAttributesReq *req,
1284	register unsigned long valuemask,
1285	register XSetWindowAttributes *attributes);
1286
1287	extern int _XDefaultError(
1288	Display *dpy,
1289	XErrorEvent *event);
1290
1291	extern int _XDefaultIOError(
1292	Display *dpy);
1293
1294	extern 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
1302	Status _XGetWindowAttributes(
1303	register Display *dpy,
1304	Window w,
1305	XWindowAttributes *attr);
1306
1307	int _XPutBackEvent (
1308	register Display *dpy,
1309	register XEvent *event);
1310
1311	_XFUNCPROTOEND
1312
1313	#endif /* _XLIBINT_H_ */

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: