Mercurial > sdl-ios-xcode
comparison src/video/Xext/Xxf86vm/XF86VMode.c @ 1662:782fd950bd46 SDL-1.3
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: */ |