Mercurial > sdl-ios-xcode
comparison src/video/Xext/XME/xme.c @ 1895:c121d94672cb
SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Mon, 10 Jul 2006 21:04:37 +0000 |
parents | ecba4bbaf9c2 |
children | dea73e1d07b0 |
comparison
equal
deleted
inserted
replaced
1894:c69cee13dd76 | 1895:c121d94672cb |
---|---|
47 #define sz_xXiGMiscQueryResolutionsReply 32 | 47 #define sz_xXiGMiscQueryResolutionsReply 32 |
48 #define sz_xXiGMiscQueryFullScreenReply 32 | 48 #define sz_xXiGMiscQueryFullScreenReply 32 |
49 | 49 |
50 /*******************************************************************/ | 50 /*******************************************************************/ |
51 | 51 |
52 typedef struct { | 52 typedef struct |
53 CARD8 reqType; /* always codes->major_opcode */ | 53 { |
54 CARD8 xigmiscReqType; /* always X_XiGMiscQueryVersion */ | 54 CARD8 reqType; /* always codes->major_opcode */ |
55 CARD16 length; | 55 CARD8 xigmiscReqType; /* always X_XiGMiscQueryVersion */ |
56 CARD16 major; | 56 CARD16 length; |
57 CARD16 minor; | 57 CARD16 major; |
58 CARD16 minor; | |
58 } xXiGMiscQueryVersionReq; | 59 } xXiGMiscQueryVersionReq; |
59 | 60 |
60 typedef struct { | 61 typedef struct |
61 CARD8 reqType; /* always codes->major_opcode */ | 62 { |
62 CARD8 xigmiscReqType; /* always X_XiGMiscQueryViews */ | 63 CARD8 reqType; /* always codes->major_opcode */ |
63 CARD16 length; | 64 CARD8 xigmiscReqType; /* always X_XiGMiscQueryViews */ |
64 CARD8 screen; | 65 CARD16 length; |
65 CARD8 pad0; | 66 CARD8 screen; |
66 CARD16 pad1; | 67 CARD8 pad0; |
68 CARD16 pad1; | |
67 } xXiGMiscQueryViewsReq; | 69 } xXiGMiscQueryViewsReq; |
68 | 70 |
69 typedef struct { | 71 typedef struct |
70 CARD8 reqType; /* always codes->major_opcode */ | 72 { |
71 CARD8 xigmiscReqType; /* always X_XiGMiscQueryResolutions */ | 73 CARD8 reqType; /* always codes->major_opcode */ |
72 CARD16 length; | 74 CARD8 xigmiscReqType; /* always X_XiGMiscQueryResolutions */ |
73 CARD8 screen; | 75 CARD16 length; |
74 CARD8 view; | 76 CARD8 screen; |
75 CARD16 pad0; | 77 CARD8 view; |
78 CARD16 pad0; | |
76 } xXiGMiscQueryResolutionsReq; | 79 } xXiGMiscQueryResolutionsReq; |
77 | 80 |
78 typedef struct { | 81 typedef struct |
79 CARD8 reqType; /* always codes->major_opcode */ | 82 { |
80 CARD8 xigmiscReqType; /* always X_XiGMiscChangeResolution */ | 83 CARD8 reqType; /* always codes->major_opcode */ |
81 CARD16 length; | 84 CARD8 xigmiscReqType; /* always X_XiGMiscChangeResolution */ |
82 CARD8 screen; | 85 CARD16 length; |
83 CARD8 view; | 86 CARD8 screen; |
84 CARD16 pad0; | 87 CARD8 view; |
85 CARD16 width; | 88 CARD16 pad0; |
86 CARD16 height; | 89 CARD16 width; |
87 INT32 refresh; | 90 CARD16 height; |
91 INT32 refresh; | |
88 } xXiGMiscChangeResolutionReq; | 92 } xXiGMiscChangeResolutionReq; |
89 | 93 |
90 typedef struct { | 94 typedef struct |
91 CARD8 reqType; /* always codes->major_opcode */ | 95 { |
92 CARD8 xigmiscReqType; /* always X_XiGMiscFullScreen */ | 96 CARD8 reqType; /* always codes->major_opcode */ |
93 CARD16 length; | 97 CARD8 xigmiscReqType; /* always X_XiGMiscFullScreen */ |
94 CARD8 screen; | 98 CARD16 length; |
95 CARD8 pad0; | 99 CARD8 screen; |
96 CARD16 pad1; | 100 CARD8 pad0; |
97 CARD32 window; | 101 CARD16 pad1; |
98 CARD32 cmap; | 102 CARD32 window; |
103 CARD32 cmap; | |
99 } xXiGMiscFullScreenReq; | 104 } xXiGMiscFullScreenReq; |
100 | 105 |
101 /*******************************************************************/ | 106 /*******************************************************************/ |
102 | 107 |
103 typedef struct { | 108 typedef struct |
104 BYTE type; /* X_Reply */ | 109 { |
105 CARD8 pad0; | 110 BYTE type; /* X_Reply */ |
106 CARD16 sequenceNumber; | 111 CARD8 pad0; |
107 CARD32 length; | 112 CARD16 sequenceNumber; |
108 CARD16 major; | 113 CARD32 length; |
109 CARD16 minor; | 114 CARD16 major; |
110 CARD32 pad1; | 115 CARD16 minor; |
111 CARD32 pad2; | 116 CARD32 pad1; |
112 CARD32 pad3; | 117 CARD32 pad2; |
113 CARD32 pad4; | 118 CARD32 pad3; |
114 CARD32 pad5; | 119 CARD32 pad4; |
120 CARD32 pad5; | |
115 } xXiGMiscQueryVersionReply; | 121 } xXiGMiscQueryVersionReply; |
116 | 122 |
117 typedef struct { | 123 typedef struct |
118 BYTE type; /* X_Reply */ | 124 { |
119 CARD8 pad0; | 125 BYTE type; /* X_Reply */ |
120 CARD16 sequenceNumber; | 126 CARD8 pad0; |
121 CARD32 length; | 127 CARD16 sequenceNumber; |
122 CARD32 nviews; | 128 CARD32 length; |
123 CARD32 pad1; | 129 CARD32 nviews; |
124 CARD32 pad2; | 130 CARD32 pad1; |
125 CARD32 pad3; | 131 CARD32 pad2; |
126 CARD32 pad4; | 132 CARD32 pad3; |
127 CARD32 pad5; | 133 CARD32 pad4; |
134 CARD32 pad5; | |
128 } xXiGMiscQueryViewsReply; | 135 } xXiGMiscQueryViewsReply; |
129 | 136 |
130 typedef struct { | 137 typedef struct |
131 BYTE type; /* X_Reply */ | 138 { |
132 CARD8 pad0; | 139 BYTE type; /* X_Reply */ |
133 CARD16 sequenceNumber; | 140 CARD8 pad0; |
134 CARD32 length; | 141 CARD16 sequenceNumber; |
135 CARD16 active; | 142 CARD32 length; |
136 CARD16 nresolutions; | 143 CARD16 active; |
137 CARD32 pad1; | 144 CARD16 nresolutions; |
138 CARD32 pad2; | 145 CARD32 pad1; |
139 CARD32 pad3; | 146 CARD32 pad2; |
140 CARD32 pad4; | 147 CARD32 pad3; |
141 CARD32 pad5; | 148 CARD32 pad4; |
149 CARD32 pad5; | |
142 } xXiGMiscQueryResolutionsReply; | 150 } xXiGMiscQueryResolutionsReply; |
143 | 151 |
144 typedef struct { | 152 typedef struct |
145 BYTE type; /* X_Reply */ | 153 { |
146 BOOL success; | 154 BYTE type; /* X_Reply */ |
147 CARD16 sequenceNumber; | 155 BOOL success; |
148 CARD32 length; | 156 CARD16 sequenceNumber; |
149 CARD32 pad1; | 157 CARD32 length; |
150 CARD32 pad2; | 158 CARD32 pad1; |
151 CARD32 pad3; | 159 CARD32 pad2; |
152 CARD32 pad4; | 160 CARD32 pad3; |
153 CARD32 pad5; | 161 CARD32 pad4; |
154 CARD32 pad6; | 162 CARD32 pad5; |
163 CARD32 pad6; | |
155 } xXiGMiscFullScreenReply; | 164 } xXiGMiscFullScreenReply; |
156 | 165 |
157 /*******************************************************************/ | 166 /*******************************************************************/ |
158 | 167 |
159 typedef struct { | 168 typedef struct |
160 INT16 x; | 169 { |
161 INT16 y; | 170 INT16 x; |
162 CARD16 w; | 171 INT16 y; |
163 CARD16 h; | 172 CARD16 w; |
173 CARD16 h; | |
164 } XiGMiscViewInfo; | 174 } XiGMiscViewInfo; |
165 | 175 |
166 typedef struct { | 176 typedef struct |
167 CARD16 width; | 177 { |
168 CARD16 height; | 178 CARD16 width; |
169 INT32 refresh; | 179 CARD16 height; |
180 INT32 refresh; | |
170 } XiGMiscResolutionInfo; | 181 } XiGMiscResolutionInfo; |
171 | 182 |
172 /*****************************************************************************/ | 183 /*****************************************************************************/ |
173 | 184 |
174 static XExtensionInfo *xigmisc_info = NULL; | 185 static XExtensionInfo *xigmisc_info = NULL; |
202 * find_display - locate the display info block | 213 * find_display - locate the display info block |
203 */ | 214 */ |
204 static int XiGMiscCloseDisplay(); | 215 static int XiGMiscCloseDisplay(); |
205 | 216 |
206 static XExtensionHooks xigmisc_extension_hooks = { | 217 static XExtensionHooks xigmisc_extension_hooks = { |
207 NULL, /* create_gc */ | 218 NULL, /* create_gc */ |
208 NULL, /* copy_gc */ | 219 NULL, /* copy_gc */ |
209 NULL, /* flush_gc */ | 220 NULL, /* flush_gc */ |
210 NULL, /* free_gc */ | 221 NULL, /* free_gc */ |
211 NULL, /* create_font */ | 222 NULL, /* create_font */ |
212 NULL, /* free_font */ | 223 NULL, /* free_font */ |
213 XiGMiscCloseDisplay, /* close_display */ | 224 XiGMiscCloseDisplay, /* close_display */ |
214 NULL, /* wire_to_event */ | 225 NULL, /* wire_to_event */ |
215 NULL, /* event_to_wire */ | 226 NULL, /* event_to_wire */ |
216 NULL, /* error */ | 227 NULL, /* error */ |
217 NULL, /* error_string */ | 228 NULL, /* error_string */ |
218 }; | 229 }; |
219 | 230 |
220 | 231 |
221 static XEXT_GENERATE_CLOSE_DISPLAY (XiGMiscCloseDisplay, xigmisc_info) | 232 static |
222 | 233 XEXT_GENERATE_CLOSE_DISPLAY(XiGMiscCloseDisplay, xigmisc_info) |
223 static XEXT_GENERATE_FIND_DISPLAY (XiGMiscFindDisplay, xigmisc_info, | 234 static XEXT_GENERATE_FIND_DISPLAY(XiGMiscFindDisplay, xigmisc_info, |
224 xigmisc_extension_name, | 235 xigmisc_extension_name, |
225 &xigmisc_extension_hooks, XiGMiscNumberEvents, NULL) | 236 &xigmisc_extension_hooks, |
226 | 237 XiGMiscNumberEvents, NULL) |
227 | |
228 /*****************************************************************************/ | 238 /*****************************************************************************/ |
229 | 239 Bool XiGMiscQueryVersion(Display * dpy, int *major, int *minor) |
230 Bool XiGMiscQueryVersion(Display *dpy, int *major, int *minor) | 240 { |
231 { | 241 int opcode, event, error; |
232 int opcode, event, error; | 242 xXiGMiscQueryVersionReq *req; |
233 xXiGMiscQueryVersionReq *req; | 243 xXiGMiscQueryVersionReply rep; |
234 xXiGMiscQueryVersionReply rep; | 244 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); |
235 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); | 245 |
236 | 246 if (!XQueryExtension(dpy, XIGMISC_PROTOCOL_NAME, &opcode, &event, &error)) |
237 if (!XQueryExtension(dpy, XIGMISC_PROTOCOL_NAME, &opcode, &event, &error)) | 247 return xFalse; |
238 return xFalse; | 248 |
239 | 249 XiGMiscCheckExtension(dpy, info, xFalse); |
240 XiGMiscCheckExtension(dpy, info, xFalse); | 250 |
241 | 251 LockDisplay(dpy); |
242 LockDisplay (dpy); | 252 XiGMiscGetReq(XiGMiscQueryVersion, req, info); |
243 XiGMiscGetReq (XiGMiscQueryVersion, req, info); | 253 |
244 | 254 req->major = XIGMISC_MAJOR_VERSION; |
245 req->major = XIGMISC_MAJOR_VERSION; | 255 req->minor = XIGMISC_MINOR_VERSION; |
246 req->minor = XIGMISC_MINOR_VERSION; | 256 |
247 | 257 if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) { |
248 if (!_XReply (dpy, (xReply *)&rep, 0, xTrue)) { | 258 UnlockDisplay(dpy); |
259 SyncHandle(); | |
260 return xFalse; | |
261 } | |
262 | |
263 *major = rep.major; | |
264 *minor = rep.minor; | |
249 UnlockDisplay(dpy); | 265 UnlockDisplay(dpy); |
250 SyncHandle(); | 266 SyncHandle(); |
251 return xFalse; | 267 |
252 } | 268 return xTrue; |
253 | |
254 *major = rep.major; | |
255 *minor = rep.minor; | |
256 UnlockDisplay(dpy); | |
257 SyncHandle(); | |
258 | |
259 return xTrue; | |
260 } | 269 } |
261 | 270 |
262 int XiGMiscQueryViews(Display *dpy, int screen, XiGMiscViewInfo **pviews) | 271 int |
263 { | 272 XiGMiscQueryViews(Display * dpy, int screen, XiGMiscViewInfo ** pviews) |
264 int n, size; | 273 { |
265 XiGMiscViewInfo *views; | 274 int n, size; |
266 xXiGMiscQueryViewsReq *req; | 275 XiGMiscViewInfo *views; |
267 xXiGMiscQueryViewsReply rep; | 276 xXiGMiscQueryViewsReq *req; |
268 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); | 277 xXiGMiscQueryViewsReply rep; |
269 XiGMiscCheckExtension(dpy, info, 0); | 278 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); |
270 | 279 XiGMiscCheckExtension(dpy, info, 0); |
271 LockDisplay (dpy); | 280 |
272 XiGMiscGetReq (XiGMiscQueryViews, req, info); | 281 LockDisplay(dpy); |
273 req->screen = screen; | 282 XiGMiscGetReq(XiGMiscQueryViews, req, info); |
274 | 283 req->screen = screen; |
275 if (!_XReply (dpy, (xReply *)&rep, 0, xFalse)) { | 284 |
285 if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { | |
286 UnlockDisplay(dpy); | |
287 SyncHandle(); | |
288 return 0; | |
289 } | |
290 | |
291 n = rep.nviews; | |
292 | |
293 if (n > 0) { | |
294 size = sizeof(XiGMiscViewInfo) * n; | |
295 views = (XiGMiscViewInfo *) Xmalloc(size); | |
296 if (!views) { | |
297 _XEatData(dpy, (unsigned long) size); | |
298 UnlockDisplay(dpy); | |
299 SyncHandle(); | |
300 return 0; | |
301 } | |
302 | |
303 _XReadPad(dpy, (void *) views, size); | |
304 | |
305 *pviews = views; | |
306 } | |
307 | |
276 UnlockDisplay(dpy); | 308 UnlockDisplay(dpy); |
277 SyncHandle(); | 309 SyncHandle(); |
278 return 0; | 310 |
279 } | 311 return n; |
280 | |
281 n = rep.nviews; | |
282 | |
283 if (n > 0) { | |
284 size = sizeof(XiGMiscViewInfo) * n; | |
285 views = (XiGMiscViewInfo*)Xmalloc(size); | |
286 if (!views) { | |
287 _XEatData(dpy, (unsigned long)size); | |
288 UnlockDisplay(dpy); | |
289 SyncHandle(); | |
290 return 0; | |
291 } | |
292 | |
293 _XReadPad(dpy, (void*)views, size); | |
294 | |
295 *pviews = views; | |
296 } | |
297 | |
298 UnlockDisplay(dpy); | |
299 SyncHandle(); | |
300 | |
301 return n; | |
302 } | 312 } |
303 | 313 |
304 int XiGMiscQueryResolutions(Display *dpy, int screen, int view, int *pactive, XiGMiscResolutionInfo **presolutions) | 314 int |
305 { | 315 XiGMiscQueryResolutions(Display * dpy, int screen, int view, int *pactive, |
306 int n, size; | 316 XiGMiscResolutionInfo ** presolutions) |
307 XiGMiscResolutionInfo *resolutions; | 317 { |
308 xXiGMiscQueryResolutionsReq *req; | 318 int n, size; |
309 xXiGMiscQueryResolutionsReply rep; | 319 XiGMiscResolutionInfo *resolutions; |
310 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); | 320 xXiGMiscQueryResolutionsReq *req; |
311 XiGMiscCheckExtension(dpy, info, 0); | 321 xXiGMiscQueryResolutionsReply rep; |
312 | 322 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); |
313 LockDisplay (dpy); | 323 XiGMiscCheckExtension(dpy, info, 0); |
314 XiGMiscGetReq (XiGMiscQueryResolutions, req, info); | 324 |
315 req->screen = screen; | 325 LockDisplay(dpy); |
316 req->view = view; | 326 XiGMiscGetReq(XiGMiscQueryResolutions, req, info); |
317 | 327 req->screen = screen; |
318 if (!_XReply (dpy, (xReply *)&rep, 0, xFalse)) { | 328 req->view = view; |
329 | |
330 if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { | |
331 UnlockDisplay(dpy); | |
332 SyncHandle(); | |
333 return 0; | |
334 } | |
335 | |
336 n = rep.nresolutions; | |
337 | |
338 if (n > 0) { | |
339 size = sizeof(XiGMiscResolutionInfo) * n; | |
340 resolutions = (XiGMiscResolutionInfo *) Xmalloc(size); | |
341 if (!resolutions) { | |
342 _XEatData(dpy, (unsigned long) size); | |
343 UnlockDisplay(dpy); | |
344 SyncHandle(); | |
345 return 0; | |
346 } | |
347 | |
348 _XReadPad(dpy, (void *) resolutions, size); | |
349 | |
350 *presolutions = resolutions; | |
351 *pactive = rep.active; | |
352 } | |
353 | |
319 UnlockDisplay(dpy); | 354 UnlockDisplay(dpy); |
320 SyncHandle(); | 355 SyncHandle(); |
321 return 0; | 356 |
322 } | 357 return n; |
323 | |
324 n = rep.nresolutions; | |
325 | |
326 if (n > 0) { | |
327 size = sizeof(XiGMiscResolutionInfo) * n; | |
328 resolutions = (XiGMiscResolutionInfo*)Xmalloc(size); | |
329 if (!resolutions) { | |
330 _XEatData(dpy, (unsigned long)size); | |
331 UnlockDisplay(dpy); | |
332 SyncHandle(); | |
333 return 0; | |
334 } | |
335 | |
336 _XReadPad(dpy, (void*)resolutions, size); | |
337 | |
338 *presolutions = resolutions; | |
339 *pactive = rep.active; | |
340 } | |
341 | |
342 UnlockDisplay(dpy); | |
343 SyncHandle(); | |
344 | |
345 return n; | |
346 } | 358 } |
347 | 359 |
348 void XiGMiscChangeResolution(Display *dpy, int screen, int view, int width, int height, int refresh) | 360 void |
349 { | 361 XiGMiscChangeResolution(Display * dpy, int screen, int view, int width, |
350 xXiGMiscChangeResolutionReq *req; | 362 int height, int refresh) |
351 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); | 363 { |
352 | 364 xXiGMiscChangeResolutionReq *req; |
353 XiGMiscSimpleCheckExtension(dpy, info); | 365 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); |
354 | 366 |
355 LockDisplay (dpy); | 367 XiGMiscSimpleCheckExtension(dpy, info); |
356 XiGMiscGetReq (XiGMiscChangeResolution, req, info); | 368 |
357 req->screen = screen; | 369 LockDisplay(dpy); |
358 req->view = view; | 370 XiGMiscGetReq(XiGMiscChangeResolution, req, info); |
359 req->width = width; | 371 req->screen = screen; |
360 req->height = height; | 372 req->view = view; |
361 req->refresh = refresh; | 373 req->width = width; |
362 | 374 req->height = height; |
363 UnlockDisplay(dpy); | 375 req->refresh = refresh; |
364 SyncHandle(); | 376 |
365 } | |
366 | |
367 | |
368 Bool XiGMiscFullScreen(Display *dpy, int screen, XID window, XID cmap) | |
369 { | |
370 xXiGMiscFullScreenReq *req; | |
371 xXiGMiscFullScreenReply rep; | |
372 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); | |
373 | |
374 XiGMiscCheckExtension(dpy, info, xFalse); | |
375 | |
376 LockDisplay (dpy); | |
377 XiGMiscGetReq (XiGMiscFullScreen, req, info); | |
378 req->screen = screen; | |
379 req->pad0 = 0; | |
380 req->pad1 = 0; | |
381 req->window = window; | |
382 req->cmap = cmap; | |
383 | |
384 if (!_XReply (dpy, (xReply *)&rep, 0, xTrue)) { | |
385 UnlockDisplay(dpy); | 377 UnlockDisplay(dpy); |
386 SyncHandle(); | 378 SyncHandle(); |
387 return xFalse; | |
388 } | |
389 | |
390 UnlockDisplay(dpy); | |
391 SyncHandle(); | |
392 | |
393 return (rep.success ? xTrue : xFalse); | |
394 } | 379 } |
395 | 380 |
381 | |
382 Bool | |
383 XiGMiscFullScreen(Display * dpy, int screen, XID window, XID cmap) | |
384 { | |
385 xXiGMiscFullScreenReq *req; | |
386 xXiGMiscFullScreenReply rep; | |
387 XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); | |
388 | |
389 XiGMiscCheckExtension(dpy, info, xFalse); | |
390 | |
391 LockDisplay(dpy); | |
392 XiGMiscGetReq(XiGMiscFullScreen, req, info); | |
393 req->screen = screen; | |
394 req->pad0 = 0; | |
395 req->pad1 = 0; | |
396 req->window = window; | |
397 req->cmap = cmap; | |
398 | |
399 if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) { | |
400 UnlockDisplay(dpy); | |
401 SyncHandle(); | |
402 return xFalse; | |
403 } | |
404 | |
405 UnlockDisplay(dpy); | |
406 SyncHandle(); | |
407 | |
408 return (rep.success ? xTrue : xFalse); | |
409 } | |
410 | |
411 /* vi: set ts=4 sw=4 expandtab: */ |