Mercurial > sdl-ios-xcode

comparison src/video/Xext/Xxf86vm/XF86VMode.c @ 1575:3ba88cb7eb1b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Updated dynamic X11 code. See details in Bugzilla #170.
author Ryan C. Gordon <icculus@icculus.org>
date Wed, 22 Mar 2006 05:00:59 +0000
parents 6fd39b50dd91
children ecba4bbaf9c2
comparison
equal deleted inserted replaced
1574:0fd72308659e 1575:3ba88cb7eb1b
130 130
131 LockDisplay(dpy); 131 LockDisplay(dpy);
132 GetReq(XF86VidModeQueryVersion, req); 132 GetReq(XF86VidModeQueryVersion, req);
133 req->reqType = info->codes->major_opcode; 133 req->reqType = info->codes->major_opcode;
134 req->xf86vidmodeReqType = X_XF86VidModeQueryVersion; 134 req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
135 if (!p_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 135 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
136 UnlockDisplay(dpy); 136 UnlockDisplay(dpy);
137 SyncHandle(); 137 SyncHandle();
138 return False; 138 return False;
139 } 139 }
140 *majorVersion = rep.majorVersion; 140 *majorVersion = rep.majorVersion;
198 LockDisplay(dpy); 198 LockDisplay(dpy);
199 GetReq(XF86VidModeGetGamma, req); 199 GetReq(XF86VidModeGetGamma, req);
200 req->reqType = info->codes->major_opcode; 200 req->reqType = info->codes->major_opcode;
201 req->xf86vidmodeReqType = X_XF86VidModeGetGamma; 201 req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
202 req->screen = screen; 202 req->screen = screen;
203 if (!p_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 203 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
204 UnlockDisplay(dpy); 204 UnlockDisplay(dpy);
205 SyncHandle(); 205 SyncHandle();
206 return False; 206 return False;
207 } 207 }
208 Gamma->red = ((float)rep.red) / 10000.; 208 Gamma->red = ((float)rep.red) / 10000.;
234 req->reqType = info->codes->major_opcode; 234 req->reqType = info->codes->major_opcode;
235 req->xf86vidmodeReqType = X_XF86VidModeGetModeLine; 235 req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
236 req->screen = screen; 236 req->screen = screen;
237 237
238 if (majorVersion < 2) { 238 if (majorVersion < 2) {
239 if (!p_XReply(dpy, (xReply *)&oldrep, 239 if (!_XReply(dpy, (xReply *)&oldrep,
240 (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) { 240 (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
241 UnlockDisplay(dpy); 241 UnlockDisplay(dpy);
242 SyncHandle(); 242 SyncHandle();
243 return False; 243 return False;
244 } 244 }
253 modeline->vsyncend = oldrep.vsyncend; 253 modeline->vsyncend = oldrep.vsyncend;
254 modeline->vtotal = oldrep.vtotal; 254 modeline->vtotal = oldrep.vtotal;
255 modeline->flags = oldrep.flags; 255 modeline->flags = oldrep.flags;
256 modeline->privsize = oldrep.privsize; 256 modeline->privsize = oldrep.privsize;
257 } else { 257 } else {
258 if (!p_XReply(dpy, (xReply *)&rep, 258 if (!_XReply(dpy, (xReply *)&rep,
259 (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) { 259 (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
260 UnlockDisplay(dpy); 260 UnlockDisplay(dpy);
261 SyncHandle(); 261 SyncHandle();
262 return False; 262 return False;
263 } 263 }
275 modeline->privsize = rep.privsize; 275 modeline->privsize = rep.privsize;
276 } 276 }
277 277
278 if (modeline->privsize > 0) { 278 if (modeline->privsize > 0) {
279 if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) { 279 if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) {
280 p_XEatData(dpy, (modeline->privsize) * sizeof(INT32)); 280 _XEatData(dpy, (modeline->privsize) * sizeof(INT32));
281 Xfree(modeline->private); 281 Xfree(modeline->private);
282 return False; 282 return False;
283 } 283 }
284 p_XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32)); 284 _XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32));
285 } else { 285 } else {
286 modeline->private = NULL; 286 modeline->private = NULL;
287 } 287 }
288 UnlockDisplay(dpy); 288 UnlockDisplay(dpy);
289 SyncHandle(); 289 SyncHandle();
328 LockDisplay(dpy); 328 LockDisplay(dpy);
329 GetReq(XF86VidModeGetAllModeLines, req); 329 GetReq(XF86VidModeGetAllModeLines, req);
330 req->reqType = info->codes->major_opcode; 330 req->reqType = info->codes->major_opcode;
331 req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines; 331 req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
332 req->screen = screen; 332 req->screen = screen;
333 if (!p_XReply(dpy, (xReply *)&rep, 333 if (!_XReply(dpy, (xReply *)&rep,
334 (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) { 334 (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) {
335 UnlockDisplay(dpy); 335 UnlockDisplay(dpy);
336 SyncHandle(); 336 SyncHandle();
337 return False; 337 return False;
338 } 338 }
341 341
342 if (!(modelines = (SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount, 342 if (!(modelines = (SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount,
343 sizeof(SDL_NAME(XF86VidModeModeInfo) *) 343 sizeof(SDL_NAME(XF86VidModeModeInfo) *)
344 +sizeof(SDL_NAME(XF86VidModeModeInfo))))) { 344 +sizeof(SDL_NAME(XF86VidModeModeInfo))))) {
345 if (majorVersion < 2) 345 if (majorVersion < 2)
346 p_XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo)); 346 _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo));
347 else 347 else
348 p_XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo)); 348 _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo));
349 Xfree(modelines); 349 Xfree(modelines);
350 UnlockDisplay(dpy); 350 UnlockDisplay(dpy);
351 SyncHandle(); 351 SyncHandle();
352 return False; 352 return False;
353 } 353 }
357 ); 357 );
358 358
359 for (i = 0; i < rep.modecount; i++) { 359 for (i = 0; i < rep.modecount; i++) {
360 modelines[i] = mdinfptr++; 360 modelines[i] = mdinfptr++;
361 if (majorVersion < 2) { 361 if (majorVersion < 2) {
362 p_XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo)); 362 _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo));
363 modelines[i]->dotclock = oldxmdline.dotclock; 363 modelines[i]->dotclock = oldxmdline.dotclock;
364 modelines[i]->hdisplay = oldxmdline.hdisplay; 364 modelines[i]->hdisplay = oldxmdline.hdisplay;
365 modelines[i]->hsyncstart = oldxmdline.hsyncstart; 365 modelines[i]->hsyncstart = oldxmdline.hsyncstart;
366 modelines[i]->hsyncend = oldxmdline.hsyncend; 366 modelines[i]->hsyncend = oldxmdline.hsyncend;
367 modelines[i]->htotal = oldxmdline.htotal; 367 modelines[i]->htotal = oldxmdline.htotal;
377 } else { 377 } else {
378 modelines[i]->privsize = oldxmdline.privsize; 378 modelines[i]->privsize = oldxmdline.privsize;
379 if (oldxmdline.privsize > 0) { 379 if (oldxmdline.privsize > 0) {
380 if (!(modelines[i]->private = 380 if (!(modelines[i]->private =
381 Xcalloc(oldxmdline.privsize, sizeof(INT32)))) { 381 Xcalloc(oldxmdline.privsize, sizeof(INT32)))) {
382 p_XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32)); 382 _XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32));
383 Xfree(modelines[i]->private); 383 Xfree(modelines[i]->private);
384 } else { 384 } else {
385 p_XRead(dpy, (char*)modelines[i]->private, 385 _XRead(dpy, (char*)modelines[i]->private,
386 oldxmdline.privsize * sizeof(INT32)); 386 oldxmdline.privsize * sizeof(INT32));
387 } 387 }
388 } else { 388 } else {
389 modelines[i]->private = NULL; 389 modelines[i]->private = NULL;
390 } 390 }
391 } 391 }
392 } else { 392 } else {
393 p_XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo)); 393 _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo));
394 modelines[i]->dotclock = xmdline.dotclock; 394 modelines[i]->dotclock = xmdline.dotclock;
395 modelines[i]->hdisplay = xmdline.hdisplay; 395 modelines[i]->hdisplay = xmdline.hdisplay;
396 modelines[i]->hsyncstart = xmdline.hsyncstart; 396 modelines[i]->hsyncstart = xmdline.hsyncstart;
397 modelines[i]->hsyncend = xmdline.hsyncend; 397 modelines[i]->hsyncend = xmdline.hsyncend;
398 modelines[i]->htotal = xmdline.htotal; 398 modelines[i]->htotal = xmdline.htotal;
408 } else { 408 } else {
409 modelines[i]->privsize = xmdline.privsize; 409 modelines[i]->privsize = xmdline.privsize;
410 if (xmdline.privsize > 0) { 410 if (xmdline.privsize > 0) {
411 if (!(modelines[i]->private = 411 if (!(modelines[i]->private =
412 Xcalloc(xmdline.privsize, sizeof(INT32)))) { 412 Xcalloc(xmdline.privsize, sizeof(INT32)))) {
413 p_XEatData(dpy, (xmdline.privsize) * sizeof(INT32)); 413 _XEatData(dpy, (xmdline.privsize) * sizeof(INT32));
414 Xfree(modelines[i]->private); 414 Xfree(modelines[i]->private);
415 } else { 415 } else {
416 p_XRead(dpy, (char*)modelines[i]->private, 416 _XRead(dpy, (char*)modelines[i]->private,
417 xmdline.privsize * sizeof(INT32)); 417 xmdline.privsize * sizeof(INT32));
418 } 418 }
419 } else { 419 } else {
420 modelines[i]->private = NULL; 420 modelines[i]->private = NULL;
421 } 421 }
433 */ 433 */
434 #if !defined(UNIXCPP) || defined(ANSICPP) 434 #if !defined(UNIXCPP) || defined(ANSICPP)
435 #define GetOldReq(name, oldname, req) \ 435 #define GetOldReq(name, oldname, req) \
436 WORD64ALIGN\ 436 WORD64ALIGN\
437 if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)\ 437 if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)\
438 p_XFlush(dpy);\ 438 _XFlush(dpy);\
439 req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\ 439 req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\
440 req->reqType = X_##name;\ 440 req->reqType = X_##name;\
441 req->length = (SIZEOF(x##oldname##Req))>>2;\ 441 req->length = (SIZEOF(x##oldname##Req))>>2;\
442 dpy->bufptr += SIZEOF(x##oldname##Req);\ 442 dpy->bufptr += SIZEOF(x##oldname##Req);\
443 dpy->request++ 443 dpy->request++
444 444
445 #else /* non-ANSI C uses empty comment instead of "##" for token concatenation */ 445 #else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
446 #define GetOldReq(name, oldname, req) \ 446 #define GetOldReq(name, oldname, req) \
447 WORD64ALIGN\ 447 WORD64ALIGN\
448 if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\ 448 if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\
449 p_XFlush(dpy);\ 449 _XFlush(dpy);\
450 req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\ 450 req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\
451 req->reqType = X_/**/name;\ 451 req->reqType = X_/**/name;\
452 req->length = (SIZEOF(x/**/oldname/**/Req))>>2;\ 452 req->length = (SIZEOF(x/**/oldname/**/Req))>>2;\
453 dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\ 453 dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\
454 dpy->request++ 454 dpy->request++
752 req->length += modeline->privsize; 752 req->length += modeline->privsize;
753 Data32(dpy, (long *) modeline->private, 753 Data32(dpy, (long *) modeline->private,
754 modeline->privsize * sizeof(INT32)); 754 modeline->privsize * sizeof(INT32));
755 } 755 }
756 } 756 }
757 if (!p_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 757 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
758 UnlockDisplay(dpy); 758 UnlockDisplay(dpy);
759 SyncHandle(); 759 SyncHandle();
760 return MODE_BAD; 760 return MODE_BAD;
761 } 761 }
762 UnlockDisplay(dpy); 762 UnlockDisplay(dpy);
914 LockDisplay(dpy); 914 LockDisplay(dpy);
915 GetReq(XF86VidModeGetMonitor, req); 915 GetReq(XF86VidModeGetMonitor, req);
916 req->reqType = info->codes->major_opcode; 916 req->reqType = info->codes->major_opcode;
917 req->xf86vidmodeReqType = X_XF86VidModeGetMonitor; 917 req->xf86vidmodeReqType = X_XF86VidModeGetMonitor;
918 req->screen = screen; 918 req->screen = screen;
919 if (!p_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 919 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
920 UnlockDisplay(dpy); 920 UnlockDisplay(dpy);
921 SyncHandle(); 921 SyncHandle();
922 return False; 922 return False;
923 } 923 }
924 monitor->nhsync = rep.nhsync; 924 monitor->nhsync = rep.nhsync;
926 #if 0 926 #if 0
927 monitor->bandwidth = (float)rep.bandwidth / 1e6; 927 monitor->bandwidth = (float)rep.bandwidth / 1e6;
928 #endif 928 #endif
929 if (rep.vendorLength) { 929 if (rep.vendorLength) {
930 if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) { 930 if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) {
931 p_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 931 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
932 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 932 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
933 UnlockDisplay(dpy); 933 UnlockDisplay(dpy);
934 SyncHandle(); 934 SyncHandle();
935 return False; 935 return False;
936 } 936 }
937 } else { 937 } else {
938 monitor->vendor = NULL; 938 monitor->vendor = NULL;
939 } 939 }
940 if (rep.modelLength) { 940 if (rep.modelLength) {
941 if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) { 941 if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) {
942 p_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 942 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
943 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 943 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
944 if (monitor->vendor) 944 if (monitor->vendor)
945 Xfree(monitor->vendor); 945 Xfree(monitor->vendor);
946 UnlockDisplay(dpy); 946 UnlockDisplay(dpy);
947 SyncHandle(); 947 SyncHandle();
949 } 949 }
950 } else { 950 } else {
951 monitor->model = NULL; 951 monitor->model = NULL;
952 } 952 }
953 if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) { 953 if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
954 p_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 954 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
955 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 955 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
956 956
957 if (monitor->vendor) 957 if (monitor->vendor)
958 Xfree(monitor->vendor); 958 Xfree(monitor->vendor);
959 if (monitor->model) 959 if (monitor->model)
961 UnlockDisplay(dpy); 961 UnlockDisplay(dpy);
962 SyncHandle(); 962 SyncHandle();
963 return False; 963 return False;
964 } 964 }
965 if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) { 965 if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
966 p_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 + 966 _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
967 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3)); 967 ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
968 if (monitor->vendor) 968 if (monitor->vendor)
969 Xfree(monitor->vendor); 969 Xfree(monitor->vendor);
970 if (monitor->model) 970 if (monitor->model)
971 Xfree(monitor->model); 971 Xfree(monitor->model);
973 UnlockDisplay(dpy); 973 UnlockDisplay(dpy);
974 SyncHandle(); 974 SyncHandle();
975 return False; 975 return False;
976 } 976 }
977 for (i = 0; i < rep.nhsync; i++) { 977 for (i = 0; i < rep.nhsync; i++) {
978 p_XRead(dpy, (char *)&syncrange, 4); 978 _XRead(dpy, (char *)&syncrange, 4);
979 monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0; 979 monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
980 monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0; 980 monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0;
981 } 981 }
982 for (i = 0; i < rep.nvsync; i++) { 982 for (i = 0; i < rep.nvsync; i++) {
983 p_XRead(dpy, (char *)&syncrange, 4); 983 _XRead(dpy, (char *)&syncrange, 4);
984 monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0; 984 monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
985 monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0; 985 monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0;
986 } 986 }
987 if (rep.vendorLength) 987 if (rep.vendorLength)
988 p_XReadPad(dpy, monitor->vendor, rep.vendorLength); 988 _XReadPad(dpy, monitor->vendor, rep.vendorLength);
989 else 989 else
990 monitor->vendor = ""; 990 monitor->vendor = "";
991 if (rep.modelLength) 991 if (rep.modelLength)
992 p_XReadPad(dpy, monitor->model, rep.modelLength); 992 _XReadPad(dpy, monitor->model, rep.modelLength);
993 else 993 else
994 monitor->model = ""; 994 monitor->model = "";
995 995
996 UnlockDisplay(dpy); 996 UnlockDisplay(dpy);
997 SyncHandle(); 997 SyncHandle();
1035 req->screen = screen; 1035 req->screen = screen;
1036 if (protocolBug) { 1036 if (protocolBug) {
1037 *x = 0; 1037 *x = 0;
1038 *y = 0; 1038 *y = 0;
1039 } else { 1039 } else {
1040 if (!p_XReply(dpy, (xReply *)&rep, 0, xFalse)) { 1040 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
1041 UnlockDisplay(dpy); 1041 UnlockDisplay(dpy);
1042 SyncHandle(); 1042 SyncHandle();
1043 return False; 1043 return False;
1044 } 1044 }
1045 *x = rep.x; 1045 *x = rep.x;
1093 LockDisplay(dpy); 1093 LockDisplay(dpy);
1094 GetReq(XF86VidModeGetDotClocks, req); 1094 GetReq(XF86VidModeGetDotClocks, req);
1095 req->reqType = info->codes->major_opcode; 1095 req->reqType = info->codes->major_opcode;
1096 req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks; 1096 req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks;
1097 req->screen = screen; 1097 req->screen = screen;
1098 if (!p_XReply(dpy, (xReply *)&rep, 1098 if (!_XReply(dpy, (xReply *)&rep,
1099 (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse)) 1099 (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse))
1100 { 1100 {
1101 UnlockDisplay(dpy); 1101 UnlockDisplay(dpy);
1102 SyncHandle(); 1102 SyncHandle();
1103 return False; 1103 return False;
1105 *numclocksPtr = rep.clocks; 1105 *numclocksPtr = rep.clocks;
1106 *maxclocksPtr = rep.maxclocks; 1106 *maxclocksPtr = rep.maxclocks;
1107 *flagsPtr = rep.flags; 1107 *flagsPtr = rep.flags;
1108 1108
1109 if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) { 1109 if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) {
1110 p_XEatData(dpy, (rep.clocks) * 4); 1110 _XEatData(dpy, (rep.clocks) * 4);
1111 Xfree(dotclocks); 1111 Xfree(dotclocks);
1112 UnlockDisplay(dpy); 1112 UnlockDisplay(dpy);
1113 SyncHandle(); 1113 SyncHandle();
1114 return False; 1114 return False;
1115 } 1115 }
1116 1116
1117 for (i = 0; i < rep.clocks; i++) { 1117 for (i = 0; i < rep.clocks; i++) {
1118 p_XRead(dpy, (char*)&dotclk, 4); 1118 _XRead(dpy, (char*)&dotclk, 4);
1119 dotclocks[i] = dotclk; 1119 dotclocks[i] = dotclk;
1120 } 1120 }
1121 *clocksPtr = dotclocks; 1121 *clocksPtr = dotclocks;
1122 UnlockDisplay(dpy); 1122 UnlockDisplay(dpy);
1123 SyncHandle(); 1123 SyncHandle();
1144 req->reqType = info->codes->major_opcode; 1144 req->reqType = info->codes->major_opcode;
1145 req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp; 1145 req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp;
1146 req->screen = screen; 1146 req->screen = screen;
1147 req->length += (length >> 1) * 3; 1147 req->length += (length >> 1) * 3;
1148 req->size = size; 1148 req->size = size;
1149 p_XSend(dpy, (char*)red, size * 2); 1149 _XSend(dpy, (char*)red, size * 2);
1150 p_XSend(dpy, (char*)green, size * 2); 1150 _XSend(dpy, (char*)green, size * 2);
1151 p_XSend(dpy, (char*)blue, size * 2); 1151 _XSend(dpy, (char*)blue, size * 2);
1152 UnlockDisplay(dpy); 1152 UnlockDisplay(dpy);
1153 SyncHandle(); 1153 SyncHandle();
1154 return True; 1154 return True;
1155 } 1155 }
1156 1156
1175 GetReq(XF86VidModeGetGammaRamp, req); 1175 GetReq(XF86VidModeGetGammaRamp, req);
1176 req->reqType = info->codes->major_opcode; 1176 req->reqType = info->codes->major_opcode;
1177 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp; 1177 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp;
1178 req->screen = screen; 1178 req->screen = screen;
1179 req->size = size; 1179 req->size = size;
1180 if (!p_XReply (dpy, (xReply *) &rep, 0, xFalse)) { 1180 if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
1181 UnlockDisplay (dpy); 1181 UnlockDisplay (dpy);
1182 SyncHandle (); 1182 SyncHandle ();
1183 return False; 1183 return False;
1184 } 1184 }
1185 if(rep.size) { 1185 if(rep.size) {
1186 p_XRead(dpy, (char*)red, rep.size << 1); 1186 _XRead(dpy, (char*)red, rep.size << 1);
1187 p_XRead(dpy, (char*)green, rep.size << 1); 1187 _XRead(dpy, (char*)green, rep.size << 1);
1188 p_XRead(dpy, (char*)blue, rep.size << 1); 1188 _XRead(dpy, (char*)blue, rep.size << 1);
1189 } 1189 }
1190 1190
1191 UnlockDisplay(dpy); 1191 UnlockDisplay(dpy);
1192 SyncHandle(); 1192 SyncHandle();
1193 return True; 1193 return True;
1210 LockDisplay(dpy); 1210 LockDisplay(dpy);
1211 GetReq(XF86VidModeGetGammaRampSize, req); 1211 GetReq(XF86VidModeGetGammaRampSize, req);
1212 req->reqType = info->codes->major_opcode; 1212 req->reqType = info->codes->major_opcode;
1213 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize; 1213 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize;
1214 req->screen = screen; 1214 req->screen = screen;
1215 if (!p_XReply (dpy, (xReply *) &rep, 0, xTrue)) { 1215 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
1216 UnlockDisplay (dpy); 1216 UnlockDisplay (dpy);
1217 SyncHandle (); 1217 SyncHandle ();
1218 return False; 1218 return False;
1219 } 1219 }
1220 *size = rep.size; 1220 *size = rep.size;