Mercurial > sdl-ios-xcode

comparison src/video/Xext/Xxf86vm/XF86VMode.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
67 * * 67 * *
68 * private utility routines * 68 * private utility routines *
69 * * 69 * *
70 *****************************************************************************/ 70 *****************************************************************************/
71 71
72 static XEXT_CLOSE_DISPLAY_PROTO(close_display); 72 static XEXT_CLOSE_DISPLAY_PROTO (close_display);
73 static /* const */ XExtensionHooks xf86vidmode_extension_hooks = { 73 static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
74 NULL, /* create_gc */ 74 NULL, /* create_gc */
75 NULL, /* copy_gc */ 75 NULL, /* copy_gc */
76 NULL, /* flush_gc */ 76 NULL, /* flush_gc */
77 NULL, /* free_gc */ 77 NULL, /* free_gc */
78 NULL, /* create_font */ 78 NULL, /* create_font */
79 NULL, /* free_font */ 79 NULL, /* free_font */
80 close_display, /* close_display */ 80 close_display, /* close_display */
81 NULL, /* wire_to_event */ 81 NULL, /* wire_to_event */
82 NULL, /* event_to_wire */ 82 NULL, /* event_to_wire */
83 NULL, /* error */ 83 NULL, /* error */
84 NULL, /* error_string */ 84 NULL, /* error_string */
85 }; 85 };
86 86
87 static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info, 87 static
88 xf86vidmode_extension_name, 88 XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info,
89 &xf86vidmode_extension_hooks, 89 xf86vidmode_extension_name,
90 0, NULL) 90 &xf86vidmode_extension_hooks, 0, NULL)
91 91 static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)
92 static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)
93
94
95 /***************************************************************************** 92 /*****************************************************************************
96 * * 93 * *
97 * public XFree86-VidMode Extension routines * 94 * public XFree86-VidMode Extension routines *
98 * * 95 * *
99 *****************************************************************************/ 96 *****************************************************************************/
100 97 Bool
101 Bool 98 SDL_NAME (XF86VidModeQueryExtension) (dpy, event_basep, error_basep)
102 SDL_NAME(XF86VidModeQueryExtension) (dpy, event_basep, error_basep) 99 Display *dpy;
103 Display *dpy; 100 int *event_basep, *error_basep;
104 int *event_basep, *error_basep; 101 {
105 { 102 XExtDisplayInfo *info = find_display (dpy);
106 XExtDisplayInfo *info = find_display (dpy); 103
107 104 if (XextHasExtension (info)) {
108 if (XextHasExtension(info)) { 105 *event_basep = info->codes->first_event;
109 *event_basep = info->codes->first_event; 106 *error_basep = info->codes->first_error;
110 *error_basep = info->codes->first_error; 107 return True;
111 return True;
112 } else { 108 } else {
113 return False; 109 return False;
114 } 110 }
115 } 111 }
116 112
117 Bool 113 Bool SDL_NAME (XF86VidModeQueryVersion) (dpy, majorVersion, minorVersion)
118 SDL_NAME(XF86VidModeQueryVersion)(dpy, majorVersion, minorVersion) 114 Display *
119 Display* dpy; 115 dpy;
120 int* majorVersion; 116 int *
121 int* minorVersion; 117 majorVersion;
118 int *
119 minorVersion;
122 { 120 {
123 XExtDisplayInfo *info = find_display (dpy); 121 XExtDisplayInfo *info = find_display (dpy);
124 xXF86VidModeQueryVersionReply rep; 122 xXF86VidModeQueryVersionReply rep;
125 xXF86VidModeQueryVersionReq *req; 123 xXF86VidModeQueryVersionReq *req;
126 124
127 XF86VidModeCheckExtension (dpy, info, False); 125 XF86VidModeCheckExtension (dpy, info, False);
128 126
129 LockDisplay(dpy); 127 LockDisplay (dpy);
130 GetReq(XF86VidModeQueryVersion, req); 128 GetReq (XF86VidModeQueryVersion, req);
131 req->reqType = info->codes->major_opcode; 129 req->reqType = info->codes->major_opcode;
132 req->xf86vidmodeReqType = X_XF86VidModeQueryVersion; 130 req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
133 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 131 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
134 UnlockDisplay(dpy); 132 UnlockDisplay (dpy);
135 SyncHandle(); 133 SyncHandle ();
136 return False; 134 return False;
137 } 135 }
138 *majorVersion = rep.majorVersion; 136 *majorVersion = rep.majorVersion;
139 *minorVersion = rep.minorVersion; 137 *minorVersion = rep.minorVersion;
140 UnlockDisplay(dpy); 138 UnlockDisplay (dpy);
141 SyncHandle(); 139 SyncHandle ();
142 if (*majorVersion >= 2) 140 if (*majorVersion >= 2)
143 SDL_NAME(XF86VidModeSetClientVersion)(dpy); 141 SDL_NAME (XF86VidModeSetClientVersion) (dpy);
144 return True; 142 return True;
145 } 143 }
146 144
147 Bool 145 Bool SDL_NAME (XF86VidModeSetClientVersion) (Display * dpy)
148 SDL_NAME(XF86VidModeSetClientVersion)(Display *dpy) 146 {
149 { 147 XExtDisplayInfo *info = find_display (dpy);
150 XExtDisplayInfo *info = find_display(dpy);
151 xXF86VidModeSetClientVersionReq *req; 148 xXF86VidModeSetClientVersionReq *req;
152 149
153 XF86VidModeCheckExtension(dpy, info, False); 150 XF86VidModeCheckExtension (dpy, info, False);
154 151
155 LockDisplay(dpy); 152 LockDisplay (dpy);
156 GetReq(XF86VidModeSetClientVersion, req); 153 GetReq (XF86VidModeSetClientVersion, req);
157 req->reqType = info->codes->major_opcode; 154 req->reqType = info->codes->major_opcode;
158 req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion; 155 req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion;
159 req->major = XF86VIDMODE_MAJOR_VERSION; 156 req->major = XF86VIDMODE_MAJOR_VERSION;
160 req->minor = XF86VIDMODE_MINOR_VERSION; 157 req->minor = XF86VIDMODE_MINOR_VERSION;
161 UnlockDisplay(dpy); 158 UnlockDisplay (dpy);
162 SyncHandle(); 159 SyncHandle ();
163 return True; 160 return True;
164 } 161 }
165 162
166 Bool 163 Bool
167 SDL_NAME(XF86VidModeSetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma) 164 SDL_NAME (XF86VidModeSetGamma) (Display * dpy, int screen,
168 { 165 SDL_NAME (XF86VidModeGamma) * Gamma)
169 XExtDisplayInfo *info = find_display(dpy); 166 {
167 XExtDisplayInfo *info = find_display (dpy);
170 xXF86VidModeSetGammaReq *req; 168 xXF86VidModeSetGammaReq *req;
171 169
172 XF86VidModeCheckExtension(dpy, info, False); 170 XF86VidModeCheckExtension (dpy, info, False);
173 171
174 LockDisplay(dpy); 172 LockDisplay (dpy);
175 GetReq(XF86VidModeSetGamma, req); 173 GetReq (XF86VidModeSetGamma, req);
176 req->reqType = info->codes->major_opcode; 174 req->reqType = info->codes->major_opcode;
177 req->xf86vidmodeReqType = X_XF86VidModeSetGamma; 175 req->xf86vidmodeReqType = X_XF86VidModeSetGamma;
178 req->screen = screen; 176 req->screen = screen;
179 req->red = (CARD32)(Gamma->red * 10000.); 177 req->red = (CARD32) (Gamma->red * 10000.);
180 req->green = (CARD32)(Gamma->green * 10000.); 178 req->green = (CARD32) (Gamma->green * 10000.);
181 req->blue = (CARD32)(Gamma->blue * 10000.); 179 req->blue = (CARD32) (Gamma->blue * 10000.);
182 UnlockDisplay(dpy); 180 UnlockDisplay (dpy);
183 SyncHandle(); 181 SyncHandle ();
184 return True; 182 return True;
185 } 183 }
186 184
187 Bool 185 Bool
188 SDL_NAME(XF86VidModeGetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma) 186 SDL_NAME (XF86VidModeGetGamma) (Display * dpy, int screen,
187 SDL_NAME (XF86VidModeGamma) * Gamma)
189 { 188 {
190 XExtDisplayInfo *info = find_display (dpy); 189 XExtDisplayInfo *info = find_display (dpy);
191 xXF86VidModeGetGammaReply rep; 190 xXF86VidModeGetGammaReply rep;
192 xXF86VidModeGetGammaReq *req; 191 xXF86VidModeGetGammaReq *req;
193 192
194 XF86VidModeCheckExtension (dpy, info, False); 193 XF86VidModeCheckExtension (dpy, info, False);
195 194
196 LockDisplay(dpy); 195 LockDisplay (dpy);
197 GetReq(XF86VidModeGetGamma, req); 196 GetReq (XF86VidModeGetGamma, req);
198 req->reqType = info->codes->major_opcode; 197 req->reqType = info->codes->major_opcode;
199 req->xf86vidmodeReqType = X_XF86VidModeGetGamma; 198 req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
200 req->screen = screen; 199 req->screen = screen;
201 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 200 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
202 UnlockDisplay(dpy); 201 UnlockDisplay (dpy);
203 SyncHandle(); 202 SyncHandle ();
204 return False; 203 return False;
205 } 204 }
206 Gamma->red = ((float)rep.red) / 10000.; 205 Gamma->red = ((float) rep.red) / 10000.;
207 Gamma->green = ((float)rep.green) / 10000.; 206 Gamma->green = ((float) rep.green) / 10000.;
208 Gamma->blue = ((float)rep.blue) / 10000.; 207 Gamma->blue = ((float) rep.blue) / 10000.;
209 UnlockDisplay(dpy); 208 UnlockDisplay (dpy);
210 SyncHandle(); 209 SyncHandle ();
211 return True; 210 return True;
212 } 211 }
213 212
214 Bool 213 Bool SDL_NAME (XF86VidModeGetModeLine) (dpy, screen, dotclock, modeline)
215 SDL_NAME(XF86VidModeGetModeLine)(dpy, screen, dotclock, modeline) 214 Display *
216 Display* dpy; 215 dpy;
217 int screen; 216 int
218 int* dotclock; 217 screen;
219 SDL_NAME(XF86VidModeModeLine)* modeline; 218 int *
219 dotclock;
220 SDL_NAME (XF86VidModeModeLine) * modeline;
220 { 221 {
221 XExtDisplayInfo *info = find_display (dpy); 222 XExtDisplayInfo *info = find_display (dpy);
222 xXF86VidModeGetModeLineReply rep; 223 xXF86VidModeGetModeLineReply rep;
223 xXF86OldVidModeGetModeLineReply oldrep; 224 xXF86OldVidModeGetModeLineReply oldrep;
224 xXF86VidModeGetModeLineReq *req; 225 xXF86VidModeGetModeLineReq *req;
225 int majorVersion, minorVersion; 226 int majorVersion, minorVersion;
226 227
227 XF86VidModeCheckExtension (dpy, info, False); 228 XF86VidModeCheckExtension (dpy, info, False);
228 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 229 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
229 230
230 LockDisplay(dpy); 231 LockDisplay (dpy);
231 GetReq(XF86VidModeGetModeLine, req); 232 GetReq (XF86VidModeGetModeLine, req);
232 req->reqType = info->codes->major_opcode; 233 req->reqType = info->codes->major_opcode;
233 req->xf86vidmodeReqType = X_XF86VidModeGetModeLine; 234 req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
234 req->screen = screen; 235 req->screen = screen;
235 236
236 if (majorVersion < 2) { 237 if (majorVersion < 2) {
237 if (!_XReply(dpy, (xReply *)&oldrep, 238 if (!_XReply (dpy, (xReply *) & oldrep,
238 (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) { 239 (SIZEOF (xXF86OldVidModeGetModeLineReply) -
239 UnlockDisplay(dpy); 240 SIZEOF (xReply)) >> 2, xFalse)) {
240 SyncHandle(); 241 UnlockDisplay (dpy);
241 return False; 242 SyncHandle ();
242 } 243 return False;
243 *dotclock = oldrep.dotclock; 244 }
244 modeline->hdisplay = oldrep.hdisplay; 245 *dotclock = oldrep.dotclock;
245 modeline->hsyncstart = oldrep.hsyncstart; 246 modeline->hdisplay = oldrep.hdisplay;
246 modeline->hsyncend = oldrep.hsyncend; 247 modeline->hsyncstart = oldrep.hsyncstart;
247 modeline->htotal = oldrep.htotal; 248 modeline->hsyncend = oldrep.hsyncend;
248 modeline->hskew = 0; 249 modeline->htotal = oldrep.htotal;
249 modeline->vdisplay = oldrep.vdisplay; 250 modeline->hskew = 0;
250 modeline->vsyncstart = oldrep.vsyncstart; 251 modeline->vdisplay = oldrep.vdisplay;
251 modeline->vsyncend = oldrep.vsyncend; 252 modeline->vsyncstart = oldrep.vsyncstart;
252 modeline->vtotal = oldrep.vtotal; 253 modeline->vsyncend = oldrep.vsyncend;
253 modeline->flags = oldrep.flags; 254 modeline->vtotal = oldrep.vtotal;
254 modeline->privsize = oldrep.privsize; 255 modeline->flags = oldrep.flags;
256 modeline->privsize = oldrep.privsize;
255 } else { 257 } else {
256 if (!_XReply(dpy, (xReply *)&rep, 258 if (!_XReply (dpy, (xReply *) & rep,
257 (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) { 259 (SIZEOF (xXF86VidModeGetModeLineReply) -
258 UnlockDisplay(dpy); 260 SIZEOF (xReply)) >> 2, xFalse)) {
259 SyncHandle(); 261 UnlockDisplay (dpy);
260 return False; 262 SyncHandle ();
261 } 263 return False;
262 *dotclock = rep.dotclock; 264 }
263 modeline->hdisplay = rep.hdisplay; 265 *dotclock = rep.dotclock;
264 modeline->hsyncstart = rep.hsyncstart; 266 modeline->hdisplay = rep.hdisplay;
265 modeline->hsyncend = rep.hsyncend; 267 modeline->hsyncstart = rep.hsyncstart;
266 modeline->htotal = rep.htotal; 268 modeline->hsyncend = rep.hsyncend;
267 modeline->hskew = rep.hskew; 269 modeline->htotal = rep.htotal;
268 modeline->vdisplay = rep.vdisplay; 270 modeline->hskew = rep.hskew;
269 modeline->vsyncstart = rep.vsyncstart; 271 modeline->vdisplay = rep.vdisplay;
270 modeline->vsyncend = rep.vsyncend; 272 modeline->vsyncstart = rep.vsyncstart;
271 modeline->vtotal = rep.vtotal; 273 modeline->vsyncend = rep.vsyncend;
272 modeline->flags = rep.flags; 274 modeline->vtotal = rep.vtotal;
273 modeline->privsize = rep.privsize; 275 modeline->flags = rep.flags;
274 } 276 modeline->privsize = rep.privsize;
275 277 }
278
276 if (modeline->privsize > 0) { 279 if (modeline->privsize > 0) {
277 if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) { 280 if (!
278 _XEatData(dpy, (modeline->privsize) * sizeof(INT32)); 281 (modeline->private =
279 Xfree(modeline->private); 282 Xcalloc (modeline->privsize, sizeof (INT32)))) {
280 return False; 283 _XEatData (dpy, (modeline->privsize) * sizeof (INT32));
281 } 284 Xfree (modeline->private);
282 _XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32)); 285 return False;
286 }
287 _XRead (dpy, (char *) modeline->private,
288 modeline->privsize * sizeof (INT32));
283 } else { 289 } else {
284 modeline->private = NULL; 290 modeline->private = NULL;
285 } 291 }
286 UnlockDisplay(dpy); 292 UnlockDisplay (dpy);
287 SyncHandle(); 293 SyncHandle ();
288 return True; 294 return True;
289 } 295 }
290 296
291 Bool 297 Bool
292 SDL_NAME(XF86VidModeGetAllModeLines)(dpy, screen, modecount, modelinesPtr) 298 SDL_NAME (XF86VidModeGetAllModeLines) (dpy, screen, modecount, modelinesPtr)
293 Display* dpy; 299 Display *dpy;
294 int screen; 300 int screen;
295 int* modecount; 301 int *modecount;
296 SDL_NAME(XF86VidModeModeInfo) ***modelinesPtr; 302 SDL_NAME (XF86VidModeModeInfo) *** modelinesPtr;
297 { 303 {
298 XExtDisplayInfo *info = find_display (dpy); 304 XExtDisplayInfo *info = find_display (dpy);
299 xXF86VidModeGetAllModeLinesReply rep; 305 xXF86VidModeGetAllModeLinesReply rep;
300 xXF86VidModeGetAllModeLinesReq *req; 306 xXF86VidModeGetAllModeLinesReq *req;
301 SDL_NAME(XF86VidModeModeInfo) *mdinfptr, **modelines; 307 SDL_NAME (XF86VidModeModeInfo) * mdinfptr, **modelines;
302 xXF86VidModeModeInfo xmdline; 308 xXF86VidModeModeInfo xmdline;
303 xXF86OldVidModeModeInfo oldxmdline; 309 xXF86OldVidModeModeInfo oldxmdline;
304 int i; 310 int i;
305 int majorVersion, minorVersion; 311 int majorVersion, minorVersion;
306 Bool protocolBug = False; 312 Bool protocolBug = False;
311 * Note: There was a bug in the protocol implementation in versions 317 * Note: There was a bug in the protocol implementation in versions
312 * 0.x with x < 8 (the .private field wasn't being passed over the wire). 318 * 0.x with x < 8 (the .private field wasn't being passed over the wire).
313 * Check the server's version, and accept the old format if appropriate. 319 * Check the server's version, and accept the old format if appropriate.
314 */ 320 */
315 321
316 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 322 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
317 if (majorVersion == 0 && minorVersion < 8) { 323 if (majorVersion == 0 && minorVersion < 8) {
318 protocolBug = True; 324 protocolBug = True;
319 #ifdef DEBUG 325 #ifdef DEBUG
320 fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is" 326 fprintf (stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
321 "running an old version (%d.%d)\n", majorVersion, 327 "running an old version (%d.%d)\n", majorVersion,
322 minorVersion); 328 minorVersion);
323 #endif 329 #endif
324 } 330 }
325 331
326 LockDisplay(dpy); 332 LockDisplay (dpy);
327 GetReq(XF86VidModeGetAllModeLines, req); 333 GetReq (XF86VidModeGetAllModeLines, req);
328 req->reqType = info->codes->major_opcode; 334 req->reqType = info->codes->major_opcode;
329 req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines; 335 req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
330 req->screen = screen; 336 req->screen = screen;
331 if (!_XReply(dpy, (xReply *)&rep, 337 if (!_XReply (dpy, (xReply *) & rep,
332 (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) { 338 (SIZEOF (xXF86VidModeGetAllModeLinesReply) -
333 UnlockDisplay(dpy); 339 SIZEOF (xReply)) >> 2, xFalse)) {
334 SyncHandle(); 340 UnlockDisplay (dpy);
335 return False; 341 SyncHandle ();
342 return False;
336 } 343 }
337 344
338 *modecount = rep.modecount; 345 *modecount = rep.modecount;
339 346
340 if (!(modelines = (SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount, 347 if (!
341 sizeof(SDL_NAME(XF86VidModeModeInfo) *) 348 (modelines =
342 +sizeof(SDL_NAME(XF86VidModeModeInfo))))) { 349 (SDL_NAME (XF86VidModeModeInfo) **) Xcalloc (rep.modecount,
343 if (majorVersion < 2) 350 sizeof (SDL_NAME
344 _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo)); 351 (XF86VidModeModeInfo)
345 else 352 *) +
346 _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo)); 353 sizeof (SDL_NAME
347 Xfree(modelines); 354 (XF86VidModeModeInfo)))))
348 UnlockDisplay(dpy); 355 {
349 SyncHandle(); 356 if (majorVersion < 2)
357 _XEatData (dpy,
358 (rep.modecount) * sizeof (xXF86OldVidModeModeInfo));
359 else
360 _XEatData (dpy, (rep.modecount) * sizeof (xXF86VidModeModeInfo));
361 Xfree (modelines);
362 UnlockDisplay (dpy);
363 SyncHandle ();
350 return False; 364 return False;
351 } 365 }
352 mdinfptr = (SDL_NAME(XF86VidModeModeInfo) *) ( 366 mdinfptr = (SDL_NAME (XF86VidModeModeInfo) *) ((char *) modelines
353 (char *) modelines 367 +
354 + rep.modecount*sizeof(SDL_NAME(XF86VidModeModeInfo) *) 368 rep.modecount *
355 ); 369 sizeof (SDL_NAME
370 (XF86VidModeModeInfo)
371 *));
356 372
357 for (i = 0; i < rep.modecount; i++) { 373 for (i = 0; i < rep.modecount; i++) {
358 modelines[i] = mdinfptr++; 374 modelines[i] = mdinfptr++;
359 if (majorVersion < 2) { 375 if (majorVersion < 2) {
360 _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo)); 376 _XRead (dpy, (char *) &oldxmdline,
361 modelines[i]->dotclock = oldxmdline.dotclock; 377 sizeof (xXF86OldVidModeModeInfo));
362 modelines[i]->hdisplay = oldxmdline.hdisplay; 378 modelines[i]->dotclock = oldxmdline.dotclock;
363 modelines[i]->hsyncstart = oldxmdline.hsyncstart; 379 modelines[i]->hdisplay = oldxmdline.hdisplay;
364 modelines[i]->hsyncend = oldxmdline.hsyncend; 380 modelines[i]->hsyncstart = oldxmdline.hsyncstart;
365 modelines[i]->htotal = oldxmdline.htotal; 381 modelines[i]->hsyncend = oldxmdline.hsyncend;
366 modelines[i]->hskew = 0; 382 modelines[i]->htotal = oldxmdline.htotal;
367 modelines[i]->vdisplay = oldxmdline.vdisplay; 383 modelines[i]->hskew = 0;
368 modelines[i]->vsyncstart = oldxmdline.vsyncstart; 384 modelines[i]->vdisplay = oldxmdline.vdisplay;
369 modelines[i]->vsyncend = oldxmdline.vsyncend; 385 modelines[i]->vsyncstart = oldxmdline.vsyncstart;
370 modelines[i]->vtotal = oldxmdline.vtotal; 386 modelines[i]->vsyncend = oldxmdline.vsyncend;
371 modelines[i]->flags = oldxmdline.flags; 387 modelines[i]->vtotal = oldxmdline.vtotal;
372 if (protocolBug) { 388 modelines[i]->flags = oldxmdline.flags;
373 modelines[i]->privsize = 0; 389 if (protocolBug) {
374 modelines[i]->private = NULL; 390 modelines[i]->privsize = 0;
375 } else { 391 modelines[i]->private = NULL;
376 modelines[i]->privsize = oldxmdline.privsize; 392 } else {
377 if (oldxmdline.privsize > 0) { 393 modelines[i]->privsize = oldxmdline.privsize;
378 if (!(modelines[i]->private = 394 if (oldxmdline.privsize > 0) {
379 Xcalloc(oldxmdline.privsize, sizeof(INT32)))) { 395 if (!(modelines[i]->private =
380 _XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32)); 396 Xcalloc (oldxmdline.privsize, sizeof (INT32)))) {
381 Xfree(modelines[i]->private); 397 _XEatData (dpy,
382 } else { 398 (oldxmdline.privsize) * sizeof (INT32));
383 _XRead(dpy, (char*)modelines[i]->private, 399 Xfree (modelines[i]->private);
384 oldxmdline.privsize * sizeof(INT32)); 400 } else {
385 } 401 _XRead (dpy, (char *) modelines[i]->private,
386 } else { 402 oldxmdline.privsize * sizeof (INT32));
387 modelines[i]->private = NULL; 403 }
388 } 404 } else {
389 } 405 modelines[i]->private = NULL;
390 } else { 406 }
391 _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo)); 407 }
392 modelines[i]->dotclock = xmdline.dotclock; 408 } else {
393 modelines[i]->hdisplay = xmdline.hdisplay; 409 _XRead (dpy, (char *) &xmdline, sizeof (xXF86VidModeModeInfo));
394 modelines[i]->hsyncstart = xmdline.hsyncstart; 410 modelines[i]->dotclock = xmdline.dotclock;
395 modelines[i]->hsyncend = xmdline.hsyncend; 411 modelines[i]->hdisplay = xmdline.hdisplay;
396 modelines[i]->htotal = xmdline.htotal; 412 modelines[i]->hsyncstart = xmdline.hsyncstart;
397 modelines[i]->hskew = xmdline.hskew; 413 modelines[i]->hsyncend = xmdline.hsyncend;
398 modelines[i]->vdisplay = xmdline.vdisplay; 414 modelines[i]->htotal = xmdline.htotal;
399 modelines[i]->vsyncstart = xmdline.vsyncstart; 415 modelines[i]->hskew = xmdline.hskew;
400 modelines[i]->vsyncend = xmdline.vsyncend; 416 modelines[i]->vdisplay = xmdline.vdisplay;
401 modelines[i]->vtotal = xmdline.vtotal; 417 modelines[i]->vsyncstart = xmdline.vsyncstart;
402 modelines[i]->flags = xmdline.flags; 418 modelines[i]->vsyncend = xmdline.vsyncend;
403 if (protocolBug) { 419 modelines[i]->vtotal = xmdline.vtotal;
404 modelines[i]->privsize = 0; 420 modelines[i]->flags = xmdline.flags;
405 modelines[i]->private = NULL; 421 if (protocolBug) {
406 } else { 422 modelines[i]->privsize = 0;
407 modelines[i]->privsize = xmdline.privsize; 423 modelines[i]->private = NULL;
408 if (xmdline.privsize > 0) { 424 } else {
409 if (!(modelines[i]->private = 425 modelines[i]->privsize = xmdline.privsize;
410 Xcalloc(xmdline.privsize, sizeof(INT32)))) { 426 if (xmdline.privsize > 0) {
411 _XEatData(dpy, (xmdline.privsize) * sizeof(INT32)); 427 if (!(modelines[i]->private =
412 Xfree(modelines[i]->private); 428 Xcalloc (xmdline.privsize, sizeof (INT32)))) {
413 } else { 429 _XEatData (dpy, (xmdline.privsize) * sizeof (INT32));
414 _XRead(dpy, (char*)modelines[i]->private, 430 Xfree (modelines[i]->private);
415 xmdline.privsize * sizeof(INT32)); 431 } else {
416 } 432 _XRead (dpy, (char *) modelines[i]->private,
417 } else { 433 xmdline.privsize * sizeof (INT32));
418 modelines[i]->private = NULL; 434 }
419 } 435 } else {
420 } 436 modelines[i]->private = NULL;
421 } 437 }
438 }
439 }
422 } 440 }
423 *modelinesPtr = modelines; 441 *modelinesPtr = modelines;
424 UnlockDisplay(dpy); 442 UnlockDisplay (dpy);
425 SyncHandle(); 443 SyncHandle ();
426 return True; 444 return True;
427 } 445 }
428 446
429 /* 447 /*
430 * GetReq replacement for use with VidMode protocols earlier than 2.0 448 * GetReq replacement for use with VidMode protocols earlier than 2.0
438 req->reqType = X_##name;\ 456 req->reqType = X_##name;\
439 req->length = (SIZEOF(x##oldname##Req))>>2;\ 457 req->length = (SIZEOF(x##oldname##Req))>>2;\
440 dpy->bufptr += SIZEOF(x##oldname##Req);\ 458 dpy->bufptr += SIZEOF(x##oldname##Req);\
441 dpy->request++ 459 dpy->request++
442 460
443 #else /* non-ANSI C uses empty comment instead of "##" for token concatenation */ 461 #else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
444 #define GetOldReq(name, oldname, req) \ 462 #define GetOldReq(name, oldname, req) \
445 WORD64ALIGN\ 463 WORD64ALIGN\
446 if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\ 464 if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\
447 _XFlush(dpy);\ 465 _XFlush(dpy);\
448 req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\ 466 req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\
451 dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\ 469 dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\
452 dpy->request++ 470 dpy->request++
453 #endif 471 #endif
454 472
455 Bool 473 Bool
456 SDL_NAME(XF86VidModeAddModeLine) (dpy, screen, newmodeline, aftermodeline) 474 SDL_NAME (XF86VidModeAddModeLine) (dpy, screen, newmodeline, aftermodeline)
457 Display *dpy; 475 Display *dpy;
458 int screen; 476 int screen;
459 SDL_NAME(XF86VidModeModeInfo)* newmodeline; 477 SDL_NAME (XF86VidModeModeInfo) * newmodeline;
460 SDL_NAME(XF86VidModeModeInfo)* aftermodeline; 478 SDL_NAME (XF86VidModeModeInfo) * aftermodeline;
461 { 479 {
462 XExtDisplayInfo *info = find_display (dpy); 480 XExtDisplayInfo *info = find_display (dpy);
463 xXF86VidModeAddModeLineReq *req; 481 xXF86VidModeAddModeLineReq *req;
464 xXF86OldVidModeAddModeLineReq *oldreq; 482 xXF86OldVidModeAddModeLineReq *oldreq;
465 int majorVersion, minorVersion; 483 int majorVersion, minorVersion;
466 484
467 XF86VidModeCheckExtension (dpy, info, False); 485 XF86VidModeCheckExtension (dpy, info, False);
468 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 486 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
469 487
470 LockDisplay(dpy); 488 LockDisplay (dpy);
471 if (majorVersion < 2) { 489 if (majorVersion < 2) {
472 GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq); 490 GetOldReq (XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq);
473 oldreq->reqType = info->codes->major_opcode; 491 oldreq->reqType = info->codes->major_opcode;
474 oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine; 492 oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
475 oldreq->screen = screen; 493 oldreq->screen = screen;
476 oldreq->dotclock = newmodeline->dotclock; 494 oldreq->dotclock = newmodeline->dotclock;
477 oldreq->hdisplay = newmodeline->hdisplay; 495 oldreq->hdisplay = newmodeline->hdisplay;
478 oldreq->hsyncstart = newmodeline->hsyncstart; 496 oldreq->hsyncstart = newmodeline->hsyncstart;
479 oldreq->hsyncend = newmodeline->hsyncend; 497 oldreq->hsyncend = newmodeline->hsyncend;
480 oldreq->htotal = newmodeline->htotal; 498 oldreq->htotal = newmodeline->htotal;
481 oldreq->vdisplay = newmodeline->vdisplay; 499 oldreq->vdisplay = newmodeline->vdisplay;
482 oldreq->vsyncstart = newmodeline->vsyncstart; 500 oldreq->vsyncstart = newmodeline->vsyncstart;
483 oldreq->vsyncend = newmodeline->vsyncend; 501 oldreq->vsyncend = newmodeline->vsyncend;
484 oldreq->vtotal = newmodeline->vtotal; 502 oldreq->vtotal = newmodeline->vtotal;
485 oldreq->flags = newmodeline->flags; 503 oldreq->flags = newmodeline->flags;
486 oldreq->privsize = newmodeline->privsize; 504 oldreq->privsize = newmodeline->privsize;
487 if (aftermodeline != NULL) { 505 if (aftermodeline != NULL) {
488 oldreq->after_dotclock = aftermodeline->dotclock; 506 oldreq->after_dotclock = aftermodeline->dotclock;
489 oldreq->after_hdisplay = aftermodeline->hdisplay; 507 oldreq->after_hdisplay = aftermodeline->hdisplay;
490 oldreq->after_hsyncstart = aftermodeline->hsyncstart; 508 oldreq->after_hsyncstart = aftermodeline->hsyncstart;
491 oldreq->after_hsyncend = aftermodeline->hsyncend; 509 oldreq->after_hsyncend = aftermodeline->hsyncend;
492 oldreq->after_htotal = aftermodeline->htotal; 510 oldreq->after_htotal = aftermodeline->htotal;
493 oldreq->after_vdisplay = aftermodeline->vdisplay; 511 oldreq->after_vdisplay = aftermodeline->vdisplay;
494 oldreq->after_vsyncstart = aftermodeline->vsyncstart; 512 oldreq->after_vsyncstart = aftermodeline->vsyncstart;
495 oldreq->after_vsyncend = aftermodeline->vsyncend; 513 oldreq->after_vsyncend = aftermodeline->vsyncend;
496 oldreq->after_vtotal = aftermodeline->vtotal; 514 oldreq->after_vtotal = aftermodeline->vtotal;
497 oldreq->after_flags = aftermodeline->flags; 515 oldreq->after_flags = aftermodeline->flags;
498 } else { 516 } else {
499 oldreq->after_dotclock = 0; 517 oldreq->after_dotclock = 0;
500 oldreq->after_hdisplay = 0; 518 oldreq->after_hdisplay = 0;
501 oldreq->after_hsyncstart = 0; 519 oldreq->after_hsyncstart = 0;
502 oldreq->after_hsyncend = 0; 520 oldreq->after_hsyncend = 0;
503 oldreq->after_htotal = 0; 521 oldreq->after_htotal = 0;
504 oldreq->after_vdisplay = 0; 522 oldreq->after_vdisplay = 0;
505 oldreq->after_vsyncstart = 0; 523 oldreq->after_vsyncstart = 0;
506 oldreq->after_vsyncend = 0; 524 oldreq->after_vsyncend = 0;
507 oldreq->after_vtotal = 0; 525 oldreq->after_vtotal = 0;
508 oldreq->after_flags = 0; 526 oldreq->after_flags = 0;
509 } 527 }
510 if (newmodeline->privsize) { 528 if (newmodeline->privsize) {
511 oldreq->length += newmodeline->privsize; 529 oldreq->length += newmodeline->privsize;
512 Data32(dpy, (long *) newmodeline->private, 530 Data32 (dpy, (long *) newmodeline->private,
513 newmodeline->privsize * sizeof(INT32)); 531 newmodeline->privsize * sizeof (INT32));
514 } 532 }
515 } else { 533 } else {
516 GetReq(XF86VidModeAddModeLine, req); 534 GetReq (XF86VidModeAddModeLine, req);
517 req->reqType = info->codes->major_opcode; 535 req->reqType = info->codes->major_opcode;
518 req->xf86vidmodeReqType = X_XF86VidModeAddModeLine; 536 req->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
519 req->screen = screen; 537 req->screen = screen;
520 req->dotclock = newmodeline->dotclock; 538 req->dotclock = newmodeline->dotclock;
521 req->hdisplay = newmodeline->hdisplay; 539 req->hdisplay = newmodeline->hdisplay;
522 req->hsyncstart = newmodeline->hsyncstart; 540 req->hsyncstart = newmodeline->hsyncstart;
523 req->hsyncend = newmodeline->hsyncend; 541 req->hsyncend = newmodeline->hsyncend;
524 req->htotal = newmodeline->htotal; 542 req->htotal = newmodeline->htotal;
525 req->hskew = newmodeline->hskew; 543 req->hskew = newmodeline->hskew;
526 req->vdisplay = newmodeline->vdisplay; 544 req->vdisplay = newmodeline->vdisplay;
527 req->vsyncstart = newmodeline->vsyncstart; 545 req->vsyncstart = newmodeline->vsyncstart;
528 req->vsyncend = newmodeline->vsyncend; 546 req->vsyncend = newmodeline->vsyncend;
529 req->vtotal = newmodeline->vtotal; 547 req->vtotal = newmodeline->vtotal;
530 req->flags = newmodeline->flags; 548 req->flags = newmodeline->flags;
531 req->privsize = newmodeline->privsize; 549 req->privsize = newmodeline->privsize;
532 if (aftermodeline != NULL) { 550 if (aftermodeline != NULL) {
533 req->after_dotclock = aftermodeline->dotclock; 551 req->after_dotclock = aftermodeline->dotclock;
534 req->after_hdisplay = aftermodeline->hdisplay; 552 req->after_hdisplay = aftermodeline->hdisplay;
535 req->after_hsyncstart = aftermodeline->hsyncstart; 553 req->after_hsyncstart = aftermodeline->hsyncstart;
536 req->after_hsyncend = aftermodeline->hsyncend; 554 req->after_hsyncend = aftermodeline->hsyncend;
537 req->after_htotal = aftermodeline->htotal; 555 req->after_htotal = aftermodeline->htotal;
538 req->after_hskew = aftermodeline->hskew; 556 req->after_hskew = aftermodeline->hskew;
539 req->after_vdisplay = aftermodeline->vdisplay; 557 req->after_vdisplay = aftermodeline->vdisplay;
540 req->after_vsyncstart = aftermodeline->vsyncstart; 558 req->after_vsyncstart = aftermodeline->vsyncstart;
541 req->after_vsyncend = aftermodeline->vsyncend; 559 req->after_vsyncend = aftermodeline->vsyncend;
542 req->after_vtotal = aftermodeline->vtotal; 560 req->after_vtotal = aftermodeline->vtotal;
543 req->after_flags = aftermodeline->flags; 561 req->after_flags = aftermodeline->flags;
544 } else { 562 } else {
545 req->after_dotclock = 0; 563 req->after_dotclock = 0;
546 req->after_hdisplay = 0; 564 req->after_hdisplay = 0;
547 req->after_hsyncstart = 0; 565 req->after_hsyncstart = 0;
548 req->after_hsyncend = 0; 566 req->after_hsyncend = 0;
549 req->after_htotal = 0; 567 req->after_htotal = 0;
550 req->after_hskew = 0; 568 req->after_hskew = 0;
551 req->after_vdisplay = 0; 569 req->after_vdisplay = 0;
552 req->after_vsyncstart = 0; 570 req->after_vsyncstart = 0;
553 req->after_vsyncend = 0; 571 req->after_vsyncend = 0;
554 req->after_vtotal = 0; 572 req->after_vtotal = 0;
555 req->after_flags = 0; 573 req->after_flags = 0;
556 } 574 }
557 if (newmodeline->privsize) { 575 if (newmodeline->privsize) {
558 req->length += newmodeline->privsize; 576 req->length += newmodeline->privsize;
559 Data32(dpy, (long *) newmodeline->private, 577 Data32 (dpy, (long *) newmodeline->private,
560 newmodeline->privsize * sizeof(INT32)); 578 newmodeline->privsize * sizeof (INT32));
561 } 579 }
562 } 580 }
563 UnlockDisplay(dpy); 581 UnlockDisplay (dpy);
564 SyncHandle(); 582 SyncHandle ();
565 return True; 583 return True;
566 } 584 }
567 585
568 Bool 586 Bool SDL_NAME (XF86VidModeDeleteModeLine) (dpy, screen, modeline)
569 SDL_NAME(XF86VidModeDeleteModeLine) (dpy, screen, modeline) 587 Display *
570 Display *dpy; 588 dpy;
571 int screen; 589 int
572 SDL_NAME(XF86VidModeModeInfo)* modeline; 590 screen;
591 SDL_NAME (XF86VidModeModeInfo) * modeline;
573 { 592 {
574 XExtDisplayInfo *info = find_display (dpy); 593 XExtDisplayInfo *info = find_display (dpy);
575 xXF86VidModeDeleteModeLineReq *req; 594 xXF86VidModeDeleteModeLineReq *req;
576 xXF86OldVidModeDeleteModeLineReq *oldreq; 595 xXF86OldVidModeDeleteModeLineReq *oldreq;
577 int majorVersion, minorVersion; 596 int majorVersion, minorVersion;
578 597
579 XF86VidModeCheckExtension (dpy, info, 0); 598 XF86VidModeCheckExtension (dpy, info, 0);
580 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 599 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
581 600
582 LockDisplay(dpy); 601 LockDisplay (dpy);
583 if (majorVersion < 2) { 602 if (majorVersion < 2) {
584 GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine, oldreq); 603 GetOldReq (XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine,
585 oldreq->reqType = info->codes->major_opcode; 604 oldreq);
586 oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine; 605 oldreq->reqType = info->codes->major_opcode;
587 oldreq->screen = screen; 606 oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
588 oldreq->dotclock = modeline->dotclock; 607 oldreq->screen = screen;
589 oldreq->hdisplay = modeline->hdisplay; 608 oldreq->dotclock = modeline->dotclock;
590 oldreq->hsyncstart = modeline->hsyncstart; 609 oldreq->hdisplay = modeline->hdisplay;
591 oldreq->hsyncend = modeline->hsyncend; 610 oldreq->hsyncstart = modeline->hsyncstart;
592 oldreq->htotal = modeline->htotal; 611 oldreq->hsyncend = modeline->hsyncend;
593 oldreq->vdisplay = modeline->vdisplay; 612 oldreq->htotal = modeline->htotal;
594 oldreq->vsyncstart = modeline->vsyncstart; 613 oldreq->vdisplay = modeline->vdisplay;
595 oldreq->vsyncend = modeline->vsyncend; 614 oldreq->vsyncstart = modeline->vsyncstart;
596 oldreq->vtotal = modeline->vtotal; 615 oldreq->vsyncend = modeline->vsyncend;
597 oldreq->flags = modeline->flags; 616 oldreq->vtotal = modeline->vtotal;
598 oldreq->privsize = modeline->privsize; 617 oldreq->flags = modeline->flags;
599 if (modeline->privsize) { 618 oldreq->privsize = modeline->privsize;
600 oldreq->length += modeline->privsize; 619 if (modeline->privsize) {
601 Data32(dpy, (long *) modeline->private, 620 oldreq->length += modeline->privsize;
602 modeline->privsize * sizeof(INT32)); 621 Data32 (dpy, (long *) modeline->private,
603 } 622 modeline->privsize * sizeof (INT32));
623 }
604 } else { 624 } else {
605 GetReq(XF86VidModeDeleteModeLine, req); 625 GetReq (XF86VidModeDeleteModeLine, req);
606 req->reqType = info->codes->major_opcode; 626 req->reqType = info->codes->major_opcode;
607 req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine; 627 req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
608 req->screen = screen; 628 req->screen = screen;
609 req->dotclock = modeline->dotclock; 629 req->dotclock = modeline->dotclock;
610 req->hdisplay = modeline->hdisplay; 630 req->hdisplay = modeline->hdisplay;
611 req->hsyncstart = modeline->hsyncstart; 631 req->hsyncstart = modeline->hsyncstart;
612 req->hsyncend = modeline->hsyncend; 632 req->hsyncend = modeline->hsyncend;
613 req->htotal = modeline->htotal; 633 req->htotal = modeline->htotal;
614 req->hskew = modeline->hskew; 634 req->hskew = modeline->hskew;
615 req->vdisplay = modeline->vdisplay; 635 req->vdisplay = modeline->vdisplay;
616 req->vsyncstart = modeline->vsyncstart; 636 req->vsyncstart = modeline->vsyncstart;
617 req->vsyncend = modeline->vsyncend; 637 req->vsyncend = modeline->vsyncend;
618 req->vtotal = modeline->vtotal; 638 req->vtotal = modeline->vtotal;
619 req->flags = modeline->flags; 639 req->flags = modeline->flags;
620 req->privsize = modeline->privsize; 640 req->privsize = modeline->privsize;
621 if (modeline->privsize) { 641 if (modeline->privsize) {
622 req->length += modeline->privsize; 642 req->length += modeline->privsize;
623 Data32(dpy, (long *) modeline->private, 643 Data32 (dpy, (long *) modeline->private,
624 modeline->privsize * sizeof(INT32)); 644 modeline->privsize * sizeof (INT32));
625 } 645 }
626 } 646 }
627 UnlockDisplay(dpy); 647 UnlockDisplay (dpy);
628 SyncHandle(); 648 SyncHandle ();
629 return True; 649 return True;
630 } 650 }
631 651
632 Bool 652 Bool SDL_NAME (XF86VidModeModModeLine) (dpy, screen, modeline)
633 SDL_NAME(XF86VidModeModModeLine) (dpy, screen, modeline) 653 Display *
634 Display *dpy; 654 dpy;
635 int screen; 655 int
636 SDL_NAME(XF86VidModeModeLine)* modeline; 656 screen;
657 SDL_NAME (XF86VidModeModeLine) * modeline;
637 { 658 {
638 XExtDisplayInfo *info = find_display (dpy); 659 XExtDisplayInfo *info = find_display (dpy);
639 xXF86VidModeModModeLineReq *req; 660 xXF86VidModeModModeLineReq *req;
640 xXF86OldVidModeModModeLineReq *oldreq; 661 xXF86OldVidModeModModeLineReq *oldreq;
641 int majorVersion, minorVersion; 662 int majorVersion, minorVersion;
642 663
643 XF86VidModeCheckExtension (dpy, info, 0); 664 XF86VidModeCheckExtension (dpy, info, 0);
644 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 665 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
645 666
646 LockDisplay(dpy); 667 LockDisplay (dpy);
647 if (majorVersion < 2) { 668 if (majorVersion < 2) {
648 GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq); 669 GetOldReq (XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq);
649 oldreq->reqType = info->codes->major_opcode; 670 oldreq->reqType = info->codes->major_opcode;
650 oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine; 671 oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine;
651 oldreq->screen = screen; 672 oldreq->screen = screen;
652 oldreq->hdisplay = modeline->hdisplay; 673 oldreq->hdisplay = modeline->hdisplay;
653 oldreq->hsyncstart = modeline->hsyncstart; 674 oldreq->hsyncstart = modeline->hsyncstart;
654 oldreq->hsyncend = modeline->hsyncend; 675 oldreq->hsyncend = modeline->hsyncend;
655 oldreq->htotal = modeline->htotal; 676 oldreq->htotal = modeline->htotal;
656 oldreq->vdisplay = modeline->vdisplay; 677 oldreq->vdisplay = modeline->vdisplay;
657 oldreq->vsyncstart = modeline->vsyncstart; 678 oldreq->vsyncstart = modeline->vsyncstart;
658 oldreq->vsyncend = modeline->vsyncend; 679 oldreq->vsyncend = modeline->vsyncend;
659 oldreq->vtotal = modeline->vtotal; 680 oldreq->vtotal = modeline->vtotal;
660 oldreq->flags = modeline->flags; 681 oldreq->flags = modeline->flags;
661 oldreq->privsize = modeline->privsize; 682 oldreq->privsize = modeline->privsize;
662 if (modeline->privsize) { 683 if (modeline->privsize) {
663 oldreq->length += modeline->privsize; 684 oldreq->length += modeline->privsize;
664 Data32(dpy, (long *) modeline->private, 685 Data32 (dpy, (long *) modeline->private,
665 modeline->privsize * sizeof(INT32)); 686 modeline->privsize * sizeof (INT32));
666 } 687 }
667 } else { 688 } else {
668 GetReq(XF86VidModeModModeLine, req); 689 GetReq (XF86VidModeModModeLine, req);
669 req->reqType = info->codes->major_opcode; 690 req->reqType = info->codes->major_opcode;
670 req->xf86vidmodeReqType = X_XF86VidModeModModeLine; 691 req->xf86vidmodeReqType = X_XF86VidModeModModeLine;
671 req->screen = screen; 692 req->screen = screen;
672 req->hdisplay = modeline->hdisplay; 693 req->hdisplay = modeline->hdisplay;
673 req->hsyncstart = modeline->hsyncstart; 694 req->hsyncstart = modeline->hsyncstart;
674 req->hsyncend = modeline->hsyncend; 695 req->hsyncend = modeline->hsyncend;
675 req->htotal = modeline->htotal; 696 req->htotal = modeline->htotal;
676 req->hskew = modeline->hskew; 697 req->hskew = modeline->hskew;
677 req->vdisplay = modeline->vdisplay; 698 req->vdisplay = modeline->vdisplay;
678 req->vsyncstart = modeline->vsyncstart; 699 req->vsyncstart = modeline->vsyncstart;
679 req->vsyncend = modeline->vsyncend; 700 req->vsyncend = modeline->vsyncend;
680 req->vtotal = modeline->vtotal; 701 req->vtotal = modeline->vtotal;
681 req->flags = modeline->flags; 702 req->flags = modeline->flags;
682 req->privsize = modeline->privsize; 703 req->privsize = modeline->privsize;
683 if (modeline->privsize) { 704 if (modeline->privsize) {
684 req->length += modeline->privsize; 705 req->length += modeline->privsize;
685 Data32(dpy, (long *) modeline->private, 706 Data32 (dpy, (long *) modeline->private,
686 modeline->privsize * sizeof(INT32)); 707 modeline->privsize * sizeof (INT32));
687 } 708 }
688 } 709 }
689 UnlockDisplay(dpy); 710 UnlockDisplay (dpy);
690 SyncHandle(); 711 SyncHandle ();
691 return True; 712 return True;
692 } 713 }
693 714
694 Status 715 Status SDL_NAME (XF86VidModeValidateModeLine) (dpy, screen, modeline)
695 SDL_NAME(XF86VidModeValidateModeLine) (dpy, screen, modeline) 716 Display *
696 Display *dpy; 717 dpy;
697 int screen; 718 int
698 SDL_NAME(XF86VidModeModeInfo)* modeline; 719 screen;
720 SDL_NAME (XF86VidModeModeInfo) * modeline;
699 { 721 {
700 XExtDisplayInfo *info = find_display (dpy); 722 XExtDisplayInfo *info = find_display (dpy);
701 xXF86VidModeValidateModeLineReq *req; 723 xXF86VidModeValidateModeLineReq *req;
702 xXF86OldVidModeValidateModeLineReq *oldreq; 724 xXF86OldVidModeValidateModeLineReq *oldreq;
703 xXF86VidModeValidateModeLineReply rep; 725 xXF86VidModeValidateModeLineReply rep;
704 int majorVersion, minorVersion; 726 int majorVersion, minorVersion;
705 727
706 XF86VidModeCheckExtension (dpy, info, 0); 728 XF86VidModeCheckExtension (dpy, info, 0);
707 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 729 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
708 730
709 LockDisplay(dpy); 731 LockDisplay (dpy);
710 732
711 if (majorVersion < 2) { 733 if (majorVersion < 2) {
712 GetOldReq(XF86VidModeValidateModeLine, XF86OldVidModeValidateModeLine, oldreq); 734 GetOldReq (XF86VidModeValidateModeLine,
713 oldreq->reqType = info->codes->major_opcode; 735 XF86OldVidModeValidateModeLine, oldreq);
714 oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine; 736 oldreq->reqType = info->codes->major_opcode;
715 oldreq->screen = screen; 737 oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
716 oldreq->dotclock = modeline->dotclock; 738 oldreq->screen = screen;
717 oldreq->hdisplay = modeline->hdisplay; 739 oldreq->dotclock = modeline->dotclock;
718 oldreq->hsyncstart = modeline->hsyncstart; 740 oldreq->hdisplay = modeline->hdisplay;
719 oldreq->hsyncend = modeline->hsyncend; 741 oldreq->hsyncstart = modeline->hsyncstart;
720 oldreq->htotal = modeline->htotal; 742 oldreq->hsyncend = modeline->hsyncend;
721 oldreq->vdisplay = modeline->vdisplay; 743 oldreq->htotal = modeline->htotal;
722 oldreq->vsyncstart = modeline->vsyncstart; 744 oldreq->vdisplay = modeline->vdisplay;
723 oldreq->vsyncend = modeline->vsyncend; 745 oldreq->vsyncstart = modeline->vsyncstart;
724 oldreq->vtotal = modeline->vtotal; 746 oldreq->vsyncend = modeline->vsyncend;
725 oldreq->flags = modeline->flags; 747 oldreq->vtotal = modeline->vtotal;
726 oldreq->privsize = modeline->privsize; 748 oldreq->flags = modeline->flags;
727 if (modeline->privsize) { 749 oldreq->privsize = modeline->privsize;
728 oldreq->length += modeline->privsize; 750 if (modeline->privsize) {
729 Data32(dpy, (long *) modeline->private, 751 oldreq->length += modeline->privsize;
730 modeline->privsize * sizeof(INT32)); 752 Data32 (dpy, (long *) modeline->private,
731 } 753 modeline->privsize * sizeof (INT32));
754 }
732 } else { 755 } else {
733 GetReq(XF86VidModeValidateModeLine, req); 756 GetReq (XF86VidModeValidateModeLine, req);
734 req->reqType = info->codes->major_opcode; 757 req->reqType = info->codes->major_opcode;
735 req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine; 758 req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
736 req->screen = screen; 759 req->screen = screen;
737 req->dotclock = modeline->dotclock; 760 req->dotclock = modeline->dotclock;
738 req->hdisplay = modeline->hdisplay; 761 req->hdisplay = modeline->hdisplay;
739 req->hsyncstart = modeline->hsyncstart; 762 req->hsyncstart = modeline->hsyncstart;
740 req->hsyncend = modeline->hsyncend; 763 req->hsyncend = modeline->hsyncend;
741 req->htotal = modeline->htotal; 764 req->htotal = modeline->htotal;
742 req->hskew = modeline->hskew; 765 req->hskew = modeline->hskew;
743 req->vdisplay = modeline->vdisplay; 766 req->vdisplay = modeline->vdisplay;
744 req->vsyncstart = modeline->vsyncstart; 767 req->vsyncstart = modeline->vsyncstart;
745 req->vsyncend = modeline->vsyncend; 768 req->vsyncend = modeline->vsyncend;
746 req->vtotal = modeline->vtotal; 769 req->vtotal = modeline->vtotal;
747 req->flags = modeline->flags; 770 req->flags = modeline->flags;
748 req->privsize = modeline->privsize; 771 req->privsize = modeline->privsize;
749 if (modeline->privsize) { 772 if (modeline->privsize) {
750 req->length += modeline->privsize; 773 req->length += modeline->privsize;
751 Data32(dpy, (long *) modeline->private, 774 Data32 (dpy, (long *) modeline->private,
752 modeline->privsize * sizeof(INT32)); 775 modeline->privsize * sizeof (INT32));
753 } 776 }
754 } 777 }
755 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 778 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
756 UnlockDisplay(dpy); 779 UnlockDisplay (dpy);
757 SyncHandle(); 780 SyncHandle ();
758 return MODE_BAD; 781 return MODE_BAD;
759 } 782 }
760 UnlockDisplay(dpy); 783 UnlockDisplay (dpy);
761 SyncHandle(); 784 SyncHandle ();
762 return rep.status; 785 return rep.status;
763 } 786 }
764 787
765 Bool 788 Bool SDL_NAME (XF86VidModeSwitchMode) (dpy, screen, zoom)
766 SDL_NAME(XF86VidModeSwitchMode)(dpy, screen, zoom) 789 Display *
767 Display* dpy; 790 dpy;
768 int screen; 791 int
769 int zoom; 792 screen;
793 int
794 zoom;
770 { 795 {
771 XExtDisplayInfo *info = find_display (dpy); 796 XExtDisplayInfo *info = find_display (dpy);
772 xXF86VidModeSwitchModeReq *req; 797 xXF86VidModeSwitchModeReq *req;
773 798
774 XF86VidModeCheckExtension (dpy, info, False); 799 XF86VidModeCheckExtension (dpy, info, False);
775 800
776 LockDisplay(dpy); 801 LockDisplay (dpy);
777 GetReq(XF86VidModeSwitchMode, req); 802 GetReq (XF86VidModeSwitchMode, req);
778 req->reqType = info->codes->major_opcode; 803 req->reqType = info->codes->major_opcode;
779 req->xf86vidmodeReqType = X_XF86VidModeSwitchMode; 804 req->xf86vidmodeReqType = X_XF86VidModeSwitchMode;
780 req->screen = screen; 805 req->screen = screen;
781 req->zoom = zoom; 806 req->zoom = zoom;
782 UnlockDisplay(dpy); 807 UnlockDisplay (dpy);
783 SyncHandle(); 808 SyncHandle ();
784 return True; 809 return True;
785 } 810 }
786 811
787 Bool 812 Bool SDL_NAME (XF86VidModeSwitchToMode) (dpy, screen, modeline)
788 SDL_NAME(XF86VidModeSwitchToMode)(dpy, screen, modeline) 813 Display *
789 Display* dpy; 814 dpy;
790 int screen; 815 int
791 SDL_NAME(XF86VidModeModeInfo)* modeline; 816 screen;
817 SDL_NAME (XF86VidModeModeInfo) * modeline;
792 { 818 {
793 XExtDisplayInfo *info = find_display (dpy); 819 XExtDisplayInfo *info = find_display (dpy);
794 xXF86VidModeSwitchToModeReq *req; 820 xXF86VidModeSwitchToModeReq *req;
795 xXF86OldVidModeSwitchToModeReq *oldreq; 821 xXF86OldVidModeSwitchToModeReq *oldreq;
796 int majorVersion, minorVersion; 822 int majorVersion, minorVersion;
803 * 0.x with x < 8 (the .private field wasn't expected to be sent over 829 * 0.x with x < 8 (the .private field wasn't expected to be sent over
804 * the wire). Check the server's version, and accept the old format 830 * the wire). Check the server's version, and accept the old format
805 * if appropriate. 831 * if appropriate.
806 */ 832 */
807 833
808 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 834 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
809 if (majorVersion == 0 && minorVersion < 8) { 835 if (majorVersion == 0 && minorVersion < 8) {
810 protocolBug = True; 836 protocolBug = True;
811 #ifdef DEBUG 837 #ifdef DEBUG
812 fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is" 838 fprintf (stderr, "XF86VidModeSwitchToMode: Warning: Xserver is"
813 "running an old version (%d.%d)\n", majorVersion, 839 "running an old version (%d.%d)\n", majorVersion,
814 minorVersion); 840 minorVersion);
815 #endif 841 #endif
816 } 842 }
817 843
818 LockDisplay(dpy); 844 LockDisplay (dpy);
819 if (majorVersion < 2) { 845 if (majorVersion < 2) {
820 GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode, oldreq); 846 GetOldReq (XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode,
821 oldreq->reqType = info->codes->major_opcode; 847 oldreq);
822 oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode; 848 oldreq->reqType = info->codes->major_opcode;
823 oldreq->screen = screen; 849 oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
824 oldreq->dotclock = modeline->dotclock; 850 oldreq->screen = screen;
825 oldreq->hdisplay = modeline->hdisplay; 851 oldreq->dotclock = modeline->dotclock;
826 oldreq->hsyncstart = modeline->hsyncstart; 852 oldreq->hdisplay = modeline->hdisplay;
827 oldreq->hsyncend = modeline->hsyncend; 853 oldreq->hsyncstart = modeline->hsyncstart;
828 oldreq->htotal = modeline->htotal; 854 oldreq->hsyncend = modeline->hsyncend;
829 oldreq->vdisplay = modeline->vdisplay; 855 oldreq->htotal = modeline->htotal;
830 oldreq->vsyncstart = modeline->vsyncstart; 856 oldreq->vdisplay = modeline->vdisplay;
831 oldreq->vsyncend = modeline->vsyncend; 857 oldreq->vsyncstart = modeline->vsyncstart;
832 oldreq->vtotal = modeline->vtotal; 858 oldreq->vsyncend = modeline->vsyncend;
833 oldreq->flags = modeline->flags; 859 oldreq->vtotal = modeline->vtotal;
834 if (protocolBug) { 860 oldreq->flags = modeline->flags;
835 oldreq->privsize = 0; 861 if (protocolBug) {
836 } else { 862 oldreq->privsize = 0;
837 oldreq->privsize = modeline->privsize; 863 } else {
838 if (modeline->privsize) { 864 oldreq->privsize = modeline->privsize;
839 oldreq->length += modeline->privsize; 865 if (modeline->privsize) {
840 Data32(dpy, (long *) modeline->private, 866 oldreq->length += modeline->privsize;
841 modeline->privsize * sizeof(INT32)); 867 Data32 (dpy, (long *) modeline->private,
842 } 868 modeline->privsize * sizeof (INT32));
843 } 869 }
870 }
844 } else { 871 } else {
845 GetReq(XF86VidModeSwitchToMode, req); 872 GetReq (XF86VidModeSwitchToMode, req);
846 req->reqType = info->codes->major_opcode; 873 req->reqType = info->codes->major_opcode;
847 req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode; 874 req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
848 req->screen = screen; 875 req->screen = screen;
849 req->dotclock = modeline->dotclock; 876 req->dotclock = modeline->dotclock;
850 req->hdisplay = modeline->hdisplay; 877 req->hdisplay = modeline->hdisplay;
851 req->hsyncstart = modeline->hsyncstart; 878 req->hsyncstart = modeline->hsyncstart;
852 req->hsyncend = modeline->hsyncend; 879 req->hsyncend = modeline->hsyncend;
853 req->htotal = modeline->htotal; 880 req->htotal = modeline->htotal;
854 req->hskew = modeline->hskew; 881 req->hskew = modeline->hskew;
855 req->vdisplay = modeline->vdisplay; 882 req->vdisplay = modeline->vdisplay;
856 req->vsyncstart = modeline->vsyncstart; 883 req->vsyncstart = modeline->vsyncstart;
857 req->vsyncend = modeline->vsyncend; 884 req->vsyncend = modeline->vsyncend;
858 req->vtotal = modeline->vtotal; 885 req->vtotal = modeline->vtotal;
859 req->flags = modeline->flags; 886 req->flags = modeline->flags;
860 if (protocolBug) { 887 if (protocolBug) {
861 req->privsize = 0; 888 req->privsize = 0;
862 } else { 889 } else {
863 req->privsize = modeline->privsize; 890 req->privsize = modeline->privsize;
864 if (modeline->privsize) { 891 if (modeline->privsize) {
865 req->length += modeline->privsize; 892 req->length += modeline->privsize;
866 Data32(dpy, (long *) modeline->private, 893 Data32 (dpy, (long *) modeline->private,
867 modeline->privsize * sizeof(INT32)); 894 modeline->privsize * sizeof (INT32));
868 } 895 }
869 } 896 }
870 } 897 }
871 UnlockDisplay(dpy); 898 UnlockDisplay (dpy);
872 SyncHandle(); 899 SyncHandle ();
873 return True; 900 return True;
874 } 901 }
875 902
876 Bool 903 Bool SDL_NAME (XF86VidModeLockModeSwitch) (dpy, screen, lock)
877 SDL_NAME(XF86VidModeLockModeSwitch)(dpy, screen, lock) 904 Display *
878 Display* dpy; 905 dpy;
879 int screen; 906 int
880 int lock; 907 screen;
908 int
909 lock;
881 { 910 {
882 XExtDisplayInfo *info = find_display (dpy); 911 XExtDisplayInfo *info = find_display (dpy);
883 xXF86VidModeLockModeSwitchReq *req; 912 xXF86VidModeLockModeSwitchReq *req;
884 913
885 XF86VidModeCheckExtension (dpy, info, False); 914 XF86VidModeCheckExtension (dpy, info, False);
886 915
887 LockDisplay(dpy); 916 LockDisplay (dpy);
888 GetReq(XF86VidModeLockModeSwitch, req); 917 GetReq (XF86VidModeLockModeSwitch, req);
889 req->reqType = info->codes->major_opcode; 918 req->reqType = info->codes->major_opcode;
890 req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch; 919 req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch;
891 req->screen = screen; 920 req->screen = screen;
892 req->lock = lock; 921 req->lock = lock;
893 UnlockDisplay(dpy); 922 UnlockDisplay (dpy);
894 SyncHandle(); 923 SyncHandle ();
895 return True; 924 return True;
896 } 925 }
897 926
898 Bool 927 Bool SDL_NAME (XF86VidModeGetMonitor) (dpy, screen, monitor)
899 SDL_NAME(XF86VidModeGetMonitor)(dpy, screen, monitor) 928 Display *
900 Display* dpy; 929 dpy;
901 int screen; 930 int
902 SDL_NAME(XF86VidModeMonitor)* monitor; 931 screen;
932 SDL_NAME (XF86VidModeMonitor) * monitor;
903 { 933 {
904 XExtDisplayInfo *info = find_display (dpy); 934 XExtDisplayInfo *info = find_display (dpy);
905 xXF86VidModeGetMonitorReply rep; 935 xXF86VidModeGetMonitorReply rep;
906 xXF86VidModeGetMonitorReq *req; 936 xXF86VidModeGetMonitorReq *req;
907 CARD32 syncrange; 937 CARD32 syncrange;
908 int i; 938 int i;
909 939
910 XF86VidModeCheckExtension (dpy, info, False); 940 XF86VidModeCheckExtension (dpy, info, False);
911 941
912 LockDisplay(dpy); 942 LockDisplay (dpy);
913 GetReq(XF86VidModeGetMonitor, req); 943 GetReq (XF86VidModeGetMonitor, req);
914 req->reqType = info->codes->major_opcode; 944 req->reqType = info->codes->major_opcode;
915 req->xf86vidmodeReqType = X_XF86VidModeGetMonitor; 945 req->xf86vidmodeReqType = X_XF86VidModeGetMonitor;
916 req->screen = screen; 946 req->screen = screen;
917 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 947 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
918 UnlockDisplay(dpy); 948 UnlockDisplay (dpy);
919 SyncHandle(); 949 SyncHandle ();
920 return False; 950 return False;
921 } 951 }
922 monitor->nhsync = rep.nhsync; 952 monitor->nhsync = rep.nhsync;
923 monitor->nvsync = rep.nvsync; 953 monitor->nvsync = rep.nvsync;
924 #if 0 954 #if 0
925 monitor->bandwidth = (float)rep.bandwidth / 1e6; 955 monitor->bandwidth = (float) rep.bandwidth / 1e6;
926 #endif 956 #endif
927 if (rep.vendorLength) { 957 if (rep.vendorLength) {
928 if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) { 958 if (!(monitor->vendor = (char *) Xcalloc (rep.vendorLength + 1, 1))) {
929 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 959 _XEatData (dpy, (rep.nhsync + rep.nvsync) * 4 +
930 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 960 ((rep.vendorLength + 3) & ~3) +
931 UnlockDisplay(dpy); 961 ((rep.modelLength + 3) & ~3));
932 SyncHandle(); 962 UnlockDisplay (dpy);
933 return False; 963 SyncHandle ();
934 } 964 return False;
965 }
935 } else { 966 } else {
936 monitor->vendor = NULL; 967 monitor->vendor = NULL;
937 } 968 }
938 if (rep.modelLength) { 969 if (rep.modelLength) {
939 if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) { 970 if (!(monitor->model = Xcalloc (rep.modelLength + 1, 1))) {
940 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 971 _XEatData (dpy, (rep.nhsync + rep.nvsync) * 4 +
941 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 972 ((rep.vendorLength + 3) & ~3) +
942 if (monitor->vendor) 973 ((rep.modelLength + 3) & ~3));
943 Xfree(monitor->vendor); 974 if (monitor->vendor)
944 UnlockDisplay(dpy); 975 Xfree (monitor->vendor);
945 SyncHandle(); 976 UnlockDisplay (dpy);
946 return False; 977 SyncHandle ();
947 } 978 return False;
979 }
948 } else { 980 } else {
949 monitor->model = NULL; 981 monitor->model = NULL;
950 } 982 }
951 if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) { 983 if (!
952 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 984 (monitor->hsync =
953 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 985 Xcalloc (rep.nhsync, sizeof (SDL_NAME (XF86VidModeSyncRange))))) {
954 986 _XEatData (dpy, (rep.nhsync + rep.nvsync) * 4 +
955 if (monitor->vendor) 987 ((rep.vendorLength + 3) & ~3) +
956 Xfree(monitor->vendor); 988 ((rep.modelLength + 3) & ~3));
957 if (monitor->model) 989
958 Xfree(monitor->model); 990 if (monitor->vendor)
959 UnlockDisplay(dpy); 991 Xfree (monitor->vendor);
960 SyncHandle(); 992 if (monitor->model)
961 return False; 993 Xfree (monitor->model);
962 } 994 UnlockDisplay (dpy);
963 if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) { 995 SyncHandle ();
964 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 996 return False;
965 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 997 }
966 if (monitor->vendor) 998 if (!
967 Xfree(monitor->vendor); 999 (monitor->vsync =
968 if (monitor->model) 1000 Xcalloc (rep.nvsync, sizeof (SDL_NAME (XF86VidModeSyncRange))))) {
969 Xfree(monitor->model); 1001 _XEatData (dpy, (rep.nhsync + rep.nvsync) * 4 +
970 Xfree(monitor->hsync); 1002 ((rep.vendorLength + 3) & ~3) +
971 UnlockDisplay(dpy); 1003 ((rep.modelLength + 3) & ~3));
972 SyncHandle(); 1004 if (monitor->vendor)
973 return False; 1005 Xfree (monitor->vendor);
1006 if (monitor->model)
1007 Xfree (monitor->model);
1008 Xfree (monitor->hsync);
1009 UnlockDisplay (dpy);
1010 SyncHandle ();
1011 return False;
974 } 1012 }
975 for (i = 0; i < rep.nhsync; i++) { 1013 for (i = 0; i < rep.nhsync; i++) {
976 _XRead(dpy, (char *)&syncrange, 4); 1014 _XRead (dpy, (char *) &syncrange, 4);
977 monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0; 1015 monitor->hsync[i].lo = (float) (syncrange & 0xFFFF) / 100.0;
978 monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0; 1016 monitor->hsync[i].hi = (float) (syncrange >> 16) / 100.0;
979 } 1017 }
980 for (i = 0; i < rep.nvsync; i++) { 1018 for (i = 0; i < rep.nvsync; i++) {
981 _XRead(dpy, (char *)&syncrange, 4); 1019 _XRead (dpy, (char *) &syncrange, 4);
982 monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0; 1020 monitor->vsync[i].lo = (float) (syncrange & 0xFFFF) / 100.0;
983 monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0; 1021 monitor->vsync[i].hi = (float) (syncrange >> 16) / 100.0;
984 } 1022 }
985 if (rep.vendorLength) 1023 if (rep.vendorLength)
986 _XReadPad(dpy, monitor->vendor, rep.vendorLength); 1024 _XReadPad (dpy, monitor->vendor, rep.vendorLength);
987 else 1025 else
988 monitor->vendor = ""; 1026 monitor->vendor = "";
989 if (rep.modelLength) 1027 if (rep.modelLength)
990 _XReadPad(dpy, monitor->model, rep.modelLength); 1028 _XReadPad (dpy, monitor->model, rep.modelLength);
991 else 1029 else
992 monitor->model = ""; 1030 monitor->model = "";
993 1031
994 UnlockDisplay(dpy); 1032 UnlockDisplay (dpy);
995 SyncHandle(); 1033 SyncHandle ();
996 return True; 1034 return True;
997 } 1035 }
998 1036
999 Bool 1037 Bool SDL_NAME (XF86VidModeGetViewPort) (dpy, screen, x, y)
1000 SDL_NAME(XF86VidModeGetViewPort)(dpy, screen, x, y) 1038 Display *
1001 Display* dpy; 1039 dpy;
1002 int screen; 1040 int
1003 int *x, *y; 1041 screen;
1042 int *
1043 x, *
1044 y;
1004 { 1045 {
1005 XExtDisplayInfo *info = find_display (dpy); 1046 XExtDisplayInfo *info = find_display (dpy);
1006 xXF86VidModeGetViewPortReply rep; 1047 xXF86VidModeGetViewPortReply rep;
1007 xXF86VidModeGetViewPortReq *req; 1048 xXF86VidModeGetViewPortReq *req;
1008 int majorVersion, minorVersion; 1049 int majorVersion, minorVersion;
1015 * 0.x with x < 8 (no reply was sent, so the client would hang) 1056 * 0.x with x < 8 (no reply was sent, so the client would hang)
1016 * Check the server's version, and don't wait for a reply with older 1057 * Check the server's version, and don't wait for a reply with older
1017 * versions. 1058 * versions.
1018 */ 1059 */
1019 1060
1020 SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion); 1061 SDL_NAME (XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
1021 if (majorVersion == 0 && minorVersion < 8) { 1062 if (majorVersion == 0 && minorVersion < 8) {
1022 protocolBug = True; 1063 protocolBug = True;
1023 #ifdef DEBUG 1064 #ifdef DEBUG
1024 fprintf(stderr, "XF86VidModeGetViewPort: Warning: Xserver is" 1065 fprintf (stderr, "XF86VidModeGetViewPort: Warning: Xserver is"
1025 "running an old version (%d.%d)\n", majorVersion, 1066 "running an old version (%d.%d)\n", majorVersion,
1026 minorVersion); 1067 minorVersion);
1027 #endif 1068 #endif
1028 } 1069 }
1029 LockDisplay(dpy); 1070 LockDisplay (dpy);
1030 GetReq(XF86VidModeGetViewPort, req); 1071 GetReq (XF86VidModeGetViewPort, req);
1031 req->reqType = info->codes->major_opcode; 1072 req->reqType = info->codes->major_opcode;
1032 req->xf86vidmodeReqType = X_XF86VidModeGetViewPort; 1073 req->xf86vidmodeReqType = X_XF86VidModeGetViewPort;
1033 req->screen = screen; 1074 req->screen = screen;
1034 if (protocolBug) { 1075 if (protocolBug) {
1035 *x = 0; 1076 *x = 0;
1036 *y = 0; 1077 *y = 0;
1037 } else { 1078 } else {
1038 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 1079 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
1039 UnlockDisplay(dpy); 1080 UnlockDisplay (dpy);
1040 SyncHandle(); 1081 SyncHandle ();
1041 return False; 1082 return False;
1042 } 1083 }
1043 *x = rep.x; 1084 *x = rep.x;
1044 *y = rep.y; 1085 *y = rep.y;
1045 } 1086 }
1046 1087
1047 UnlockDisplay(dpy); 1088 UnlockDisplay (dpy);
1048 SyncHandle(); 1089 SyncHandle ();
1049 return True; 1090 return True;
1050 } 1091 }
1051 1092
1052 Bool 1093 Bool SDL_NAME (XF86VidModeSetViewPort) (dpy, screen, x, y)
1053 SDL_NAME(XF86VidModeSetViewPort)(dpy, screen, x, y) 1094 Display *
1054 Display* dpy; 1095 dpy;
1055 int screen; 1096 int
1056 int x, y; 1097 screen;
1098 int
1099 x,
1100 y;
1057 { 1101 {
1058 XExtDisplayInfo *info = find_display (dpy); 1102 XExtDisplayInfo *info = find_display (dpy);
1059 xXF86VidModeSetViewPortReq *req; 1103 xXF86VidModeSetViewPortReq *req;
1060 1104
1061 XF86VidModeCheckExtension (dpy, info, False); 1105 XF86VidModeCheckExtension (dpy, info, False);
1062 1106
1063 LockDisplay(dpy); 1107 LockDisplay (dpy);
1064 GetReq(XF86VidModeSetViewPort, req); 1108 GetReq (XF86VidModeSetViewPort, req);
1065 req->reqType = info->codes->major_opcode; 1109 req->reqType = info->codes->major_opcode;
1066 req->xf86vidmodeReqType = X_XF86VidModeSetViewPort; 1110 req->xf86vidmodeReqType = X_XF86VidModeSetViewPort;
1067 req->screen = screen; 1111 req->screen = screen;
1068 req->x = x; 1112 req->x = x;
1069 req->y = y; 1113 req->y = y;
1070 1114
1071 UnlockDisplay(dpy); 1115 UnlockDisplay (dpy);
1072 SyncHandle(); 1116 SyncHandle ();
1073 return True; 1117 return True;
1074 } 1118 }
1075 1119
1076 Bool 1120 Bool
1077 SDL_NAME(XF86VidModeGetDotClocks)(dpy, screen, 1121 SDL_NAME (XF86VidModeGetDotClocks) (dpy, screen,
1078 flagsPtr, numclocksPtr, maxclocksPtr, clocksPtr) 1122 flagsPtr, numclocksPtr, maxclocksPtr,
1079 Display* dpy; 1123 clocksPtr)
1080 int screen; 1124 Display *dpy;
1081 int *flagsPtr, *numclocksPtr, *maxclocksPtr, *clocksPtr[]; 1125 int screen;
1126 int *flagsPtr, *numclocksPtr, *maxclocksPtr, *clocksPtr[];
1082 { 1127 {
1083 XExtDisplayInfo *info = find_display (dpy); 1128 XExtDisplayInfo *info = find_display (dpy);
1084 xXF86VidModeGetDotClocksReply rep; 1129 xXF86VidModeGetDotClocksReply rep;
1085 xXF86VidModeGetDotClocksReq *req; 1130 xXF86VidModeGetDotClocksReq *req;
1086 int i, *dotclocks; 1131 int i, *dotclocks;
1087 CARD32 dotclk; 1132 CARD32 dotclk;
1088 1133
1089 XF86VidModeCheckExtension (dpy, info, False); 1134 XF86VidModeCheckExtension (dpy, info, False);
1090 1135
1091 LockDisplay(dpy); 1136 LockDisplay (dpy);
1092 GetReq(XF86VidModeGetDotClocks, req); 1137 GetReq (XF86VidModeGetDotClocks, req);
1093 req->reqType = info->codes->major_opcode; 1138 req->reqType = info->codes->major_opcode;
1094 req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks; 1139 req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks;
1095 req->screen = screen; 1140 req->screen = screen;
1096 if (!_XReply(dpy, (xReply *)&rep, 1141 if (!_XReply (dpy, (xReply *) & rep,
1097 (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse)) 1142 (SIZEOF (xXF86VidModeGetDotClocksReply) -
1098 { 1143 SIZEOF (xReply)) >> 2, xFalse)) {
1099 UnlockDisplay(dpy); 1144 UnlockDisplay (dpy);
1100 SyncHandle(); 1145 SyncHandle ();
1101 return False; 1146 return False;
1102 } 1147 }
1103 *numclocksPtr = rep.clocks; 1148 *numclocksPtr = rep.clocks;
1104 *maxclocksPtr = rep.maxclocks; 1149 *maxclocksPtr = rep.maxclocks;
1105 *flagsPtr = rep.flags; 1150 *flagsPtr = rep.flags;
1106 1151
1107 if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) { 1152 if (!(dotclocks = (int *) Xcalloc (rep.clocks, sizeof (int)))) {
1108 _XEatData(dpy, (rep.clocks) * 4); 1153 _XEatData (dpy, (rep.clocks) * 4);
1109 Xfree(dotclocks); 1154 Xfree (dotclocks);
1110 UnlockDisplay(dpy); 1155 UnlockDisplay (dpy);
1111 SyncHandle(); 1156 SyncHandle ();
1112 return False; 1157 return False;
1113 } 1158 }
1114 1159
1115 for (i = 0; i < rep.clocks; i++) { 1160 for (i = 0; i < rep.clocks; i++) {
1116 _XRead(dpy, (char*)&dotclk, 4); 1161 _XRead (dpy, (char *) &dotclk, 4);
1117 dotclocks[i] = dotclk; 1162 dotclocks[i] = dotclk;
1118 } 1163 }
1119 *clocksPtr = dotclocks; 1164 *clocksPtr = dotclocks;
1120 UnlockDisplay(dpy); 1165 UnlockDisplay (dpy);
1121 SyncHandle(); 1166 SyncHandle ();
1122 return True; 1167 return True;
1123 } 1168 }
1124 1169
1125 Bool 1170 Bool
1126 SDL_NAME(XF86VidModeSetGammaRamp) ( 1171 SDL_NAME (XF86VidModeSetGammaRamp) (Display * dpy,
1127 Display *dpy, 1172 int screen,
1128 int screen, 1173 int size,
1129 int size, 1174 unsigned short *red,
1130 unsigned short *red, 1175 unsigned short *green,
1131 unsigned short *green, 1176 unsigned short *blue)
1132 unsigned short *blue
1133 )
1134 { 1177 {
1135 int length = (size + 1) & ~1; 1178 int length = (size + 1) & ~1;
1136 XExtDisplayInfo *info = find_display (dpy); 1179 XExtDisplayInfo *info = find_display (dpy);
1137 xXF86VidModeSetGammaRampReq *req; 1180 xXF86VidModeSetGammaRampReq *req;
1138 1181
1139 XF86VidModeCheckExtension (dpy, info, False); 1182 XF86VidModeCheckExtension (dpy, info, False);
1140 LockDisplay(dpy); 1183 LockDisplay (dpy);
1141 GetReq(XF86VidModeSetGammaRamp, req); 1184 GetReq (XF86VidModeSetGammaRamp, req);
1142 req->reqType = info->codes->major_opcode; 1185 req->reqType = info->codes->major_opcode;
1143 req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp; 1186 req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp;
1144 req->screen = screen; 1187 req->screen = screen;
1145 req->length += (length >> 1) * 3; 1188 req->length += (length >> 1) * 3;
1146 req->size = size; 1189 req->size = size;
1147 _XSend(dpy, (char*)red, size * 2); 1190 _XSend (dpy, (char *) red, size * 2);
1148 _XSend(dpy, (char*)green, size * 2); 1191 _XSend (dpy, (char *) green, size * 2);
1149 _XSend(dpy, (char*)blue, size * 2); 1192 _XSend (dpy, (char *) blue, size * 2);
1150 UnlockDisplay(dpy); 1193 UnlockDisplay (dpy);
1151 SyncHandle(); 1194 SyncHandle ();
1152 return True; 1195 return True;
1153 } 1196 }
1154 1197
1155 1198
1156 Bool 1199 Bool
1157 SDL_NAME(XF86VidModeGetGammaRamp) ( 1200 SDL_NAME (XF86VidModeGetGammaRamp) (Display * dpy,
1158 Display *dpy, 1201 int screen,
1159 int screen, 1202 int size,
1160 int size, 1203 unsigned short *red,
1161 unsigned short *red, 1204 unsigned short *green,
1162 unsigned short *green, 1205 unsigned short *blue)
1163 unsigned short *blue
1164 )
1165 { 1206 {
1166 XExtDisplayInfo *info = find_display (dpy); 1207 XExtDisplayInfo *info = find_display (dpy);
1167 xXF86VidModeGetGammaRampReq *req; 1208 xXF86VidModeGetGammaRampReq *req;
1168 xXF86VidModeGetGammaRampReply rep; 1209 xXF86VidModeGetGammaRampReply rep;
1169 1210
1170 XF86VidModeCheckExtension (dpy, info, False); 1211 XF86VidModeCheckExtension (dpy, info, False);
1171 1212
1172 LockDisplay(dpy); 1213 LockDisplay (dpy);
1173 GetReq(XF86VidModeGetGammaRamp, req); 1214 GetReq (XF86VidModeGetGammaRamp, req);
1174 req->reqType = info->codes->major_opcode; 1215 req->reqType = info->codes->major_opcode;
1175 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp; 1216 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp;
1176 req->screen = screen; 1217 req->screen = screen;
1177 req->size = size; 1218 req->size = size;
1178 if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { 1219 if (!_XReply (dpy, (xReply *) & rep, 0, xFalse)) {
1179 UnlockDisplay (dpy); 1220 UnlockDisplay (dpy);
1180 SyncHandle (); 1221 SyncHandle ();
1181 return False; 1222 return False;
1182 } 1223 }
1183 if(rep.size) { 1224 if (rep.size) {
1184 _XRead(dpy, (char*)red, rep.size << 1); 1225 _XRead (dpy, (char *) red, rep.size << 1);
1185 _XRead(dpy, (char*)green, rep.size << 1); 1226 _XRead (dpy, (char *) green, rep.size << 1);
1186 _XRead(dpy, (char*)blue, rep.size << 1); 1227 _XRead (dpy, (char *) blue, rep.size << 1);
1187 } 1228 }
1188 1229
1189 UnlockDisplay(dpy); 1230 UnlockDisplay (dpy);
1190 SyncHandle(); 1231 SyncHandle ();
1191 return True; 1232 return True;
1192 } 1233 }
1193 1234
1194 Bool SDL_NAME(XF86VidModeGetGammaRampSize)( 1235 Bool SDL_NAME (XF86VidModeGetGammaRampSize) (Display * dpy,
1195 Display *dpy, 1236 int screen, int *size)
1196 int screen,
1197 int *size
1198 )
1199 { 1237 {
1200 XExtDisplayInfo *info = find_display (dpy); 1238 XExtDisplayInfo *info = find_display (dpy);
1201 xXF86VidModeGetGammaRampSizeReq *req; 1239 xXF86VidModeGetGammaRampSizeReq *req;
1202 xXF86VidModeGetGammaRampSizeReply rep; 1240 xXF86VidModeGetGammaRampSizeReply rep;
1203 1241
1204 *size = 0; 1242 *size = 0;
1205 1243
1206 XF86VidModeCheckExtension (dpy, info, False); 1244 XF86VidModeCheckExtension (dpy, info, False);
1207 1245
1208 LockDisplay(dpy); 1246 LockDisplay (dpy);
1209 GetReq(XF86VidModeGetGammaRampSize, req); 1247 GetReq (XF86VidModeGetGammaRampSize, req);
1210 req->reqType = info->codes->major_opcode; 1248 req->reqType = info->codes->major_opcode;
1211 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize; 1249 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize;
1212 req->screen = screen; 1250 req->screen = screen;
1213 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 1251 if (!_XReply (dpy, (xReply *) & rep, 0, xTrue)) {
1214 UnlockDisplay (dpy); 1252 UnlockDisplay (dpy);
1215 SyncHandle (); 1253 SyncHandle ();
1216 return False; 1254 return False;
1217 } 1255 }
1218 *size = rep.size; 1256 *size = rep.size;
1219 UnlockDisplay(dpy); 1257 UnlockDisplay (dpy);
1220 SyncHandle(); 1258 SyncHandle ();
1221 return True; 1259 return True;
1222 } 1260 }
1223 1261
1262 /* vi: set ts=4 sw=4 expandtab: */