* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
-#include "../include/GL/freeglut.h"
+#include <GL/freeglut.h>
#include "freeglut_internal.h"
#include <limits.h>
#include <errno.h>
#include <sys/stat.h>
#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_WINCE
+ // including gx.h does only work in c++ (thanks MS...),
+ // so we define this on our own...
+struct GXKeyList {
+ short vkUp; // key for up
+ POINT ptUp; // x,y position of key/button. Not on screen but in screen coordinates.
+ short vkDown;
+ POINT ptDown;
+ short vkLeft;
+ POINT ptLeft;
+ short vkRight;
+ POINT ptRight;
+ short vkA;
+ POINT ptA;
+ short vkB;
+ POINT ptB;
+ short vkC;
+ POINT ptC;
+ short vkStart;
+ POINT ptStart;
+};
+extern void wince_GetDefaultKeys(void* nData, int iOptions);
+extern void wince_OpenInput();
#endif
#ifndef MAX
width, height );
XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
+#if !TARGET_HOST_WINCE
{
RECT rect;
}
/*
- * SWP_NOACTIVATE Do not activate the window
- * SWP_NOOWNERZORDER Do not change position in z-order
- * SWP_NOSENDCHANGING Supress WM_WINDOWPOSCHANGING message
- * SWP_NOZORDER Retains the current Z order (ignore 2nd param)
+ * SWP_NOACTIVATE Do not activate the window
+ * SWP_NOOWNERZORDER Do not change position in z-order
+ * SWP_NOSENDCHANGING Supress WM_WINDOWPOSCHANGING message
+ * SWP_NOZORDER Retains the current Z order (ignore 2nd param)
*/
SetWindowPos( window->Window.Handle,
SWP_NOZORDER
);
}
+#endif //TARGET_HOST_WINCE
/*
* XXX Should update {window->State.OldWidth, window->State.OldHeight}
fgSetWindow( window );
- fghReshapeWindowByHandle(
+ fghReshapeWindowByHandle(
window->Window.Handle,
window->State.Width,
window->State.Height
);
window->State.NeedToResize = GL_FALSE;
- fgSetWindow ( current_window );
+ fgSetWindow( current_window );
}
INVOKE_WCB( *window, Display, ( ) );
fgSetWindow( window );
- fghReshapeWindowByHandle(
+ fghReshapeWindowByHandle(
window->Window.Handle,
window->State.Width,
window->State.Height
INVOKE_WCB( *window, Display, ( ) );
fgSetWindow( current_window );
}
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
RedrawWindow(
- window->Window.Handle, NULL, NULL,
+ window->Window.Handle, NULL, NULL,
RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_UPDATENOW
);
#endif
if( window->State.JoystickLastPoll + window->State.JoystickPollRate <=
checkTime )
{
+#if !TARGET_HOST_WINCE
fgJoystickPollWindow( window );
+#endif //!TARGET_HOST_WINCE
window->State.JoystickLastPoll = checkTime;
}
return elapsed;
#elif TARGET_HOST_WIN32
return timeGetTime() - fgState.Time.Value;
+#elif TARGET_HOST_WINCE
+ return GetTickCount() - fgState.Time.Value;
#endif
}
else
gettimeofday( &fgState.Time.Value, NULL );
#elif TARGET_HOST_WIN32
fgState.Time.Value = timeGetTime ();
+#elif TARGET_HOST_WINCE
+ fgState.Time.Value = GetTickCount();
#endif
fgState.Time.Set = GL_TRUE ;
* Indicates whether Joystick events are being used by ANY window.
*
* The current mechanism is to walk all of the windows and ask if
- * there is a joystick callback. Certainly in some cases, maybe
- * in all cases, the joystick is attached to the system and accessed
- * from ONE point by GLUT/freeglut, so this is not the right way,
- * in general, to do this. However, the Joystick code is segregated
- * in its own little world, so we can't access the information that
- * we need in order to do that nicely.
- *
- * Some alternatives:
- * * Store Joystick data into freeglut global state.
- * * Provide NON-static functions or data from Joystick *.c file.
+ * there is a joystick callback. We have a short-circuit early
+ * return if we find any joystick handler registered.
*
- * Basically, the RIGHT way to do this requires knowing something
- * about the Joystick. Right now, the Joystick code is behind
- * an opaque wall.
+ * The real way to do this is to make use of the glutTimer() API
+ * to more cleanly re-implement the joystick API. Then, this code
+ * and all other "joystick timer" code can be yanked.
*
*/
static void fgCheckJoystickCallback( SFG_Window* w, SFG_Enumerator* e)
e->data = w;
}
fgEnumSubWindows( w, fgHavePendingRedisplaysCallback, e );
-}
+}
static int fgHavePendingRedisplays (void)
{
SFG_Enumerator enumerator;
*/
static void fgSleepForEvents( void )
{
- long msec;
+ long msec;
if( fgState.IdleCallback || fgHavePendingRedisplays( ) )
return;
msec = MIN( msec, 10 ); /* XXX Dumb; forces granularity to .01sec */
#if TARGET_HOST_UNIX_X11
+ /*
+ * Possibly due to aggressive use of XFlush() and friends,
+ * it is possible to have our socket drained but still have
+ * unprocessed events. (Or, this may just be normal with
+ * X, anyway?) We do non-trivial processing of X events
+ * after tham in event-reading loop, in any case, so we
+ * need to allow that we may have an empty socket but non-
+ * empty event queue.
+ */
+ if( ! XPending( fgDisplay.Display ) )
{
fd_set fdset;
int err;
int socket;
struct timeval wait;
+
socket = ConnectionNumber( fgDisplay.Display );
FD_ZERO( &fdset );
FD_SET( socket, &fdset );
-
wait.tv_sec = msec / 1000;
wait.tv_usec = (msec % 1000) * 1000;
err = select( socket+1, &fdset, NULL, NULL, &wait );
if( -1 == err )
fgWarning ( "freeglut select() error: %d\n", errno );
}
-#elif TARGET_HOST_WIN32
- MsgWaitForMultipleObjects ( 0, NULL, FALSE, msec, QS_ALLEVENTS );
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
+ MsgWaitForMultipleObjects( 0, NULL, FALSE, msec, QS_ALLEVENTS );
#endif
}
ret |= GLUT_ACTIVE_CTRL;
if( event->xkey.state & Mod1Mask )
ret |= GLUT_ACTIVE_ALT;
-
+
return ret;
}
#endif
*/
if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow )
{
- GETWINDOW( xclient );
+ GETWINDOW( xclient );
fgDestroyWindow ( window );
* XXX double-buffered does not respect viewport when we
* XXX do a buffer-swap).
*
- * XXX GETWINDOW( xexpose );
- * XXX fgSetWindow( window );
- * XXX glutPostRedisplay( );
*/
if( event.xexpose.count == 0 )
- fghRedrawWindowByHandle( event.xexpose.window );
+ {
+ GETWINDOW( xexpose );
+ fgSetWindow( window );
+ glutPostRedisplay( );
+ }
break;
case MapNotify:
case VisibilityNotify:
{
- GETWINDOW( xvisibility );
+ GETWINDOW( xvisibility );
/*
* XXX INVOKE_WCB() does this check for us.
*/
INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) );
window->State.Visible = GL_TRUE;
break;
-
+
case VisibilityPartiallyObscured:
INVOKE_WCB( *window, WindowStatus,
( GLUT_PARTIALLY_RETAINED ) );
window->State.Visible = GL_TRUE;
break;
-
+
case VisibilityFullyObscured:
INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_COVERED ) );
window->State.Visible = GL_FALSE;
*/
GETWINDOW( xbutton );
GETMOUSE( xbutton );
-
+
/*
* An X button (at least in XFree86) is numbered from 1.
* A GLUT button is numbered from 0.
window->ActiveMenu->Window->State.MouseY =
event.xbutton.y_root - window->ActiveMenu->Y;
}
-
+
/* In the menu, invoke the callback and deactivate the menu*/
if( fgCheckActiveMenu( window->ActiveMenu->Window,
window->ActiveMenu ) )
int direction = -1;
if( button % 2 )
direction = 1;
-
+
if( pressed )
INVOKE_WCB( *window, MouseWheel, ( wheel_number,
direction,
GETWINDOW( xkey );
GETMOUSE( xkey );
+ /* Detect auto repeated keys, if configured globally or per-window */
+
+ if ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE )
+ {
+ if (event.type==KeyRelease)
+ {
+ /*
+ * Look at X11 keystate to detect repeat mode.
+ * While X11 says the key is actually held down, we'll ignore KeyRelease/KeyPress pairs.
+ */
+
+ char keys[32];
+ XQueryKeymap( fgDisplay.Display, keys ); /* Look at X11 keystate to detect repeat mode */
+
+ if ( keys[event.xkey.keycode>>3] & (1<<(event.xkey.keycode%8)) )
+ window->State.KeyRepeating = GL_TRUE;
+ else
+ window->State.KeyRepeating = GL_FALSE;
+ }
+ }
+ else
+ window->State.KeyRepeating = GL_FALSE;
+
+ /* Cease processing this event if it is auto repeated */
+
+ if (window->State.KeyRepeating)
+ break;
+
if( event.type == KeyPress )
{
keyboard_cb = FETCH_WCB( *window, Keyboard );
}
}
-#elif TARGET_HOST_WIN32
+#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
MSG stMsg;
{
int action;
-#if TARGET_HOST_WIN32
+#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE
SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;
#endif
freeglut_assert_ready;
-#if TARGET_HOST_WIN32
+#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE
/*
* Processing before the main loop: If there is a window which is open and
* which has a visibility callback, call it. I know this is an ugly hack,
INVOKE_WCB( *window, Visibility, ( window->State.Visible ) );
fgSetWindow( current_window );
}
-
+
window = (SFG_Window *)window->Node.Next ;
}
#endif
/*
* Step through the list of windows, seeing if there are any
* that are not menus
- */
+ */
for( window = ( SFG_Window * )fgStructure.Windows.First;
window;
window = ( SFG_Window * )window->Node.Next )
if ( ! ( window->IsMenu ) )
break;
-
+
if( ! window )
fgState.ExecState = GLUT_EXEC_STATE_STOP;
else
}
-#if TARGET_HOST_WIN32
+#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE
/*
* Determine a GLUT modifer mask based on MS-WINDOWS system info.
*/
{
unsigned int current_DisplayMode = fgState.DisplayMode;
fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
+#if !TARGET_HOST_WINCE
fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE );
+#endif
fgState.DisplayMode = current_DisplayMode;
if( fgStructure.MenuContext )
}
else
{
+#if !TARGET_HOST_WINCE
fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE );
+#endif
if( ! fgState.UseCurrentContext )
window->Window.Context =
window->State.Height = fgState.Size.Y;
ReleaseDC( window->Window.Handle, window->Window.Device );
+
+#if TARGET_HOST_WINCE
+ // Take over button handling
+ wince_OpenInput();
+#endif //TARGET_HOST_WINCE
break;
case WM_SIZE:
if( window->State.Visible )
{
window->State.NeedToResize = GL_TRUE;
+#if TARGET_HOST_WINCE
+ window->State.Width = HIWORD(lParam);
+ window->State.Height = LOWORD(lParam);
+#else
window->State.Width = LOWORD(lParam);
window->State.Height = HIWORD(lParam);
+#endif //TARGET_HOST_WINCE
}
break;
#if 0
- case WM_SETFOCUS:
+ case WM_SETFOCUS:
printf("WM_SETFOCUS: %p\n", window );
lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
break;
- case WM_ACTIVATE:
+ case WM_ACTIVATE:
if (LOWORD(wParam) != WA_INACTIVE)
{
/* glutSetCursor( fgStructure.Window->State.Cursor ); */
* XXX call glutSetCurdsor() instead of defining two macros
* XXX and implementing a nested case in-line.
*/
- case WM_SETCURSOR:
+ case WM_SETCURSOR:
/* Set the cursor AND change it for this window class. */
#define MAP_CURSOR(a,b) \
case a: \
case WM_MOUSEMOVE:
{
+#if TARGET_HOST_WINCE
+ window->State.MouseX = 320-HIWORD( lParam );
+ window->State.MouseY = LOWORD( lParam );
+#else
window->State.MouseX = LOWORD( lParam );
window->State.MouseY = HIWORD( lParam );
-
+#endif //TARGET_HOST_WINCE
+
if ( window->ActiveMenu )
{
window->State.Redisplay = GL_TRUE;
GLboolean pressed = GL_TRUE;
int button;
+#if TARGET_HOST_WINCE
+ window->State.MouseX = 320-HIWORD( lParam );
+ window->State.MouseY = LOWORD( lParam );
+#else
window->State.MouseX = LOWORD( lParam );
window->State.MouseY = HIWORD( lParam );
+#endif //TARGET_HOST_WINCE
switch( uMsg )
{
break;
}
+#if !TARGET_HOST_WINCE
if( GetSystemMetrics( SM_SWAPBUTTON ) )
{
if( button == GLUT_LEFT_BUTTON )
if( button == GLUT_RIGHT_BUTTON )
button = GLUT_LEFT_BUTTON;
}
+#endif //!TARGET_HOST_WINCE
if( button == -1 )
return DefWindowProc( hWnd, uMsg, lParam, wParam );
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
{
+#if TARGET_HOST_WINCE
+ struct GXKeyList gxKeyList;
+#endif //TARGET_HOST_WINCE
int keypress = -1;
POINT mouse_pos ;
- if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
+ if( ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) && (HIWORD(lParam) & KF_REPEAT) )
break;
/*
- * Remember the current modifiers state. This is done here in order
+ * Remember the current modifiers state. This is done here in order
* to make sure the VK_DELETE keyboard callback is executed properly.
*/
fgState.Modifiers = fgGetWin32Modifiers( );
);
}
+#if TARGET_HOST_WINCE
+ if(!(lParam & 0x40000000)) // Prevent auto-repeat
+ {
+ wince_GetDefaultKeys(&gxKeyList, 0x03);
+
+ if(wParam==(unsigned)gxKeyList.vkRight)
+ keypress = GLUT_KEY_RIGHT;
+ else if(wParam==(unsigned)gxKeyList.vkLeft)
+ keypress = GLUT_KEY_LEFT;
+ else if(wParam==(unsigned)gxKeyList.vkUp)
+ keypress = GLUT_KEY_UP;
+ else if(wParam==(unsigned)gxKeyList.vkDown)
+ keypress = GLUT_KEY_DOWN;
+ else if(wParam==(unsigned)gxKeyList.vkA)
+ keypress = GLUT_KEY_F1;
+ else if(wParam==(unsigned)gxKeyList.vkB)
+ keypress = GLUT_KEY_F2;
+ else if(wParam==(unsigned)gxKeyList.vkC)
+ keypress = GLUT_KEY_F3;
+ else if(wParam==(unsigned)gxKeyList.vkStart)
+ keypress = GLUT_KEY_F4;
+ }
+#endif
+
if( keypress != -1 )
INVOKE_WCB( *window, Special,
( keypress,
POINT mouse_pos;
/*
- * Remember the current modifiers state. This is done here in order
+ * Remember the current modifiers state. This is done here in order
* to make sure the VK_DELETE keyboard callback is executed properly.
*/
fgState.Modifiers = fgGetWin32Modifiers( );
default:
{
+#if !TARGET_HOST_WINCE
BYTE state[ 256 ];
WORD code[ 2 ];
-
+
GetKeyboardState( state );
-
+
if( ToAscii( wParam, 0, state, code, 0 ) == 1 )
wParam=code[ 0 ];
( (char)wParam,
window->State.MouseX, window->State.MouseY )
);
+#endif //!TARGET_HOST_WINCE
}
}
case WM_SYSCHAR:
case WM_CHAR:
{
- if( fgState.IgnoreKeyRepeat && (lParam & KF_REPEAT) )
+ if( (fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE) && (HIWORD(lParam) & KF_REPEAT) )
break;
fgState.Modifiers = fgGetWin32Modifiers( );
lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
break;
+#if !TARGET_HOST_WINCE
case WM_SYNCPAINT: /* 0x0088 */
/* Another window has moved, need to update this one */
window->State.Redisplay = GL_TRUE;
break ;
}
}
+#endif //!TARGET_HOST_WINCE
/* We need to pass the message on to the operating system as well */
lRet = DefWindowProc( hWnd, uMsg, wParam, lParam );
projects / freeglut / blobdiff