9ddfdd9186de9116f38fc4d963dfe079050f9081
[freeglut] / fg_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 #include <GL/freeglut.h>
29 #include "fg_internal.h"
30
31 /*
32  * TODO BEFORE THE STABLE RELEASE:
33  *
34  *  glutGet()               -- X11 tests passed, but check if all enums
35  *                             handled (what about Win32?)
36  *  glutDeviceGet()         -- X11 tests passed, but check if all enums
37  *                             handled (what about Win32?)
38  *  glutGetModifiers()      -- OK, but could also remove the limitation
39  *  glutLayerGet()          -- what about GLUT_NORMAL_DAMAGED?
40  *
41  * The fail-on-call policy will help adding the most needed things imho.
42  */
43
44 extern int fgPlatformGlutGet ( GLenum eWhat );
45 extern int fgPlatformGlutDeviceGet ( GLenum eWhat );
46 extern int *fgPlatformGlutGetModeValues(GLenum eWhat, int *size);
47
48
49 /* -- LOCAL DEFINITIONS ---------------------------------------------------- */
50
51 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
52
53
54 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
55
56 /*
57  * General settings assignment method
58  */
59 void FGAPIENTRY glutSetOption( GLenum eWhat, int value )
60 {
61     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetOption" );
62
63     /*
64      * XXX In chronological code add order.  (WHY in that order?)
65      */
66     switch( eWhat )
67     {
68     case GLUT_INIT_WINDOW_X:
69         fgState.Position.X = (GLint)value;
70         break;
71
72     case GLUT_INIT_WINDOW_Y:
73         fgState.Position.Y = (GLint)value;
74         break;
75
76     case GLUT_INIT_WINDOW_WIDTH:
77         fgState.Size.X = (GLint)value;
78         break;
79
80     case GLUT_INIT_WINDOW_HEIGHT:
81         fgState.Size.Y = (GLint)value;
82         break;
83
84     case GLUT_INIT_DISPLAY_MODE:
85         fgState.DisplayMode = (unsigned int)value;
86         break;
87
88     case GLUT_ACTION_ON_WINDOW_CLOSE:
89         fgState.ActionOnWindowClose = value;
90         break;
91
92     case GLUT_RENDERING_CONTEXT:
93         fgState.UseCurrentContext =
94             ( value == GLUT_USE_CURRENT_CONTEXT ) ? GL_TRUE : GL_FALSE;
95         break;
96
97     case GLUT_DIRECT_RENDERING:
98         fgState.DirectContext = value;
99         break;
100
101     case GLUT_WINDOW_CURSOR:
102         if( fgStructure.CurrentWindow != NULL )
103             fgStructure.CurrentWindow->State.Cursor = value;
104         break;
105
106     case GLUT_AUX:
107       fgState.AuxiliaryBufferNumber = value;
108       break;
109
110     case GLUT_MULTISAMPLE:
111       fgState.SampleNumber = value;
112       break;
113
114     case GLUT_SKIP_STALE_MOTION_EVENTS:
115       fgState.SkipStaleMotion = value;
116       break;
117
118     case GLUT_GEOMETRY_VISUALIZE_NORMALS:
119       if( fgStructure.CurrentWindow != NULL )
120         fgStructure.CurrentWindow->State.VisualizeNormals = value;
121       break;
122
123     default:
124         fgWarning( "glutSetOption(): missing enum handle %d", eWhat );
125         break;
126     }
127 }
128
129 /*
130  * General settings query method
131  */
132 int FGAPIENTRY glutGet( GLenum eWhat )
133 {
134     switch (eWhat)
135     {
136     case GLUT_INIT_STATE:
137         return fgState.Initialised;
138
139     /* Although internally the time store is 64bits wide, the return value
140      * here still wraps every 49.7 days. Integer overflows cancel however
141      * when subtracting an initial start time, unless the total time exceeds
142      * 32-bit, so you can still work with this.
143      * XXX: a glutGet64 to return the time might be an idea...
144      */
145     case GLUT_ELAPSED_TIME:
146         return (int) fgElapsedTime();
147     }
148
149     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGet" );
150
151     /* XXX In chronological code add order.  (WHY in that order?) */
152     switch( eWhat )
153     {
154     /* Following values are stored in fgState and fgDisplay global structures */
155     case GLUT_SCREEN_WIDTH:         return fgDisplay.ScreenWidth   ;
156     case GLUT_SCREEN_HEIGHT:        return fgDisplay.ScreenHeight  ;
157     case GLUT_SCREEN_WIDTH_MM:      return fgDisplay.ScreenWidthMM ;
158     case GLUT_SCREEN_HEIGHT_MM:     return fgDisplay.ScreenHeightMM;
159     case GLUT_INIT_WINDOW_X:        return fgState.Position.Use ?
160                                            fgState.Position.X : -1 ;
161     case GLUT_INIT_WINDOW_Y:        return fgState.Position.Use ?
162                                            fgState.Position.Y : -1 ;
163     case GLUT_INIT_WINDOW_WIDTH:    return fgState.Size.Use ?
164                                            fgState.Size.X : -1     ;
165     case GLUT_INIT_WINDOW_HEIGHT:   return fgState.Size.Use ?
166                                            fgState.Size.Y : -1     ;
167     case GLUT_INIT_DISPLAY_MODE:    return fgState.DisplayMode     ;
168     case GLUT_INIT_MAJOR_VERSION:   return fgState.MajorVersion    ;
169     case GLUT_INIT_MINOR_VERSION:   return fgState.MinorVersion    ;
170     case GLUT_INIT_FLAGS:           return fgState.ContextFlags    ;
171     case GLUT_INIT_PROFILE:         return fgState.ContextProfile  ;
172
173     /* The window structure queries */
174     case GLUT_WINDOW_PARENT:
175         if( fgStructure.CurrentWindow         == NULL ) return 0;
176         if( fgStructure.CurrentWindow->Parent == NULL ) return 0;
177         return fgStructure.CurrentWindow->Parent->ID;
178
179     case GLUT_WINDOW_NUM_CHILDREN:
180         if( fgStructure.CurrentWindow == NULL )
181             return 0;
182         return fgListLength( &fgStructure.CurrentWindow->Children );
183
184     case GLUT_WINDOW_CURSOR:
185         if( fgStructure.CurrentWindow == NULL )
186             return 0;
187         return fgStructure.CurrentWindow->State.Cursor;
188
189     case GLUT_MENU_NUM_ITEMS:
190         if( fgStructure.CurrentMenu == NULL )
191             return 0;
192         return fgListLength( &fgStructure.CurrentMenu->Entries );
193
194     case GLUT_ACTION_ON_WINDOW_CLOSE:
195         return fgState.ActionOnWindowClose;
196
197     case GLUT_VERSION :
198         return VERSION_MAJOR * 10000 + VERSION_MINOR * 100 + VERSION_PATCH;
199
200     case GLUT_RENDERING_CONTEXT:
201         return fgState.UseCurrentContext ? GLUT_USE_CURRENT_CONTEXT
202                                          : GLUT_CREATE_NEW_CONTEXT;
203
204     case GLUT_DIRECT_RENDERING:
205         return fgState.DirectContext;
206
207     case GLUT_FULL_SCREEN:
208         return fgStructure.CurrentWindow->State.IsFullscreen;
209
210     case GLUT_AUX:
211       return fgState.AuxiliaryBufferNumber;
212
213     case GLUT_MULTISAMPLE:
214       return fgState.SampleNumber;
215
216     case GLUT_SKIP_STALE_MOTION_EVENTS:
217       return fgState.SkipStaleMotion;
218
219     case GLUT_GEOMETRY_VISUALIZE_NORMALS:
220       if( fgStructure.CurrentWindow == NULL )
221         return GL_FALSE;
222       return fgStructure.CurrentWindow->State.VisualizeNormals;
223
224     default:
225         return fgPlatformGlutGet ( eWhat );
226         break;
227     }
228     return -1;
229 }
230
231 /*
232  * Returns various device information.
233  */
234 int FGAPIENTRY glutDeviceGet( GLenum eWhat )
235 {
236     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDeviceGet" );
237
238     /* XXX WARNING: we are mostly lying in this function. */
239     switch( eWhat )
240     {
241     case GLUT_HAS_JOYSTICK:
242         return fgJoystickDetect ();
243
244     case GLUT_OWNS_JOYSTICK:
245         return fgState.JoysticksInitialised;
246
247     case GLUT_JOYSTICK_POLL_RATE:
248         return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.JoystickPollRate : 0;
249
250     /* XXX The following two are only for Joystick 0 but this is an improvement */
251     case GLUT_JOYSTICK_BUTTONS:
252         return glutJoystickGetNumButtons ( 0 );
253
254     case GLUT_JOYSTICK_AXES:
255         return glutJoystickGetNumAxes ( 0 );
256
257     case GLUT_HAS_DIAL_AND_BUTTON_BOX:
258         return fgInputDeviceDetect ();
259
260     case GLUT_NUM_DIALS:
261         if ( fgState.InputDevsInitialised ) return 8;
262         return 0;
263  
264     case GLUT_NUM_BUTTON_BOX_BUTTONS:
265         return 0;
266
267     case GLUT_HAS_SPACEBALL:
268         return fgHasSpaceball();
269
270     case GLUT_HAS_TABLET:
271         return 0;
272
273     case GLUT_NUM_SPACEBALL_BUTTONS:
274         return fgSpaceballNumButtons();
275
276     case GLUT_NUM_TABLET_BUTTONS:
277         return 0;
278
279     case GLUT_DEVICE_IGNORE_KEY_REPEAT:
280         return fgStructure.CurrentWindow ? fgStructure.CurrentWindow->State.IgnoreKeyRepeat : 0;
281
282     case GLUT_DEVICE_KEY_REPEAT:
283         return fgState.KeyRepeat;
284
285     default:
286                 return fgPlatformGlutDeviceGet ( eWhat );
287     }
288
289     /* And now -- the failure. */
290     return -1;
291 }
292
293 /*
294  * This should return the current state of ALT, SHIFT and CTRL keys.
295  */
296 int FGAPIENTRY glutGetModifiers( void )
297 {
298     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGetModifiers" );
299     if( fgState.Modifiers == INVALID_MODIFIERS )
300     {
301         fgWarning( "glutGetModifiers() called outside an input callback" );
302         return 0;
303     }
304
305     return fgState.Modifiers;
306 }
307
308 /*
309  * Return the state of the GLUT API overlay subsystem. A misery ;-)
310  */
311 int FGAPIENTRY glutLayerGet( GLenum eWhat )
312 {
313     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLayerGet" );
314
315     /*
316      * This is easy as layers are not implemented and
317      * overlay support is not planned. E.g. on Windows,
318      * overlay requests in PFDs are ignored
319      * (see iLayerType at http://msdn.microsoft.com/en-us/library/dd368826(v=vs.85).aspx)
320      */
321     switch( eWhat )
322     {
323
324     case GLUT_OVERLAY_POSSIBLE:
325         return 0 ;
326
327     case GLUT_LAYER_IN_USE:
328         return GLUT_NORMAL;
329
330     case GLUT_HAS_OVERLAY:
331         return 0;
332
333     case GLUT_TRANSPARENT_INDEX:
334         /*
335         * Return just anything, which is always defined as zero
336         *
337         * XXX HUH?
338         */
339         return 0;
340
341     case GLUT_NORMAL_DAMAGED:
342         /* XXX Actually I do not know. Maybe. */
343         return 0;
344
345     case GLUT_OVERLAY_DAMAGED:
346         return -1;
347
348     default:
349         fgWarning( "glutLayerGet(): missing enum handle %d", eWhat );
350         break;
351     }
352
353     /* And fail. That's good. Programs do love failing. */
354     return -1;
355 }
356
357 int * FGAPIENTRY glutGetModeValues(GLenum eWhat, int *size)
358 {
359   int *array;
360
361   FREEGLUT_EXIT_IF_NOT_INITIALISED("glutGetModeValues");
362
363   *size = 0;
364   array = fgPlatformGlutGetModeValues ( eWhat, size );
365
366   return array;
367 }
368
369 /*** END OF FILE ***/