← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/glut/os2/glut_gamemode.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glut/os2/glut_gamemode.cpp
1
 
 
2
 
/* Copyright (c) Mark J. Kilgard, 1998. */
3
 
 
4
 
/* This program is freely distributable without licensing fees
5
 
   and is provided without guarantee or warrantee expressed or
6
 
   implied. This program is -not- in the public domain. */
7
 
 
8
 
 
9
 
#include <assert.h>
10
 
#include <stdio.h>
11
 
#include <stdlib.h>
12
 
#include <string.h>
13
 
 
14
 
#include "glutint.h"
15
 
 
16
 
#if !defined(_WIN32) && !defined(__OS2__)
17
 
#include <X11/Xlib.h>
18
 
#include <X11/Xatom.h>
19
 
 
20
 
/* SGI optimization introduced in IRIX 6.3 to avoid X server
21
 
   round trips for interning common X atoms. */
22
 
#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
23
 
#include <X11/SGIFastAtom.h>
24
 
#else
25
 
#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
26
 
#endif
27
 
#endif  /* not _WIN32 */
28
 
 
29
 
int __glutDisplaySettingsChanged = 0;
30
 
static DisplayMode *dmodes, *currentDm = NULL;
31
 
static int ndmodes = -1;
32
 
GLUTwindow *__glutGameModeWindow = NULL;
33
 
 
34
 
#ifdef TEST
35
 
static char *compstr[] =
36
 
{
37
 
  "none", "=", "!=", "<=", ">=", ">", "<", "~"
38
 
};
39
 
static char *capstr[] =
40
 
{
41
 
  "width", "height", "bpp", "hertz", "num"
42
 
};
43
 
#endif
44
 
 
45
 
#if defined(__OS2__)
46
 
void
47
 
#else
48
 
void __cdecl
49
 
#endif
50
 
__glutCloseDownGameMode(void)
51
 
{
52
 
  if (__glutDisplaySettingsChanged) {
53
 
#ifdef _WIN32
54
 
    /* Assumes that display settings have been changed, that
55
 
       is __glutDisplaySettingsChanged is true. */
56
 
    ChangeDisplaySettings(NULL, 0);
57
 
#endif
58
 
    __glutDisplaySettingsChanged = 0;
59
 
  }
60
 
  __glutGameModeWindow = NULL;
61
 
}
62
 
 
63
 
void GLUTAPIENTRY
64
 
glutLeaveGameMode(void)
65
 
{
66
 
  if (__glutGameModeWindow == NULL) {
67
 
    __glutWarning("not in game mode so cannot leave game mode");
68
 
    return;
69
 
  }
70
 
  __glutDestroyWindow(__glutGameModeWindow,
71
 
    __glutGameModeWindow);
72
 
  XFlush(__glutDisplay);
73
 
  __glutGameModeWindow = NULL;
74
 
}
75
 
 
76
 
#ifdef _WIN32
77
 
 
78
 
/* Same values as from MSDN's SetDisp.c example. */
79
 
#define MIN_WIDTH 400
80
 
#define MIN_FREQUENCY 60
81
 
 
82
 
static void
83
 
initGameModeSupport(void)
84
 
{
85
 
  DEVMODE dm;
86
 
  DWORD mode;
87
 
  int i;
88
 
 
89
 
  if (ndmodes >= 0) {
90
 
    /* ndmodes is initially -1 to indicate no
91
 
       dmodes allocated yet. */
92
 
    return;
93
 
  }
94
 
 
95
 
  /* Determine how many display modes there are. */
96
 
  ndmodes = 0;
97
 
  mode = 0;
98
 
  while (EnumDisplaySettings(NULL, mode, &dm)) {
99
 
    if (dm.dmPelsWidth >= MIN_WIDTH &&
100
 
      (dm.dmDisplayFrequency == 0 ||
101
 
      dm.dmDisplayFrequency >= MIN_FREQUENCY)) {
102
 
      ndmodes++;
103
 
    }
104
 
    mode++;
105
 
  }
106
 
 
107
 
  /* Allocate memory for a list of all the display modes. */
108
 
  dmodes = (DisplayMode*)
109
 
    malloc(ndmodes * sizeof(DisplayMode));
110
 
 
111
 
  /* Now that we know how many display modes to expect,
112
 
     enumerate them again and save the information in
113
 
     the list we allocated above. */
114
 
  i = 0;
115
 
  mode = 0;
116
 
  while (EnumDisplaySettings(NULL, mode, &dm)) {
117
 
    /* Try to reject any display settings that seem unplausible. */
118
 
    if (dm.dmPelsWidth >= MIN_WIDTH &&
119
 
      (dm.dmDisplayFrequency == 0 ||
120
 
      dm.dmDisplayFrequency >= MIN_FREQUENCY)) {
121
 
      dmodes[i].devmode = dm;
122
 
      dmodes[i].valid = 1;  /* XXX Not used for now. */
123
 
      dmodes[i].cap[DM_WIDTH] = dm.dmPelsWidth;
124
 
      dmodes[i].cap[DM_HEIGHT] = dm.dmPelsHeight;
125
 
      dmodes[i].cap[DM_PIXEL_DEPTH] = dm.dmBitsPerPel;
126
 
      if (dm.dmDisplayFrequency == 0) {
127
 
       /* Guess a reasonable guess. */
128
 
       /* Lame Windows 95 version of EnumDisplaySettings. */
129
 
        dmodes[i].cap[DM_HERTZ] = 60;
130
 
      } else {
131
 
       dmodes[i].cap[DM_HERTZ] = dm.dmDisplayFrequency;
132
 
      }
133
 
      i++;
134
 
    }
135
 
    mode++;
136
 
  }
137
 
 
138
 
  assert(i == ndmodes);
139
 
}
140
 
 
141
 
#else
142
 
 
143
 
/* X Windows version of initGameModeSupport. */
144
 
static void
145
 
initGameModeSupport(void)
146
 
{
147
 
  if (ndmodes >= 0) {
148
 
    /* ndmodes is initially -1 to indicate no
149
 
       dmodes allocated yet. */
150
 
    return;
151
 
  }
152
 
 
153
 
  /* Determine how many display modes there are. */
154
 
  ndmodes = 0;
155
 
}
156
 
 
157
 
#endif
158
 
 
159
 
/* This routine is based on similiar code in glut_dstr.c */
160
 
static DisplayMode *
161
 
findMatch(DisplayMode * dmodes, int ndmodes,
162
 
  Criterion * criteria, int ncriteria)
163
 
{
164
 
  DisplayMode *found;
165
 
  int *bestScore, *thisScore;
166
 
  int i, j, numok, result = 0, worse, better;
167
 
 
168
 
  found = NULL;
169
 
  numok = 1;            /* "num" capability is indexed from 1,
170
 
                           not 0. */
171
 
 
172
 
  /* XXX alloca canidate. */
173
 
  bestScore = (int *) malloc(ncriteria * sizeof(int));
174
 
  if (!bestScore) {
175
 
    __glutFatalError("out of memory.");
176
 
  }
177
 
  for (j = 0; j < ncriteria; j++) {
178
 
    /* Very negative number. */
179
 
    bestScore[j] = -32768;
180
 
  }
181
 
 
182
 
  /* XXX alloca canidate. */
183
 
  thisScore = (int *) malloc(ncriteria * sizeof(int));
184
 
  if (!thisScore) {
185
 
    __glutFatalError("out of memory.");
186
 
  }
187
 
 
188
 
  for (i = 0; i < ndmodes; i++) {
189
 
    if (dmodes[i].valid) {
190
 
      worse = 0;
191
 
      better = 0;
192
 
 
193
 
      for (j = 0; j < ncriteria; j++) {
194
 
        int cap, cvalue, dvalue;
195
 
 
196
 
        cap = criteria[j].capability;
197
 
        cvalue = criteria[j].value;
198
 
        if (cap == NUM) {
199
 
          dvalue = numok;
200
 
        } else {
201
 
          dvalue = dmodes[i].cap[cap];
202
 
        }
203
 
#ifdef TEST
204
 
        if (verbose)
205
 
          printf("  %s %s %d to %d\n",
206
 
            capstr[cap], compstr[criteria[j].comparison], cvalue, dvalue);
207
 
#endif
208
 
        switch (criteria[j].comparison) {
209
 
        case EQ:
210
 
          result = cvalue == dvalue;
211
 
          thisScore[j] = 1;
212
 
          break;
213
 
        case NEQ:
214
 
          result = cvalue != dvalue;
215
 
          thisScore[j] = 1;
216
 
          break;
217
 
        case LT:
218
 
          result = dvalue < cvalue;
219
 
          thisScore[j] = dvalue - cvalue;
220
 
          break;
221
 
        case GT:
222
 
          result = dvalue > cvalue;
223
 
          thisScore[j] = dvalue - cvalue;
224
 
          break;
225
 
        case LTE:
226
 
          result = dvalue <= cvalue;
227
 
          thisScore[j] = dvalue - cvalue;
228
 
          break;
229
 
        case GTE:
230
 
          result = (dvalue >= cvalue);
231
 
          thisScore[j] = dvalue - cvalue;
232
 
          break;
233
 
        case MIN:
234
 
          result = dvalue >= cvalue;
235
 
          thisScore[j] = cvalue - dvalue;
236
 
          break;
237
 
        }
238
 
 
239
 
#ifdef TEST
240
 
        if (verbose)
241
 
          printf("                result=%d   score=%d   bestScore=%d\n", result, thisScore[j], bestScore[j]);
242
 
#endif
243
 
 
244
 
        if (result) {
245
 
          if (better || thisScore[j] > bestScore[j]) {
246
 
            better = 1;
247
 
          } else if (thisScore[j] == bestScore[j]) {
248
 
            /* Keep looking. */
249
 
          } else {
250
 
            goto nextDM;
251
 
          }
252
 
        } else {
253
 
          if (cap == NUM) {
254
 
            worse = 1;
255
 
          } else {
256
 
            goto nextDM;
257
 
          }
258
 
        }
259
 
 
260
 
      }
261
 
 
262
 
      if (better && !worse) {
263
 
        found = &dmodes[i];
264
 
        for (j = 0; j < ncriteria; j++) {
265
 
          bestScore[j] = thisScore[j];
266
 
        }
267
 
      }
268
 
      numok++;
269
 
 
270
 
    nextDM:;
271
 
 
272
 
    }
273
 
  }
274
 
  free(bestScore);
275
 
  free(thisScore);
276
 
  return found;
277
 
}
278
 
 
279
 
/**
280
 
 * Parses strings in the form of:
281
 
 *  800x600
282
 
 *  800x600:16
283
 
 *  800x600@60
284
 
 *  800x600:16@60
285
 
 *  @60
286
 
 *  :16
287
 
 *  :16@60
288
 
 * NOTE that @ before : is not parsed.
289
 
 */
290
 
static int
291
 
specialCaseParse(char *word, Criterion * criterion, int mask)
292
 
{
293
 
  char *xstr, *response;
294
 
  int got;
295
 
  int width, height, bpp, hertz;
296
 
 
297
 
  switch(word[0]) {
298
 
  case '0':
299
 
  case '1':
300
 
  case '2':
301
 
  case '3':
302
 
  case '4':
303
 
  case '5':
304
 
  case '6':
305
 
  case '7':
306
 
  case '8':
307
 
  case '9':
308
 
    /* The WWWxHHH case. */
309
 
    if (mask & (1 << DM_WIDTH)) {
310
 
      return -1;
311
 
    }
312
 
    xstr = strpbrk(&word[1], "x");
313
 
    if (xstr) {
314
 
      width = (int) strtol(word, &response, 0);
315
 
      if (response == word || response[0] != 'x') {
316
 
        /* Not a valid number OR needs to be followed by 'x'. */
317
 
       return -1;
318
 
      }
319
 
      height = (int) strtol(&xstr[1], &response, 0);
320
 
      if (response == &xstr[1]) {
321
 
        /* Not a valid number. */
322
 
       return -1;
323
 
      }
324
 
      criterion[0].capability = DM_WIDTH;
325
 
      criterion[0].comparison = EQ;
326
 
      criterion[0].value = width;
327
 
      criterion[1].capability = DM_HEIGHT;
328
 
      criterion[1].comparison = EQ;
329
 
      criterion[1].value = height;
330
 
      got = specialCaseParse(response,
331
 
        &criterion[2], 1 << DM_WIDTH);
332
 
      if (got >= 0) {
333
 
        return got + 2;
334
 
      } else {
335
 
        return -1;
336
 
      }
337
 
    }
338
 
    return -1;
339
 
  case ':':
340
 
    /* The :BPP case. */
341
 
    if (mask & (1 << DM_PIXEL_DEPTH)) {
342
 
      return -1;
343
 
    }
344
 
    bpp = (int) strtol(&word[1], &response, 0);
345
 
    if (response == &word[1]) {
346
 
      /* Not a valid number. */
347
 
      return -1;
348
 
    }
349
 
    criterion[0].capability = DM_PIXEL_DEPTH;
350
 
    criterion[0].comparison = EQ;
351
 
    criterion[0].value = bpp;
352
 
    got = specialCaseParse(response,
353
 
      &criterion[1], (1 << DM_WIDTH) | (1 << DM_PIXEL_DEPTH));
354
 
    if (got >= 0) {
355
 
      return got + 1;
356
 
    } else {
357
 
      return -1;
358
 
    }
359
 
  case '@':
360
 
    /* The @HZ case. */
361
 
    if (mask & (1 << DM_HERTZ)) {
362
 
      return -1;
363
 
    }
364
 
    hertz = (int) strtol(&word[1], &response, 0);
365
 
    if (response == &word[1]) {
366
 
      /* Not a valid number. */
367
 
      return -1;
368
 
    }
369
 
    criterion[0].capability = DM_HERTZ;
370
 
    criterion[0].comparison = EQ;
371
 
    criterion[0].value = hertz;
372
 
    got = specialCaseParse(response,
373
 
      &criterion[1], ~DM_HERTZ);
374
 
    if (got >= 0) {
375
 
      return got + 1;
376
 
    } else {
377
 
      return -1;
378
 
    }
379
 
  case '\0':
380
 
    return 0;
381
 
  }
382
 
  return -1;
383
 
}
384
 
 
385
 
/* This routine is based on similiar code in glut_dstr.c */
386
 
static int
387
 
parseCriteria(char *word, Criterion * criterion)
388
 
{
389
 
  char *cstr, *vstr, *response;
390
 
  int comparator, value = 0;
391
 
 
392
 
  cstr = strpbrk(word, "=><!~");
393
 
  if (cstr) {
394
 
    switch (cstr[0]) {
395
 
    case '=':
396
 
      comparator = EQ;
397
 
      vstr = &cstr[1];
398
 
      break;
399
 
    case '~':
400
 
      comparator = MIN;
401
 
      vstr = &cstr[1];
402
 
      break;
403
 
    case '>':
404
 
      if (cstr[1] == '=') {
405
 
        comparator = GTE;
406
 
        vstr = &cstr[2];
407
 
      } else {
408
 
        comparator = GT;
409
 
        vstr = &cstr[1];
410
 
      }
411
 
      break;
412
 
    case '<':
413
 
      if (cstr[1] == '=') {
414
 
        comparator = LTE;
415
 
        vstr = &cstr[2];
416
 
      } else {
417
 
        comparator = LT;
418
 
        vstr = &cstr[1];
419
 
      }
420
 
      break;
421
 
    case '!':
422
 
      if (cstr[1] == '=') {
423
 
        comparator = NEQ;
424
 
        vstr = &cstr[2];
425
 
      } else {
426
 
        return -1;
427
 
      }
428
 
      break;
429
 
    default:
430
 
      return -1;
431
 
    }
432
 
    value = (int) strtol(vstr, &response, 0);
433
 
    if (response == vstr) {
434
 
      /* Not a valid number. */
435
 
      return -1;
436
 
    }
437
 
    *cstr = '\0';
438
 
  } else {
439
 
    comparator = NONE;
440
 
  }
441
 
  switch (word[0]) {
442
 
  case 'b':
443
 
    if (!strcmp(word, "bpp")) {
444
 
      criterion[0].capability = DM_PIXEL_DEPTH;
445
 
      if (comparator == NONE) {
446
 
        return -1;
447
 
      } else {
448
 
        criterion[0].comparison = comparator;
449
 
        criterion[0].value = value;
450
 
        return 1;
451
 
      }
452
 
    }
453
 
    return -1;
454
 
  case 'h':
455
 
    if (!strcmp(word, "height")) {
456
 
      criterion[0].capability = DM_HEIGHT;
457
 
      if (comparator == NONE) {
458
 
        return -1;
459
 
      } else {
460
 
        criterion[0].comparison = comparator;
461
 
        criterion[0].value = value;
462
 
        return 1;
463
 
      }
464
 
    }
465
 
    if (!strcmp(word, "hertz")) {
466
 
      criterion[0].capability = DM_HERTZ;
467
 
      if (comparator == NONE) {
468
 
        return -1;
469
 
      } else {
470
 
        criterion[0].comparison = comparator;
471
 
        criterion[0].value = value;
472
 
        return 1;
473
 
      }
474
 
    }
475
 
    return -1;
476
 
  case 'n':
477
 
    if (!strcmp(word, "num")) {
478
 
      criterion[0].capability = DM_NUM;
479
 
      if (comparator == NONE) {
480
 
        return -1;
481
 
      } else {
482
 
        criterion[0].comparison = comparator;
483
 
        criterion[0].value = value;
484
 
        return 1;
485
 
      }
486
 
    }
487
 
    return -1;
488
 
  case 'w':
489
 
    if (!strcmp(word, "width")) {
490
 
      criterion[0].capability = DM_WIDTH;
491
 
      if (comparator == NONE) {
492
 
        return -1;
493
 
      } else {
494
 
        criterion[0].comparison = comparator;
495
 
        criterion[0].value = value;
496
 
        return 1;
497
 
      }
498
 
    }
499
 
    return -1;
500
 
  }
501
 
  if (comparator == NONE) {
502
 
    return specialCaseParse(word, criterion, 0);
503
 
  }
504
 
  return -1;
505
 
}
506
 
 
507
 
/* This routine is based on similiar code in glut_dstr.c */
508
 
static Criterion *
509
 
parseDisplayString(const char *display, int *ncriteria)
510
 
{
511
 
  Criterion *criteria = NULL;
512
 
  int n, parsed;
513
 
  char *copy, *word;
514
 
 
515
 
  copy = __glutStrdup(display);
516
 
  /* Attempt to estimate how many criteria entries should be
517
 
     needed. */
518
 
  n = 0;
519
 
  word = strtok(copy, " \t");
520
 
  while (word) {
521
 
    n++;
522
 
    word = strtok(NULL, " \t");
523
 
  }
524
 
  /* Allocate number of words of criteria.  A word
525
 
     could contain as many as four criteria in the
526
 
     worst case.  Example: 800x600:16@60 */
527
 
  criteria = (Criterion *) malloc(4 * n * sizeof(Criterion));
528
 
  if (!criteria) {
529
 
    __glutFatalError("out of memory.");
530
 
  }
531
 
 
532
 
  /* Re-copy the copy of the display string. */
533
 
  strcpy(copy, display);
534
 
 
535
 
  n = 0;
536
 
  word = strtok(copy, " \t");
537
 
  while (word) {
538
 
    parsed = parseCriteria(word, &criteria[n]);
539
 
    if (parsed >= 0) {
540
 
      n += parsed;
541
 
    } else {
542
 
      __glutWarning("Unrecognized game mode string word: %s (ignoring)\n", word);
543
 
    }
544
 
    word = strtok(NULL, " \t");
545
 
  }
546
 
 
547
 
  free(copy);
548
 
  *ncriteria = n;
549
 
  return criteria;
550
 
}
551
 
 
552
 
void GLUTAPIENTRY
553
 
glutGameModeString(const char *string)
554
 
{
555
 
  Criterion *criteria;
556
 
  int ncriteria;
557
 
 
558
 
  initGameModeSupport();
559
 
  criteria = parseDisplayString(string, &ncriteria);
560
 
  currentDm = findMatch(dmodes, ndmodes, criteria, ncriteria);
561
 
  free(criteria);
562
 
}
563
 
 
564
 
int GLUTAPIENTRY
565
 
glutEnterGameMode(void)
566
 
{
567
 
  GLUTwindow *window;
568
 
  int width, height;
569
 
  Window win;
570
 
 
571
 
  if (__glutMappedMenu) {
572
 
    __glutFatalUsage("entering game mode not allowed while menus in use");
573
 
  }
574
 
  if (__glutGameModeWindow) {
575
 
    /* Already in game mode, so blow away game mode
576
 
       window so apps can change resolutions. */
577
 
    window = __glutGameModeWindow;
578
 
    /* Setting the game mode window to NULL tricks
579
 
       the window destroy code into not undoing the
580
 
       screen display change since we plan on immediately
581
 
       doing another mode change. */
582
 
    __glutGameModeWindow = NULL;
583
 
    __glutDestroyWindow(window, window);
584
 
  }
585
 
 
586
 
  /* Assume default screen size until we find out if we
587
 
     can actually change the display settings. */
588
 
  width = __glutScreenWidth;
589
 
  height = __glutScreenHeight;
590
 
 
591
 
  if (currentDm) {
592
 
#ifdef _WIN32
593
 
    LONG status;
594
 
    static int registered = 0;
595
 
 
596
 
    status = ChangeDisplaySettings(&currentDm->devmode,
597
 
      CDS_FULLSCREEN);
598
 
    if (status == DISP_CHANGE_SUCCESSFUL) {
599
 
      __glutDisplaySettingsChanged = 1;
600
 
      width = currentDm->cap[DM_WIDTH];
601
 
      height = currentDm->cap[DM_HEIGHT];
602
 
      if (!registered) {
603
 
        atexit(__glutCloseDownGameMode);
604
 
        registered = 1;
605
 
      }
606
 
    } else {
607
 
      /* Switch back to default resolution. */
608
 
      ChangeDisplaySettings(NULL, 0);
609
 
    }
610
 
#endif
611
 
  }
612
 
 
613
 
  window = __glutCreateWindow(NULL, 0, 0,
614
 
    width, height, /* game mode */ 1);
615
 
  win = window->win;
616
 
 
617
 
#if !defined(_WIN32) && !defined(__OS2__)
618
 
  if (__glutMotifHints == None) {
619
 
    __glutMotifHints = XSGIFastInternAtom(__glutDisplay, "_MOTIF_WM_HINTS",
620
 
      SGI_XA__MOTIF_WM_HINTS, 0);
621
 
    if (__glutMotifHints == None) {
622
 
      __glutWarning("Could not intern X atom for _MOTIF_WM_HINTS.");
623
 
    }
624
 
  }
625
 
 
626
 
  /* Game mode window is a toplevel window. */
627
 
  XSetWMProtocols(__glutDisplay, win, &__glutWMDeleteWindow, 1);
628
 
#endif
629
 
 
630
 
  /* Schedule the fullscreen property to be added and to
631
 
     make sure the window is configured right.  Win32
632
 
     doesn't need this. */
633
 
  window->desiredX = 0;
634
 
  window->desiredY = 0;
635
 
  window->desiredWidth = width;
636
 
  window->desiredHeight = height;
637
 
  window->desiredConfMask |= CWX | CWY | CWWidth | CWHeight;
638
 
#ifdef _WIN32
639
 
  /* Win32 does not want to use GLUT_FULL_SCREEN_WORK
640
 
     for game mode because we need to be maximizing
641
 
     the window in game mode, not just sizing it to
642
 
     take up the full screen.  The Win32-ness of game
643
 
     mode happens when you pass 1 in the gameMode parameter
644
 
     to __glutCreateWindow above.  A gameMode of creates
645
 
     a WS_POPUP window, not a standard WS_OVERLAPPEDWINDOW
646
 
     window.  WS_POPUP ensures the taskbar is hidden. */
647
 
  __glutPutOnWorkList(window,
648
 
    GLUT_CONFIGURE_WORK);
649
 
#else
650
 
  __glutPutOnWorkList(window,
651
 
    GLUT_CONFIGURE_WORK | GLUT_FULL_SCREEN_WORK);
652
 
#endif
653
 
 
654
 
  __glutGameModeWindow = window;
655
 
  return window->num + 1;
656
 
}
657
 
 
658
 
int GLUTAPIENTRY
659
 
glutGameModeGet(GLenum mode)
660
 
{
661
 
  switch (mode) {
662
 
  case GLUT_GAME_MODE_ACTIVE:
663
 
    return __glutGameModeWindow != NULL;
664
 
  case GLUT_GAME_MODE_POSSIBLE:
665
 
    return currentDm != NULL;
666
 
  case GLUT_GAME_MODE_WIDTH:
667
 
    return currentDm ? currentDm->cap[DM_WIDTH] : -1;
668
 
  case GLUT_GAME_MODE_HEIGHT:
669
 
    return currentDm ? currentDm->cap[DM_HEIGHT] : -1;
670
 
  case GLUT_GAME_MODE_PIXEL_DEPTH:
671
 
    return currentDm ? currentDm->cap[DM_PIXEL_DEPTH] : -1;
672
 
  case GLUT_GAME_MODE_REFRESH_RATE:
673
 
    return currentDm ? currentDm->cap[DM_HERTZ] : -1;
674
 
  case GLUT_GAME_MODE_DISPLAY_CHANGED:
675
 
    return __glutDisplaySettingsChanged;
676
 
  default:
677
 
    return -1;
678
 
  }
679
 
}
680
 

 
 
b'\\ No newline at end of file'