ruby-glfw 0.9

data/glfw-src/lib/dos/dos_time.c

@@ -0,0 +1,309 @@
+//========================================================================
+// GLFW - An OpenGL framework
+// File:        dos_time.c
+// Platform:    DOS
+// API version: 2.6
+// WWW:         http://glfw.sourceforge.net
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Camilla Berglund
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+// We use the __i386 define later in the code. Check if there are any
+// other defines that hint that we are compiling for 32-bit x86.
+#ifndef __i386
+ #if defined(__i386__) || defined(i386) || defined(X86) || defined(_M_IX86)
+  #define __i386
+ #endif
+#endif // __i386
+
+// Should we use inline x86 assembler?
+#if defined(__i386) && defined(__GNUC__)
+ #define _USE_X86_ASM
+#endif
+
+
+
+//************************************************************************
+//****                  GLFW internal functions                       ****
+//************************************************************************
+
+// Functions for accessing upper and lower parts of 64-bit integers
+// (Note: These are endian dependent, but ONLY used on x86 platforms!)
+#define _HIGH(x) ((unsigned int*)&x)[1]
+#define _LOW(x)  *((unsigned int*)&x)
+
+
+//========================================================================
+// _glfwCPUID() - Execute x86 CPUID instruction
+//========================================================================
+
+#ifdef _USE_X86_ASM
+
+static int _glfwCPUID( unsigned int ID, unsigned int *a, unsigned int *b,
+    unsigned int *c, unsigned int *d )
+{
+    int has_cpuid;
+    unsigned int local_a, local_b, local_c, local_d;
+
+    // Inline assembly - GCC version
+#if defined(__i386) && defined(__GNUC__)
+
+    // Detect CPUID support
+    asm(
+        "pushf\n\t"
+        "pop    %%eax\n\t"
+        "movl   %%eax,%%ebx\n\t"
+        "xorl   $0x00200000,%%eax\n\t"
+        "push   %%eax\n\t"
+        "popf\n\t"
+        "pushf\n\t"
+        "pop    %%eax\n\t"
+        "xorl   %%eax,%%ebx\n\t"
+        "movl   %%eax,%0\n\t"
+        : "=m" (has_cpuid)
+        :
+        : "%eax", "%ebx"
+    );
+    if( !has_cpuid )
+    {
+        return GL_FALSE;
+    }
+
+    // Execute CPUID
+    asm(
+        "movl   %4,%%eax\n\t"
+        "cpuid\n\t"
+        "movl   %%eax,%0\n\t"
+        "movl   %%ebx,%1\n\t"
+        "movl   %%ecx,%2\n\t"
+        "movl   %%edx,%3\n\t"
+        : "=m" (local_a), "=m" (local_b), "=m" (local_c), "=m" (local_d)
+        : "m" (ID)
+        : "%eax", "%ebx", "%ecx", "%edx"
+    );
+
+#endif
+
+    // Common code for all compilers
+    *a = local_a;
+    *b = local_b;
+    *c = local_c;
+    *d = local_d;
+    return GL_TRUE;
+}
+
+#endif // _USE_X86_ASM
+
+
+//========================================================================
+// _glfwHasRDTSC() - Check for RDTSC availability AND usefulness
+//========================================================================
+
+static int _glfwHasRDTSC( void )
+{
+#ifdef _USE_X86_ASM
+
+    unsigned int cpu_name1, cpu_name2, cpu_name3;
+    unsigned int cpu_signature, cpu_brandID;
+    unsigned int max_base, feature_flags;
+    unsigned int dummy;
+
+    // Get processor vendor string (will return 0 if CPUID is not
+    // supported)
+    if( !_glfwCPUID( 0, &max_base, &cpu_name1, &cpu_name3, &cpu_name2 ) )
+    {
+        return GL_FALSE;
+    }
+
+    // Does the processor support base CPUID function 1?
+    if( max_base < 1 )
+    {
+        return GL_FALSE;
+    }
+
+    // Get CPU capabilities, CPU Brand ID & CPU Signature
+    _glfwCPUID( 1, &cpu_signature, &cpu_brandID, &dummy, &feature_flags );
+
+    // Is RDTSC supported?
+    if( !(feature_flags & 0x00000010) )
+    {
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+
+#else
+
+    // Not a supported compiler
+    return GL_FALSE;
+
+#endif
+}
+
+
+//------------------------------------------------------------------------
+// _RDTSC() - Get CPU cycle count using the RDTSC instruction
+//------------------------------------------------------------------------
+
+#if defined(__i386) && defined(__GNUC__)
+
+// Read 64-bit processor Time Stamp Counter - GCC version
+#define _RDTSC( hi, lo ) \
+    asm( \
+        "rdtsc\n\t" \
+        "movl %%edx,%0\n\t" \
+        "movl %%eax,%1" \
+        : "=m" (hi), "=m" (lo) \
+        :  \
+        : "%edx", "%eax" \
+    );
+
+#else
+
+#define _RDTSC( hi, lo ) {hi=lo=0;}
+
+#endif
+
+
+
+
+//========================================================================
+// _glfwInitTimer() - Initialize timer
+//========================================================================
+
+int _glfwInitTimer( void )
+{
+    clock_t   t, t1, t2;
+    long long c1, c2;
+
+    // Do we have RDTSC?
+    _glfwTimer.HasRDTSC = _glfwHasRDTSC();
+    if( _glfwTimer.HasRDTSC )
+    {
+        // Measure the CPU clock with the raw DOS clock (18.2 Hz)
+        t = clock();
+        while( (t1=clock()) == t );
+        _RDTSC( _HIGH(c1), _LOW(c1) );
+        t = t1+CLOCKS_PER_SEC/3;
+        while( (t2=clock()) < t );
+        _RDTSC( _HIGH(c2), _LOW(c2) );
+
+        // Calculate CPU clock period
+        _glfwTimer.Period = (double)(t2-t1) /
+                            (CLOCKS_PER_SEC * (double)(c2-c1));
+        _RDTSC( _HIGH(_glfwTimer.t0), _LOW(_glfwTimer.t0) );
+    }
+    else
+    {
+        // Use the raw DOS clock (18.2 Hz)
+        _glfwTimer.Period = 1.0 / CLOCKS_PER_SEC;
+        _glfwTimer.t0 = clock();
+    }
+
+    return 1;
+}
+
+
+//========================================================================
+// _glfwTerminateTimer() - Terminate timer
+//========================================================================
+
+void _glfwTerminateTimer( void )
+{
+    // Nothing to do here
+}
+
+
+//************************************************************************
+//****               Platform implementation functions                ****
+//************************************************************************
+
+//========================================================================
+// _glfwPlatformGetTime() - Return timer value in seconds
+//========================================================================
+
+double _glfwPlatformGetTime( void )
+{
+    long long t_now;
+
+    // Get current clock count
+    if( _glfwTimer.HasRDTSC )
+    {
+        _RDTSC( _HIGH(t_now), _LOW(t_now) );
+    }
+    else
+    {
+        t_now = (long long) clock();
+    }
+
+    // Convert to seconds
+    return (t_now-_glfwTimer.t0) * _glfwTimer.Period;
+}
+
+
+//========================================================================
+// _glfwPlatformSetTime() - Set timer value in seconds
+//========================================================================
+
+void _glfwPlatformSetTime( double t )
+{
+    long long t_now;
+
+    // Get current clock count
+    if( _glfwTimer.HasRDTSC )
+    {
+        _RDTSC( _HIGH(t_now), _LOW(t_now) );
+    }
+    else
+    {
+        t_now = (long long) clock();
+    }
+
+    // Set timer
+    _glfwTimer.t0 = t_now - (long long)(t/_glfwTimer.Period);
+}
+
+
+//========================================================================
+// _glfwPlatformSleep() - Put a thread to sleep for a specified amount of
+// time
+//========================================================================
+
+void _glfwPlatformSleep( double time )
+{
+    // TODO: Proper threaded version
+    if( time > 0 )
+    {
+        if( time < 0.001 )
+        {
+            delay( 1 );
+        }
+        else
+        {
+            delay( (unsigned int)(time*1000.0+0.5) );
+        }
+    }
+}

data/glfw-src/lib/dos/dos_window.c

@@ -0,0 +1,563 @@
+//========================================================================
+// GLFW - An OpenGL framework
+// File:        dos_window.c
+// Platform:    DOS
+// API version: 2.6
+// WWW:         http://glfw.sourceforge.net
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Camilla Berglund
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+
+//************************************************************************
+//****                  GLFW internal functions                       ****
+//************************************************************************
+
+//========================================================================
+// _glfwRedirectOutput() - Standard output redirection
+//========================================================================
+
+static void _glfwRedirectOutput( void )
+{
+    // Generate temporary names
+    tmpnam( _glfwWin.OutName );
+    tmpnam( _glfwWin.ErrName );
+
+    // Open temporary output files
+    _glfwWin.hOut = open( _glfwWin.OutName, O_WRONLY | O_CREAT | O_TEXT |
+                                            O_TRUNC, S_IREAD | S_IWRITE );
+    _glfwWin.hErr = open( _glfwWin.ErrName, O_WRONLY | O_CREAT | O_TEXT |
+                                            O_TRUNC, S_IREAD | S_IWRITE );
+
+    // Redirect stdout
+    if( _glfwWin.hOut > 0 )
+    {
+        _glfwWin.hOutOld = dup( STDOUT_FILENO );
+        fflush( stdout );
+        dup2( _glfwWin.hOut, STDOUT_FILENO );
+    }
+
+    // Redirect stderr
+    if( _glfwWin.hErr > 0 )
+    {
+        _glfwWin.hErrOld = dup( STDERR_FILENO );
+        fflush( stderr );
+        dup2( _glfwWin.hErr, STDERR_FILENO );
+    }
+}
+
+
+//========================================================================
+// _glfwRestoreOutput() - Standard output redirection
+//========================================================================
+
+static void _glfwRestoreOutput( void )
+{
+    FILE *f;
+    char *str = alloca( 512 );
+
+    // Dump from temporary file to stdout
+    if( _glfwWin.hOut > 0)
+    {
+        // Restore old stdout
+        dup2( _glfwWin.hOutOld, STDOUT_FILENO );
+        close( _glfwWin.hOut );
+        close( _glfwWin.hOutOld );
+        _glfwWin.hOut = 0;
+
+        // Dump file to stdout
+        f = fopen( _glfwWin.OutName, "rt" );
+        while( fgets( str, 512, f ) )
+        {
+            fputs( str, stdout );
+        }
+        fclose( f );
+
+        // Remove temporary file
+        remove( _glfwWin.OutName );
+     }
+
+    // Dump from temporary file to stderr
+    if( _glfwWin.hOut > 0)
+    {
+        // Restore old stderr
+        dup2( _glfwWin.hErrOld, STDERR_FILENO );
+        close( _glfwWin.hErr );
+        close( _glfwWin.hErrOld );
+        _glfwWin.hErr = 0;
+
+        // Dump file to stderr
+        f = fopen( _glfwWin.ErrName, "rt" );
+        while( fgets( str, 512, f ) )
+        {
+            fputs( str, stderr );
+        }
+        fclose( f );
+
+        // Remove temporary file
+        remove( _glfwWin.ErrName );
+     }
+}
+
+
+//========================================================================
+// _glfwTranslateChar() - Translates a DOS key code to Unicode
+//========================================================================
+
+static int _glfwTranslateChar( int keycode )
+{
+    // Unicode?
+    if( (keycode >= 32 && keycode <= 126) || keycode >= 160 )
+    {
+        return keycode;
+    }
+
+    return -1;
+}
+
+
+//========================================================================
+// _glfwTranslateKey() - Translates a DOS key code to GLFW coding
+//========================================================================
+
+static int _glfwTranslateKey( int keycode )
+{
+    // ISO 8859-1?
+    if( ((keycode>=32) && (keycode<=126)) ||
+        ((keycode>=160) && (keycode<=254)) )
+    {
+        return keycode;
+    }
+
+    // Special keys?
+    if( keycode < 0 )
+    {
+        return -keycode;
+    }
+
+    return -1;
+}
+
+
+
+//************************************************************************
+//****               Platform implementation functions                ****
+//************************************************************************
+
+//========================================================================
+// _glfwPlatformOpenWindow() - Here is where the window is created, and
+// the OpenGL rendering context is created
+//========================================================================
+
+int _glfwPlatformOpenWindow( int width, int height, int redbits,
+    int greenbits, int bluebits, int alphabits, int depthbits,
+    int stencilbits, int mode, int accumredbits, int accumgreenbits,
+    int accumbluebits, int accumalphabits, int auxbuffers, int stereo,
+    int refreshrate )
+{
+    GLint params[2];
+
+    // Clear window resources
+    _glfwWin.Visual  = NULL;
+    _glfwWin.Context = NULL;
+    _glfwWin.Buffer  = NULL;
+    _glfwWin.hOut    = 0;
+    _glfwWin.hErr    = 0;
+
+    // For now, we only support 640x480, 800x600 and 1024x768
+    if( (width*height) < (700*500) )
+    {
+        width  = 640;
+        height = 480;
+    }
+    else if( (width*height) < (900*700) )
+    {
+        width  = 800;
+        height = 600;
+    }
+    else
+    {
+        width  = 1024;
+        height = 768;
+    }
+
+    // For now, we only support 5,6,5 and 8,8,8 color formats
+    if( (redbits+greenbits+bluebits) < 20 )
+    {
+        redbits   = 5;
+        greenbits = 6;
+        bluebits  = 5;
+    }
+    else
+    {
+        redbits   = 8;
+        greenbits = 8;
+        bluebits  = 8;
+    }
+
+    // For now, we always set refresh rate = 0 (default)
+    refreshrate = 0;
+
+    // stdout/stderr redirection
+    _glfwRedirectOutput();
+
+    // Create visual
+    _glfwWin.Visual = DMesaCreateVisual(
+                        width, height,
+                        redbits+greenbits+bluebits,
+                        refreshrate,
+                        GL_TRUE,                    // Double buffer
+                        GL_TRUE,                    // RGB mode
+                        alphabits?GL_TRUE:GL_FALSE, // Alpha buffer?
+                        depthbits,
+                        stencilbits,
+                        (accumredbits+accumgreenbits+
+                         accumbluebits+accumalphabits)>>2
+                      );
+    if( _glfwWin.Visual == NULL )
+    {
+        printf("Unable to create visual\n");
+        _glfwPlatformCloseWindow();
+        return GL_FALSE;
+    }
+
+    // Create context
+    _glfwWin.Context = DMesaCreateContext( _glfwWin.Visual, NULL );
+    if( _glfwWin.Context == NULL )
+    {
+        printf("Unable to create context\n");
+        _glfwPlatformCloseWindow();
+        return GL_FALSE;
+    }
+
+    // Create buffer
+    _glfwWin.Buffer = DMesaCreateBuffer( _glfwWin.Visual, 0, 0,
+                                         width, height );
+    if( _glfwWin.Buffer == NULL )
+    {
+        printf("Unable to create buffer\n");
+        _glfwPlatformCloseWindow();
+        return GL_FALSE;
+    }
+
+    // Make current context
+    if( !DMesaMakeCurrent( _glfwWin.Context, _glfwWin.Buffer ) )
+    {
+        printf("Unable to make current context\n");
+        _glfwPlatformCloseWindow();
+        return GL_FALSE;
+    }
+
+    // Start DOS event handler
+    if( !_glfwInitEvents() )
+    {
+        printf("Unable to start event handler\n");
+        _glfwPlatformCloseWindow();
+        return GL_FALSE;
+    }
+
+    // Start keyboard handler
+    if( !_glfwInitKeyboard() )
+    {
+        printf("Unable to start keyboard driver\n");
+        _glfwPlatformCloseWindow();
+        return GL_FALSE;
+    }
+
+    // Start mouse handler
+    if( !_glfwInitMouse() )
+    {
+        printf("***Warning: Unable to start mouse driver\n");
+    }
+
+    // Remember actual screen/window size
+    _glfwWin.Width  = width;
+    _glfwWin.Height = height;
+
+    return GL_TRUE;
+}
+
+
+//========================================================================
+// _glfwPlatformCloseWindow() - Properly kill the window/video display
+//========================================================================
+
+void _glfwPlatformCloseWindow( void )
+{
+    // Terminate mouse handler
+    _glfwTerminateMouse();
+
+    // Terminate keyboard handler
+    _glfwTerminateKeyboard();
+
+    // Terminate event handler
+    _glfwTerminateEvents();
+
+    // Destroy buffer
+    if( _glfwWin.Buffer != NULL )
+    {
+        DMesaDestroyBuffer( _glfwWin.Buffer );
+        _glfwWin.Buffer = NULL;
+    }
+
+    // Destroy context
+    if( _glfwWin.Context != NULL )
+    {
+        DMesaDestroyContext( _glfwWin.Context );
+        _glfwWin.Context = NULL;
+    }
+
+    // Destroy visual
+    if( _glfwWin.Visual != NULL )
+    {
+        DMesaDestroyVisual( _glfwWin.Visual );
+        _glfwWin.Visual = NULL;
+    }
+
+    // stdout/stderr redirection
+    _glfwRestoreOutput();
+}
+
+
+//========================================================================
+// _glfwPlatformSetWindowTitle() - Set the window title.
+//========================================================================
+
+void _glfwPlatformSetWindowTitle( const char *title )
+{
+    // Nothing to do here...
+}
+
+
+//========================================================================
+// _glfwPlatformSetWindowSize() - Set the window size.
+//========================================================================
+
+void _glfwPlatformSetWindowSize( int width, int height )
+{
+    // TODO
+}
+
+
+//========================================================================
+// _glfwPlatformSetWindowPos() - Set the window position.
+//========================================================================
+
+void _glfwPlatformSetWindowPos( int x, int y )
+{
+    // Nothing to do here...
+}
+
+
+//========================================================================
+// _glfwPlatformIconfyWindow() - Window iconification
+//========================================================================
+
+void _glfwPlatformIconifyWindow( void )
+{
+    // Nothing to do here...
+}
+
+
+//========================================================================
+// _glfwPlatformRestoreWindow() - Window un-iconification
+//========================================================================
+
+void _glfwPlatformRestoreWindow( void )
+{
+    // Nothing to do here...
+}
+
+
+//========================================================================
+// _glfwPlatformSwapBuffers() - Swap buffers (double-buffering) and poll
+// any new events.
+//========================================================================
+
+void _glfwPlatformSwapBuffers( void )
+{
+    DMesaSwapBuffers( _glfwWin.Buffer );
+}
+
+
+//========================================================================
+// _glfwPlatformSwapInterval() - Set double buffering swap interval
+//========================================================================
+
+void _glfwPlatformSwapInterval( int interval )
+{
+    // TODO
+}
+
+
+//========================================================================
+// _glfwPlatformRefreshWindowParams()
+//========================================================================
+
+void _glfwPlatformRefreshWindowParams( void )
+{
+    GLint     x;
+    GLboolean b;
+
+    // Fill out information
+    _glfwWin.Accelerated    = GL_TRUE;
+    glGetIntegerv( GL_RED_BITS, &x );
+    _glfwWin.RedBits        = x;
+    glGetIntegerv( GL_GREEN_BITS, &x );
+    _glfwWin.GreenBits      = x;
+    glGetIntegerv( GL_BLUE_BITS, &x );
+    _glfwWin.BlueBits       = x;
+    glGetIntegerv( GL_ALPHA_BITS, &x );
+    _glfwWin.AlphaBits      = x;
+    glGetIntegerv( GL_DEPTH_BITS, &x );
+    _glfwWin.DepthBits      = x;
+    glGetIntegerv( GL_STENCIL_BITS, &x );
+    _glfwWin.StencilBits    = x;
+    glGetIntegerv( GL_ACCUM_RED_BITS, &x );
+    _glfwWin.AccumRedBits   = x;
+    glGetIntegerv( GL_ACCUM_GREEN_BITS, &x );
+    _glfwWin.AccumGreenBits = x;
+    glGetIntegerv( GL_ACCUM_BLUE_BITS, &x );
+    _glfwWin.AccumBlueBits  = x;
+    glGetIntegerv( GL_ACCUM_ALPHA_BITS, &x );
+    _glfwWin.AccumAlphaBits = x;
+    glGetIntegerv( GL_AUX_BUFFERS, &x );
+    _glfwWin.AuxBuffers     = x;
+    glGetBooleanv( GL_AUX_BUFFERS, &b );
+    _glfwWin.Stereo         = b ? GL_TRUE : GL_FALSE;
+    _glfwWin.RefreshRate    = 0;
+}
+
+
+//========================================================================
+// _glfwPlatformPollEvents() - Poll for new window and input events
+//========================================================================
+
+void _glfwPlatformPollEvents( void )
+{
+    _GLFWdosevent event;
+    struct key_event         *key;
+    struct mousemove_event   *mousemove;
+    struct mousewheel_event  *mousewheel;
+    struct mousebutton_event *mousebutton;
+
+    // Empty the event queue
+    while( _glfwGetNextEvent( &event ) )
+    {
+        switch( event.Type )
+        {
+        // Keyboard event?
+        case _GLFW_DOS_KEY_EVENT:
+            key = &event.Key;
+            _glfwInputKey( _glfwTranslateKey( key->KeyNoMod ),
+                           key->Action );
+            _glfwInputChar( _glfwTranslateChar( key->Key ),
+                            key->Action );
+            break;
+
+        // Mouse move event?
+        case _GLFW_DOS_MOUSE_MOVE_EVENT:
+            mousemove = &event.MouseMove;
+            _glfwInput.MousePosX += mousemove->DeltaX;
+            _glfwInput.MousePosY += mousemove->DeltaY;
+
+            // Call user callback function
+            if( _glfwWin.MousePosCallback )
+            {
+                _glfwWin.MousePosCallback( _glfwInput.MousePosX,
+                                           _glfwInput.MousePosY );
+            }
+            break;
+
+        // Mouse wheel event?
+        case _GLFW_DOS_MOUSE_WHEEL_EVENT:
+            mousewheel = &event.MouseWheel;
+            _glfwInput.WheelPos += mousewheel->WheelDelta;
+
+            // Call user callback function
+            if( _glfwWin.MouseWheelCallback )
+            {
+                _glfwWin.MouseWheelCallback( _glfwInput.WheelPos );
+            }
+            break;
+
+        // Mouse button event?
+        case _GLFW_DOS_MOUSE_BUTTON_EVENT:
+            mousebutton = &event.MouseButton;
+            _glfwInputMouseClick( mousebutton->Button,
+                                  mousebutton->Action );
+            break;
+
+        default:
+            break;
+        }
+
+    }
+}
+
+
+//========================================================================
+// _glfwPlatformWaitEvents() - Wait for new window and input events
+//========================================================================
+
+void _glfwPlatformWaitEvents( void )
+{
+    // Wait for new events
+    _glfwWaitNextEvent;
+
+    // Poll new events
+    _glfwPlatformPollEvents();
+}
+
+
+//========================================================================
+// _glfwPlatformHideMouseCursor() - Hide mouse cursor (lock it)
+//========================================================================
+
+void _glfwPlatformHideMouseCursor( void )
+{
+    // TODO
+}
+
+
+//========================================================================
+// _glfwPlatformShowMouseCursor() - Show mouse cursor (unlock it)
+//========================================================================
+
+void _glfwPlatformShowMouseCursor( void )
+{
+    // TODO
+}
+
+
+//========================================================================
+// _glfwPlatformSetMouseCursorPos() - Set physical mouse cursor position
+//========================================================================
+
+void _glfwPlatformSetMouseCursorPos( int x, int y )
+{
+    // TODO
+}