Resolve bug 806008 -- let Microsoft's compiler know to use Windows libraries even...
[freeglut] / src / freeglut_state.c
1 /*
2  * freeglut_state.c
3  *
4  * Freeglut state query methods.
5  *
6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8  * Creation date: Thu Dec 16 1999
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining a
11  * copy of this software and associated documentation files (the "Software"),
12  * to deal in the Software without restriction, including without limitation
13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14  * and/or sell copies of the Software, and to permit persons to whom the
15  * Software is furnished to do so, subject to the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be included
18  * in all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26  */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #define  G_LOG_DOMAIN  "freeglut-state"
33
34 #include "../include/GL/freeglut.h"
35 #include "freeglut_internal.h"
36
37 /*
38  * TODO BEFORE THE STABLE RELEASE:
39  *
40  *  glutGet()               -- X11 tests passed, but check if all enums handled (what about Win32?)
41  *  glutDeviceGet()         -- X11 tests passed, but check if all enums handled (what about Win32?)
42  *  glutGetModifiers()      -- OK, but could also remove the limitation
43  *  glutLayerGet()          -- what about GLUT_NORMAL_DAMAGED?
44  *
45  * The fail-on-call policy will help adding the most needed things imho.
46  */
47
48 /* -- LOCAL DEFINITIONS ---------------------------------------------------- */
49
50 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
51
52 #if TARGET_HOST_UNIX_X11
53 /*
54  * Queries the GL context about some attributes
55  */
56 static int fghGetConfig( int attribute )
57 {
58   int returnValue ;
59
60   /*
61    * Return nothing if there is no current window set
62    */
63   if( fgStructure.Window == NULL )
64     return( 0 );
65
66   /*
67    * glXGetConfig should work fine
68    */
69   glXGetConfig( fgDisplay.Display, fgStructure.Window->Window.VisualInfo, attribute, &returnValue );
70
71
72   /*
73    * Have the query results returned
74    */
75   return ( returnValue ) ;
76 }
77 #endif
78
79 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
80
81 /*
82  * General settings assignment method
83  */
84 void FGAPIENTRY glutSetOption( GLenum eWhat, int value )
85 {
86   freeglut_assert_ready;
87
88   /*
89    * Check what is the caller querying for. In chronological code add order.
90    */
91   switch( eWhat )
92   {
93   case GLUT_INIT_WINDOW_X:          fgState.Position.X          = (GLint)value ;
94                                     break ;
95   case GLUT_INIT_WINDOW_Y:          fgState.Position.Y          = (GLint)value ;
96                                     break ;
97   case GLUT_INIT_WINDOW_WIDTH:      fgState.Size.X              = (GLint)value ;
98                                     break ;
99   case GLUT_INIT_WINDOW_HEIGHT:     fgState.Size.Y              = (GLint)value ;
100                                     break ;
101   case GLUT_INIT_DISPLAY_MODE:      fgState.DisplayMode         = (unsigned int)value ;
102                                     break ;
103
104   case GLUT_ACTION_ON_WINDOW_CLOSE: fgState.ActionOnWindowClose = value ;
105                                     break ;
106
107   case GLUT_RENDERING_CONTEXT:      fgState.UseCurrentContext   = ( value == GLUT_USE_CURRENT_CONTEXT ) ? TRUE : FALSE ;
108                                     break ;
109
110   case GLUT_WINDOW_CURSOR:
111       if( fgStructure.Window != NULL ) fgStructure.Window->State.Cursor = value ;
112       break ;
113
114   default:
115       /*
116        * Just have it reported, so that we can see what needs to be implemented
117        */
118       fgWarning( "glutSetOption(): missing enum handle %i\n", eWhat );
119       break;
120   }
121 }
122
123 /*
124  * General settings query method
125  */
126 int FGAPIENTRY glutGet( GLenum eWhat )
127 {
128   int returnValue ;
129   GLboolean boolValue ;
130
131   if ( eWhat == GLUT_INIT_STATE )
132     return ( fgState.Time.Set ) ;
133
134     freeglut_assert_ready;
135
136     /*
137      * Check what is the caller querying for. In chronological code add order.
138      */
139     switch( eWhat )
140     {
141     case GLUT_ELAPSED_TIME:
142         /*
143          * This is easy and nicely portable, as we are using GLib...
144          */
145         return( fgElapsedTime() );
146
147     /*
148      * Following values are stored in fgState and fgDisplay global structures
149      */
150     case GLUT_SCREEN_WIDTH:         return( fgDisplay.ScreenWidth    );
151     case GLUT_SCREEN_HEIGHT:        return( fgDisplay.ScreenHeight   );
152     case GLUT_SCREEN_WIDTH_MM:      return( fgDisplay.ScreenWidthMM  );
153     case GLUT_SCREEN_HEIGHT_MM:     return( fgDisplay.ScreenHeightMM );
154     case GLUT_INIT_WINDOW_X:        return( fgState.Position.X       );
155     case GLUT_INIT_WINDOW_Y:        return( fgState.Position.Y       );
156     case GLUT_INIT_WINDOW_WIDTH:    return( fgState.Size.X           );
157     case GLUT_INIT_WINDOW_HEIGHT:   return( fgState.Size.Y           );
158     case GLUT_INIT_DISPLAY_MODE:    return( fgState.DisplayMode      );
159
160     /*
161      * The window/context specific queries are handled mostly by fghGetConfig().
162      */
163     case GLUT_WINDOW_NUM_SAMPLES:
164         /*
165          * Multisampling. Return what I know about multisampling.
166          */
167         return( 0 );
168
169 #if TARGET_HOST_UNIX_X11
170     /*
171      * The rest of GLX queries under X are general enough to use a macro to check them
172      */
173 #   define GLX_QUERY(a,b) case a: return( fghGetConfig( b ) );
174
175     GLX_QUERY( GLUT_WINDOW_RGBA,                GLX_RGBA                );
176     GLX_QUERY( GLUT_WINDOW_DOUBLEBUFFER,        GLX_DOUBLEBUFFER        );
177     GLX_QUERY( GLUT_WINDOW_BUFFER_SIZE,         GLX_BUFFER_SIZE         );
178     GLX_QUERY( GLUT_WINDOW_STENCIL_SIZE,        GLX_STENCIL_SIZE        );
179     GLX_QUERY( GLUT_WINDOW_DEPTH_SIZE,          GLX_DEPTH_SIZE          );
180     GLX_QUERY( GLUT_WINDOW_RED_SIZE,            GLX_RED_SIZE            );
181     GLX_QUERY( GLUT_WINDOW_GREEN_SIZE,          GLX_GREEN_SIZE          );
182     GLX_QUERY( GLUT_WINDOW_BLUE_SIZE,           GLX_BLUE_SIZE           );
183     GLX_QUERY( GLUT_WINDOW_ALPHA_SIZE,          GLX_ALPHA_SIZE          );
184     GLX_QUERY( GLUT_WINDOW_ACCUM_RED_SIZE,      GLX_ACCUM_RED_SIZE      );
185     GLX_QUERY( GLUT_WINDOW_ACCUM_GREEN_SIZE,    GLX_ACCUM_GREEN_SIZE    );
186     GLX_QUERY( GLUT_WINDOW_ACCUM_BLUE_SIZE,     GLX_ACCUM_BLUE_SIZE     );
187     GLX_QUERY( GLUT_WINDOW_ACCUM_ALPHA_SIZE,    GLX_ACCUM_ALPHA_SIZE    );
188     GLX_QUERY( GLUT_WINDOW_STEREO,              GLX_STEREO              );
189
190 #   undef GLX_QUERY
191
192     /*
193      * Colormap size is handled in a bit different way than all the rest
194      */
195     case GLUT_WINDOW_COLORMAP_SIZE:
196         /*
197          * Check for the visual type
198          */
199         if( (fghGetConfig( GLX_RGBA )) || (fgStructure.Window == NULL) )
200         {
201             /*
202              * We've got a RGBA visual, so there is no colormap at all.
203              * The other possibility is that we have no current window set.
204              */
205             return( 0 );
206         }
207
208         /*
209          * Otherwise return the number of entries in the colormap
210          */
211         return( fgStructure.Window->Window.VisualInfo->visual->map_entries );
212
213     /*
214      * Those calls are somewhat similiar, as they use XGetWindowAttributes() function
215      */
216     case GLUT_WINDOW_X:
217     case GLUT_WINDOW_Y:
218     case GLUT_WINDOW_BORDER_WIDTH:
219     case GLUT_WINDOW_HEADER_HEIGHT:
220     {
221         int x, y;
222         Window w;
223
224         if( fgStructure.Window == NULL )
225             return( 0 );
226
227         XTranslateCoordinates(
228             fgDisplay.Display,
229             fgStructure.Window->Window.Handle,
230             fgDisplay.RootWindow,
231             0, 0, &x, &y, &w);
232
233         switch ( eWhat )
234         {
235         case GLUT_WINDOW_X: return x;
236         case GLUT_WINDOW_Y: return y;
237         }
238
239         if ( w == 0 )
240             return( 0 );  /* Just in case */
241
242         XTranslateCoordinates(
243             fgDisplay.Display,
244             fgStructure.Window->Window.Handle,
245             w, 0, 0, &x, &y, &w);
246
247         switch ( eWhat )
248         {
249         case GLUT_WINDOW_BORDER_WIDTH:  return x;
250         case GLUT_WINDOW_HEADER_HEIGHT: return y;
251         }
252     }
253
254     case GLUT_WINDOW_WIDTH:
255     case GLUT_WINDOW_HEIGHT:
256     {
257         XWindowAttributes winAttributes;
258
259         /*
260          * Return zero if there is no current window set
261          */
262         if( fgStructure.Window == NULL )
263             return( 0 );
264
265         /*
266          * Grab the current window's attributes now
267          */
268         XGetWindowAttributes(
269             fgDisplay.Display,
270             fgStructure.Window->Window.Handle,
271             &winAttributes
272         );
273
274         /*
275          * See which window attribute to return
276          */
277         switch ( eWhat )
278         {
279         case GLUT_WINDOW_WIDTH:            return winAttributes.width ;
280         case GLUT_WINDOW_HEIGHT:           return winAttributes.height ;
281         }
282     }
283
284     /*
285      * I do not know yet if there will be a fgChooseVisual() function for Win32
286      */
287     case GLUT_DISPLAY_MODE_POSSIBLE:
288         /*
289          * Check if the current display mode is possible
290          */
291         return( fgChooseVisual() == NULL ? 0 : 1 );
292
293     /*
294      * This is system-dependant
295      */
296     case GLUT_WINDOW_FORMAT_ID:
297         /*
298          * Return the visual ID, if there is a current window naturally:
299          */
300         if( fgStructure.Window == NULL )
301             return( 0 );
302
303         return( fgStructure.Window->Window.VisualInfo->visualid );
304
305 #elif TARGET_HOST_WIN32
306
307     /*
308      * Handle the OpenGL inquiries
309      */
310     case GLUT_WINDOW_RGBA:
311       glGetBooleanv ( GL_RGBA_MODE, &boolValue ) ;         /* True if color buffers store RGBA */
312       returnValue = boolValue ? 1 : 0 ;
313       return ( returnValue ) ;
314     case GLUT_WINDOW_DOUBLEBUFFER:
315       glGetBooleanv ( GL_DOUBLEBUFFER, &boolValue ) ;      /* True if front and back buffers exist */
316       returnValue = boolValue ? 1 : 0 ;
317       return ( returnValue ) ;
318     case GLUT_WINDOW_STEREO:
319       glGetBooleanv ( GL_STEREO, &boolValue ) ;            /* True if left and right buffers exist */
320       returnValue = boolValue ? 1 : 0 ;
321       return ( returnValue ) ;
322
323     case GLUT_WINDOW_RED_SIZE:
324       glGetIntegerv ( GL_RED_BITS, &returnValue ) ;          /* Number of bits per red component in color buffers */
325       return ( returnValue ) ;
326     case GLUT_WINDOW_GREEN_SIZE:
327       glGetIntegerv ( GL_GREEN_BITS, &returnValue ) ;        /* Number of bits per green component in color buffers */
328       return ( returnValue ) ;
329     case GLUT_WINDOW_BLUE_SIZE:
330       glGetIntegerv ( GL_BLUE_BITS, &returnValue ) ;         /* Number of bits per blue component in color buffers */
331       return ( returnValue ) ;
332     case GLUT_WINDOW_ALPHA_SIZE:
333       glGetIntegerv ( GL_ALPHA_BITS, &returnValue ) ;        /* Number of bits per alpha component in color buffers */
334       return ( returnValue ) ;
335     case GLUT_WINDOW_ACCUM_RED_SIZE:
336       glGetIntegerv ( GL_ACCUM_RED_BITS, &returnValue ) ;    /* Number of bits per red component in the accumulation buffer */
337       return ( returnValue ) ;
338     case GLUT_WINDOW_ACCUM_GREEN_SIZE:
339       glGetIntegerv ( GL_ACCUM_GREEN_BITS, &returnValue ) ;  /* Number of bits per green component in the accumulation buffer */
340       return ( returnValue ) ;
341     case GLUT_WINDOW_ACCUM_BLUE_SIZE:
342       glGetIntegerv ( GL_ACCUM_BLUE_BITS, &returnValue ) ;   /* Number of bits per blue component in the accumulation buffer */
343       return ( returnValue ) ;
344     case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
345       glGetIntegerv ( GL_ACCUM_ALPHA_BITS, &returnValue ) ;  /* Number of bits per alpha component in the accumulation buffer */
346       return ( returnValue ) ;
347     case GLUT_WINDOW_DEPTH_SIZE:
348       glGetIntegerv ( GL_DEPTH_BITS, &returnValue ) ;        /* Number of depth-buffer bitplanes */
349       return ( returnValue ) ;
350
351     case GLUT_WINDOW_BUFFER_SIZE:
352       returnValue = 1 ;                                      /* ????? */
353       return ( returnValue ) ;
354     case GLUT_WINDOW_STENCIL_SIZE:
355       returnValue = 0 ;                                      /* ????? */
356       return ( returnValue ) ;
357
358     /*
359      * Window position and size
360      */
361     case GLUT_WINDOW_X:
362     case GLUT_WINDOW_Y:
363     case GLUT_WINDOW_WIDTH:
364     case GLUT_WINDOW_HEIGHT:
365     {
366         /*
367          *  There is considerable confusion about the "right thing to do" concerning window
368          * size and position.  GLUT itself is not consistent between Windows and Linux; since
369          * platform independence is a virtue for "freeglut", we decided to break with GLUT's
370          * behaviour.
371          *  Under Linux, it is apparently not possible to get the window border sizes in order
372          * to subtract them off the window's initial position until some time after the window
373          * has been created.  Therefore we decided on the following behaviour, both under
374          * Windows and under Linux:
375          *  - When you create a window with position (x,y) and size (w,h), the upper left hand
376          *    corner of the outside of the window is at (x,y) and the size of the drawable area
377          *    is (w,h).
378          *  - When you query the size and position of the window--as is happening here for
379          *    Windows--"freeglut" will return the size of the drawable area--the (w,h) that you
380          *    specified when you created the window--and the coordinates of the upper left hand
381          *    corner of the drawable area--which is NOT the (x,y) you specified.
382          */
383
384         RECT winRect;
385
386         /*
387          * Check if there is a window to be queried for dimensions:
388          */
389         freeglut_return_val_if_fail( fgStructure.Window != NULL, 0 );
390
391         /*
392          * We need to call GetWindowRect() first...
393          *  (this returns the pixel coordinates of the outside of the window)
394          */
395         GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
396
397         /*
398          * ...then we've got to correct the results we've just received...
399          */
400         if ( ( fgStructure.GameMode != fgStructure.Window ) && ( fgStructure.Window->Parent == NULL ) &&
401              ( ! fgStructure.Window->IsMenu ) )
402         {
403           winRect.left   += GetSystemMetrics( SM_CXSIZEFRAME );
404           winRect.right  -= GetSystemMetrics( SM_CXSIZEFRAME );
405           winRect.top    += GetSystemMetrics( SM_CYSIZEFRAME ) + GetSystemMetrics( SM_CYCAPTION );
406           winRect.bottom -= GetSystemMetrics( SM_CYSIZEFRAME );
407         }
408
409         /*
410          * ...and finally return the caller the desired value:
411          */
412         switch( eWhat )
413         {
414         case GLUT_WINDOW_X:      return( winRect.left                 );
415         case GLUT_WINDOW_Y:      return( winRect.top                  );
416         case GLUT_WINDOW_WIDTH:  return( winRect.right - winRect.left );
417         case GLUT_WINDOW_HEIGHT: return( winRect.bottom - winRect.top );
418         }
419     }
420     break;
421
422     case GLUT_WINDOW_BORDER_WIDTH :
423         return ( GetSystemMetrics( SM_CXSIZEFRAME ) ) ;
424
425     case GLUT_WINDOW_HEADER_HEIGHT :
426         return ( GetSystemMetrics( SM_CYCAPTION ) ) ;
427
428     case GLUT_DISPLAY_MODE_POSSIBLE:
429         /*
430          * Check if the current display mode is possible
431          */
432         return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_MAIN_PLANE ) );
433
434     case GLUT_WINDOW_FORMAT_ID:
435         /*
436          * Return the pixel format of the current window
437          */
438         if( fgStructure.Window != NULL )
439             return( GetPixelFormat( fgStructure.Window->Window.Device ) );
440
441         /*
442          * If the current window does not exist, fail:
443          */
444         return( 0 );
445
446 #endif
447
448     /*
449      * The window structure queries
450      */
451     case GLUT_WINDOW_PARENT:
452         /*
453          * Return the ID number of current window's parent, if any
454          */
455         if( fgStructure.Window         == NULL ) return( 0 );
456         if( fgStructure.Window->Parent == NULL ) return( 0 );
457
458         return( fgStructure.Window->Parent->ID );
459
460     case GLUT_WINDOW_NUM_CHILDREN:
461         /*
462          * Return the number of children attached to the current window
463          */
464         if( fgStructure.Window == NULL )
465             return( 0 );
466
467         return( fgListLength( &fgStructure.Window->Children ) );
468
469     case GLUT_WINDOW_CURSOR:
470         /*
471          * Return the currently selected window cursor
472          */
473         if( fgStructure.Window == NULL )
474             return( 0 );
475
476         return( fgStructure.Window->State.Cursor );
477
478     case GLUT_MENU_NUM_ITEMS:
479         /*
480          * Return the number of menu entries in the current menu
481          */
482         if( fgStructure.Menu == NULL )
483             return( 0 );
484
485         return( fgListLength( &fgStructure.Menu->Entries ) );
486
487     case GLUT_ACTION_ON_WINDOW_CLOSE:
488         return fgState.ActionOnWindowClose ;
489
490     case GLUT_VERSION :
491         return VERSION_MAJOR * 10000 + VERSION_MINOR * 100 + VERSION_PATCH ;
492
493     case GLUT_RENDERING_CONTEXT:
494         return ( fgState.UseCurrentContext ? GLUT_USE_CURRENT_CONTEXT : GLUT_CREATE_NEW_CONTEXT ) ;
495
496     default:
497         /*
498          * Just have it reported, so that we can see what needs to be implemented
499          */
500         fgWarning( "glutGet(): missing enum handle %i\n", eWhat );
501         break;
502     }
503
504     /*
505      * If nothing happens, then we are in deep trouble...
506      */
507     return( -1 );
508 }
509
510 /*
511  * Returns various device information.
512  */
513 int FGAPIENTRY glutDeviceGet( GLenum eWhat )
514 {
515     freeglut_assert_ready;
516
517     /*
518      * See why are we bothered...
519      *
520      * WARNING: we are mostly lying in this function.
521      */
522     switch( eWhat )
523     {
524     case GLUT_HAS_KEYBOARD:
525         /*
526          * We always have a keyboard present on PC machines...
527          */
528         return( TRUE );
529
530 #if TARGET_HOST_UNIX_X11
531
532     case GLUT_HAS_MOUSE:
533         /*
534          * Hey, my Atari 65XE hasn't had a mouse!
535          */
536         return( TRUE );
537
538     case GLUT_NUM_MOUSE_BUTTONS:
539         /*
540          * Return the number of mouse buttons available. This is a big guess.
541          */
542         return( 3 );
543
544 #elif TARGET_HOST_WIN32
545
546     case GLUT_HAS_MOUSE:
547         /*
548          * The Windows can be booted without a mouse. 
549          * It would be nice to have this reported.
550          */
551         return( GetSystemMetrics( SM_MOUSEPRESENT ) );
552
553     case GLUT_NUM_MOUSE_BUTTONS:
554         /*
555          * We are much more fortunate under Win32 about this...
556          */
557         return( GetSystemMetrics( SM_CMOUSEBUTTONS ) );
558
559 #endif
560
561     case GLUT_JOYSTICK_POLL_RATE:
562     case GLUT_HAS_JOYSTICK:
563     case GLUT_JOYSTICK_BUTTONS:
564     case GLUT_JOYSTICK_AXES:
565         /*
566          * WARNING: THIS IS A BIG LIE!
567          */
568         return( 0 );
569
570     case GLUT_HAS_SPACEBALL:
571     case GLUT_HAS_DIAL_AND_BUTTON_BOX:
572     case GLUT_HAS_TABLET:
573         /*
574          * Sounds cool. And unuseful.
575          */
576         return( FALSE );
577
578     case GLUT_NUM_SPACEBALL_BUTTONS:
579     case GLUT_NUM_BUTTON_BOX_BUTTONS:
580     case GLUT_NUM_DIALS:
581     case GLUT_NUM_TABLET_BUTTONS:
582         /*
583          * Zero is not the answer. Zero is the question. Continuum is the answer.
584          */
585         return( 0 );
586
587     case GLUT_DEVICE_IGNORE_KEY_REPEAT:
588         /*
589          * Return what we think about the key auto repeat settings
590          */
591         return( fgState.IgnoreKeyRepeat );
592
593     case GLUT_DEVICE_KEY_REPEAT:
594         /*
595          * WARNING: THIS IS A BIG LIE!
596          */
597         return( GLUT_KEY_REPEAT_DEFAULT );
598
599     default:
600         /*
601          * Complain.
602          */
603         fgWarning( "glutDeviceGet(): missing enum handle %i\n", eWhat );
604         break;
605     }
606
607     /*
608      * And now -- the failure.
609      */
610     return( -1 );
611 }
612
613 /*
614  * This should return the current state of ALT, SHIFT and CTRL keys.
615  */
616 int FGAPIENTRY glutGetModifiers( void )
617 {
618     /*
619      * Fail if there is no current window or called outside an input callback
620      */
621     if( fgStructure.Window == NULL )
622         return( 0 );
623
624     if( fgStructure.Window->State.Modifiers == 0xffffffff )
625     {
626         fgWarning( "glutGetModifiers() called outside an input callback" );
627         return( 0 );
628     }
629
630     /*
631      * Return the current modifiers state otherwise
632      */
633     return( fgStructure.Window->State.Modifiers );
634 }
635
636 /*
637  * Return the state of the GLUT API overlay subsystem. A misery ;-)
638  */
639 int FGAPIENTRY glutLayerGet( GLenum eWhat )
640 {
641     freeglut_assert_ready;
642
643     /*
644      * This is easy as layers are not implemented ;-)
645      */
646     switch( eWhat )
647     {
648
649 #if TARGET_HOST_UNIX_X11
650
651     case GLUT_OVERLAY_POSSIBLE:
652         /*
653          * Nope, overlays are not possible.
654          */
655         return( FALSE );
656
657     case GLUT_LAYER_IN_USE:
658         /*
659          * The normal plane is always in use
660          */
661         return( GLUT_NORMAL );
662
663     case GLUT_HAS_OVERLAY:
664         /*
665          * No window is allowed to have an overlay
666          */
667         return( FALSE );
668
669     case GLUT_TRANSPARENT_INDEX:
670         /*
671          * Return just anything, which is always defined as zero
672          */
673         return( 0 );
674
675     case GLUT_NORMAL_DAMAGED:
676         /*
677          * Actually I do not know. Maybe.
678          */
679         return( FALSE );
680
681     case GLUT_OVERLAY_DAMAGED:
682         /*
683          * Return minus one to mark that no layer is in use
684          */
685         return( -1 );
686
687 #elif TARGET_HOST_WIN32
688
689     case GLUT_OVERLAY_POSSIBLE:
690         /*
691          * Check if an overlay display mode is possible
692          */
693 /*        return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_OVERLAY_PLANE ) ); */
694       return FALSE ;
695
696     case GLUT_LAYER_IN_USE:
697         /*
698          * The normal plane is always in use
699          */
700         return( GLUT_NORMAL );
701
702     case GLUT_HAS_OVERLAY:
703         /*
704          * No window is allowed to have an overlay
705          */
706         return( FALSE );
707
708     case GLUT_TRANSPARENT_INDEX:
709         /*
710          * Return just anything, which is always defined as zero
711          */
712         return( 0 );
713
714     case GLUT_NORMAL_DAMAGED:
715         /*
716          * Actually I do not know. Maybe.
717          */
718         return( FALSE );
719
720     case GLUT_OVERLAY_DAMAGED:
721         /*
722          * Return minus one to mark that no layer is in use
723          */
724         return( -1 );
725 #endif
726
727     default:
728         /*
729          * Complain to the user about the obvious bug
730          */
731         fgWarning( "glutLayerGet(): missing enum handle %i\n", eWhat );
732         break;
733     }
734
735     /*
736      * And fail. That's good. Programs do love failing.
737      */
738     return( -1 );
739 }
740
741 /*** END OF FILE ***/