Mercurial > sdl-ios-xcode

comparison src/video/Xext/XME/xme.c @ 1895:c121d94672cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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: */