Mercurial > sdl-ios-xcode

comparison src/video/Xext/Xinerama/Xinerama.c @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents ecba4bbaf9c2
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
29 #define NEED_REPLIES 29 #define NEED_REPLIES
30 30
31 #include <X11/Xlibint.h> 31 #include <X11/Xlibint.h>
32 #include <X11/Xutil.h> 32 #include <X11/Xutil.h>
33 #include "../extensions/Xext.h" 33 #include "../extensions/Xext.h"
34 #include "../extensions/extutil.h" /* in ../include */ 34 #include "../extensions/extutil.h" /* in ../include */
35 #include "../extensions/panoramiXext.h" 35 #include "../extensions/panoramiXext.h"
36 #include "../extensions/panoramiXproto.h" /* in ../include */ 36 #include "../extensions/panoramiXproto.h" /* in ../include */
37 #include "../extensions/Xinerama.h" 37 #include "../extensions/Xinerama.h"
38 38
39 static XExtensionInfo _panoramiX_ext_info_data; 39 static XExtensionInfo _panoramiX_ext_info_data;
40 static XExtensionInfo *panoramiX_ext_info = &_panoramiX_ext_info_data; 40 static XExtensionInfo *panoramiX_ext_info = &_panoramiX_ext_info_data;
41 static /* const */ char *panoramiX_extension_name = PANORAMIX_PROTOCOL_NAME; 41 static /* const */ char *panoramiX_extension_name = PANORAMIX_PROTOCOL_NAME;
43 #define PanoramiXCheckExtension(dpy,i,val) \ 43 #define PanoramiXCheckExtension(dpy,i,val) \
44 XextCheckExtension (dpy, i, panoramiX_extension_name, val) 44 XextCheckExtension (dpy, i, panoramiX_extension_name, val)
45 #define PanoramiXSimpleCheckExtension(dpy,i) \ 45 #define PanoramiXSimpleCheckExtension(dpy,i) \
46 XextSimpleCheckExtension (dpy, i, panoramiX_extension_name) 46 XextSimpleCheckExtension (dpy, i, panoramiX_extension_name)
47 47
48 static int close_display(); 48 static int close_display ();
49 static /* const */ XExtensionHooks panoramiX_extension_hooks = { 49 static /* const */ XExtensionHooks panoramiX_extension_hooks = {
50 NULL, /* create_gc */ 50 NULL, /* create_gc */
51 NULL, /* copy_gc */ 51 NULL, /* copy_gc */
52 NULL, /* flush_gc */ 52 NULL, /* flush_gc */
53 NULL, /* free_gc */ 53 NULL, /* free_gc */
54 NULL, /* create_font */ 54 NULL, /* create_font */
55 NULL, /* free_font */ 55 NULL, /* free_font */
56 close_display, /* close_display */ 56 close_display, /* close_display */
57 NULL, /* wire_to_event */ 57 NULL, /* wire_to_event */
58 NULL, /* event_to_wire */ 58 NULL, /* event_to_wire */
59 NULL, /* error */ 59 NULL, /* error */
60 NULL, /* error_string */ 60 NULL, /* error_string */
61 }; 61 };
62 62
63 static XEXT_GENERATE_FIND_DISPLAY (find_display, panoramiX_ext_info, 63 static
64 panoramiX_extension_name, 64 XEXT_GENERATE_FIND_DISPLAY (find_display, panoramiX_ext_info,
65 &panoramiX_extension_hooks, 65 panoramiX_extension_name,
66 0, NULL) 66 &panoramiX_extension_hooks, 0, NULL)
67 67 static XEXT_GENERATE_CLOSE_DISPLAY (close_display, panoramiX_ext_info)
68 static XEXT_GENERATE_CLOSE_DISPLAY (close_display, panoramiX_ext_info)
69
70
71
72 /**************************************************************************** 68 /****************************************************************************
73 * * 69 * *
74 * PanoramiX public interfaces * 70 * PanoramiX public interfaces *
75 * * 71 * *
76 ****************************************************************************/ 72 ****************************************************************************/
77 73 Bool SDL_NAME (XPanoramiXQueryExtension) (Display * dpy,
78 Bool SDL_NAME(XPanoramiXQueryExtension) ( 74 int *event_basep,
79 Display *dpy, 75 int *error_basep)
80 int *event_basep, 76 {
81 int *error_basep 77 XExtDisplayInfo *info = find_display (dpy);
82 ) 78
83 { 79 if (XextHasExtension (info)) {
84 XExtDisplayInfo *info = find_display (dpy); 80 *event_basep = info->codes->first_event;
85 81 *error_basep = info->codes->first_error;
86 if (XextHasExtension(info)) { 82 return True;
87 *event_basep = info->codes->first_event;
88 *error_basep = info->codes->first_error;
89 return True;
90 } else { 83 } else {
91 return False; 84 return False;
92 } 85 }
93 } 86 }
94 87
95 88
96 Status SDL_NAME(XPanoramiXQueryVersion)( 89 Status SDL_NAME (XPanoramiXQueryVersion) (Display * dpy,
97 Display *dpy, 90 int *major_versionp,
98 int *major_versionp, 91 int *minor_versionp)
99 int *minor_versionp 92 {
100 ) 93 XExtDisplayInfo *info = find_display (dpy);
101 { 94 xPanoramiXQueryVersionReply rep;
102 XExtDisplayInfo *info = find_display (dpy); 95 register xPanoramiXQueryVersionReq *req;
103 xPanoramiXQueryVersionReply rep;
104 register xPanoramiXQueryVersionReq *req;
105 96
106 PanoramiXCheckExtension (dpy, info, 0); 97 PanoramiXCheckExtension (dpy, info, 0);
107 98
108 LockDisplay (dpy); 99 LockDisplay (dpy);
109 GetReq (PanoramiXQueryVersion, req); 100 GetReq (PanoramiXQueryVersion, req);
110 req->reqType = info->codes->major_opcode; 101 req->reqType = info->codes->major_opcode;
111 req->panoramiXReqType = X_PanoramiXQueryVersion; 102 req->panoramiXReqType = X_PanoramiXQueryVersion;
112 req->clientMajor = PANORAMIX_MAJOR_VERSION; 103 req->clientMajor = PANORAMIX_MAJOR_VERSION;
113 req->clientMinor = PANORAMIX_MINOR_VERSION; 104 req->clientMinor = PANORAMIX_MINOR_VERSION;
114 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 105 if (!_XReply (dpy, (xReply *) & rep, 0, xTrue)) {
115 UnlockDisplay (dpy); 106 UnlockDisplay (dpy);
116 SyncHandle (); 107 SyncHandle ();
117 return 0; 108 return 0;
118 } 109 }
119 *major_versionp = rep.majorVersion; 110 *major_versionp = rep.majorVersion;
120 *minor_versionp = rep.minorVersion; 111 *minor_versionp = rep.minorVersion;
121 UnlockDisplay (dpy); 112 UnlockDisplay (dpy);
122 SyncHandle (); 113 SyncHandle ();
123 return 1; 114 return 1;
124 } 115 }
125 116
126 SDL_NAME(XPanoramiXInfo) *SDL_NAME(XPanoramiXAllocInfo)(void) 117 SDL_NAME (XPanoramiXInfo) * SDL_NAME (XPanoramiXAllocInfo) (void)
127 { 118 {
128 return (SDL_NAME(XPanoramiXInfo) *) Xmalloc (sizeof (SDL_NAME(XPanoramiXInfo))); 119 return (SDL_NAME (XPanoramiXInfo) *)
129 } 120 Xmalloc (sizeof (SDL_NAME (XPanoramiXInfo)));
130 121 }
131 Status SDL_NAME(XPanoramiXGetState) ( 122
132 Display *dpy, 123 Status SDL_NAME (XPanoramiXGetState) (Display * dpy,
133 Drawable drawable, 124 Drawable drawable,
134 SDL_NAME(XPanoramiXInfo) *panoramiX_info 125 SDL_NAME (XPanoramiXInfo) *
135 ) 126 panoramiX_info)
136 { 127 {
137 XExtDisplayInfo *info = find_display (dpy); 128 XExtDisplayInfo *info = find_display (dpy);
138 xPanoramiXGetStateReply rep; 129 xPanoramiXGetStateReply rep;
139 register xPanoramiXGetStateReq *req; 130 register xPanoramiXGetStateReq *req;
140 131
141 PanoramiXCheckExtension (dpy, info, 0); 132 PanoramiXCheckExtension (dpy, info, 0);
142 133
143 LockDisplay (dpy); 134 LockDisplay (dpy);
144 GetReq (PanoramiXGetState, req); 135 GetReq (PanoramiXGetState, req);
145 req->reqType = info->codes->major_opcode; 136 req->reqType = info->codes->major_opcode;
146 req->panoramiXReqType = X_PanoramiXGetState; 137 req->panoramiXReqType = X_PanoramiXGetState;
147 req->window = drawable; 138 req->window = drawable;
148 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 139 if (!_XReply (dpy, (xReply *) & rep, 0, xTrue)) {
149 UnlockDisplay (dpy); 140 UnlockDisplay (dpy);
150 SyncHandle (); 141 SyncHandle ();
151 return 0; 142 return 0;
152 } 143 }
153 UnlockDisplay (dpy); 144 UnlockDisplay (dpy);
154 SyncHandle (); 145 SyncHandle ();
155 panoramiX_info->window = rep.window; 146 panoramiX_info->window = rep.window;
156 panoramiX_info->State = rep.state; 147 panoramiX_info->State = rep.state;
157 return 1; 148 return 1;
158 } 149 }
159 150
160 Status SDL_NAME(XPanoramiXGetScreenCount) ( 151 Status SDL_NAME (XPanoramiXGetScreenCount) (Display * dpy,
161 Display *dpy, 152 Drawable drawable,
162 Drawable drawable, 153 SDL_NAME (XPanoramiXInfo) *
163 SDL_NAME(XPanoramiXInfo) *panoramiX_info 154 panoramiX_info)
164 ) 155 {
165 { 156 XExtDisplayInfo *info = find_display (dpy);
166 XExtDisplayInfo *info = find_display (dpy); 157 xPanoramiXGetScreenCountReply rep;
167 xPanoramiXGetScreenCountReply rep; 158 register xPanoramiXGetScreenCountReq *req;
168 register xPanoramiXGetScreenCountReq *req;
169 159
170 PanoramiXCheckExtension (dpy, info, 0); 160 PanoramiXCheckExtension (dpy, info, 0);
171 161
172 LockDisplay (dpy); 162 LockDisplay (dpy);
173 GetReq (PanoramiXGetScreenCount, req); 163 GetReq (PanoramiXGetScreenCount, req);
174 req->reqType = info->codes->major_opcode; 164 req->reqType = info->codes->major_opcode;
175 req->panoramiXReqType = X_PanoramiXGetScreenCount; 165 req->panoramiXReqType = X_PanoramiXGetScreenCount;
176 req->window = drawable; 166 req->window = drawable;
177 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 167 if (!_XReply (dpy, (xReply *) & rep, 0, xTrue)) {
178 UnlockDisplay (dpy); 168 UnlockDisplay (dpy);
179 SyncHandle (); 169 SyncHandle ();
180 return 0; 170 return 0;
181 } 171 }
182 UnlockDisplay (dpy); 172 UnlockDisplay (dpy);
183 SyncHandle (); 173 SyncHandle ();
184 panoramiX_info->window = rep.window; 174 panoramiX_info->window = rep.window;
185 panoramiX_info->ScreenCount = rep.ScreenCount; 175 panoramiX_info->ScreenCount = rep.ScreenCount;
186 return 1; 176 return 1;
187 } 177 }
188 178
189 Status SDL_NAME(XPanoramiXGetScreenSize) ( 179 Status SDL_NAME (XPanoramiXGetScreenSize) (Display * dpy,
190 Display *dpy, 180 Drawable drawable,
191 Drawable drawable, 181 int screen_num,
192 int screen_num, 182 SDL_NAME (XPanoramiXInfo) *
193 SDL_NAME(XPanoramiXInfo) *panoramiX_info 183 panoramiX_info)
194 ) 184 {
195 { 185 XExtDisplayInfo *info = find_display (dpy);
196 XExtDisplayInfo *info = find_display (dpy); 186 xPanoramiXGetScreenSizeReply rep;
197 xPanoramiXGetScreenSizeReply rep; 187 register xPanoramiXGetScreenSizeReq *req;
198 register xPanoramiXGetScreenSizeReq *req;
199 188
200 PanoramiXCheckExtension (dpy, info, 0); 189 PanoramiXCheckExtension (dpy, info, 0);
201 190
202 LockDisplay (dpy); 191 LockDisplay (dpy);
203 GetReq (PanoramiXGetScreenSize, req); 192 GetReq (PanoramiXGetScreenSize, req);
204 req->reqType = info->codes->major_opcode; 193 req->reqType = info->codes->major_opcode;
205 req->panoramiXReqType = X_PanoramiXGetScreenSize; 194 req->panoramiXReqType = X_PanoramiXGetScreenSize;
206 req->window = drawable; 195 req->window = drawable;
207 req->screen = screen_num; /* need to define */ 196 req->screen = screen_num; /* need to define */
208 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 197 if (!_XReply (dpy, (xReply *) & rep, 0, xTrue)) {
209 UnlockDisplay (dpy); 198 UnlockDisplay (dpy);
210 SyncHandle (); 199 SyncHandle ();
211 return 0; 200 return 0;
212 } 201 }
213 UnlockDisplay (dpy); 202 UnlockDisplay (dpy);
214 SyncHandle (); 203 SyncHandle ();
215 panoramiX_info->window = rep.window; 204 panoramiX_info->window = rep.window;
216 panoramiX_info->screen = rep.screen; 205 panoramiX_info->screen = rep.screen;
217 panoramiX_info->width = rep.width; 206 panoramiX_info->width = rep.width;
218 panoramiX_info->height = rep.height; 207 panoramiX_info->height = rep.height;
219 return 1; 208 return 1;
220 } 209 }
221 210
222 /*******************************************************************\ 211 /*******************************************************************\
223 Alternate interface to make up for shortcomings in the original, 212 Alternate interface to make up for shortcomings in the original,
224 namely, the omission of the screen origin. The new interface is 213 namely, the omission of the screen origin. The new interface is
225 in the "Xinerama" namespace instead of "PanoramiX". 214 in the "Xinerama" namespace instead of "PanoramiX".
226 \*******************************************************************/ 215 \*******************************************************************/
227 216
228 Bool SDL_NAME(XineramaQueryExtension) ( 217 Bool SDL_NAME (XineramaQueryExtension) (Display * dpy,
229 Display *dpy, 218 int *event_base, int *error_base)
230 int *event_base, 219 {
231 int *error_base 220 return SDL_NAME (XPanoramiXQueryExtension) (dpy, event_base, error_base);
232 ) 221 }
233 { 222
234 return SDL_NAME(XPanoramiXQueryExtension)(dpy, event_base, error_base); 223 Status SDL_NAME (XineramaQueryVersion) (Display * dpy, int *major, int *minor)
235 } 224 {
236 225 return SDL_NAME (XPanoramiXQueryVersion) (dpy, major, minor);
237 Status SDL_NAME(XineramaQueryVersion)( 226 }
238 Display *dpy, 227
239 int *major, 228 Bool SDL_NAME (XineramaIsActive) (Display * dpy)
240 int *minor 229 {
241 ) 230 xXineramaIsActiveReply rep;
242 { 231 xXineramaIsActiveReq *req;
243 return SDL_NAME(XPanoramiXQueryVersion)(dpy, major, minor); 232 XExtDisplayInfo *info = find_display (dpy);
244 } 233
245 234 if (!XextHasExtension (info))
246 Bool SDL_NAME(XineramaIsActive)(Display *dpy) 235 return False; /* server doesn't even have the extension */
247 {
248 xXineramaIsActiveReply rep;
249 xXineramaIsActiveReq *req;
250 XExtDisplayInfo *info = find_display (dpy);
251
252 if(!XextHasExtension(info))
253 return False; /* server doesn't even have the extension */
254 236
255 LockDisplay (dpy); 237 LockDisplay (dpy);
256 GetReq (XineramaIsActive, req); 238 GetReq (XineramaIsActive, req);
257 req->reqType = info->codes->major_opcode; 239 req->reqType = info->codes->major_opcode;
258 req->panoramiXReqType = X_XineramaIsActive; 240 req->panoramiXReqType = X_XineramaIsActive;
259 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 241 if (!_XReply (dpy, (xReply *) & rep, 0, xTrue)) {
260 UnlockDisplay (dpy); 242 UnlockDisplay (dpy);
261 SyncHandle (); 243 SyncHandle ();
262 return False; 244 return False;
263 } 245 }
264 UnlockDisplay (dpy); 246 UnlockDisplay (dpy);
265 SyncHandle (); 247 SyncHandle ();
266 return rep.state; 248 return rep.state;
267 } 249 }
268 250
269 #include <stdio.h> 251 #include <stdio.h>
270 252
271 SDL_NAME(XineramaScreenInfo) * 253 SDL_NAME (XineramaScreenInfo) *
272 SDL_NAME(XineramaQueryScreens)( 254 SDL_NAME (XineramaQueryScreens) (Display * dpy, int *number)
273 Display *dpy, 255 {
274 int *number 256 XExtDisplayInfo *info = find_display (dpy);
275 ) 257 xXineramaQueryScreensReply rep;
276 { 258 xXineramaQueryScreensReq *req;
277 XExtDisplayInfo *info = find_display (dpy); 259 SDL_NAME (XineramaScreenInfo) * scrnInfo = NULL;
278 xXineramaQueryScreensReply rep;
279 xXineramaQueryScreensReq *req;
280 SDL_NAME(XineramaScreenInfo) *scrnInfo = NULL;
281 260
282 PanoramiXCheckExtension (dpy, info, 0); 261 PanoramiXCheckExtension (dpy, info, 0);
283 262
284 LockDisplay (dpy); 263 LockDisplay (dpy);
285 GetReq (XineramaQueryScreens, req); 264 GetReq (XineramaQueryScreens, req);
286 req->reqType = info->codes->major_opcode; 265 req->reqType = info->codes->major_opcode;
287 req->panoramiXReqType = X_XineramaQueryScreens; 266 req->panoramiXReqType = X_XineramaQueryScreens;
288 if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { 267 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
289 UnlockDisplay (dpy); 268 UnlockDisplay (dpy);
290 SyncHandle (); 269 SyncHandle ();
291 return NULL; 270 return NULL;
292 } 271 }
293 272
294 if(rep.number) { 273 if (rep.number) {
295 if((scrnInfo = Xmalloc(sizeof(SDL_NAME(XineramaScreenInfo)) * rep.number))) { 274 if ((scrnInfo =
296 xXineramaScreenInfo scratch; 275 Xmalloc (sizeof (SDL_NAME (XineramaScreenInfo)) * rep.number))) {
297 int i; 276 xXineramaScreenInfo scratch;
298 277 int i;
299 for(i = 0; i < rep.number; i++) { 278
300 _XRead(dpy, (char*)(&scratch), sz_XineramaScreenInfo); 279 for (i = 0; i < rep.number; i++) {
301 scrnInfo[i].screen_number = i; 280 _XRead (dpy, (char *) (&scratch), sz_XineramaScreenInfo);
302 scrnInfo[i].x_org = scratch.x_org; 281 scrnInfo[i].screen_number = i;
303 scrnInfo[i].y_org = scratch.y_org; 282 scrnInfo[i].x_org = scratch.x_org;
304 scrnInfo[i].width = scratch.width; 283 scrnInfo[i].y_org = scratch.y_org;
305 scrnInfo[i].height = scratch.height; 284 scrnInfo[i].width = scratch.width;
306 } 285 scrnInfo[i].height = scratch.height;
307 286 }
308 *number = rep.number; 287
309 } else 288 *number = rep.number;
310 _XEatData(dpy, rep.length << 2); 289 } else
290 _XEatData (dpy, rep.length << 2);
311 } 291 }
312 292
313 UnlockDisplay (dpy); 293 UnlockDisplay (dpy);
314 SyncHandle (); 294 SyncHandle ();
315 return scrnInfo; 295 return scrnInfo;
316 } 296 }
317 297
318 298 /* vi: set ts=4 sw=4 expandtab: */
319