git.mutantstargoat.com Git - freeglut/blob - src/fg_callbacks.c

   1 /*
   2  * fg_callbacks.c
   3  *
   4  * The callbacks setting 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: Fri Dec 3 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 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
  32
  33
  34 /*
  35  * Global callbacks.
  36  */
  37 /* Sets the global idle callback */
  38 void FGAPIENTRY glutIdleFunc( FGCBIdle callback )
  39 {
  40     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutIdleFunc" );
  41     fgState.IdleCallback = callback;
  42 }
  43
  44 /* Creates a timer and sets its callback */
  45 void FGAPIENTRY glutTimerFunc( unsigned int timeOut, FGCBTimer callback, int timerID )
  46 {
  47     SFG_Timer *timer, *node;
  48
  49     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutTimerFunc" );
  50
  51     if( (timer = fgState.FreeTimers.Last) )
  52     {
  53         fgListRemove( &fgState.FreeTimers, &timer->Node );
  54     }
  55     else
  56     {
  57         if( ! (timer = malloc(sizeof(SFG_Timer))) )
  58             fgError( "Fatal error: "
  59                      "Memory allocation failure in glutTimerFunc()" );
  60     }
  61
  62     timer->Callback  = callback;
  63     timer->ID        = timerID;
  64     timer->TriggerTime = fgElapsedTime() + timeOut;
  65
  66     /* Insert such that timers are sorted by end-time */
  67     for( node = fgState.Timers.First; node; node = node->Node.Next )
  68     {
  69         if( node->TriggerTime > timer->TriggerTime )
  70             break;
  71     }
  72
  73     fgListInsert( &fgState.Timers, &node->Node, &timer->Node );
  74 }
  75
  76 /* Deprecated version of glutMenuStatusFunc callback setting method */
  77 void FGAPIENTRY glutMenuStateFunc( FGCBMenuState callback )
  78 {
  79     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuStateFunc" );
  80     fgState.MenuStateCallback = callback;
  81 }
  82
  83 /* Sets the global menu status callback for the current window */
  84 void FGAPIENTRY glutMenuStatusFunc( FGCBMenuStatus callback )
  85 {
  86     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuStatusFunc" );
  87     fgState.MenuStatusCallback = callback;
  88 }
  89
  90
  91 /*
  92  * Menu specific callbacks.
  93  */
  94 /* Callback upon menu destruction */
  95 void FGAPIENTRY glutMenuDestroyFunc( FGCBDestroy callback )
  96 {
  97     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMenuDestroyFunc" );
  98     if( fgStructure.CurrentMenu )
  99         fgStructure.CurrentMenu->Destroy = callback;
 100 }
 101
 102
 103 /*
 104  * All of the window-specific callbacks setting methods can be generalized to this:
 105  */
 106 #define SET_CALLBACK(a)                                         \
 107 do                                                              \
 108 {                                                               \
 109     if( fgStructure.CurrentWindow == NULL )                     \
 110         return;                                                 \
 111     SET_WCB( ( *( fgStructure.CurrentWindow ) ), a, callback ); \
 112 } while( 0 )
 113 /*
 114  * And almost every time the callback setter function can be implemented like this:
 115  */
 116 #define IMPLEMENT_CALLBACK_FUNC_2NAME(a,b)                      \
 117 void FGAPIENTRY glut##a##Func( FGCB##b callback )               \
 118 {                                                               \
 119     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glut"#a"Func" );    \
 120     SET_CALLBACK( b );                                          \
 121 }
 122 #define IMPLEMENT_CALLBACK_FUNC(a) IMPLEMENT_CALLBACK_FUNC_2NAME(a,a)
 123
 124 /* Implement all these callback setter functions... */
 125 IMPLEMENT_CALLBACK_FUNC(Position)
 126 IMPLEMENT_CALLBACK_FUNC(Keyboard)
 127 IMPLEMENT_CALLBACK_FUNC(KeyboardUp)
 128 IMPLEMENT_CALLBACK_FUNC(Special)
 129 IMPLEMENT_CALLBACK_FUNC(SpecialUp)
 130 IMPLEMENT_CALLBACK_FUNC(Mouse)
 131 IMPLEMENT_CALLBACK_FUNC(MouseWheel)
 132 IMPLEMENT_CALLBACK_FUNC(Motion)
 133 IMPLEMENT_CALLBACK_FUNC_2NAME(PassiveMotion,Passive)
 134 IMPLEMENT_CALLBACK_FUNC(Entry)
 135 /* glutWMCloseFunc is an alias for glutCloseFunc; both set the window's Destroy callback */
 136 IMPLEMENT_CALLBACK_FUNC_2NAME(Close,Destroy)
 137 IMPLEMENT_CALLBACK_FUNC_2NAME(WMClose,Destroy)
 138 IMPLEMENT_CALLBACK_FUNC(OverlayDisplay)
 139 IMPLEMENT_CALLBACK_FUNC(WindowStatus)
 140 IMPLEMENT_CALLBACK_FUNC(ButtonBox)
 141 IMPLEMENT_CALLBACK_FUNC(Dials)
 142 IMPLEMENT_CALLBACK_FUNC(TabletMotion)
 143 IMPLEMENT_CALLBACK_FUNC(TabletButton)
 144 IMPLEMENT_CALLBACK_FUNC(MultiEntry)
 145 IMPLEMENT_CALLBACK_FUNC(MultiButton)
 146 IMPLEMENT_CALLBACK_FUNC(MultiMotion)
 147 IMPLEMENT_CALLBACK_FUNC(MultiPassive)
 148 IMPLEMENT_CALLBACK_FUNC(InitContext)
 149 IMPLEMENT_CALLBACK_FUNC(AppStatus)
 150
 151
 152
 153 /*
 154  * Sets the Display callback for the current window
 155  */
 156 void FGAPIENTRY glutDisplayFunc( FGCBDisplay callback )
 157 {
 158     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDisplayFunc" );
 159     if( !callback )
 160         fgError( "Fatal error in program.  NULL display callback not "
 161                  "permitted in GLUT 3.0+ or freeglut 2.0.1+" );
 162     SET_CALLBACK( Display );
 163 }
 164
 165 void fghDefaultReshape(int width, int height)
 166 {
 167     glViewport( 0, 0, width, height );
 168 }
 169
 170 void FGAPIENTRY glutReshapeFunc( FGCBReshape callback )
 171 {
 172     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutReshapeFunc" );
 173
 174     if( !callback )
 175         callback = fghDefaultReshape;
 176
 177     SET_CALLBACK( Reshape );
 178 }
 179
 180 /*
 181  * Sets the Visibility callback for the current window.
 182  * NB: the Visibility func is deprecated in favor of the WindowStatus func,
 183  * which provides more detail. The visibility func callback is implemented
 184  * as a translation step from the windowStatus func. When the user sets the
 185  * windowStatus func, any visibility func is overwritten.
 186  * DEVELOPER NOTE: in the library, only invoke the window status func, this
 187  * gets automatically translated to the visibility func if thats what the
 188  * user has set.
 189  * window status is kind of anemic on win32 as there are no window messages
 190  * to notify us that the window is covered by other windows or not.
 191  * Should one want to query this, see
 192  * http://stackoverflow.com/questions/5445889/get-which-process-window-is-actually-visible-in-c-sharp
 193  * for an implementation outline (but it would be polling based, not push based).
 194  */
 195 static void fghVisibility( int status )
 196 {
 197     int vis_status;
 198
 199     FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED ( "Visibility Callback" );
 200     freeglut_return_if_fail( fgStructure.CurrentWindow );
 201
 202     /* Translate window status func states to visibility states */
 203     if( ( GLUT_HIDDEN == status )  || ( GLUT_FULLY_COVERED == status ) )
 204         vis_status = GLUT_NOT_VISIBLE;
 205     else    /* GLUT_FULLY_RETAINED, GLUT_PARTIALLY_RETAINED */
 206         vis_status = GLUT_VISIBLE;
 207
 208     INVOKE_WCB( *( fgStructure.CurrentWindow ), Visibility, ( vis_status ) );
 209 }
 210
 211 void FGAPIENTRY glutVisibilityFunc( FGCBVisibility callback )
 212 {
 213     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutVisibilityFunc" );
 214     SET_CALLBACK( Visibility );
 215
 216     if( callback )
 217         glutWindowStatusFunc( fghVisibility );
 218     else
 219         glutWindowStatusFunc( NULL );
 220 }
 221
 222 /*
 223  * Sets the joystick callback and polling rate for the current window
 224  */
 225 void FGAPIENTRY glutJoystickFunc( FGCBJoystick callback, int pollInterval )
 226 {
 227     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutJoystickFunc" );
 228     fgInitialiseJoysticks ();
 229
 230     if ( (
 231            fgStructure.CurrentWindow->State.JoystickPollRate <= 0 ||        /* Joystick callback was disabled */
 232            !FETCH_WCB(*fgStructure.CurrentWindow,Joystick)
 233          ) &&
 234          (
 235            callback && ( pollInterval > 0 )                                 /* but is now enabled */
 236          ) )
 237         ++fgState.NumActiveJoysticks;
 238     else if ( (
 239                 fgStructure.CurrentWindow->State.JoystickPollRate > 0 &&    /* Joystick callback was enabled */
 240                 FETCH_WCB(*fgStructure.CurrentWindow,Joystick)
 241               ) &&
 242               (
 243                 !callback || ( pollInterval <= 0 )                          /* but is now disabled */
 244               ) )
 245         --fgState.NumActiveJoysticks;
 246
 247     SET_CALLBACK( Joystick );
 248     fgStructure.CurrentWindow->State.JoystickPollRate = pollInterval;
 249
 250     /* set last poll time such that joystick will be polled asap */
 251     fgStructure.CurrentWindow->State.JoystickLastPoll = fgElapsedTime();
 252     if (fgStructure.CurrentWindow->State.JoystickLastPoll < pollInterval)
 253         fgStructure.CurrentWindow->State.JoystickLastPoll = 0;
 254     else
 255         fgStructure.CurrentWindow->State.JoystickLastPoll -= pollInterval;
 256 }
 257
 258
 259
 260 /*
 261  * Sets the spaceball motion callback for the current window
 262  */
 263 void FGAPIENTRY glutSpaceballMotionFunc( FGCBSpaceMotion callback )
 264 {
 265     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballMotionFunc" );
 266     fgInitialiseSpaceball();
 267
 268     SET_CALLBACK( SpaceMotion );
 269 }
 270
 271 /*
 272  * Sets the spaceball rotate callback for the current window
 273  */
 274 void FGAPIENTRY glutSpaceballRotateFunc( FGCBSpaceRotation callback )
 275 {
 276     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballRotateFunc" );
 277     fgInitialiseSpaceball();
 278
 279     SET_CALLBACK( SpaceRotation );
 280 }
 281
 282 /*
 283  * Sets the spaceball button callback for the current window
 284  */
 285 void FGAPIENTRY glutSpaceballButtonFunc( FGCBSpaceButton callback )
 286 {
 287     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSpaceballButtonFunc" );
 288     fgInitialiseSpaceball();
 289
 290     SET_CALLBACK( SpaceButton );
 291 }
 292
 293 /*** END OF FILE ***/