This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
XF86VMode.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* $XConsortium: XF86VMode.c /main/2 1995/11/14 18:17:58 kaleb $ */
/* $XFree86: xc/lib/Xxf86vm/XF86VMode.c,v 3.32 2001/07/25 15:04:54 dawes Exp $ */
/*
Copyright (c) 1995 Kaleb S. KEITHLEY
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of Kaleb S. KEITHLEY
shall not be used in advertising or otherwise to promote the sale, use
or other dealings in this Software without prior written authorization
from Kaleb S. KEITHLEY.
*/
/* $XConsortium: XF86VMode.c /main/4 1996/01/16 07:52:25 kaleb CHECKEDOUT $ */
/* THIS IS NOT AN X CONSORTIUM STANDARD */
#define NEED_EVENTS
#define NEED_REPLIES
39
#ifndef XBUILD_IN_CLIENT
40
#include <X11/Xlibint.h>
41
#include "../extensions/xf86vmstr.h"
42
#include "../extensions/Xext.h"
43
#include "../extensions/extutil.h"
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#else
#include "lib/X11/Xlibint.h"
#include "include/extensions/xf86vmstr.h"
#include "include/extensions/Xext.h"
#include "include/extensions/extutil.h"
#endif
#ifdef DEBUG
#include <stdio.h>
#endif
#ifndef MODE_BAD
#define MODE_BAD 255
#endif
static XExtensionInfo _xf86vidmode_info_data;
static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data;
static char *xf86vidmode_extension_name = XF86VIDMODENAME;
#define XF86VidModeCheckExtension(dpy,i,val) \
XextCheckExtension (dpy, i, xf86vidmode_extension_name, val)
/*****************************************************************************
* *
* private utility routines *
* *
*****************************************************************************/
72
static XEXT_CLOSE_DISPLAY_PROTO(close_display);
73
static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
74
75
76
77
78
79
80
81
82
83
84
NULL, /* create_gc */
NULL, /* copy_gc */
NULL, /* flush_gc */
NULL, /* free_gc */
NULL, /* create_font */
NULL, /* free_font */
close_display, /* close_display */
NULL, /* wire_to_event */
NULL, /* event_to_wire */
NULL, /* error */
NULL, /* error_string */
88
89
90
91
XEXT_GENERATE_FIND_DISPLAY(find_display, xf86vidmode_info,
xf86vidmode_extension_name,
&xf86vidmode_extension_hooks, 0, NULL)
static XEXT_GENERATE_CLOSE_DISPLAY(close_display, xf86vidmode_info)
92
93
94
95
96
/*****************************************************************************
* *
* public XFree86-VidMode Extension routines *
* *
*****************************************************************************/
98
SDL_NAME(XF86VidModeQueryExtension) (dpy, event_basep, error_basep)
99
100
Display *dpy;
int *event_basep, *error_basep;
102
XExtDisplayInfo *info = find_display(dpy);
104
if (XextHasExtension(info)) {
105
106
107
*event_basep = info->codes->first_event;
*error_basep = info->codes->first_error;
return True;
108
} else {
110
111
112
}
}
113
Bool SDL_NAME(XF86VidModeQueryVersion) (dpy, majorVersion, minorVersion)
114
115
116
117
118
119
Display *
dpy;
int *
majorVersion;
int *
minorVersion;
121
XExtDisplayInfo *info = find_display(dpy);
122
123
124
xXF86VidModeQueryVersionReply rep;
xXF86VidModeQueryVersionReq *req;
125
XF86VidModeCheckExtension(dpy, info, False);
127
128
LockDisplay(dpy);
GetReq(XF86VidModeQueryVersion, req);
129
130
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
131
132
133
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
135
136
137
}
*majorVersion = rep.majorVersion;
*minorVersion = rep.minorVersion;
138
139
UnlockDisplay(dpy);
SyncHandle();
140
if (*majorVersion >= 2)
141
SDL_NAME(XF86VidModeSetClientVersion) (dpy);
142
143
144
return True;
}
145
Bool SDL_NAME(XF86VidModeSetClientVersion) (Display * dpy)
147
XExtDisplayInfo *info = find_display(dpy);
148
149
xXF86VidModeSetClientVersionReq *req;
150
XF86VidModeCheckExtension(dpy, info, False);
152
153
LockDisplay(dpy);
GetReq(XF86VidModeSetClientVersion, req);
154
155
156
157
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion;
req->major = XF86VIDMODE_MAJOR_VERSION;
req->minor = XF86VIDMODE_MINOR_VERSION;
158
159
UnlockDisplay(dpy);
SyncHandle();
160
161
162
163
return True;
}
Bool
164
165
SDL_NAME(XF86VidModeSetGamma) (Display * dpy, int screen,
SDL_NAME(XF86VidModeGamma) * Gamma)
167
XExtDisplayInfo *info = find_display(dpy);
168
169
xXF86VidModeSetGammaReq *req;
170
XF86VidModeCheckExtension(dpy, info, False);
172
173
LockDisplay(dpy);
GetReq(XF86VidModeSetGamma, req);
174
175
176
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeSetGamma;
req->screen = screen;
177
178
179
req->red = (CARD32) (Gamma->red * 10000.);
req->green = (CARD32) (Gamma->green * 10000.);
req->blue = (CARD32) (Gamma->blue * 10000.);
180
181
UnlockDisplay(dpy);
SyncHandle();
182
183
184
185
return True;
}
Bool
186
187
SDL_NAME(XF86VidModeGetGamma) (Display * dpy, int screen,
SDL_NAME(XF86VidModeGamma) * Gamma)
189
XExtDisplayInfo *info = find_display(dpy);
190
191
192
xXF86VidModeGetGammaReply rep;
xXF86VidModeGetGammaReq *req;
193
XF86VidModeCheckExtension(dpy, info, False);
195
196
LockDisplay(dpy);
GetReq(XF86VidModeGetGamma, req);
197
198
199
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
req->screen = screen;
200
201
202
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
205
206
207
Gamma->red = ((float) rep.red) / 10000.;
Gamma->green = ((float) rep.green) / 10000.;
Gamma->blue = ((float) rep.blue) / 10000.;
208
209
UnlockDisplay(dpy);
SyncHandle();
210
211
212
return True;
}
213
Bool SDL_NAME(XF86VidModeGetModeLine) (dpy, screen, dotclock, modeline)
214
215
216
217
218
219
Display *
dpy;
int
screen;
int *
dotclock;
220
SDL_NAME(XF86VidModeModeLine) * modeline;
222
XExtDisplayInfo *info = find_display(dpy);
223
224
225
226
227
xXF86VidModeGetModeLineReply rep;
xXF86OldVidModeGetModeLineReply oldrep;
xXF86VidModeGetModeLineReq *req;
int majorVersion, minorVersion;
228
229
XF86VidModeCheckExtension(dpy, info, False);
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
231
232
LockDisplay(dpy);
GetReq(XF86VidModeGetModeLine, req);
233
234
235
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
req->screen = screen;
237
if (majorVersion < 2) {
238
239
240
241
242
if (!_XReply(dpy, (xReply *) & oldrep,
(SIZEOF(xXF86OldVidModeGetModeLineReply) -
SIZEOF(xReply)) >> 2, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
243
244
245
246
247
248
249
250
251
252
253
254
255
256
return False;
}
*dotclock = oldrep.dotclock;
modeline->hdisplay = oldrep.hdisplay;
modeline->hsyncstart = oldrep.hsyncstart;
modeline->hsyncend = oldrep.hsyncend;
modeline->htotal = oldrep.htotal;
modeline->hskew = 0;
modeline->vdisplay = oldrep.vdisplay;
modeline->vsyncstart = oldrep.vsyncstart;
modeline->vsyncend = oldrep.vsyncend;
modeline->vtotal = oldrep.vtotal;
modeline->flags = oldrep.flags;
modeline->privsize = oldrep.privsize;
257
} else {
258
259
260
261
262
if (!_XReply(dpy, (xReply *) & rep,
(SIZEOF(xXF86VidModeGetModeLineReply) -
SIZEOF(xReply)) >> 2, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
263
264
265
266
267
268
269
270
271
272
273
274
275
276
return False;
}
*dotclock = rep.dotclock;
modeline->hdisplay = rep.hdisplay;
modeline->hsyncstart = rep.hsyncstart;
modeline->hsyncend = rep.hsyncend;
modeline->htotal = rep.htotal;
modeline->hskew = rep.hskew;
modeline->vdisplay = rep.vdisplay;
modeline->vsyncstart = rep.vsyncstart;
modeline->vsyncend = rep.vsyncend;
modeline->vtotal = rep.vtotal;
modeline->flags = rep.flags;
modeline->privsize = rep.privsize;
279
if (modeline->privsize > 0) {
280
281
282
if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) {
_XEatData(dpy, (modeline->privsize) * sizeof(INT32));
Xfree(modeline->private);
283
284
return False;
}
285
286
_XRead(dpy, (char *) modeline->private,
modeline->privsize * sizeof(INT32));
287
} else {
288
modeline->private = NULL;
290
291
UnlockDisplay(dpy);
SyncHandle();
292
293
294
295
return True;
}
Bool
296
SDL_NAME(XF86VidModeGetAllModeLines) (dpy, screen, modecount, modelinesPtr)
297
298
299
Display *dpy;
int screen;
int *modecount;
300
SDL_NAME(XF86VidModeModeInfo) *** modelinesPtr;
302
XExtDisplayInfo *info = find_display(dpy);
303
304
xXF86VidModeGetAllModeLinesReply rep;
xXF86VidModeGetAllModeLinesReq *req;
305
SDL_NAME(XF86VidModeModeInfo) * mdinfptr, **modelines;
306
307
308
309
310
311
xXF86VidModeModeInfo xmdline;
xXF86OldVidModeModeInfo oldxmdline;
int i;
int majorVersion, minorVersion;
Bool protocolBug = False;
312
XF86VidModeCheckExtension(dpy, info, False);
313
314
315
316
317
318
319
/*
* Note: There was a bug in the protocol implementation in versions
* 0.x with x < 8 (the .private field wasn't being passed over the wire).
* Check the server's version, and accept the old format if appropriate.
*/
320
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
321
if (majorVersion == 0 && minorVersion < 8) {
322
protocolBug = True;
323
#ifdef DEBUG
324
325
326
fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
"running an old version (%d.%d)\n", majorVersion,
minorVersion);
327
328
#endif
}
330
331
LockDisplay(dpy);
GetReq(XF86VidModeGetAllModeLines, req);
332
333
334
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
req->screen = screen;
335
336
337
338
339
if (!_XReply(dpy, (xReply *) & rep,
(SIZEOF(xXF86VidModeGetAllModeLinesReply) -
SIZEOF(xReply)) >> 2, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
341
342
343
344
}
*modecount = rep.modecount;
345
346
if (!
(modelines =
347
348
349
350
351
352
(SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount,
sizeof(SDL_NAME
(XF86VidModeModeInfo)
*) +
sizeof(SDL_NAME
(XF86VidModeModeInfo)))))
353
354
{
if (majorVersion < 2)
355
_XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo));
357
358
359
360
_XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo));
Xfree(modelines);
UnlockDisplay(dpy);
SyncHandle();
361
362
return False;
}
363
364
365
366
367
368
mdinfptr = (SDL_NAME(XF86VidModeModeInfo) *) ((char *) modelines
+
rep.modecount *
sizeof(SDL_NAME
(XF86VidModeModeInfo)
*));
369
370
371
for (i = 0; i < rep.modecount; i++) {
modelines[i] = mdinfptr++;
372
if (majorVersion < 2) {
373
374
_XRead(dpy, (char *) &oldxmdline,
sizeof(xXF86OldVidModeModeInfo));
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
modelines[i]->dotclock = oldxmdline.dotclock;
modelines[i]->hdisplay = oldxmdline.hdisplay;
modelines[i]->hsyncstart = oldxmdline.hsyncstart;
modelines[i]->hsyncend = oldxmdline.hsyncend;
modelines[i]->htotal = oldxmdline.htotal;
modelines[i]->hskew = 0;
modelines[i]->vdisplay = oldxmdline.vdisplay;
modelines[i]->vsyncstart = oldxmdline.vsyncstart;
modelines[i]->vsyncend = oldxmdline.vsyncend;
modelines[i]->vtotal = oldxmdline.vtotal;
modelines[i]->flags = oldxmdline.flags;
if (protocolBug) {
modelines[i]->privsize = 0;
modelines[i]->private = NULL;
} else {
modelines[i]->privsize = oldxmdline.privsize;
if (oldxmdline.privsize > 0) {
if (!(modelines[i]->private =
393
394
395
Xcalloc(oldxmdline.privsize, sizeof(INT32)))) {
_XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32));
Xfree(modelines[i]->private);
397
398
_XRead(dpy, (char *) modelines[i]->private,
oldxmdline.privsize * sizeof(INT32));
399
400
401
402
403
404
}
} else {
modelines[i]->private = NULL;
}
}
} else {
405
_XRead(dpy, (char *) &xmdline, sizeof(xXF86VidModeModeInfo));
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
modelines[i]->dotclock = xmdline.dotclock;
modelines[i]->hdisplay = xmdline.hdisplay;
modelines[i]->hsyncstart = xmdline.hsyncstart;
modelines[i]->hsyncend = xmdline.hsyncend;
modelines[i]->htotal = xmdline.htotal;
modelines[i]->hskew = xmdline.hskew;
modelines[i]->vdisplay = xmdline.vdisplay;
modelines[i]->vsyncstart = xmdline.vsyncstart;
modelines[i]->vsyncend = xmdline.vsyncend;
modelines[i]->vtotal = xmdline.vtotal;
modelines[i]->flags = xmdline.flags;
if (protocolBug) {
modelines[i]->privsize = 0;
modelines[i]->private = NULL;
} else {
modelines[i]->privsize = xmdline.privsize;
if (xmdline.privsize > 0) {
if (!(modelines[i]->private =
424
425
426
Xcalloc(xmdline.privsize, sizeof(INT32)))) {
_XEatData(dpy, (xmdline.privsize) * sizeof(INT32));
Xfree(modelines[i]->private);
428
429
_XRead(dpy, (char *) modelines[i]->private,
xmdline.privsize * sizeof(INT32));
430
431
432
433
434
435
}
} else {
modelines[i]->private = NULL;
}
}
}
436
437
}
*modelinesPtr = modelines;
438
439
UnlockDisplay(dpy);
SyncHandle();
440
441
442
443
444
445
446
447
448
449
return True;
}
/*
* GetReq replacement for use with VidMode protocols earlier than 2.0
*/
#if !defined(UNIXCPP) || defined(ANSICPP)
#define GetOldReq(name, oldname, req) \
WORD64ALIGN\
if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)\
450
_XFlush(dpy);\
451
452
453
454
455
456
req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\
req->reqType = X_##name;\
req->length = (SIZEOF(x##oldname##Req))>>2;\
dpy->bufptr += SIZEOF(x##oldname##Req);\
dpy->request++
457
#else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
458
459
460
#define GetOldReq(name, oldname, req) \
WORD64ALIGN\
if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)\
461
_XFlush(dpy);\
462
463
464
465
466
467
468
469
req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);\
req->reqType = X_/**/name;\
req->length = (SIZEOF(x/**/oldname/**/Req))>>2;\
dpy->bufptr += SIZEOF(x/**/oldname/**/Req);\
dpy->request++
#endif
Bool
470
SDL_NAME(XF86VidModeAddModeLine) (dpy, screen, newmodeline, aftermodeline)
471
472
Display *dpy;
int screen;
473
474
SDL_NAME(XF86VidModeModeInfo) * newmodeline;
SDL_NAME(XF86VidModeModeInfo) * aftermodeline;
476
XExtDisplayInfo *info = find_display(dpy);
477
478
479
480
xXF86VidModeAddModeLineReq *req;
xXF86OldVidModeAddModeLineReq *oldreq;
int majorVersion, minorVersion;
481
482
XF86VidModeCheckExtension(dpy, info, False);
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
484
LockDisplay(dpy);
485
if (majorVersion < 2) {
486
GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq);
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
oldreq->reqType = info->codes->major_opcode;
oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
oldreq->screen = screen;
oldreq->dotclock = newmodeline->dotclock;
oldreq->hdisplay = newmodeline->hdisplay;
oldreq->hsyncstart = newmodeline->hsyncstart;
oldreq->hsyncend = newmodeline->hsyncend;
oldreq->htotal = newmodeline->htotal;
oldreq->vdisplay = newmodeline->vdisplay;
oldreq->vsyncstart = newmodeline->vsyncstart;
oldreq->vsyncend = newmodeline->vsyncend;
oldreq->vtotal = newmodeline->vtotal;
oldreq->flags = newmodeline->flags;
oldreq->privsize = newmodeline->privsize;
if (aftermodeline != NULL) {
oldreq->after_dotclock = aftermodeline->dotclock;
oldreq->after_hdisplay = aftermodeline->hdisplay;
oldreq->after_hsyncstart = aftermodeline->hsyncstart;
oldreq->after_hsyncend = aftermodeline->hsyncend;
oldreq->after_htotal = aftermodeline->htotal;
oldreq->after_vdisplay = aftermodeline->vdisplay;
oldreq->after_vsyncstart = aftermodeline->vsyncstart;
oldreq->after_vsyncend = aftermodeline->vsyncend;
oldreq->after_vtotal = aftermodeline->vtotal;
oldreq->after_flags = aftermodeline->flags;
} else {
oldreq->after_dotclock = 0;
oldreq->after_hdisplay = 0;
oldreq->after_hsyncstart = 0;
oldreq->after_hsyncend = 0;
oldreq->after_htotal = 0;
oldreq->after_vdisplay = 0;
oldreq->after_vsyncstart = 0;
oldreq->after_vsyncend = 0;
oldreq->after_vtotal = 0;
oldreq->after_flags = 0;
}
if (newmodeline->privsize) {
oldreq->length += newmodeline->privsize;
526
527
Data32(dpy, (long *) newmodeline->private,
newmodeline->privsize * sizeof(INT32));
529
} else {
530
GetReq(XF86VidModeAddModeLine, req);
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
req->screen = screen;
req->dotclock = newmodeline->dotclock;
req->hdisplay = newmodeline->hdisplay;
req->hsyncstart = newmodeline->hsyncstart;
req->hsyncend = newmodeline->hsyncend;
req->htotal = newmodeline->htotal;
req->hskew = newmodeline->hskew;
req->vdisplay = newmodeline->vdisplay;
req->vsyncstart = newmodeline->vsyncstart;
req->vsyncend = newmodeline->vsyncend;
req->vtotal = newmodeline->vtotal;
req->flags = newmodeline->flags;
req->privsize = newmodeline->privsize;
if (aftermodeline != NULL) {
req->after_dotclock = aftermodeline->dotclock;
req->after_hdisplay = aftermodeline->hdisplay;
req->after_hsyncstart = aftermodeline->hsyncstart;
req->after_hsyncend = aftermodeline->hsyncend;
req->after_htotal = aftermodeline->htotal;
req->after_hskew = aftermodeline->hskew;
req->after_vdisplay = aftermodeline->vdisplay;
req->after_vsyncstart = aftermodeline->vsyncstart;
req->after_vsyncend = aftermodeline->vsyncend;
req->after_vtotal = aftermodeline->vtotal;
req->after_flags = aftermodeline->flags;
} else {
req->after_dotclock = 0;
req->after_hdisplay = 0;
req->after_hsyncstart = 0;
req->after_hsyncend = 0;
req->after_htotal = 0;
req->after_hskew = 0;
req->after_vdisplay = 0;
req->after_vsyncstart = 0;
req->after_vsyncend = 0;
req->after_vtotal = 0;
req->after_flags = 0;
}
if (newmodeline->privsize) {
req->length += newmodeline->privsize;
573
574
Data32(dpy, (long *) newmodeline->private,
newmodeline->privsize * sizeof(INT32));
577
578
UnlockDisplay(dpy);
SyncHandle();
579
580
581
return True;
}
582
Bool SDL_NAME(XF86VidModeDeleteModeLine) (dpy, screen, modeline)
583
584
585
586
Display *
dpy;
int
screen;
587
SDL_NAME(XF86VidModeModeInfo) * modeline;
589
XExtDisplayInfo *info = find_display(dpy);
590
591
592
593
xXF86VidModeDeleteModeLineReq *req;
xXF86OldVidModeDeleteModeLineReq *oldreq;
int majorVersion, minorVersion;
594
595
XF86VidModeCheckExtension(dpy, info, 0);
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
597
LockDisplay(dpy);
598
if (majorVersion < 2) {
599
600
GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine,
oldreq);
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
oldreq->reqType = info->codes->major_opcode;
oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
oldreq->screen = screen;
oldreq->dotclock = modeline->dotclock;
oldreq->hdisplay = modeline->hdisplay;
oldreq->hsyncstart = modeline->hsyncstart;
oldreq->hsyncend = modeline->hsyncend;
oldreq->htotal = modeline->htotal;
oldreq->vdisplay = modeline->vdisplay;
oldreq->vsyncstart = modeline->vsyncstart;
oldreq->vsyncend = modeline->vsyncend;
oldreq->vtotal = modeline->vtotal;
oldreq->flags = modeline->flags;
oldreq->privsize = modeline->privsize;
if (modeline->privsize) {
oldreq->length += modeline->privsize;
617
618
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
620
} else {
621
GetReq(XF86VidModeDeleteModeLine, req);
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
req->screen = screen;
req->dotclock = modeline->dotclock;
req->hdisplay = modeline->hdisplay;
req->hsyncstart = modeline->hsyncstart;
req->hsyncend = modeline->hsyncend;
req->htotal = modeline->htotal;
req->hskew = modeline->hskew;
req->vdisplay = modeline->vdisplay;
req->vsyncstart = modeline->vsyncstart;
req->vsyncend = modeline->vsyncend;
req->vtotal = modeline->vtotal;
req->flags = modeline->flags;
req->privsize = modeline->privsize;
if (modeline->privsize) {
req->length += modeline->privsize;
639
640
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
643
644
UnlockDisplay(dpy);
SyncHandle();
645
646
647
return True;
}
648
Bool SDL_NAME(XF86VidModeModModeLine) (dpy, screen, modeline)
649
650
651
652
Display *
dpy;
int
screen;
653
SDL_NAME(XF86VidModeModeLine) * modeline;
655
XExtDisplayInfo *info = find_display(dpy);
656
657
658
659
xXF86VidModeModModeLineReq *req;
xXF86OldVidModeModModeLineReq *oldreq;
int majorVersion, minorVersion;
660
661
XF86VidModeCheckExtension(dpy, info, 0);
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
663
LockDisplay(dpy);
664
if (majorVersion < 2) {
665
GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq);
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
oldreq->reqType = info->codes->major_opcode;
oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine;
oldreq->screen = screen;
oldreq->hdisplay = modeline->hdisplay;
oldreq->hsyncstart = modeline->hsyncstart;
oldreq->hsyncend = modeline->hsyncend;
oldreq->htotal = modeline->htotal;
oldreq->vdisplay = modeline->vdisplay;
oldreq->vsyncstart = modeline->vsyncstart;
oldreq->vsyncend = modeline->vsyncend;
oldreq->vtotal = modeline->vtotal;
oldreq->flags = modeline->flags;
oldreq->privsize = modeline->privsize;
if (modeline->privsize) {
oldreq->length += modeline->privsize;
681
682
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
684
} else {
685
GetReq(XF86VidModeModModeLine, req);
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeModModeLine;
req->screen = screen;
req->hdisplay = modeline->hdisplay;
req->hsyncstart = modeline->hsyncstart;
req->hsyncend = modeline->hsyncend;
req->htotal = modeline->htotal;
req->hskew = modeline->hskew;
req->vdisplay = modeline->vdisplay;
req->vsyncstart = modeline->vsyncstart;
req->vsyncend = modeline->vsyncend;
req->vtotal = modeline->vtotal;
req->flags = modeline->flags;
req->privsize = modeline->privsize;
if (modeline->privsize) {
req->length += modeline->privsize;
702
703
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
706
707
UnlockDisplay(dpy);
SyncHandle();
708
709
710
return True;
}
711
Status SDL_NAME(XF86VidModeValidateModeLine) (dpy, screen, modeline)
712
713
714
715
Display *
dpy;
int
screen;
716
SDL_NAME(XF86VidModeModeInfo) * modeline;
718
XExtDisplayInfo *info = find_display(dpy);
719
720
721
722
723
xXF86VidModeValidateModeLineReq *req;
xXF86OldVidModeValidateModeLineReq *oldreq;
xXF86VidModeValidateModeLineReply rep;
int majorVersion, minorVersion;
724
725
XF86VidModeCheckExtension(dpy, info, 0);
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
727
LockDisplay(dpy);
728
729
if (majorVersion < 2) {
730
731
GetOldReq(XF86VidModeValidateModeLine,
XF86OldVidModeValidateModeLine, oldreq);
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
oldreq->reqType = info->codes->major_opcode;
oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
oldreq->screen = screen;
oldreq->dotclock = modeline->dotclock;
oldreq->hdisplay = modeline->hdisplay;
oldreq->hsyncstart = modeline->hsyncstart;
oldreq->hsyncend = modeline->hsyncend;
oldreq->htotal = modeline->htotal;
oldreq->vdisplay = modeline->vdisplay;
oldreq->vsyncstart = modeline->vsyncstart;
oldreq->vsyncend = modeline->vsyncend;
oldreq->vtotal = modeline->vtotal;
oldreq->flags = modeline->flags;
oldreq->privsize = modeline->privsize;
if (modeline->privsize) {
oldreq->length += modeline->privsize;
748
749
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
751
} else {
752
GetReq(XF86VidModeValidateModeLine, req);
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
req->screen = screen;
req->dotclock = modeline->dotclock;
req->hdisplay = modeline->hdisplay;
req->hsyncstart = modeline->hsyncstart;
req->hsyncend = modeline->hsyncend;
req->htotal = modeline->htotal;
req->hskew = modeline->hskew;
req->vdisplay = modeline->vdisplay;
req->vsyncstart = modeline->vsyncstart;
req->vsyncend = modeline->vsyncend;
req->vtotal = modeline->vtotal;
req->flags = modeline->flags;
req->privsize = modeline->privsize;
if (modeline->privsize) {
req->length += modeline->privsize;
770
771
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
774
775
776
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
777
return MODE_BAD;
779
780
UnlockDisplay(dpy);
SyncHandle();
781
782
783
return rep.status;
}
784
Bool SDL_NAME(XF86VidModeSwitchMode) (dpy, screen, zoom)
785
786
787
788
789
790
Display *
dpy;
int
screen;
int
zoom;
792
XExtDisplayInfo *info = find_display(dpy);
793
794
xXF86VidModeSwitchModeReq *req;
795
XF86VidModeCheckExtension(dpy, info, False);
797
798
LockDisplay(dpy);
GetReq(XF86VidModeSwitchMode, req);
799
800
801
802
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeSwitchMode;
req->screen = screen;
req->zoom = zoom;
803
804
UnlockDisplay(dpy);
SyncHandle();
805
806
return True;
}
808
Bool SDL_NAME(XF86VidModeSwitchToMode) (dpy, screen, modeline)
809
810
811
812
Display *
dpy;
int
screen;
813
SDL_NAME(XF86VidModeModeInfo) * modeline;
815
XExtDisplayInfo *info = find_display(dpy);
816
817
818
819
820
xXF86VidModeSwitchToModeReq *req;
xXF86OldVidModeSwitchToModeReq *oldreq;
int majorVersion, minorVersion;
Bool protocolBug = False;
821
XF86VidModeCheckExtension(dpy, info, False);
822
823
824
825
826
827
828
829
/*
* Note: There was a bug in the protocol implementation in versions
* 0.x with x < 8 (the .private field wasn't expected to be sent over
* the wire). Check the server's version, and accept the old format
* if appropriate.
*/
830
SDL_NAME(XF86VidModeQueryVersion) (dpy, &majorVersion, &minorVersion);
831
if (majorVersion == 0 && minorVersion < 8) {
832
protocolBug = True;
833
#ifdef DEBUG
834
835
836
fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is"
"running an old version (%d.%d)\n", majorVersion,
minorVersion);
837
838
#endif
}
840
LockDisplay(dpy);
841
if (majorVersion < 2) {
842
843
GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode,
oldreq);
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
oldreq->reqType = info->codes->major_opcode;
oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
oldreq->screen = screen;
oldreq->dotclock = modeline->dotclock;
oldreq->hdisplay = modeline->hdisplay;
oldreq->hsyncstart = modeline->hsyncstart;
oldreq->hsyncend = modeline->hsyncend;
oldreq->htotal = modeline->htotal;
oldreq->vdisplay = modeline->vdisplay;
oldreq->vsyncstart = modeline->vsyncstart;
oldreq->vsyncend = modeline->vsyncend;
oldreq->vtotal = modeline->vtotal;
oldreq->flags = modeline->flags;
if (protocolBug) {
oldreq->privsize = 0;
} else {
oldreq->privsize = modeline->privsize;
if (modeline->privsize) {
oldreq->length += modeline->privsize;
863
864
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
867
} else {
868
GetReq(XF86VidModeSwitchToMode, req);
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
req->screen = screen;
req->dotclock = modeline->dotclock;
req->hdisplay = modeline->hdisplay;
req->hsyncstart = modeline->hsyncstart;
req->hsyncend = modeline->hsyncend;
req->htotal = modeline->htotal;
req->hskew = modeline->hskew;
req->vdisplay = modeline->vdisplay;
req->vsyncstart = modeline->vsyncstart;
req->vsyncend = modeline->vsyncend;
req->vtotal = modeline->vtotal;
req->flags = modeline->flags;
if (protocolBug) {
req->privsize = 0;
} else {
req->privsize = modeline->privsize;
if (modeline->privsize) {
req->length += modeline->privsize;
889
890
Data32(dpy, (long *) modeline->private,
modeline->privsize * sizeof(INT32));
894
895
UnlockDisplay(dpy);
SyncHandle();
896
897
return True;
}
899
Bool SDL_NAME(XF86VidModeLockModeSwitch) (dpy, screen, lock)
900
901
902
903
904
905
Display *
dpy;
int
screen;
int
lock;
907
XExtDisplayInfo *info = find_display(dpy);
908
909
xXF86VidModeLockModeSwitchReq *req;
910
XF86VidModeCheckExtension(dpy, info, False);
912
913
LockDisplay(dpy);
GetReq(XF86VidModeLockModeSwitch, req);
914
915
916
917
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch;
req->screen = screen;
req->lock = lock;
918
919
UnlockDisplay(dpy);
SyncHandle();
920
921
return True;
}
923
Bool SDL_NAME(XF86VidModeGetMonitor) (dpy, screen, monitor)
924
925
926
927
Display *
dpy;
int
screen;
928
SDL_NAME(XF86VidModeMonitor) * monitor;
930
XExtDisplayInfo *info = find_display(dpy);
931
932
933
934
935
xXF86VidModeGetMonitorReply rep;
xXF86VidModeGetMonitorReq *req;
CARD32 syncrange;
int i;
936
XF86VidModeCheckExtension(dpy, info, False);
938
939
LockDisplay(dpy);
GetReq(XF86VidModeGetMonitor, req);
940
941
942
req->reqType = info->codes->major_opcode;
req->xf86vidmodeReqType = X_XF86VidModeGetMonitor;
req->screen = screen;
943
944
945
if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
947
948
949
950
}
monitor->nhsync = rep.nhsync;
monitor->nvsync = rep.nvsync;
#if 0
951
monitor->bandwidth = (float) rep.bandwidth / 1e6;
952
953
#endif
if (rep.vendorLength) {
954
955
956
957
958
959
if (!(monitor->vendor = (char *) Xcalloc(rep.vendorLength + 1, 1))) {
_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
((rep.vendorLength + 3) & ~3) +
((rep.modelLength + 3) & ~3));
UnlockDisplay(dpy);
SyncHandle();
960
961
return False;
}
962
} else {
963
monitor->vendor = NULL;
964
965
}
if (rep.modelLength) {
966
967
968
969
if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) {
_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
((rep.vendorLength + 3) & ~3) +
((rep.modelLength + 3) & ~3));
970
if (monitor->vendor)
971
972
973
Xfree(monitor->vendor);
UnlockDisplay(dpy);
SyncHandle();
974
975
return False;
}
976
} else {
977
monitor->model = NULL;
979
980
if (!
(monitor->hsync =
981
982
983
984
Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
((rep.vendorLength + 3) & ~3) +
((rep.modelLength + 3) & ~3));
985
986
if (monitor->vendor)
987
Xfree(monitor->vendor);
988
if (monitor->model)
989
990
991
Xfree(monitor->model);
UnlockDisplay(dpy);
SyncHandle();
994
995
if (!
(monitor->vsync =
996
997
998
999
Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
_XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
((rep.vendorLength + 3) & ~3) +
((rep.modelLength + 3) & ~3));
1000
if (monitor->vendor)