rik/jlibxinput
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace tabs with spaces

Browse Source
This commit is contained in:
Rik Veenboer
2015-09-01 13:15:14 +01:00
parent 45f730d9f3
commit c4948c1ff1
43 changed files with 2735 additions and 2735 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
src/main/cpp/JXInputManager.cpp
View File

@@ -13,55 +13,55 @@ mhWnd( hWnd ),
mDeviceCounter( 0 )
{
for ( int i = 0; i < MAX_JXINPUTS; ++i )
{
mDevices[ i ] = NULL;
}
for ( int i = 0; i < MAX_JXINPUTS; ++i )
{
mDevices[ i ] = NULL;
}
if ( FAILED( InitDirectInput( hWnd ) ) )
{
FreeDirectInput();
}
if ( FAILED( InitDirectInput( hWnd ) ) )
{
FreeDirectInput();
}
}
JXInputManager::~JXInputManager()
{
for ( int i = 0; i < getNumberOfJXInputs(); ++i )
{
delete mDevices[ i ];
mDevices[ i ] = NULL;
}
for ( int i = 0; i < getNumberOfJXInputs(); ++i )
{
delete mDevices[ i ];
mDevices[ i ] = NULL;
}
FreeDirectInput();
FreeDirectInput();
}
int JXInputManager::getNumberOfJXInputs() const
{
return mDeviceCounter;
return mDeviceCounter;
}
JXInput& JXInputManager::getJXInput( int idx ) const
{
assert( idx < mDeviceCounter );
return * mDevices[ idx ];
assert( idx < mDeviceCounter );
return * mDevices[ idx ];
}
int JXInputManager::getMaxNumberOfAxes() const
{
return JXINPUT_MAX_AXES;
return JXINPUT_MAX_AXES;
}
int JXInputManager::getMaxNumberOfButtons() const
{
return JXINPUT_MAX_BUTTONS;
return JXINPUT_MAX_BUTTONS;
}
int JXInputManager::getMaxNumberOfDirectionals() const
{
return JXINPUT_MAX_DIRECTIONALS;
return JXINPUT_MAX_DIRECTIONALS;
}
@@ -87,7 +87,7 @@ HRESULT JXInputManager::InitDirectInput( HWND hWnd )
(VOID*)this, DIEDFL_ALLDEVICES /*| DIEDFL_INCLUDEPHANTOMS*/ ) ) )
return hr;
// Look for a other devices
// Look for a other devices
if( FAILED( hr = mpDI->EnumDevices( DI8DEVCLASS_DEVICE,
EnumJoysticksCallback,
(VOID*)this, DIEDFL_ALLDEVICES /*| DIEDFL_INCLUDEPHANTOMS*/ ) ) )
@@ -104,9 +104,9 @@ HRESULT JXInputManager::InitDirectInput( HWND hWnd )
HRESULT JXInputManager::FreeDirectInput()
{
if ( NULL != mpDI )
mpDI->Release();
mpDI = NULL;
if ( NULL != mpDI )
mpDI->Release();
mpDI = NULL;
return S_OK;
}
@@ -120,43 +120,43 @@ BOOL CALLBACK JXInputManager::EnumJoysticksCallback( const DIDEVICEINSTANCE* pdi
VOID* pContext )
{
HRESULT hr;
LPDIRECTINPUTDEVICE8 pJoystick;
LPDIRECTINPUTDEVICE8 pJoystick;
JXInputManager* pThis = (JXInputManager*)pContext;
JXInputManager* pThis = (JXInputManager*)pContext;
//
// if the maximum number of devices is already registered,
// issue a warning and stop enumeration.
//
if( MAX_JXINPUTS == pThis->mDeviceCounter )
{
OutputDebugString( "Max. number of devices exceeded!" );
return DIENUM_STOP;
}
//
// if the maximum number of devices is already registered,
// issue a warning and stop enumeration.
//
if( MAX_JXINPUTS == pThis->mDeviceCounter )
{
OutputDebugString( "Max. number of devices exceeded!" );
return DIENUM_STOP;
}
// Obtain an interface to the enumerated joystick.
hr = pThis->mpDI->CreateDevice( pdidInstance->guidInstance, &pJoystick, NULL );
hr = pThis->mpDI->CreateDevice( pdidInstance->guidInstance, &pJoystick, NULL );
// If it failed, then we can't use this joystick. (Maybe the user unplugged
// it while we were in the middle of enumerating it.)
if( FAILED(hr) )
return DIENUM_CONTINUE;
JXInput* pJ = new JXInput( pJoystick, pThis->mhWnd );
JXInput* pJ = new JXInput( pJoystick, pThis->mhWnd );
//
// only register useful devices
//
if( pJ->getNumberOfAxes() + pJ->getNumberOfButtons() + pJ->getNumberOfDirectionals() > 0 )
{
pThis->addJXInput( pJ );
}
else
{
delete pJ;
}
//
// only register useful devices
//
if( pJ->getNumberOfAxes() + pJ->getNumberOfButtons() + pJ->getNumberOfDirectionals() > 0 )
{
pThis->addJXInput( pJ );
}
else
{
delete pJ;
}
return DIENUM_CONTINUE;
}
@@ -167,8 +167,8 @@ BOOL CALLBACK JXInputManager::EnumJoysticksCallback( const DIDEVICEINSTANCE* pdi
*/
void JXInputManager::addJXInput( JXInput* pJ )
{
assert( mDeviceCounter < MAX_JXINPUTS );
assert( mDeviceCounter < MAX_JXINPUTS );
if( mDeviceCounter < MAX_JXINPUTS )
mDevices[ mDeviceCounter++ ] = pJ;
if( mDeviceCounter < MAX_JXINPUTS )
mDevices[ mDeviceCounter++ ] = pJ;
}

214
src/main/cpp/de_hardcode_jxinput_directinput_DirectInputDriver.cpp
View File

@@ -8,47 +8,47 @@
//
extern HINSTANCE g_hInst;
static JXInputManager* pJXInputManager = NULL;
static JXInput* apJXInput[ MAX_JXINPUTS ];
static HWND hWndJava;
static JXInputManager* pJXInputManager = NULL;
static JXInput* apJXInput[ MAX_JXINPUTS ];
static HWND hWndJava;
//
// IDs of the static Java arrays.
//
static jfieldID sAxesFieldID;
static jfieldID sButtonsFieldID;
static jfieldID sDirectionsFieldID;
static jfieldID sAxesFieldID;
static jfieldID sButtonsFieldID;
static jfieldID sDirectionsFieldID;
/**
* Remove all resources allocated by the Java binding.
*/
void shutdownJavaResources()
{
if ( NULL != pJXInputManager )
delete pJXInputManager;
if ( NULL != pJXInputManager )
delete pJXInputManager;
if ( NULL != hWndJava )
DestroyWindow( hWndJava );
if ( NULL != hWndJava )
DestroyWindow( hWndJava );
pJXInputManager = NULL;
pJXInputManager = NULL;
for( int i = 0; i < MAX_JXINPUTS; ++i )
apJXInput[ i ] = NULL;
for( int i = 0; i < MAX_JXINPUTS; ++i )
apJXInput[ i ] = NULL;
hWndJava = NULL;
hWndJava = NULL;
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
{
return JNI_VERSION_1_2;
return JNI_VERSION_1_2;
}
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved)
{
shutdownJavaResources();
shutdownJavaResources();
}
@@ -56,39 +56,39 @@ JNIEXPORT jboolean JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDrive
(JNIEnv * penv, jclass pClazz )
{
//
// Create a non-visible window as 'owner' of the DI device.
//
hWndJava = CreateWindowEx(
0/*WS_EX_APPWINDOW*/, // DWORD dwExStyle, // extended window style
"STATIC", // LPCTSTR lpClassName, // pointer to registered class name
NULL, // LPCTSTR lpWindowName, // pointer to window name
0/*WS_CAPTION*/, // DWORD dwStyle, // window style
0, // int x, // horizontal position of window
0, // int y, // vertical position of window
0, // int nWidth, // window width
0, // int nHeight, // window height
NULL, // HWND hWndParent, // handle to parent or owner window
NULL, // HMENU hMenu, // handle to menu, or child-window identifier
g_hInst, // HINSTANCE hInstance, // handle to application instance
NULL // LPVOID lpParam // pointer to window-creation data
);
if ( NULL == pJXInputManager )
{
pJXInputManager = new JXInputManager( hWndJava );
//
// Create a non-visible window as 'owner' of the DI device.
//
hWndJava = CreateWindowEx(
0/*WS_EX_APPWINDOW*/, // DWORD dwExStyle, // extended window style
"STATIC", // LPCTSTR lpClassName, // pointer to registered class name
NULL, // LPCTSTR lpWindowName, // pointer to window name
0/*WS_CAPTION*/, // DWORD dwStyle, // window style
0, // int x, // horizontal position of window
0, // int y, // vertical position of window
0, // int nWidth, // window width
0, // int nHeight, // window height
NULL, // HWND hWndParent, // handle to parent or owner window
NULL, // HMENU hMenu, // handle to menu, or child-window identifier
g_hInst, // HINSTANCE hInstance, // handle to application instance
NULL // LPVOID lpParam // pointer to window-creation data
);
if ( NULL == pJXInputManager )
{
pJXInputManager = new JXInputManager( hWndJava );
for( int i = 0; i < MAX_JXINPUTS; ++i )
apJXInput[ i ] = NULL;
for( int i = 0; i < MAX_JXINPUTS; ++i )
apJXInput[ i ] = NULL;
for ( int i = 0; i < pJXInputManager->getNumberOfJXInputs(); ++i )
{
apJXInput[ i ] = & pJXInputManager->getJXInput( i );
}
}
for ( int i = 0; i < pJXInputManager->getNumberOfJXInputs(); ++i )
{
apJXInput[ i ] = & pJXInputManager->getJXInput( i );
}
}
return true;
return true;
}
@@ -96,7 +96,7 @@ JNIEXPORT jboolean JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDrive
JNIEXPORT void JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_nativeexit
(JNIEnv *, jclass )
{
shutdownJavaResources();
shutdownJavaResources();
}
@@ -106,111 +106,111 @@ JNIEXPORT void JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_na
JNIEXPORT void JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_bind
(JNIEnv * penv, jclass pClazz)
{
//
// All fields are static.
//
sAxesFieldID = penv->GetStaticFieldID( pClazz, "sAxisValues", "[[D" );
sButtonsFieldID = penv->GetStaticFieldID( pClazz, "sButtonStates", "[[Z" );
sDirectionsFieldID = penv->GetStaticFieldID( pClazz, "sDirectionalValues", "[[I" );
//
// All fields are static.
//
sAxesFieldID = penv->GetStaticFieldID( pClazz, "sAxisValues", "[[D" );
sButtonsFieldID = penv->GetStaticFieldID( pClazz, "sButtonStates", "[[Z" );
sDirectionsFieldID = penv->GetStaticFieldID( pClazz, "sDirectionalValues", "[[I" );
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getNumberOfDevices
(JNIEnv *penv, jclass)
{
return pJXInputManager->getNumberOfJXInputs();
return pJXInputManager->getNumberOfJXInputs();
}
JNIEXPORT jstring JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getName
(JNIEnv *penv, jclass, jint dev)
{
return penv->NewStringUTF( apJXInput[ dev ]->getName() );
return penv->NewStringUTF( apJXInput[ dev ]->getName() );
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getNumberOfAxes
(JNIEnv *, jclass, jint dev)
{
return apJXInput[ dev ]->getNumberOfAxes();
return apJXInput[ dev ]->getNumberOfAxes();
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getNumberOfButtons
(JNIEnv *, jclass, jint dev)
{
return apJXInput[ dev ]->getNumberOfButtons();
return apJXInput[ dev ]->getNumberOfButtons();
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getNumberOfDirectionals
(JNIEnv *, jclass, jint dev)
{
return apJXInput[ dev ]->getNumberOfDirectionals();
return apJXInput[ dev ]->getNumberOfDirectionals();
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getMaxNumberOfAxes
(JNIEnv *, jclass)
{
return pJXInputManager->getMaxNumberOfAxes();
return pJXInputManager->getMaxNumberOfAxes();
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getMaxNumberOfButtons
(JNIEnv *, jclass)
{
return pJXInputManager->getMaxNumberOfButtons();
return pJXInputManager->getMaxNumberOfButtons();
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getMaxNumberOfDirectionals
(JNIEnv *, jclass)
{
return pJXInputManager->getMaxNumberOfDirectionals();
return pJXInputManager->getMaxNumberOfDirectionals();
}
JNIEXPORT jboolean JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_isAxisAvailable
(JNIEnv *, jclass, jint dev, jint idx )
{
return apJXInput[ dev ]->isAxisAvailable( idx );
return apJXInput[ dev ]->isAxisAvailable( idx );
}
JNIEXPORT jstring JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getAxisName
(JNIEnv *penv, jclass, jint dev, jint idx )
{
return penv->NewStringUTF( apJXInput[ dev ]->getAxisName( idx ) );
return penv->NewStringUTF( apJXInput[ dev ]->getAxisName( idx ) );
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getAxisType
(JNIEnv *, jclass, jint dev, jint idx )
{
return apJXInput[ dev ]->getAxisType( idx );
return apJXInput[ dev ]->getAxisType( idx );
}
JNIEXPORT jboolean JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_isButtonAvailable
(JNIEnv *, jclass, jint dev, jint idx )
{
return apJXInput[ dev ]->isButtonAvailable( idx );
return apJXInput[ dev ]->isButtonAvailable( idx );
}
JNIEXPORT jstring JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getButtonName
(JNIEnv *penv, jclass, jint dev, jint idx )
{
return penv->NewStringUTF( apJXInput[ dev ]->getButtonName( idx ) );
return penv->NewStringUTF( apJXInput[ dev ]->getButtonName( idx ) );
}
JNIEXPORT jint JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getButtonType
(JNIEnv *, jclass, jint dev, jint idx )
{
return apJXInput[ dev ]->getButtonType( idx );
return apJXInput[ dev ]->getButtonType( idx );
}
JNIEXPORT jboolean JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_isDirectionalAvailable
(JNIEnv *, jclass, jint dev, jint idx )
{
return apJXInput[ dev ]->isDirectionalAvailable( idx );
return apJXInput[ dev ]->isDirectionalAvailable( idx );
}
JNIEXPORT jstring JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_getDirectionalName
(JNIEnv *penv, jclass, jint dev, jint idx )
{
return penv->NewStringUTF( apJXInput[ dev ]->getDirectionalName( idx ) );
return penv->NewStringUTF( apJXInput[ dev ]->getDirectionalName( idx ) );
}
@@ -223,53 +223,53 @@ JNIEXPORT void JNICALL Java_de_hardcode_jxinput_directinput_DirectInputDriver_na
(JNIEnv * penv, jclass pClazz )
{
static jdouble axes [ MAX_JXINPUTS ][ JXINPUT_MAX_AXES ];
static jboolean buttons [ MAX_JXINPUTS ][ JXINPUT_MAX_BUTTONS ];
static jint directions [ MAX_JXINPUTS ][ JXINPUT_MAX_DIRECTIONALS ];
static jdouble axes [ MAX_JXINPUTS ][ JXINPUT_MAX_AXES ];
static jboolean buttons [ MAX_JXINPUTS ][ JXINPUT_MAX_BUTTONS ];
static jint directions [ MAX_JXINPUTS ][ JXINPUT_MAX_DIRECTIONALS ];
static jobjectArray axisarrayarray;
static jobjectArray buttonarrayarray;
static jobjectArray directionarrayarray;
static jobjectArray axisarrayarray;
static jobjectArray buttonarrayarray;
static jobjectArray directionarrayarray;
static jdoubleArray axisarray;
static jbooleanArray buttonarray;
static jintArray directionarray;
static jdoubleArray axisarray;
static jbooleanArray buttonarray;
static jintArray directionarray;
axisarrayarray = (jobjectArray)penv->GetStaticObjectField( pClazz, sAxesFieldID );
buttonarrayarray = (jobjectArray)penv->GetStaticObjectField( pClazz, sButtonsFieldID );
directionarrayarray = (jobjectArray)penv->GetStaticObjectField( pClazz, sDirectionsFieldID );
axisarrayarray = (jobjectArray)penv->GetStaticObjectField( pClazz, sAxesFieldID );
buttonarrayarray = (jobjectArray)penv->GetStaticObjectField( pClazz, sButtonsFieldID );
directionarrayarray = (jobjectArray)penv->GetStaticObjectField( pClazz, sDirectionsFieldID );
//
// For each device....
//
for ( int dev = 0; dev < pJXInputManager->getNumberOfJXInputs(); ++dev )
{
// Do the update of the device.
apJXInput[ dev ]->update();
//
// For each device....
//
for ( int dev = 0; dev < pJXInputManager->getNumberOfJXInputs(); ++dev )
{
// Do the update of the device.
apJXInput[ dev ]->update();
//
// Copy all values into my arrays.
//
for ( int i = 0; i < JXINPUT_MAX_AXES; ++i )
axes[ dev ][ i ] = apJXInput[ dev ]->getAxisValue( i );
for ( int i = 0; i < JXINPUT_MAX_BUTTONS; ++i )
buttons[ dev ][ i ] = apJXInput[ dev ]->isButtonDown( i );
for ( int i = 0; i < JXINPUT_MAX_DIRECTIONALS; ++i )
directions[ dev ][ i ] = apJXInput[ dev ]->getDirection( i );
//
// Copy all values into my arrays.
//
for ( int i = 0; i < JXINPUT_MAX_AXES; ++i )
axes[ dev ][ i ] = apJXInput[ dev ]->getAxisValue( i );
for ( int i = 0; i < JXINPUT_MAX_BUTTONS; ++i )
buttons[ dev ][ i ] = apJXInput[ dev ]->isButtonDown( i );
for ( int i = 0; i < JXINPUT_MAX_DIRECTIONALS; ++i )
directions[ dev ][ i ] = apJXInput[ dev ]->getDirection( i );
//
// Move my arrays to the Java arrays.
//
axisarray = (jdoubleArray)penv->GetObjectArrayElement( axisarrayarray, dev );
penv->SetDoubleArrayRegion( axisarray, 0, JXINPUT_MAX_AXES, axes[ dev ] );
//
// Move my arrays to the Java arrays.
//
axisarray = (jdoubleArray)penv->GetObjectArrayElement( axisarrayarray, dev );
penv->SetDoubleArrayRegion( axisarray, 0, JXINPUT_MAX_AXES, axes[ dev ] );
buttonarray = (jbooleanArray)penv->GetObjectArrayElement( buttonarrayarray, dev );
penv->SetBooleanArrayRegion( buttonarray, 0, JXINPUT_MAX_BUTTONS, buttons[ dev ] );
buttonarray = (jbooleanArray)penv->GetObjectArrayElement( buttonarrayarray, dev );
penv->SetBooleanArrayRegion( buttonarray, 0, JXINPUT_MAX_BUTTONS, buttons[ dev ] );
directionarray = (jintArray)penv->GetObjectArrayElement( directionarrayarray, dev );
penv->SetIntArrayRegion( directionarray, 0, JXINPUT_MAX_DIRECTIONALS, directions[ dev ] );
}
directionarray = (jintArray)penv->GetObjectArrayElement( directionarrayarray, dev );
penv->SetIntArrayRegion( directionarray, 0, JXINPUT_MAX_DIRECTIONALS, directions[ dev ] );
}
}

404
src/main/cpp/jxinput.cpp
View File

@@ -11,19 +11,19 @@ extern HINSTANCE g_hInst;
* Ctor: Connect with DI
*/
JXInput::JXInput( LPDIRECTINPUTDEVICE8 pJoystick, HWND hWnd ) :
mpJoystick( pJoystick ),
mSliderCount( 0 ),
mPOVCount( 0 ),
mButtonCount( 0 )
mpJoystick( pJoystick ),
mSliderCount( 0 ),
mPOVCount( 0 ),
mButtonCount( 0 )
{
initAxisConfig();
initButtonsConfig();
initDirectionalsConfig();
initAxisConfig();
initButtonsConfig();
initDirectionalsConfig();
if ( FAILED( InitDirectInput( hWnd ) ) )
{
FreeDirectInput();
}
if ( FAILED( InitDirectInput( hWnd ) ) )
{
FreeDirectInput();
}
}
@@ -34,113 +34,113 @@ JXInput::JXInput( LPDIRECTINPUTDEVICE8 pJoystick, HWND hWnd ) :
*/
JXInput::~JXInput()
{
FreeDirectInput();
FreeDirectInput();
}
void JXInput::update()
{
UpdateInputState();
UpdateInputState();
}
TCHAR * const JXInput::getName() const
{
return (TCHAR*)mdiDevInfo.tszInstanceName;
return (TCHAR*)mdiDevInfo.tszInstanceName;
}
int JXInput::getNumberOfAxes() const
{
return mdiDevCaps.dwAxes;
return mdiDevCaps.dwAxes;
}
int JXInput::getNumberOfButtons() const
{
return mButtonCount;
return mButtonCount;
}
int JXInput::getNumberOfDirectionals() const
{
return mPOVCount;
return mPOVCount;
}
double JXInput::getAxisValueHelper( LONG val, int idx ) const
{
const AxisConfig& cfg = mAxisConfig[ idx ];
const AxisConfig& cfg = mAxisConfig[ idx ];
double span = (double)( cfg.mMaxValue - cfg.mMinValue );
double ret = (double)(val - cfg.mMinValue) / span;
if ( TYPE_SLIDER != cfg.mType )
return ret*2.0 - 1.0;
return ret;
double span = (double)( cfg.mMaxValue - cfg.mMinValue );
double ret = (double)(val - cfg.mMinValue) / span;
if ( TYPE_SLIDER != cfg.mType )
return ret*2.0 - 1.0;
return ret;
}
double JXInput::getX() const
{
return getAxisValueHelper( mJS.lX, ID_X );
return getAxisValueHelper( mJS.lX, ID_X );
}
double JXInput::getY() const
{
return getAxisValueHelper( mJS.lY, ID_Y );
return getAxisValueHelper( mJS.lY, ID_Y );
}
double JXInput::getZ() const
{
return getAxisValueHelper( mJS.lZ, ID_Z );
return getAxisValueHelper( mJS.lZ, ID_Z );
}
double JXInput::getRotX() const
{
return getAxisValueHelper( mJS.lRx, ID_ROTX );
return getAxisValueHelper( mJS.lRx, ID_ROTX );
}
double JXInput::getRotY() const
{
return getAxisValueHelper( mJS.lRy, ID_ROTY );
return getAxisValueHelper( mJS.lRy, ID_ROTY );
}
double JXInput::getRotZ() const
{
return getAxisValueHelper( mJS.lRz, ID_ROTZ );
return getAxisValueHelper( mJS.lRz, ID_ROTZ );
}
double JXInput::getSlider0() const
{
return getAxisValueHelper( mJS.rglSlider[ 0 ], ID_SLIDER0 );
return getAxisValueHelper( mJS.rglSlider[ 0 ], ID_SLIDER0 );
}
double JXInput::getSlider1() const
{
return getAxisValueHelper( mJS.rglSlider[ 1 ], ID_SLIDER1 );
return getAxisValueHelper( mJS.rglSlider[ 1 ], ID_SLIDER1 );
}
bool JXInput::isAxisAvailable( int idx ) const
{
assert( idx < JXINPUT_MAX_AXES );
return mAxisConfig[ idx ].mIsAvailable;
assert( idx < JXINPUT_MAX_AXES );
return mAxisConfig[ idx ].mIsAvailable;
}
TCHAR * const JXInput::getAxisName( int idx ) const
{
assert( idx < JXINPUT_MAX_AXES );
return (char*const)mAxisConfig[ idx ].mName;
assert( idx < JXINPUT_MAX_AXES );
return (char*const)mAxisConfig[ idx ].mName;
}
int JXInput::getAxisType( int idx ) const
{
assert( idx < JXINPUT_MAX_AXES );
return mAxisConfig[ idx ].mType;
assert( idx < JXINPUT_MAX_AXES );
return mAxisConfig[ idx ].mType;
}
double JXInput::getAxisValue( int idx ) const
{
assert( idx < JXINPUT_MAX_AXES );
assert( idx < JXINPUT_MAX_AXES );
// Failsafe if called accidentally
if ( ! mAxisConfig[ idx ].mIsAvailable )
return 0.0;
// Failsafe if called accidentally
if ( ! mAxisConfig[ idx ].mIsAvailable )
return 0.0;
return (this->*mAxisConfig[ idx ].mGetValueMethod)();
return (this->*mAxisConfig[ idx ].mGetValueMethod)();
}
@@ -149,45 +149,45 @@ double JXInput::getAxisValue( int idx ) const
bool JXInput::isButtonAvailable( int idx ) const
{
assert( idx < JXINPUT_MAX_BUTTONS );
return mButtonConfig[ idx ].mIsAvailable;
assert( idx < JXINPUT_MAX_BUTTONS );
return mButtonConfig[ idx ].mIsAvailable;
}
TCHAR * const JXInput::getButtonName( int idx ) const
{
assert( idx < JXINPUT_MAX_BUTTONS );
return (char*const)mButtonConfig[ idx ].mName;
assert( idx < JXINPUT_MAX_BUTTONS );
return (char*const)mButtonConfig[ idx ].mName;
}
int JXInput::getButtonType( int idx ) const
{
assert( idx < JXINPUT_MAX_BUTTONS );
return mButtonConfig[ idx ].mType;
assert( idx < JXINPUT_MAX_BUTTONS );
return mButtonConfig[ idx ].mType;
}
bool JXInput::isButtonDown( int idx ) const
{
assert( idx < JXINPUT_MAX_BUTTONS );
return 0 != mJS.rgbButtons[ idx ] ;
assert( idx < JXINPUT_MAX_BUTTONS );
return 0 != mJS.rgbButtons[ idx ] ;
}
bool JXInput::isDirectionalAvailable( int idx ) const
{
assert( idx < JXINPUT_MAX_DIRECTIONALS );
return mDirectionalConfig[ idx ].mIsAvailable;
assert( idx < JXINPUT_MAX_DIRECTIONALS );
return mDirectionalConfig[ idx ].mIsAvailable;
}
TCHAR * const JXInput::getDirectionalName( int idx ) const
{
assert( idx < JXINPUT_MAX_DIRECTIONALS );
return (char*const)mDirectionalConfig[ idx ].mName;
assert( idx < JXINPUT_MAX_DIRECTIONALS );
return (char*const)mDirectionalConfig[ idx ].mName;
}
int JXInput::getDirection( int idx ) const
{
assert( idx < JXINPUT_MAX_DIRECTIONALS );
return mJS.rgdwPOV[ idx ] ;
assert( idx < JXINPUT_MAX_DIRECTIONALS );
return mJS.rgdwPOV[ idx ] ;
}
@@ -196,37 +196,37 @@ int JXInput::getDirection( int idx ) const
*/
void JXInput::initAxisConfig()
{
mAxisConfig[ ID_X ].mIsAvailable = false;
mAxisConfig[ ID_X ].mType = TYPE_TRANSLATION;
mAxisConfig[ ID_X ].mGetValueMethod = &JXInput::getX;
mAxisConfig[ ID_X ].mIsAvailable = false;
mAxisConfig[ ID_X ].mType = TYPE_TRANSLATION;
mAxisConfig[ ID_X ].mGetValueMethod = &JXInput::getX;
mAxisConfig[ ID_Y ].mIsAvailable = false;
mAxisConfig[ ID_Y ].mType = TYPE_TRANSLATION;
mAxisConfig[ ID_Y ].mGetValueMethod = &JXInput::getY;
mAxisConfig[ ID_Y ].mIsAvailable = false;
mAxisConfig[ ID_Y ].mType = TYPE_TRANSLATION;
mAxisConfig[ ID_Y ].mGetValueMethod = &JXInput::getY;
mAxisConfig[ ID_Z ].mIsAvailable = false;
mAxisConfig[ ID_Z ].mType = TYPE_TRANSLATION;
mAxisConfig[ ID_Z ].mGetValueMethod = &JXInput::getZ;
mAxisConfig[ ID_Z ].mIsAvailable = false;
mAxisConfig[ ID_Z ].mType = TYPE_TRANSLATION;
mAxisConfig[ ID_Z ].mGetValueMethod = &JXInput::getZ;
mAxisConfig[ ID_ROTX ].mIsAvailable = false;
mAxisConfig[ ID_ROTX ].mType = TYPE_ROTATION;
mAxisConfig[ ID_ROTX ].mGetValueMethod = &JXInput::getRotX;
mAxisConfig[ ID_ROTX ].mIsAvailable = false;
mAxisConfig[ ID_ROTX ].mType = TYPE_ROTATION;
mAxisConfig[ ID_ROTX ].mGetValueMethod = &JXInput::getRotX;
mAxisConfig[ ID_ROTY ].mIsAvailable = false;
mAxisConfig[ ID_ROTY ].mType = TYPE_ROTATION;
mAxisConfig[ ID_ROTY ].mGetValueMethod = &JXInput::getRotY;
mAxisConfig[ ID_ROTY ].mIsAvailable = false;
mAxisConfig[ ID_ROTY ].mType = TYPE_ROTATION;
mAxisConfig[ ID_ROTY ].mGetValueMethod = &JXInput::getRotY;
mAxisConfig[ ID_ROTZ ].mIsAvailable = false;
mAxisConfig[ ID_ROTZ ].mType = TYPE_ROTATION;
mAxisConfig[ ID_ROTZ ].mGetValueMethod = &JXInput::getRotZ;
mAxisConfig[ ID_SLIDER0 ].mIsAvailable = false;
mAxisConfig[ ID_SLIDER0 ].mType = TYPE_SLIDER;
mAxisConfig[ ID_SLIDER0 ].mGetValueMethod = &JXInput::getSlider0;
mAxisConfig[ ID_ROTZ ].mIsAvailable = false;
mAxisConfig[ ID_ROTZ ].mType = TYPE_ROTATION;
mAxisConfig[ ID_ROTZ ].mGetValueMethod = &JXInput::getRotZ;
mAxisConfig[ ID_SLIDER0 ].mIsAvailable = false;
mAxisConfig[ ID_SLIDER0 ].mType = TYPE_SLIDER;
mAxisConfig[ ID_SLIDER0 ].mGetValueMethod = &JXInput::getSlider0;
mAxisConfig[ ID_SLIDER1 ].mIsAvailable = false;
mAxisConfig[ ID_SLIDER1 ].mType = TYPE_SLIDER;
mAxisConfig[ ID_SLIDER1 ].mGetValueMethod = &JXInput::getSlider1;
mAxisConfig[ ID_SLIDER1 ].mIsAvailable = false;
mAxisConfig[ ID_SLIDER1 ].mType = TYPE_SLIDER;
mAxisConfig[ ID_SLIDER1 ].mGetValueMethod = &JXInput::getSlider1;
}
@@ -235,12 +235,12 @@ void JXInput::initAxisConfig()
*/
void JXInput::initButtonsConfig()
{
for ( int i = 0; i < JXINPUT_MAX_BUTTONS; ++i )
{
mButtonConfig[ i ].mIsAvailable = false;
mButtonConfig[ i ].mName[ 0 ] = '\0';
mButtonConfig[ i ].mType = TYPE_PUSHBUTTON;
}
for ( int i = 0; i < JXINPUT_MAX_BUTTONS; ++i )
{
mButtonConfig[ i ].mIsAvailable = false;
mButtonConfig[ i ].mName[ 0 ] = '\0';
mButtonConfig[ i ].mType = TYPE_PUSHBUTTON;
}
}
@@ -250,11 +250,11 @@ void JXInput::initButtonsConfig()
*/
void JXInput::initDirectionalsConfig()
{
for ( int i = 0; i < JXINPUT_MAX_DIRECTIONALS; ++i )
{
mDirectionalConfig[ i ].mIsAvailable = false;
mDirectionalConfig[ i ].mName[ 0 ] = '\0';
}
for ( int i = 0; i < JXINPUT_MAX_DIRECTIONALS; ++i )
{
mDirectionalConfig[ i ].mIsAvailable = false;
mDirectionalConfig[ i ].mName[ 0 ] = '\0';
}
}
@@ -267,46 +267,46 @@ void JXInput::initDirectionalsConfig()
BOOL CALLBACK JXInput::EnumAxesCallback( const DIDEVICEOBJECTINSTANCE* pdidoi,
VOID* pContext )
{
JXInput* pThis = (JXInput*)pContext;
JXInput* pThis = (JXInput*)pContext;
AxisConfig* pAxCfg = NULL;
AxisConfig* pAxCfg = NULL;
// Set the UI to reflect what objects the joystick supports
// Code derived from M$ samples, really sucks, eh?
// Code derived from M$ samples, really sucks, eh?
if (pdidoi->guidType == GUID_XAxis)
{
pAxCfg = & pThis->mAxisConfig[ ID_X ];
pAxCfg = & pThis->mAxisConfig[ ID_X ];
}
if (pdidoi->guidType == GUID_YAxis)
{
pAxCfg = & pThis->mAxisConfig[ ID_Y ];
pAxCfg = & pThis->mAxisConfig[ ID_Y ];
}
if (pdidoi->guidType == GUID_ZAxis)
{
pAxCfg = & pThis->mAxisConfig[ ID_Z ];
pAxCfg = & pThis->mAxisConfig[ ID_Z ];
}
if (pdidoi->guidType == GUID_RxAxis)
{
pAxCfg = & pThis->mAxisConfig[ ID_ROTX ];
pAxCfg = & pThis->mAxisConfig[ ID_ROTX ];
}
if (pdidoi->guidType == GUID_RyAxis)
{
pAxCfg = & pThis->mAxisConfig[ ID_ROTY ];
pAxCfg = & pThis->mAxisConfig[ ID_ROTY ];
}
if (pdidoi->guidType == GUID_RzAxis)
{
pAxCfg = & pThis->mAxisConfig[ ID_ROTZ ];
}
pAxCfg = & pThis->mAxisConfig[ ID_ROTZ ];
}
if (pdidoi->guidType == GUID_Slider)
{
switch( pThis->mSliderCount++ )
{
case 0 :
pAxCfg = & pThis->mAxisConfig[ ID_SLIDER0 ];
pAxCfg = & pThis->mAxisConfig[ ID_SLIDER0 ];
break;
case 1 :
pAxCfg = & pThis->mAxisConfig[ ID_SLIDER1 ];
pAxCfg = & pThis->mAxisConfig[ ID_SLIDER1 ];
break;
}
}
@@ -316,25 +316,25 @@ BOOL CALLBACK JXInput::EnumAxesCallback( const DIDEVICEOBJECTINSTANCE* pdidoi,
return DIENUM_CONTINUE;
//
// Perform config.
//
//
// Perform config.
//
DIPROPRANGE diprg;
diprg.diph.dwSize = sizeof(DIPROPRANGE);
diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
diprg.diph.dwHow = DIPH_BYID;
diprg.diph.dwHow = DIPH_BYID;
diprg.diph.dwObj = pdidoi->dwType; // Specify the enumerated axis
// Get the range for the axis
if( FAILED( pThis->mpJoystick->GetProperty( DIPROP_RANGE, &diprg.diph ) ) )
return DIENUM_CONTINUE;
pAxCfg->mMinValue = diprg.lMin;
pAxCfg->mMaxValue = diprg.lMax;
pAxCfg->mMinValue = diprg.lMin;
pAxCfg->mMaxValue = diprg.lMax;
strcpy( (char*)pAxCfg->mName, (char*)pdidoi->tszName );
pAxCfg->mIsAvailable = true;
strcpy( (char*)pAxCfg->mName, (char*)pdidoi->tszName );
pAxCfg->mIsAvailable = true;
return DIENUM_CONTINUE;
}
@@ -348,39 +348,39 @@ BOOL CALLBACK JXInput::EnumAxesCallback( const DIDEVICEOBJECTINSTANCE* pdidoi,
BOOL CALLBACK JXInput::EnumButtonsCallback( const DIDEVICEOBJECTINSTANCE* pdidoi,
VOID* pContext )
{
JXInput* pThis = (JXInput*)pContext;
JXInput* pThis = (JXInput*)pContext;
//
// if the maximum number of buttons is already registered,
// issue a warning and stop enumeration.
//
if( JXINPUT_MAX_BUTTONS == pThis->mButtonCount )
{
OutputDebugString( "Max. number of buttons exceeded!" );
return DIENUM_STOP;
}
//
// if the maximum number of buttons is already registered,
// issue a warning and stop enumeration.
//
if( JXINPUT_MAX_BUTTONS == pThis->mButtonCount )
{
OutputDebugString( "Max. number of buttons exceeded!" );
return DIENUM_STOP;
}
ButtonConfig* pBtCfg = NULL;
ButtonConfig* pBtCfg = NULL;
if ( pdidoi->guidType == GUID_Button )
{
assert( JXINPUT_MAX_BUTTONS > pThis->mButtonCount );
pBtCfg = & pThis->mButtonConfig[ pThis->mButtonCount++ ];
}
assert( JXINPUT_MAX_BUTTONS > pThis->mButtonCount );
pBtCfg = & pThis->mButtonConfig[ pThis->mButtonCount++ ];
}
// fail-safe
if( NULL == pBtCfg ) // e.g. unknown stuff
return DIENUM_CONTINUE;
assert( NULL != pBtCfg );
assert( NULL != pBtCfg );
//
// Perform config.
//
//
// Perform config.
//
strcpy( (char*)pBtCfg->mName, (char*)pdidoi->tszName );
pBtCfg->mIsAvailable = true;
strcpy( (char*)pBtCfg->mName, (char*)pdidoi->tszName );
pBtCfg->mIsAvailable = true;
return DIENUM_CONTINUE;
}
@@ -393,38 +393,38 @@ BOOL CALLBACK JXInput::EnumButtonsCallback( const DIDEVICEOBJECTINSTANCE* pdidoi
BOOL CALLBACK JXInput::EnumPOVsCallback( const DIDEVICEOBJECTINSTANCE* pdidoi,
VOID* pContext )
{
JXInput* pThis = (JXInput*)pContext;
JXInput* pThis = (JXInput*)pContext;
//
// if the maximum number of buttons is already registered,
// issue a warning and stop enumeration.
//
if( JXINPUT_MAX_DIRECTIONALS == pThis->mPOVCount )
{
OutputDebugString( "Max. number of POVs exceeded!" );
return DIENUM_STOP;
}
//
// if the maximum number of buttons is already registered,
// issue a warning and stop enumeration.
//
if( JXINPUT_MAX_DIRECTIONALS == pThis->mPOVCount )
{
OutputDebugString( "Max. number of POVs exceeded!" );
return DIENUM_STOP;
}
DirectionalConfig* pDirCfg = NULL;
DirectionalConfig* pDirCfg = NULL;
if (pdidoi->guidType == GUID_POV)
{
assert( JXINPUT_MAX_DIRECTIONALS > pThis->mPOVCount );
pDirCfg = & pThis->mDirectionalConfig[ pThis->mPOVCount++ ];
assert( JXINPUT_MAX_DIRECTIONALS > pThis->mPOVCount );
pDirCfg = & pThis->mDirectionalConfig[ pThis->mPOVCount++ ];
}
// fail-safe
if( NULL == pDirCfg ) // e.g. unknown stuff
return DIENUM_CONTINUE;
assert( NULL != pDirCfg );
assert( NULL != pDirCfg );
//
// Perform config.
//
//
// Perform config.
//
strcpy( (char*)pDirCfg->mName, (char*)pdidoi->tszName );
pDirCfg->mIsAvailable = true;
strcpy( (char*)pDirCfg->mName, (char*)pdidoi->tszName );
pDirCfg->mIsAvailable = true;
return DIENUM_CONTINUE;
}
@@ -436,13 +436,13 @@ BOOL CALLBACK JXInput::EnumPOVsCallback( const DIDEVICEOBJECTINSTANCE* pdidoi,
// Desc: Callback function for enumerating the effects of a joystick
//-----------------------------------------------------------------------------
BOOL CALLBACK JXInput::EnumEffectsCallback( const DIEFFECTINFO* pdidoi,
VOID* pContext )
VOID* pContext )
{
//JXInput* pThis = (JXInput*)pContext;
//JXInput* pThis = (JXInput*)pContext;
//
// Work on that!!
//
//
// Work on that!!
//
return DIENUM_CONTINUE;
}
@@ -463,12 +463,12 @@ HRESULT JXInput::InitDirectInput( HWND hWnd )
return E_FAIL;
}
//
// Ask the device for some useful information.
//
mdiDevInfo.dwSize = sizeof( DIDEVICEINSTANCE );
hr = mpJoystick->GetDeviceInfo( &mdiDevInfo );
//
// Ask the device for some useful information.
//
mdiDevInfo.dwSize = sizeof( DIDEVICEINSTANCE );
hr = mpJoystick->GetDeviceInfo( &mdiDevInfo );
if( FAILED(hr) )
return hr;
@@ -484,10 +484,10 @@ HRESULT JXInput::InitDirectInput( HWND hWnd )
// Set the cooperative level to let DInput know how this device should
// interact with the system and with other DInput applications.
// hr = g_pJoystick->SetCooperativeLevel( hDlg, DISCL_EXCLUSIVE|DISCL_FOREGROUND );
DWORD mode = ( NULL == hWnd ? DISCL_NONEXCLUSIVE|DISCL_BACKGROUND : DISCL_EXCLUSIVE|DISCL_BACKGROUND );
hr = mpJoystick->SetCooperativeLevel( hWnd, mode );
if( FAILED(hr) )
return hr;
DWORD mode = ( NULL == hWnd ? DISCL_NONEXCLUSIVE|DISCL_BACKGROUND : DISCL_EXCLUSIVE|DISCL_BACKGROUND );
hr = mpJoystick->SetCooperativeLevel( hWnd, mode );
if( FAILED(hr) )
return hr;
// Determine how many axis the joystick has (so we don't error out setting
// properties for unavailable axis)
@@ -500,14 +500,14 @@ HRESULT JXInput::InitDirectInput( HWND hWnd )
// Enumerate the axes of the joyctick and set the range of each axis. Note:
// we could just use the defaults, but we're just trying to show an example
// of enumerating device objects (axes, buttons, etc.).
mpJoystick->EnumObjects( EnumAxesCallback, (VOID*)this, DIDFT_AXIS );
mpJoystick->EnumObjects( EnumButtonsCallback, (VOID*)this, DIDFT_BUTTON );
mpJoystick->EnumObjects( EnumPOVsCallback, (VOID*)this, DIDFT_POV );
mpJoystick->EnumObjects( EnumAxesCallback, (VOID*)this, DIDFT_AXIS );
mpJoystick->EnumObjects( EnumButtonsCallback, (VOID*)this, DIDFT_BUTTON );
mpJoystick->EnumObjects( EnumPOVsCallback, (VOID*)this, DIDFT_POV );
mpJoystick->EnumEffects( EnumEffectsCallback, (VOID*)this, DIEFT_ALL );
mpJoystick->EnumEffects( EnumEffectsCallback, (VOID*)this, DIEFT_ALL );
// For FF sticks, switch on autocenter as long as we do not use real FF
SwitchAutoCenter( true );
// For FF sticks, switch on autocenter as long as we do not use real FF
SwitchAutoCenter( true );
return S_OK;
}
@@ -527,27 +527,27 @@ HRESULT JXInput::UpdateInputState()
if( mpJoystick )
{
// Poll the device to read the current state
hr = mpJoystick->Poll();
if( FAILED(hr) )
{
// DInput is telling us that the input stream has been
// interrupted. We aren't tracking any state between polls, so
// we don't have any special reset that needs to be done. We
// just re-acquire and try again.
hr = mpJoystick->Acquire();
while( hr == DIERR_INPUTLOST )
hr = mpJoystick->Acquire();
// Poll the device to read the current state
hr = mpJoystick->Poll();
if( FAILED(hr) )
{
// DInput is telling us that the input stream has been
// interrupted. We aren't tracking any state between polls, so
// we don't have any special reset that needs to be done. We
// just re-acquire and try again.
hr = mpJoystick->Acquire();
while( hr == DIERR_INPUTLOST )
hr = mpJoystick->Acquire();
// hr may be DIERR_OTHERAPPHASPRIO or other errors. This
// may occur when the app is minimized or in the process of
// switching, so just try again later
return S_OK;
}
// hr may be DIERR_OTHERAPPHASPRIO or other errors. This
// may occur when the app is minimized or in the process of
// switching, so just try again later
return S_OK;
}
// Get the input's device state
if( FAILED( hr = mpJoystick->GetDeviceState( sizeof(DIJOYSTATE2), &mJS ) ) )
return hr; // The device should have been acquired during the Poll()
// Get the input's device state
if( FAILED( hr = mpJoystick->GetDeviceState( sizeof(DIJOYSTATE2), &mJS ) ) )
return hr; // The device should have been acquired during the Poll()
}
@@ -570,8 +570,8 @@ HRESULT JXInput::FreeDirectInput()
// the app tried to exit while the device is still acquired.
mpJoystick->Unacquire();
mpJoystick->Release();
mpJoystick = NULL;
mpJoystick->Release();
mpJoystick = NULL;
}
return S_OK;
@@ -583,14 +583,14 @@ HRESULT JXInput::SwitchAutoCenter( bool onoff )
{
HRESULT hr;
DIPROPDWORD DIPropAutoCenter;
DIPROPDWORD DIPropAutoCenter;
DIPropAutoCenter.diph.dwSize = sizeof(DIPropAutoCenter);
DIPropAutoCenter.diph.dwHeaderSize = sizeof(DIPROPHEADER);
DIPropAutoCenter.diph.dwObj = 0;
DIPropAutoCenter.diph.dwHow = DIPH_DEVICE;
DIPropAutoCenter.dwData = ( onoff ? DIPROPAUTOCENTER_ON : DIPROPAUTOCENTER_OFF );
DIPropAutoCenter.diph.dwSize = sizeof(DIPropAutoCenter);
DIPropAutoCenter.diph.dwHeaderSize = sizeof(DIPROPHEADER);
DIPropAutoCenter.diph.dwObj = 0;
DIPropAutoCenter.diph.dwHow = DIPH_DEVICE;
DIPropAutoCenter.dwData = ( onoff ? DIPROPAUTOCENTER_ON : DIPROPAUTOCENTER_OFF );
hr = mpJoystick->SetProperty( DIPROP_AUTOCENTER, &DIPropAutoCenter.diph );
return hr;
hr = mpJoystick->SetProperty( DIPROP_AUTOCENTER, &DIPropAutoCenter.diph );
return hr;
}

22
src/main/cpp/main.cpp
View File

@@ -6,19 +6,19 @@ HINSTANCE g_hInst;
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
g_hInst = (HINSTANCE)hModule;
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
g_hInst = NULL;
break;
{
case DLL_PROCESS_ATTACH:
g_hInst = (HINSTANCE)hModule;
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
g_hInst = NULL;
break;
}
return TRUE;
}

36
src/main/headers/JXInputManager.h
View File

@@ -5,29 +5,29 @@ class JXInput;
class JXINPUT_API JXInputManager
{
public:
JXInputManager( HWND hWnd );
virtual ~JXInputManager();
JXInputManager( HWND hWnd );
virtual ~JXInputManager();
int getNumberOfJXInputs() const;
JXInput& getJXInput( int idx ) const;
int getNumberOfJXInputs() const;
JXInput& getJXInput( int idx ) const;
//
// Numbering methods
//
int getMaxNumberOfAxes() const;
int getMaxNumberOfButtons() const;
int getMaxNumberOfDirectionals() const;
//
// Numbering methods
//
int getMaxNumberOfAxes() const;
int getMaxNumberOfButtons() const;
int getMaxNumberOfDirectionals() const;
private:
LPDIRECTINPUT8 mpDI;
HWND mhWnd;
JXInput* mDevices[ MAX_JXINPUTS ];
int mDeviceCounter;
LPDIRECTINPUT8 mpDI;
HWND mhWnd;
JXInput* mDevices[ MAX_JXINPUTS ];
int mDeviceCounter;
HRESULT InitDirectInput( HWND hWnd = NULL );
HRESULT FreeDirectInput();
HRESULT InitDirectInput( HWND hWnd = NULL );
HRESULT FreeDirectInput();
static BOOL CALLBACK EnumJoysticksCallback( const DIDEVICEINSTANCE* pdidInstance,
static BOOL CALLBACK EnumJoysticksCallback( const DIDEVICEINSTANCE* pdidInstance,
VOID* pContext );
void addJXInput( JXInput* pJ );
void addJXInput( JXInput* pJ );
};

92
src/main/java/de/hardcode/jxinput/Axis.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 19. Dezember 2001, 21:58
// Created on 19. Dezember 2001, 21:58
//**********************************************************************************************
package de.hardcode.jxinput;
@@ -15,49 +15,49 @@ package de.hardcode.jxinput;
*/
public interface Axis extends Feature
{
// Enumeration of axes.
final static int ID_X = 0;
final static int ID_Y = 1;
final static int ID_Z = 2;
final static int ID_ROTX = 3;
final static int ID_ROTY = 4;
final static int ID_ROTZ = 5;
final static int ID_SLIDER0 = 6;
final static int ID_SLIDER1 = 7;
final static int NUMBER_OF_ID = 8;
// Enumeration of axis types
final static int TRANSLATION = 0;
final static int ROTATION = 1;
final static int SLIDER = 2;
// Enumeration of axes.
final static int ID_X = 0;
final static int ID_Y = 1;
final static int ID_Z = 2;
final static int ID_ROTX = 3;
final static int ID_ROTY = 4;
final static int ID_ROTZ = 5;
final static int ID_SLIDER0 = 6;
final static int ID_SLIDER1 = 7;
final static int NUMBER_OF_ID = 8;
// Enumeration of axis types
final static int TRANSLATION = 0;
final static int ROTATION = 1;
final static int SLIDER = 2;
/**
* Retrieve the type of the axis.
* The type is describes the meaning and the range of values of the axis.
* <p>
* <code>TRANSLATION</code> typed axes denote a translational deviation from a center
* position. This can be e.g. the common, basic joystick axes.
* The range of <code>getValue()</code> is <code>[-1.0,1.0]</code>.
* <p>
* <code>ROTATION</code> typed axes denote a rotational deviation from a center
* position. Something on the stick is turned or twisted.
* The range of <code>getValue()</code> is <code>[-1.0,1.0]</code>.
* <p>
* <code>SLIDER</code> typed axes denote a shifting device without a center position.
* A good sample is a throttle control.
* The range of <code>getValue()</code> is <code>[0.0,1.0]</code>.
*
* @return [ TRANSLATION | ROTATION | SLIDER ]
*/
int getType();
/**
* Retrieve the type of the axis.
* The type is describes the meaning and the range of values of the axis.
* <p>
* <code>TRANSLATION</code> typed axes denote a translational deviation from a center
* position. This can be e.g. the common, basic joystick axes.
* The range of <code>getValue()</code> is <code>[-1.0,1.0]</code>.
* <p>
* <code>ROTATION</code> typed axes denote a rotational deviation from a center
* position. Something on the stick is turned or twisted.
* The range of <code>getValue()</code> is <code>[-1.0,1.0]</code>.
* <p>
* <code>SLIDER</code> typed axes denote a shifting device without a center position.
* A good sample is a throttle control.
* The range of <code>getValue()</code> is <code>[0.0,1.0]</code>.
*
* @return [ TRANSLATION | ROTATION | SLIDER ]
*/
int getType();
/**
* Returns the current value of the axis.
* The range of the result depends on the axis type.
*
* @return value [-1.0,1.0] or [0.0,1.0]
*/
double getValue();
/**
* Returns the current value of the axis.
* The range of the result depends on the axis type.
*
* @return value [-1.0,1.0] or [0.0,1.0]
*/
double getValue();
/**

44
src/main/java/de/hardcode/jxinput/Button.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 19. Dezember 2001, 21:58
// Created on 19. Dezember 2001, 21:58
//**********************************************************************************************
package de.hardcode.jxinput;
@@ -14,22 +14,22 @@ package de.hardcode.jxinput;
*/
public interface Button extends Feature
{
// Enumeration of button types
final static int PUSHBUTTON = 0;
final static int TOGGLEBUTTON = 1;
/**
* Retrieve the type of the button.
* Pushbutton will deliver <code>true==getState()</code> as long as they are pressed down.
* Togglebuttons will change their state once they are pressed and keep that state
* until they are pressed again.
* @return [ PUSHBUTTON | TOGGLEBUTTON ]
*/
int getType();
/**
* Tells the state of the button at last update.
*/
boolean getState();
// Enumeration of button types
final static int PUSHBUTTON = 0;
final static int TOGGLEBUTTON = 1;
/**
* Retrieve the type of the button.
* Pushbutton will deliver <code>true==getState()</code> as long as they are pressed down.
* Togglebuttons will change their state once they are pressed and keep that state
* until they are pressed again.
* @return [ PUSHBUTTON | TOGGLEBUTTON ]
*/
int getType();
/**
* Tells the state of the button at last update.
*/
boolean getState();
}

58
src/main/java/de/hardcode/jxinput/Directional.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 27. Dezember 2001, 23:33
// Created on 27. Dezember 2001, 23:33
//**********************************************************************************************
package de.hardcode.jxinput;
@@ -14,32 +14,32 @@ package de.hardcode.jxinput;
*/
public interface Directional extends Feature
{
/**
* If the Directional has a center position where it points to no direction, this
* flag is true when this position is reached.
*/
boolean isCentered();
/**
* Retrieve the direction pointed to.
* Value is given in 1/100 degree, [0,36000]
*/
int getDirection();
/**
* If the Directional has a center position where it points to no direction, this
* flag is true when this position is reached.
*/
boolean isCentered();
/**
* Retrieve the direction pointed to.
* Value is given in 1/100 degree, [0,36000]
*/
int getDirection();
/**
* Retrieve the analog value pointing to the angle described by
* <code>getDirection()</code>.
* For coolie hats this will be either 1,0 for any direction or 0.0
* when <code>isCentered()==true</code>.
*/
double getValue();
/**
* Retrieve the analog value pointing to the angle described by
* <code>getDirection()</code>.
* For coolie hats this will be either 1,0 for any direction or 0.0
* when <code>isCentered()==true</code>.
*/
double getValue();
/**
* Inform about the resolution of the value returned by <code>getValue()</code>.
*
* @return resolution, e.g. 1.0 for coolie hats
*/
double getResolution();
/**
* Inform about the resolution of the value returned by <code>getValue()</code>.
*
* @return resolution, e.g. 1.0 for coolie hats
*/
double getResolution();
}

26
src/main/java/de/hardcode/jxinput/Feature.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 27. Dezember 2001, 00:19
// Created on 27. Dezember 2001, 00:19
//**********************************************************************************************
package de.hardcode.jxinput;
@@ -24,15 +24,15 @@ package de.hardcode.jxinput;
*/
public abstract interface Feature
{
/**
/**
* Features may have a name provided e.g. by the driver.
*/
String getName();
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
boolean hasChanged();
String getName();
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
boolean hasChanged();
}

68
src/main/java/de/hardcode/jxinput/JXInputDevice.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 19. Dezember 2001, 21:47
// Created on 19. Dezember 2001, 21:47
//**********************************************************************************************
package de.hardcode.jxinput;
@@ -30,42 +30,42 @@ package de.hardcode.jxinput;
*/
public interface JXInputDevice
{
/**
* @directed
*/
/**
* @directed
*/
/*#Features lnkFeatures;*/
/**
*@link aggregationByValue
*/
/**
*@link aggregationByValue
*/
/*#Feature lnkFeature;*/
/**
* Devices may have a name.
* This name might be provided by a system dependant driver.
*/
String getName();
/** Actual number of available axes. */
int getNumberOfAxes();
/**
* Devices may have a name.
* This name might be provided by a system dependant driver.
*/
String getName();
/** Actual number of available axes. */
int getNumberOfAxes();
/** Actual number of available buttons. */
int getNumberOfButtons();
/** Actual number of available buttons. */
int getNumberOfButtons();
/** Actual number of available directional features. */
int getNumberOfDirectionals();
/** Maximum number of axes as an upper bound for index values. */
int getMaxNumberOfAxes();
/** Actual number of available directional features. */
int getNumberOfDirectionals();
/** Maximum number of axes as an upper bound for index values. */
int getMaxNumberOfAxes();
/** Maximum number of buttons as an upper bound for index values. */
int getMaxNumberOfButtons();
/** Maximum number of buttons as an upper bound for index values. */
int getMaxNumberOfButtons();
/** Maximum number of directional features as an upper bound for index values. */
int getMaxNumberOfDirectionals();
Axis getAxis( int idx );
Button getButton( int idx );
Directional getDirectional( int idx );
/** Maximum number of directional features as an upper bound for index values. */
int getMaxNumberOfDirectionals();
Axis getAxis( int idx );
Button getButton( int idx );
Directional getDirectional( int idx );
}

316
src/main/java/de/hardcode/jxinput/JXInputManager.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 29. Dezember 2001, 02:17
// Created on 29. Dezember 2001, 02:17
//**********************************************************************************************
package de.hardcode.jxinput;
@@ -29,44 +29,44 @@ import java.awt.Component;
*/
public class JXInputManager
{
/** Remember when the last update took place. */
private static long mTimeOfLastUpdate;
/** Remember when the last update took place. */
private static long mTimeOfLastUpdate;
/** Maintain a list of devices. */
private final static ArrayList mDevices = new ArrayList();
/** Maintain a list of direct input devices. */
private final static ArrayList mDIDevices = new ArrayList();
/** Maintain a list of devices. */
private final static ArrayList mDevices = new ArrayList();
/** Maintain a list of direct input devices. */
private final static ArrayList mDIDevices = new ArrayList();
/** Maintain a list of virtual devices. */
private final static ArrayList mVirtualDevices = new ArrayList();
/** Maintain a list of virtual devices. */
private final static ArrayList mVirtualDevices = new ArrayList();
/** Maintain a list of keyboard devices. */
private final static ArrayList mKBDevices = new ArrayList();
/**
* Statically retrieve all DirectInputDevices available.
*/
/** Maintain a list of keyboard devices. */
private final static ArrayList mKBDevices = new ArrayList();
/**
* Statically retrieve all DirectInputDevices available.
*/
static
{
reset();
}
reset();
}
/**
* @directed
*/
* @directed
*/
/*#JXInputDevice lnkJXInputDevice;*/
/**
* Creates a new instance of JXInputManager.
* This is prohibited - it only has static members.
*/
private JXInputManager()
{
}
/**
* Creates a new instance of JXInputManager.
* This is prohibited - it only has static members.
*/
private JXInputManager()
{
}
/**
* Retrieve the number of available input devices.
@@ -76,158 +76,158 @@ public class JXInputManager
return mDevices.size();
}
/**
* Delivers the JXInputDevice with the desired index.
* <p>
/**
* Delivers the JXInputDevice with the desired index.
* <p>
* Take care that <code>idx < getNumberOfDevices()</code>!
*/
public static JXInputDevice getJXInputDevice( int idx )
{
//
// Be well-behaved even if idx is out of range.
//
if ( idx >= mDevices.size() )
return null;
public static JXInputDevice getJXInputDevice( int idx )
{
//
// Be well-behaved even if idx is out of range.
//
if ( idx >= mDevices.size() )
return null;
return (JXInputDevice)mDevices.get( idx );
}
/**
* Master reset for all devices and events.
* After calling reset(), better forget all devices created or retrieved.
* They are no longer valid.
* Event listeners will no longer be called and should be discarded.
*/
synchronized public static void reset()
{
JXInputEventManager.reset();
mDevices.clear();
/**
* Master reset for all devices and events.
* After calling reset(), better forget all devices created or retrieved.
* They are no longer valid.
* Event listeners will no longer be called and should be discarded.
*/
synchronized public static void reset()
{
JXInputEventManager.reset();
mDevices.clear();
mVirtualDevices.clear();
mDIDevices.clear();
mVirtualDevices.clear();
mDIDevices.clear();
DirectInputDevice.reset();
DirectInputDevice.reset();
for ( int i = 0; i < DirectInputDevice.getNumberOfDevices(); ++i )
{
DirectInputDevice dev = new DirectInputDevice( i );
DirectInputDevice dev = new DirectInputDevice( i );
mDevices.add( dev );
mDIDevices.add( dev );
}
// I have to call updateFeatures one time here during initialization
// bc. I experienced difficulties otherwise while running with the
// J3D sensoring stuff!
// updateFeatures();
DirectInputDevice.update();
int n = mKBDevices.size();
for ( int i = 0; i < n; ++i )
((JXKeyboardInputDevice)mKBDevices.get( i )).shutdown();
mKBDevices.clear();
}
// I have to call updateFeatures one time here during initialization
// bc. I experienced difficulties otherwise while running with the
// J3D sensoring stuff!
// updateFeatures();
DirectInputDevice.update();
int n = mKBDevices.size();
for ( int i = 0; i < n; ++i )
((JXKeyboardInputDevice)mKBDevices.get( i )).shutdown();
mKBDevices.clear();
}
/**
* Update the (shared) state of all features in one step.
* This method asks the actual device for a consistant state.
* After calling this method, all features may have new values.
* updateFeatures() is meant to be called e.g. once per frame in a gaming environment.
*/
public static void updateFeatures()
/**
* Update the (shared) state of all features in one step.
* This method asks the actual device for a consistant state.
* After calling this method, all features may have new values.
* updateFeatures() is meant to be called e.g. once per frame in a gaming environment.
*/
public static void updateFeatures()
{
// Get timing
long now = System.currentTimeMillis();
long deltaT = now - mTimeOfLastUpdate;
// Update available driver
DirectInputDevice.update();
long now = System.currentTimeMillis();
long deltaT = now - mTimeOfLastUpdate;
//
// Update the virtual devices.
//
Iterator vdevices = mVirtualDevices.iterator();
while ( vdevices.hasNext() )
{
((JXVirtualInputDevice)vdevices.next()).update( deltaT );
}
// Update available driver
DirectInputDevice.update();
//
// Update the virtual devices.
//
Iterator vdevices = mVirtualDevices.iterator();
while ( vdevices.hasNext() )
{
((JXVirtualInputDevice)vdevices.next()).update( deltaT );
}
// Remember time
mTimeOfLastUpdate = now;
mTimeOfLastUpdate = now;
// Fire all events.
// Fire all events.
JXInputEventManager.trigger();
}
/**
* Get time when last update occurred.
* @return tickervalue in milliseconds
*/
public static long getLastUpdateTime()
/**
* Get time when last update occurred.
* @return tickervalue in milliseconds
*/
public static long getLastUpdateTime()
{
return mTimeOfLastUpdate;
}
return mTimeOfLastUpdate;
}
/**
* Create a new pseudo-device.
*/
public static JXKeyboardInputDevice createKeyboardDevice()
{
JXKeyboardInputDevice d = new JXKeyboardInputDevice();
mDevices.add( d );
mKBDevices.add( d );
return d;
}
/**
* Create a new pseudo-device listening to a Swing component.
* Make sure that the component also has the keyboard focus!!
*/
public static JXKeyboardInputDevice createKeyboardDevice( Component comp )
{
JXKeyboardInputDevice d = new JXKeyboardInputDevice( comp );
mDevices.add( d );
mKBDevices.add( d );
return d;
}
/**
* Create a new pseudo-device.
*/
public static JXKeyboardInputDevice createKeyboardDevice()
{
JXKeyboardInputDevice d = new JXKeyboardInputDevice();
mDevices.add( d );
mKBDevices.add( d );
return d;
}
/**
* Create a new pseudo-device listening to a Swing component.
* Make sure that the component also has the keyboard focus!!
*/
public static JXKeyboardInputDevice createKeyboardDevice( Component comp )
{
JXKeyboardInputDevice d = new JXKeyboardInputDevice( comp );
mDevices.add( d );
mKBDevices.add( d );
return d;
}
/**
* Delete a keyboard device again e.g. when the corresponding
* JComponent gets deleted.
*/
public static void deleteKeyboardDevice( JXKeyboardInputDevice dev )
{
mDevices.remove( dev );
mKBDevices.remove( dev );
((JXKeyboardInputDevice)dev).shutdown();
}
/**
* Delete a keyboard device again e.g. when the corresponding
* JComponent gets deleted.
*/
public static void deleteKeyboardDevice( JXKeyboardInputDevice dev )
{
mDevices.remove( dev );
mKBDevices.remove( dev );
((JXKeyboardInputDevice)dev).shutdown();
}
/**
* Create a new pseudo-device.
*/
public static JXVirtualInputDevice createVirtualDevice()
{
JXVirtualInputDevice d = new JXVirtualInputDevice();
mDevices.add( d );
mVirtualDevices.add( d );
return d;
}
/**
* Create a new pseudo-device.
*/
public static JXVirtualInputDevice createVirtualDevice()
{
JXVirtualInputDevice d = new JXVirtualInputDevice();
mDevices.add( d );
mVirtualDevices.add( d );
return d;
}
/**
* Delete a virtual device again.
*/
public static void deleteVirtualDevice( JXVirtualInputDevice dev )
{
mDevices.remove( dev );
mVirtualDevices.remove( dev );
}
/**
* Delete a virtual device again.
*/
public static void deleteVirtualDevice( JXVirtualInputDevice dev )
{
mDevices.remove( dev );
mVirtualDevices.remove( dev );
}
}

94
src/main/java/de/hardcode/jxinput/directinput/DIAxis.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 27. Dezember 2001, 00:14
// Created on 27. Dezember 2001, 00:14
//**********************************************************************************************
package de.hardcode.jxinput.directinput;
@@ -17,53 +17,53 @@ import de.hardcode.jxinput.Axis;
class DIAxis implements Axis
{
private final int mDeviceIdx;
private final int mIdx;
private final int mIdx;
/**
* Creates a new instance of DIAxis.
*/
DIAxis( int devidx, int idx )
{
/**
* Creates a new instance of DIAxis.
*/
DIAxis( int devidx, int idx )
{
mDeviceIdx = devidx;
mIdx = idx;
}
mIdx = idx;
}
public String getName()
{
return DirectInputDriver.getAxisName( mDeviceIdx, mIdx );
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
public String getName()
{
return DirectInputDriver.getAxisName( mDeviceIdx, mIdx );
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
public double getValue()
{
return DirectInputDriver.getAxisValue( mDeviceIdx, mIdx );
}
public int getType()
{
return DirectInputDriver.getAxisType( mDeviceIdx, mIdx );
}
public double getValue()
{
return DirectInputDriver.getAxisValue( mDeviceIdx, mIdx );
}
public int getType()
{
return DirectInputDriver.getAxisType( mDeviceIdx, mIdx );
}
/**
* Inform about the resolution of the axis.
*
* @return resolution, e.g. 2^-16
*/
public double getResolution()
{
// extend the driver here!!
// Here I assume typical 16 bit resolution
return ( getType() == Axis.SLIDER ? 1.0/65536.0 : 2.0/65536.0 ) ;
}
/**
* Inform about the resolution of the axis.
*
* @return resolution, e.g. 2^-16
*/
public double getResolution()
{
// extend the driver here!!
// Here I assume typical 16 bit resolution
return ( getType() == Axis.SLIDER ? 1.0/65536.0 : 2.0/65536.0 ) ;
}
}

72
src/main/java/de/hardcode/jxinput/directinput/DIButton.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 27. Dezember 2001, 00:14
// Created on 27. Dezember 2001, 00:14
//**********************************************************************************************
package de.hardcode.jxinput.directinput;
@@ -18,38 +18,38 @@ import de.hardcode.jxinput.Button;
class DIButton implements Button
{
private final int mDeviceIdx;
private final int mIdx;
private final int mIdx;
/**
* Creates a new instance of DIButton.
*/
DIButton( int devidx, int idx )
{
/**
* Creates a new instance of DIButton.
*/
DIButton( int devidx, int idx )
{
mDeviceIdx = devidx;
mIdx = idx;
}
public String getName()
{
return DirectInputDriver.getButtonName( mDeviceIdx, mIdx );
}
mIdx = idx;
}
public String getName()
{
return DirectInputDriver.getButtonName( mDeviceIdx, mIdx );
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
public int getType()
{
return DirectInputDriver.getButtonType( mDeviceIdx, mIdx );
}
public boolean getState()
{
return DirectInputDriver.getButtonState( mDeviceIdx, mIdx );
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
public int getType()
{
return DirectInputDriver.getButtonType( mDeviceIdx, mIdx );
}
public boolean getState()
{
return DirectInputDriver.getButtonState( mDeviceIdx, mIdx );
}
}

114
src/main/java/de/hardcode/jxinput/directinput/DIDirectional.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 27. Dezember 2001, 23:40
// Created on 27. Dezember 2001, 23:40
//**********************************************************************************************
package de.hardcode.jxinput.directinput;
@@ -17,62 +17,62 @@ import de.hardcode.jxinput.Directional;
class DIDirectional implements Directional
{
private final int mDeviceIdx;
private final int mIdx;
/**
* Creates a new instance of DIDirectional.
*/
DIDirectional( int devidx, int idx )
{
private final int mIdx;
/**
* Creates a new instance of DIDirectional.
*/
DIDirectional( int devidx, int idx )
{
mDeviceIdx = devidx;
mIdx = idx;
}
/** Features may have a name provided e.g. by the driver. */
public String getName()
{
return DirectInputDriver.getDirectionalName( mDeviceIdx, mIdx );
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
mIdx = idx;
}
/** Features may have a name provided e.g. by the driver. */
public String getName()
{
return DirectInputDriver.getDirectionalName( mDeviceIdx, mIdx );
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
public boolean isCentered()
{
return ( 0xffff == (DirectInputDriver.getDirection( mDeviceIdx, mIdx ) & 0xffff) );
}
public int getDirection()
{
return isCentered() ? 0 : DirectInputDriver.getDirection( mDeviceIdx, mIdx );
}
public boolean isCentered()
{
return ( 0xffff == (DirectInputDriver.getDirection( mDeviceIdx, mIdx ) & 0xffff) );
}
public int getDirection()
{
return isCentered() ? 0 : DirectInputDriver.getDirection( mDeviceIdx, mIdx );
}
public double getValue()
{
if ( isCentered() )
return 0.0;
return 1.0;
}
public double getValue()
{
if ( isCentered() )
return 0.0;
return 1.0;
}
/**
* Inform about the resolution of the value returned by <code>getValue()</code>.
*
* @return resolution, e.g. 1.0 for coolie hats
*/
public double getResolution()
{
// DI POV always return 0.0 or 1.0, so the resolution is 1.0.
return 1.0;
}
/**
* Inform about the resolution of the value returned by <code>getValue()</code>.
*
* @return resolution, e.g. 1.0 for coolie hats
*/
public double getResolution()
{
// DI POV always return 0.0 or 1.0, so the resolution is 1.0.
return 1.0;
}
}

240
src/main/java/de/hardcode/jxinput/directinput/DirectInputDevice.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 26. Dezember 2001, 00:40
// Created on 26. Dezember 2001, 00:40
//**********************************************************************************************
package de.hardcode.jxinput.directinput;
@@ -18,151 +18,151 @@ import de.hardcode.jxinput.Button;
* @author Herkules
*/
public class DirectInputDevice implements JXInputDevice
{
{
int mDeviceIdx;
private DIAxis[] mAxes;
private DIButton[] mButtons;
private DIDirectional[] mDirectionals;
/**
* The number of DirectInput devices available with the driver.
*/
private DIAxis[] mAxes;
private DIButton[] mButtons;
private DIDirectional[] mDirectionals;
/**
* The number of DirectInput devices available with the driver.
*/
public static int getNumberOfDevices()
{
if ( DirectInputDriver.isAvailable() )
return DirectInputDriver.getNumberOfDevices();
return 0;
}
/**
* Update the state of all devices.
*/
public static void update()
{
if ( DirectInputDriver.isAvailable() )
DirectInputDriver.nativeupdate();
{
if ( DirectInputDriver.isAvailable() )
return DirectInputDriver.getNumberOfDevices();
return 0;
}
/**
* Update the state of all devices.
*/
public static void update()
{
if ( DirectInputDriver.isAvailable() )
DirectInputDriver.nativeupdate();
}
/**
* Creates a new instance of DirectInputDevice.
*/
public DirectInputDevice( int devidx )
{
/**
* Creates a new instance of DirectInputDevice.
*/
public DirectInputDevice( int devidx )
{
mDeviceIdx = devidx;
init();
}
init();
}
/**
* Reset the DirectInput connection.
*/
public static void reset()
{
if ( DirectInputDriver.isAvailable() )
if ( DirectInputDriver.isAvailable() )
DirectInputDriver.reset();
}
/**
* Initialisation of fields.
*/
private final void init()
{
/**
* Initialisation of fields.
*/
private final void init()
{
//
// Allocate arrays for max. number of features
//
mAxes = new DIAxis [ getMaxNumberOfAxes() ];
mButtons = new DIButton [ getMaxNumberOfButtons() ];
mDirectionals = new DIDirectional [ getMaxNumberOfDirectionals() ];
mAxes = new DIAxis [ getMaxNumberOfAxes() ];
mButtons = new DIButton [ getMaxNumberOfButtons() ];
mDirectionals = new DIDirectional [ getMaxNumberOfDirectionals() ];
//
// Fill arrays due to the state of the driver.
//
for ( int i = 0; i < mAxes.length; ++i )
{
if ( DirectInputDriver.isAxisAvailable( mDeviceIdx, i ) )
mAxes[ i ] = new DIAxis( mDeviceIdx, i );
}
for ( int i = 0; i < mButtons.length; ++i )
{
if ( DirectInputDriver.isButtonAvailable( mDeviceIdx, i ) )
mButtons[ i ] = new DIButton( mDeviceIdx, i );
}
for ( int i = 0; i < mAxes.length; ++i )
{
if ( DirectInputDriver.isAxisAvailable( mDeviceIdx, i ) )
mAxes[ i ] = new DIAxis( mDeviceIdx, i );
}
for ( int i = 0; i < mButtons.length; ++i )
{
if ( DirectInputDriver.isButtonAvailable( mDeviceIdx, i ) )
mButtons[ i ] = new DIButton( mDeviceIdx, i );
}
for ( int i = 0; i < mDirectionals.length; ++i )
{
if ( DirectInputDriver.isDirectionalAvailable( mDeviceIdx, i ) )
mDirectionals[ i ] = new DIDirectional( mDeviceIdx, i );
}
}
for ( int i = 0; i < mDirectionals.length; ++i )
{
if ( DirectInputDriver.isDirectionalAvailable( mDeviceIdx, i ) )
mDirectionals[ i ] = new DIDirectional( mDeviceIdx, i );
}
}
/** Devices may have a name. */
public String getName()
{
String name = DirectInputDriver.getName( mDeviceIdx );
if ( null == name )
return "Win32 DirectInput Joystick";
return name;
}
/** Actual number of available buttons. */
public int getNumberOfButtons()
{
return DirectInputDriver.getNumberOfButtons( mDeviceIdx );
}
/** Actual number of available axes. */
public int getNumberOfAxes()
{
return DirectInputDriver.getNumberOfAxes( mDeviceIdx );
}
/** Actual number of available directional features. */
public int getNumberOfDirectionals()
{
return DirectInputDriver.getNumberOfDirectionals( mDeviceIdx );
}
/** Maximum number of buttons as an upper bound for index values. */
public int getMaxNumberOfButtons()
{
return DirectInputDriver.getMaxNumberOfButtons();
}
/** Maximum number of axes as an upper bound for index values. */
public int getMaxNumberOfAxes()
{
return DirectInputDriver.getMaxNumberOfAxes();
}
/** Maximum number of available directional features. */
public int getMaxNumberOfDirectionals()
{
return DirectInputDriver.getMaxNumberOfDirectionals();
}
public String getName()
{
String name = DirectInputDriver.getName( mDeviceIdx );
if ( null == name )
return "Win32 DirectInput Joystick";
return name;
}
public Axis getAxis(int idx)
{
return mAxes[ idx ];
}
/** Actual number of available buttons. */
public int getNumberOfButtons()
{
return DirectInputDriver.getNumberOfButtons( mDeviceIdx );
}
public Button getButton(int idx)
{
return mButtons[ idx ];
}
/** Actual number of available axes. */
public int getNumberOfAxes()
{
return DirectInputDriver.getNumberOfAxes( mDeviceIdx );
}
public Directional getDirectional(int idx)
{
return mDirectionals[ idx ];
}
/** Actual number of available directional features. */
public int getNumberOfDirectionals()
{
return DirectInputDriver.getNumberOfDirectionals( mDeviceIdx );
}
/** Maximum number of buttons as an upper bound for index values. */
public int getMaxNumberOfButtons()
{
return DirectInputDriver.getMaxNumberOfButtons();
}
/** Maximum number of axes as an upper bound for index values. */
public int getMaxNumberOfAxes()
{
return DirectInputDriver.getMaxNumberOfAxes();
}
/** Maximum number of available directional features. */
public int getMaxNumberOfDirectionals()
{
return DirectInputDriver.getMaxNumberOfDirectionals();
}
public Axis getAxis(int idx)
{
return mAxes[ idx ];
}
public Button getButton(int idx)
{
return mButtons[ idx ];
}
public Directional getDirectional(int idx)
{
return mDirectionals[ idx ];
}
}

218
src/main/java/de/hardcode/jxinput/directinput/DirectInputDriver.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 19. Dezember 2001, 22:44
// Created on 19. Dezember 2001, 22:44
//**********************************************************************************************
package de.hardcode.jxinput.directinput;
@@ -27,115 +27,115 @@ import com.github.boukefalos.jlibloader.Native;
*/
class DirectInputDriver
{
private final static String NATIVE_LIB_NAME = "jxinput";
/** Remember wether nativeinit() succeeded. */
static boolean sIsOperational = false;
//
// Static arrays to hold the values.
//
private static double [][] sAxisValues;
private static boolean [][] sButtonStates;
private static int [][] sDirectionalValues;
private final static String NATIVE_LIB_NAME = "jxinput";
/** Remember wether nativeinit() succeeded. */
static boolean sIsOperational = false;
//
// Static arrays to hold the values.
//
private static double [][] sAxisValues;
private static boolean [][] sButtonStates;
private static int [][] sDirectionalValues;
/**
* Perform the static initialization.
*/
static
{
try
{
Native.load("com.github.boukefalos", "jlibxinput");
/**
* Perform the static initialization.
*/
static
{
try
{
Native.load("com.github.boukefalos", "jlibxinput");
init();
}
catch( SecurityException e )
{
Log.logger.warning("Native library jxinput not loaded due to a SecurityException.");
}
catch( UnsatisfiedLinkError e )
{
Log.logger.info("Native library jxinput not loaded due to an UnsatisfiedLinkError.");
}
}
}
catch( SecurityException e )
{
Log.logger.warning("Native library jxinput not loaded due to a SecurityException.");
}
catch( UnsatisfiedLinkError e )
{
Log.logger.info("Native library jxinput not loaded due to an UnsatisfiedLinkError.");
}
}
private final static void init()
{
sIsOperational = false;
sIsOperational = false;
//
// Initialize it.
//
if ( nativeinit() )
{
int devs = getNumberOfDevices();
sAxisValues = new double [ devs ][ DirectInputDriver.getMaxNumberOfAxes() ];
sButtonStates = new boolean [ devs ][ DirectInputDriver.getMaxNumberOfButtons() ];
sDirectionalValues = new int [ devs ][ DirectInputDriver.getMaxNumberOfDirectionals() ];
int devs = getNumberOfDevices();
sAxisValues = new double [ devs ][ DirectInputDriver.getMaxNumberOfAxes() ];
sButtonStates = new boolean [ devs ][ DirectInputDriver.getMaxNumberOfButtons() ];
sDirectionalValues = new int [ devs ][ DirectInputDriver.getMaxNumberOfDirectionals() ];
// Bind the native lib to my variables.
bind();
// Remember I am fine.
sIsOperational = true;
sIsOperational = true;
}
}
/**
* Static ctor of DirectInputDriver.
* No object will be created due to the static layout.
*/
private DirectInputDriver()
{
}
// Administration
private static native boolean nativeinit();
private static native void nativeexit();
private static native void bind();
/**
* Static ctor of DirectInputDriver.
* No object will be created due to the static layout.
*/
private DirectInputDriver()
{
}
// Administration
private static native boolean nativeinit();
private static native void nativeexit();
private static native void bind();
static native int getNumberOfDevices();
// Configuration
static native String getName( int dev );
static native int getNumberOfAxes( int dev );
static native int getNumberOfButtons( int dev );
static native int getNumberOfDirectionals( int dev );
static native int getMaxNumberOfAxes();
static native int getMaxNumberOfButtons();
static native int getMaxNumberOfDirectionals();
static native boolean isAxisAvailable( int dev, int idx );
static native String getAxisName( int dev, int idx );
static native int getAxisType( int dev, int idx );
// Configuration
static native String getName( int dev );
static native int getNumberOfAxes( int dev );
static native int getNumberOfButtons( int dev );
static native int getNumberOfDirectionals( int dev );
static native int getMaxNumberOfAxes();
static native int getMaxNumberOfButtons();
static native int getMaxNumberOfDirectionals();
static native boolean isAxisAvailable( int dev, int idx );
static native String getAxisName( int dev, int idx );
static native int getAxisType( int dev, int idx );
static native boolean isButtonAvailable( int dev, int idx );
static native String getButtonName( int dev, int idx );
static native int getButtonType( int dev, int idx );
static native boolean isButtonAvailable( int dev, int idx );
static native String getButtonName( int dev, int idx );
static native int getButtonType( int dev, int idx );
static native boolean isDirectionalAvailable( int dev, int idx );
static native String getDirectionalName( int dev, int idx );
// Operation
static native void nativeupdate();
static native boolean isDirectionalAvailable( int dev, int idx );
static native String getDirectionalName( int dev, int idx );
// Operation
static native void nativeupdate();
public static boolean isAvailable()
{
return sIsOperational;
}
public static boolean isAvailable()
{
return sIsOperational;
}
/**
* Shutdown the device and free all Win32 resources.
* It is not a good idea to access any joystick features after
* <code>shutdown()</code>.
*/
static void shutdown()
{
nativeexit();
static void shutdown()
{
nativeexit();
sAxisValues = null;
sButtonStates = null;
sDirectionalValues = null;
@@ -145,40 +145,40 @@ class DirectInputDriver
/**
* Reset the device and free all Win32 resources.
*/
static void reset()
{
shutdown();
static void reset()
{
shutdown();
init();
}
static double getAxisValue( int dev, int idx )
{
return sAxisValues[ dev ][ idx ];
}
static boolean getButtonState( int dev, int idx )
{
return sButtonStates[ dev ][ idx ];
}
static double getAxisValue( int dev, int idx )
{
return sAxisValues[ dev ][ idx ];
}
static boolean getButtonState( int dev, int idx )
{
return sButtonStates[ dev ][ idx ];
}
static int getDirection( int dev, int idx )
{
return sDirectionalValues[ dev ][ idx ];
}
static int getDirection( int dev, int idx )
{
return sDirectionalValues[ dev ][ idx ];
}
/**
* @param args the command line arguments
*/
public static void main (String args[])
{
{
if ( ! sIsOperational )
return;
for( int i = 0; i < 5000; ++i )
nativeupdate();
if ( ! sIsOperational )
return;
for( int i = 0; i < 5000; ++i )
nativeupdate();
shutdown();
}
shutdown();
}
}

8
src/main/java/de/hardcode/jxinput/directinput/Log.java
View File

@@ -1,8 +1,8 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 29. Oktober 2002, 22:57
//**********************************************************************************************

24
src/main/java/de/hardcode/jxinput/event/JXInputAxisEvent.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:33
// Created on 31. Januar 2002, 23:33
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -18,15 +18,15 @@ import de.hardcode.jxinput.Axis;
public class JXInputAxisEvent
{
private final Axis mAxis;
double mDelta;
/**
double mDelta;
/**
* Creates a new instance of JXInputEvent.
*/
JXInputAxisEvent( Axis axis )
{
*/
JXInputAxisEvent( Axis axis )
{
mAxis = axis;
}
}
/**
* The feature that caused the event.

12
src/main/java/de/hardcode/jxinput/event/JXInputAxisEventListener.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:54
// Created on 31. Januar 2002, 23:54
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -14,6 +14,6 @@ package de.hardcode.jxinput.event;
*/
public interface JXInputAxisEventListener
{
void changed( JXInputAxisEvent ev );
void changed( JXInputAxisEvent ev );
}

24
src/main/java/de/hardcode/jxinput/event/JXInputButtonEvent.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:33
// Created on 31. Januar 2002, 23:33
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -18,14 +18,14 @@ import de.hardcode.jxinput.Button;
public class JXInputButtonEvent
{
final Button mButton;
/**
/**
* Creates a new instance of JXInputEvent.
*/
JXInputButtonEvent( Button button )
{
mButton = button;
}
*/
JXInputButtonEvent( Button button )
{
mButton = button;
}
/**
* The feature that caused the event.

12
src/main/java/de/hardcode/jxinput/event/JXInputButtonEventListener.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:54
// Created on 31. Januar 2002, 23:54
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -14,6 +14,6 @@ package de.hardcode.jxinput.event;
*/
public interface JXInputButtonEventListener
{
void changed( JXInputButtonEvent ev );
void changed( JXInputButtonEvent ev );
}

30
src/main/java/de/hardcode/jxinput/event/JXInputDirectionalEvent.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:33
// Created on 31. Januar 2002, 23:33
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -18,16 +18,16 @@ import de.hardcode.jxinput.Directional;
public class JXInputDirectionalEvent
{
private final Directional mDirectional;
double mValueDelta;
int mDirectionDelta;
/**
double mValueDelta;
int mDirectionDelta;
/**
* Creates a new instance of JXInputEvent.
*/
JXInputDirectionalEvent( Directional directional )
{
mDirectional = directional;
}
*/
JXInputDirectionalEvent( Directional directional )
{
mDirectional = directional;
}
/**
* The feature that caused the event.
@@ -45,7 +45,7 @@ public class JXInputDirectionalEvent
return mValueDelta;
}
/**
/**
* Return the change in direction that caused the event.
*/
public int getDirectionDelta()

12
src/main/java/de/hardcode/jxinput/event/JXInputDirectionalEventListener.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:54
// Created on 31. Januar 2002, 23:54
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -14,6 +14,6 @@ package de.hardcode.jxinput.event;
*/
public interface JXInputDirectionalEventListener
{
void changed( JXInputDirectionalEvent ev );
void changed( JXInputDirectionalEvent ev );
}

366
src/main/java/de/hardcode/jxinput/event/JXInputEventManager.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 31. Januar 2002, 23:42
// Created on 31. Januar 2002, 23:42
//**********************************************************************************************
package de.hardcode.jxinput.event;
@@ -24,13 +24,13 @@ import de.hardcode.jxinput.Directional;
*/
public class JXInputEventManager
{
private final static ArrayList mAxisEventListeners = new ArrayList();
private final static ArrayList mButtonEventListeners = new ArrayList();
private final static ArrayList mDirectionalEventListeners = new ArrayList();
private final static ArrayList mAxisEventListeners = new ArrayList();
private final static ArrayList mButtonEventListeners = new ArrayList();
private final static ArrayList mDirectionalEventListeners = new ArrayList();
private static autotrigger mAutoTrigger = null;
private static autotrigger mAutoTrigger = null;
/**
* Inner class combining a listener with its scheduling parameters.
*/
@@ -39,29 +39,29 @@ public class JXInputEventManager
final JXInputAxisEventListener mListener;
final double mTreshold;
final JXInputAxisEvent mEvent;
double mLastValueFired = 0.0;
double mLastValueFired = 0.0;
axislistener( JXInputAxisEventListener l, Axis axis, double treshold )
axislistener( JXInputAxisEventListener l, Axis axis, double treshold )
{
mListener = l;
mTreshold = treshold;
mEvent = new JXInputAxisEvent( axis );
mEvent = new JXInputAxisEvent( axis );
}
final void checkTrigger()
{
double curval = mEvent.getAxis().getValue();
double delta = curval - mLastValueFired;
final void checkTrigger()
{
double curval = mEvent.getAxis().getValue();
double delta = curval - mLastValueFired;
if ( Math.abs( delta ) >= mTreshold )
{
mLastValueFired = curval;
mEvent.mDelta = delta;
mListener.changed( mEvent );
}
}
}
if ( Math.abs( delta ) >= mTreshold )
{
mLastValueFired = curval;
mEvent.mDelta = delta;
mListener.changed( mEvent );
}
}
}
/**
* Inner class combining a listener with its scheduling parameters.
*/
@@ -69,142 +69,142 @@ public class JXInputEventManager
{
final JXInputButtonEventListener mListener;
final JXInputButtonEvent mEvent;
boolean mLastValueFired = false;
boolean mLastValueFired = false;
buttonlistener( JXInputButtonEventListener l, Button button )
buttonlistener( JXInputButtonEventListener l, Button button )
{
mListener = l;
mEvent = new JXInputButtonEvent( button );
mEvent = new JXInputButtonEvent( button );
}
final void checkTrigger()
{
boolean curstate = mEvent.getButton().getState();
if ( curstate != mLastValueFired )
{
mLastValueFired = curstate;
mListener.changed( mEvent );
}
}
}
final void checkTrigger()
{
boolean curstate = mEvent.getButton().getState();
if ( curstate != mLastValueFired )
{
mLastValueFired = curstate;
mListener.changed( mEvent );
}
}
}
private static class directionallistener
{
final JXInputDirectionalEventListener mListener;
final double mValueTreshold;
final JXInputDirectionalEvent mEvent;
double mLastValueFired = 0.0;
boolean mLastCenteredFired = true;
int mLastDirectionFired = 0;
directionallistener( JXInputDirectionalEventListener l, Directional directional, double valuetreshold )
double mLastValueFired = 0.0;
boolean mLastCenteredFired = true;
int mLastDirectionFired = 0;
directionallistener( JXInputDirectionalEventListener l, Directional directional, double valuetreshold )
{
mListener = l;
mValueTreshold = valuetreshold;
mEvent = new JXInputDirectionalEvent( directional );
mEvent = new JXInputDirectionalEvent( directional );
}
final void checkTrigger()
{
double curval = mEvent.getDirectional().getValue();
int curdir = mEvent.getDirectional().getDirection();
boolean curctr = mEvent.getDirectional().isCentered();
double delta = curval - mLastValueFired;
int dirdelta = curdir - mLastDirectionFired;
boolean centeredchanged = mLastCenteredFired != curctr;
final void checkTrigger()
{
double curval = mEvent.getDirectional().getValue();
int curdir = mEvent.getDirectional().getDirection();
boolean curctr = mEvent.getDirectional().isCentered();
double delta = curval - mLastValueFired;
int dirdelta = curdir - mLastDirectionFired;
boolean centeredchanged = mLastCenteredFired != curctr;
if ( Math.abs( delta ) >= mValueTreshold
|| Math.abs( dirdelta ) > 0
|| centeredchanged )
{
mLastValueFired = curval;
mLastDirectionFired = curdir;
mLastCenteredFired = curctr;
mEvent.mValueDelta = delta;
mEvent.mDirectionDelta = dirdelta;
mListener.changed( mEvent );
}
}
}
/**
* Creates a new instance of JXInputEventManager.
*/
private JXInputEventManager()
{
}
if ( Math.abs( delta ) >= mValueTreshold
|| Math.abs( dirdelta ) > 0
|| centeredchanged )
{
mLastValueFired = curval;
mLastDirectionFired = curdir;
mLastCenteredFired = curctr;
mEvent.mValueDelta = delta;
mEvent.mDirectionDelta = dirdelta;
mListener.changed( mEvent );
}
}
}
/**
* Creates a new instance of JXInputEventManager.
*/
private JXInputEventManager()
{
}
/**
* Remove all listeners at once.
*/
public static void reset()
{
mAxisEventListeners.clear();
mButtonEventListeners.clear();
mDirectionalEventListeners.clear();
}
/**
* Remove all listeners at once.
*/
public static void reset()
{
mAxisEventListeners.clear();
mButtonEventListeners.clear();
mDirectionalEventListeners.clear();
}
/**
* Query devices and fire all occuring events.
* <code>trigger()</code> is thought to be called by <code>JXInputManager#updateFeatures()</code>.
*/
public static void trigger()
{
int n = mAxisEventListeners.size();
for ( int i = 0; i < n; i++ )
{
axislistener l = (axislistener)mAxisEventListeners.get( i );
l.checkTrigger();
}
int n = mAxisEventListeners.size();
for ( int i = 0; i < n; i++ )
{
axislistener l = (axislistener)mAxisEventListeners.get( i );
l.checkTrigger();
}
n = mButtonEventListeners.size();
for ( int i = 0; i < n; i++ )
{
buttonlistener l = (buttonlistener)mButtonEventListeners.get( i );
l.checkTrigger();
}
n = mButtonEventListeners.size();
for ( int i = 0; i < n; i++ )
{
buttonlistener l = (buttonlistener)mButtonEventListeners.get( i );
l.checkTrigger();
}
n = mDirectionalEventListeners.size();
for ( int i = 0; i < n; i++ )
{
directionallistener l = (directionallistener)mDirectionalEventListeners.get( i );
l.checkTrigger();
}
}
private final static class autotrigger extends Thread
{
boolean mFinish = false;
final int mDelay;
autotrigger( int delay )
{
mDelay = delay;
}
public void run()
{
while ( ! mFinish )
{
try
{
Thread.sleep( mDelay );
JXInputManager.updateFeatures();
}
catch ( InterruptedException ex )
{
}
}
}
}
n = mDirectionalEventListeners.size();
for ( int i = 0; i < n; i++ )
{
directionallistener l = (directionallistener)mDirectionalEventListeners.get( i );
l.checkTrigger();
}
}
private final static class autotrigger extends Thread
{
boolean mFinish = false;
final int mDelay;
autotrigger( int delay )
{
mDelay = delay;
}
public void run()
{
while ( ! mFinish )
{
try
{
Thread.sleep( mDelay );
JXInputManager.updateFeatures();
}
catch ( InterruptedException ex )
{
}
}
}
}
/**
* Set the intervall in ms that is used to check for new values of the features.
* Set it to <= 0 to prohibit automatic triggering. Events will then only be fired
@@ -212,30 +212,30 @@ public class JXInputEventManager
*/
public static void setTriggerIntervall( int ms )
{
//
// Kill current thread, if any
//
if ( null != mAutoTrigger )
{
mAutoTrigger.mFinish = true;
try
{
mAutoTrigger.join();
}
catch ( InterruptedException ex )
{
}
}
mAutoTrigger = null;
if ( ms > 0 )
{
mAutoTrigger = new autotrigger( ms );
mAutoTrigger.start();
}
//
// Kill current thread, if any
//
if ( null != mAutoTrigger )
{
mAutoTrigger.mFinish = true;
try
{
mAutoTrigger.join();
}
catch ( InterruptedException ex )
{
}
}
mAutoTrigger = null;
if ( ms > 0 )
{
mAutoTrigger = new autotrigger( ms );
mAutoTrigger.start();
}
}
}
@@ -245,40 +245,40 @@ public class JXInputEventManager
mAxisEventListeners.add( new JXInputEventManager.axislistener( l, axis, treshold ) );
}
public static void addListener( JXInputAxisEventListener l, Axis axis )
public static void addListener( JXInputAxisEventListener l, Axis axis )
{
mAxisEventListeners.add( new JXInputEventManager.axislistener( l, axis, axis.getResolution() ) );
}
public static void removeListener( JXInputAxisEventListener l )
{
mAxisEventListeners.remove( l );
}
public static void addListener( JXInputButtonEventListener l, Button button )
public static void removeListener( JXInputAxisEventListener l )
{
mAxisEventListeners.remove( l );
}
public static void addListener( JXInputButtonEventListener l, Button button )
{
mButtonEventListeners.add( new JXInputEventManager.buttonlistener( l, button ) );
}
public static void removeListener( JXInputButtonEventListener l )
{
mButtonEventListeners.remove( l );
}
public static void removeListener( JXInputButtonEventListener l )
{
mButtonEventListeners.remove( l );
}
public static void addListener( JXInputDirectionalEventListener l, Directional directional, double valuetreshold )
public static void addListener( JXInputDirectionalEventListener l, Directional directional, double valuetreshold )
{
mDirectionalEventListeners.add( new JXInputEventManager.directionallistener( l, directional, valuetreshold ) );
}
public static void addListener( JXInputDirectionalEventListener l, Directional directional )
public static void addListener( JXInputDirectionalEventListener l, Directional directional )
{
mDirectionalEventListeners.add( new JXInputEventManager.directionallistener( l, directional, directional.getResolution() ) );
}
public static void removeListener( JXInputDirectionalEventListener l )
{
mDirectionalEventListeners.remove( l );
}
public static void removeListener( JXInputDirectionalEventListener l )
{
mDirectionalEventListeners.remove( l );
}
}

152
src/main/java/de/hardcode/jxinput/j3d/DeviceConfiguration.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 23. Februar 2002, 14:05
// Created on 23. Februar 2002, 14:05
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
@@ -18,78 +18,78 @@ import de.hardcode.jxinput.Axis;
*/
public class DeviceConfiguration
{
public final static int AXIS_X = 0;
public final static int AXIS_Y = 1;
public final static int AXIS_Z = 2;
private final static class axisvalue
{
private final Axis mAxis;
private final IsActiveCondition mIsActive;
private final IsActiveCondition mIsIncremental;
private final double mScale;
private final double mOffset;
private double mValue;
axisvalue( Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
mAxis = axis;
mIsActive = active;
mIsIncremental = incremental;
mValue = mOffset = offset;
mScale = scale;
}
double value()
{
if ( mIsActive.isActive() )
{
double newval = mAxis.getValue() * mScale;
if ( mIsIncremental.isActive() )
mValue += newval;
else
mValue = newval + mOffset;
}
return mValue;
}
}
public final static int AXIS_X = 0;
public final static int AXIS_Y = 1;
public final static int AXIS_Z = 2;
private final static class axisvalue
{
private final Axis mAxis;
private final IsActiveCondition mIsActive;
private final IsActiveCondition mIsIncremental;
private final double mScale;
private final double mOffset;
private double mValue;
axisvalue( Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
mAxis = axis;
mIsActive = active;
mIsIncremental = incremental;
mValue = mOffset = offset;
mScale = scale;
}
double value()
{
if ( mIsActive.isActive() )
{
double newval = mAxis.getValue() * mScale;
if ( mIsIncremental.isActive() )
mValue += newval;
else
mValue = newval + mOffset;
}
return mValue;
}
}
DeviceConfiguration.axisvalue [] mAxisTrans = new DeviceConfiguration.axisvalue[ 3 ];
DeviceConfiguration.axisvalue [] mAxisRot = new DeviceConfiguration.axisvalue[ 3 ];
/**
* Creates a new instance of DeviceConfiguration.
*/
public DeviceConfiguration()
{
}
double getTranslational( int axisid )
{
DeviceConfiguration.axisvalue val = mAxisTrans[ axisid ];
return null == val ? 0.0 : val.value();
}
double getRotational( int axisid )
{
DeviceConfiguration.axisvalue val = mAxisRot[ axisid ];
return null == val ? 0.0 : val.value();
}
DeviceConfiguration.axisvalue [] mAxisTrans = new DeviceConfiguration.axisvalue[ 3 ];
DeviceConfiguration.axisvalue [] mAxisRot = new DeviceConfiguration.axisvalue[ 3 ];
/**
* Creates a new instance of DeviceConfiguration.
*/
public DeviceConfiguration()
{
}
double getTranslational( int axisid )
{
DeviceConfiguration.axisvalue val = mAxisTrans[ axisid ];
return null == val ? 0.0 : val.value();
}
double getRotational( int axisid )
{
DeviceConfiguration.axisvalue val = mAxisRot[ axisid ];
return null == val ? 0.0 : val.value();
}
public void setTranslational( int axisid, Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
if ( axisid < 0 || axisid > AXIS_Z )
throw new IllegalArgumentException();
mAxisTrans[ axisid ] = new DeviceConfiguration.axisvalue( axis, active, incremental, offset, scale );
}
public void setTranslational( int axisid, Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
if ( axisid < 0 || axisid > AXIS_Z )
throw new IllegalArgumentException();
mAxisTrans[ axisid ] = new DeviceConfiguration.axisvalue( axis, active, incremental, offset, scale );
}
public void setRotational( int axisid, Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
if ( axisid < 0 || axisid > AXIS_Z )
throw new IllegalArgumentException();
mAxisRot[ axisid ] = new DeviceConfiguration.axisvalue( axis, active, incremental, offset, scale );
}
public void setRotational( int axisid, Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
if ( axisid < 0 || axisid > AXIS_Z )
throw new IllegalArgumentException();
mAxisRot[ axisid ] = new DeviceConfiguration.axisvalue( axis, active, incremental, offset, scale );
}
}

22
src/main/java/de/hardcode/jxinput/j3d/IsActiveCondition.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 25. Februar 2002, 22:41
// Created on 25. Februar 2002, 22:41
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
@@ -14,12 +14,12 @@ package de.hardcode.jxinput.j3d;
*/
public interface IsActiveCondition
{
public final static IsActiveCondition ALWAYS = IsAlwaysActiveCondition.ALWAYS;
public final static IsActiveCondition NEVER = IsAlwaysActiveCondition.NEVER;
public final static IsActiveCondition ALWAYS = IsAlwaysActiveCondition.ALWAYS;
public final static IsActiveCondition NEVER = IsAlwaysActiveCondition.NEVER;
/**
* Tell wether a certain thing is active.
*/
boolean isActive();
/**
* Tell wether a certain thing is active.
*/
boolean isActive();
}

52
src/main/java/de/hardcode/jxinput/j3d/IsActiveOnButtonCondition.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 25. Februar 2002, 22:43
// Created on 25. Februar 2002, 22:43
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
@@ -15,25 +15,25 @@ import de.hardcode.jxinput.Button;
* @author Herkules
*/
public class IsActiveOnButtonCondition implements IsActiveCondition
{
private final boolean mActiveState;
private final Button mButton;
/**
* Creates a new instance of IsAlwayActiveCondition.
*/
public IsActiveOnButtonCondition( Button button, boolean activestate )
{
mActiveState = activestate;
mButton = button;
}
/**
* Tell wether a certain thing is active.
*/
public boolean isActive()
{
return mButton.getState() == mActiveState;
}
{
private final boolean mActiveState;
private final Button mButton;
/**
* Creates a new instance of IsAlwayActiveCondition.
*/
public IsActiveOnButtonCondition( Button button, boolean activestate )
{
mActiveState = activestate;
mButton = button;
}
/**
* Tell wether a certain thing is active.
*/
public boolean isActive()
{
return mButton.getState() == mActiveState;
}
}

52
src/main/java/de/hardcode/jxinput/j3d/IsAlwaysActiveCondition.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 25. Februar 2002, 22:43
// Created on 25. Februar 2002, 22:43
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
@@ -14,25 +14,25 @@ package de.hardcode.jxinput.j3d;
*/
final class IsAlwaysActiveCondition implements IsActiveCondition
{
private final boolean mIsActive;
public final static IsActiveCondition ALWAYS = new IsAlwaysActiveCondition( true );
public final static IsActiveCondition NEVER = new IsAlwaysActiveCondition( false );
/**
* Creates a new instance of IsAlwayActiveCondition.
*/
private IsAlwaysActiveCondition(boolean isactive)
{
mIsActive = isactive;
}
/**
* Tell wether a certain thing is active.
*/
public boolean isActive()
{
return mIsActive;
}
private final boolean mIsActive;
public final static IsActiveCondition ALWAYS = new IsAlwaysActiveCondition( true );
public final static IsActiveCondition NEVER = new IsAlwaysActiveCondition( false );
/**
* Creates a new instance of IsAlwayActiveCondition.
*/
private IsAlwaysActiveCondition(boolean isactive)
{
mIsActive = isactive;
}
/**
* Tell wether a certain thing is active.
*/
public boolean isActive()
{
return mIsActive;
}
}

222
src/main/java/de/hardcode/jxinput/j3d/J3DInputDevice.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 22. Februar 2002, 13:21
// Created on 22. Februar 2002, 13:21
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
@@ -22,121 +22,121 @@ import de.hardcode.jxinput.JXInputManager;
* @author Herkules
*/
public class J3DInputDevice
implements InputDevice
implements InputDevice
{
private Vector3d mPosition = new Vector3d();
private Transform3D mNewTransform = new Transform3D();
private Transform3D mRotTransX = new Transform3D();
private Transform3D mRotTransX = new Transform3D();
private Transform3D mRotTransY = new Transform3D();
private Transform3D mRotTransZ = new Transform3D();
private Vector3d mInitPos = new Vector3d( 0.0, 0.0, 0.0 );
private Sensor mSensor = new Sensor( this );
private SensorRead mSensorRead = new SensorRead();
private DeviceConfiguration mConfig;
/**
* Creates a new instance of J3DInputDevice.
*/
public J3DInputDevice( DeviceConfiguration config )
{
mConfig = config;
setNominalPositionAndOrientation();
}
public void close()
{
// Intentionally empty
}
/**
* Retrieve processing mode.
* For this device, it always is NON_BLOCKING.
*/
public int getProcessingMode()
{
return InputDevice.NON_BLOCKING;
}
/**
* Don't care for the index, I only support one sensor.
* And I deliver that.
*/
public Sensor getSensor( int param )
{
return mSensor;
}
private Sensor mSensor = new Sensor( this );
private SensorRead mSensorRead = new SensorRead();
private DeviceConfiguration mConfig;
/**
* Creates a new instance of J3DInputDevice.
*/
public J3DInputDevice( DeviceConfiguration config )
{
mConfig = config;
setNominalPositionAndOrientation();
}
public void close()
{
// Intentionally empty
}
/**
* Retrieve processing mode.
* For this device, it always is NON_BLOCKING.
*/
public int getProcessingMode()
{
return InputDevice.NON_BLOCKING;
}
/**
* Don't care for the index, I only support one sensor.
* And I deliver that.
*/
public Sensor getSensor( int param )
{
return mSensor;
}
/**
* Tell the world about the only one sensor I support.
*/
public int getSensorCount()
{
return 1;
}
/**
* Tell the world about the only one sensor I support.
*/
public int getSensorCount()
{
return 1;
}
/**
* Well - initialize!
* Nothing to do here.
*/
public boolean initialize()
{
return true;
}
/**
* The main update method.
*/
public void pollAndProcessInput()
{
JXInputManager.updateFeatures();
/**
* Well - initialize!
* Nothing to do here.
*/
public boolean initialize()
{
return true;
}
/**
* The main update method.
*/
public void pollAndProcessInput()
{
JXInputManager.updateFeatures();
mSensorRead.setTime( JXInputManager.getLastUpdateTime() );
mRotTransX.rotX( mConfig.getRotational( DeviceConfiguration.AXIS_X ) );
mRotTransX.rotX( mConfig.getRotational( DeviceConfiguration.AXIS_X ) );
mRotTransY.rotY( mConfig.getRotational( DeviceConfiguration.AXIS_Y ) );
mRotTransZ.rotZ( mConfig.getRotational( DeviceConfiguration.AXIS_Z ) );
mPosition.set(
mConfig.getTranslational( DeviceConfiguration.AXIS_X ),
mConfig.getTranslational( DeviceConfiguration.AXIS_Y ),
mConfig.getTranslational( DeviceConfiguration.AXIS_Z )
);
mConfig.getTranslational( DeviceConfiguration.AXIS_X ),
mConfig.getTranslational( DeviceConfiguration.AXIS_Y ),
mConfig.getTranslational( DeviceConfiguration.AXIS_Z )
);
mNewTransform.set( mPosition );
mNewTransform.set( mPosition );
mNewTransform.mul( mRotTransX );
mNewTransform.mul( mRotTransY );
mNewTransform.mul( mRotTransZ );
mSensorRead.set( mNewTransform );
mSensorRead.set( mNewTransform );
mSensor.setNextSensorRead( mSensorRead );
}
/**
* Not called by current j3d implementation.
*/
public void processStreamInput()
{
// Intentionally empty
}
/**
* Reset state.
*/
public void setNominalPositionAndOrientation()
{
}
/**
* Not called by current j3d implementation.
*/
public void processStreamInput()
{
// Intentionally empty
}
/**
* Reset state.
*/
public void setNominalPositionAndOrientation()
{
mSensorRead.setTime( JXInputManager.getLastUpdateTime() );
mRotTransX.rotX( 0.0 );
@@ -153,19 +153,19 @@ public class J3DInputDevice
mSensorRead.set( mNewTransform );
mSensor.setNextSensorRead( mSensorRead );
}
/**
* Set the processing mode.
* Only NON_BLOCKING is allowed!
*/
public void setProcessingMode(int param)
{
}
/**
* Set the processing mode.
* Only NON_BLOCKING is allowed!
*/
public void setProcessingMode(int param)
{
if ( param != InputDevice.NON_BLOCKING )
throw new IllegalArgumentException("Processing mode must be NON_BLOCKING");
}
throw new IllegalArgumentException("Processing mode must be NON_BLOCKING");
}
}

42
src/main/java/de/hardcode/jxinput/keyboard/InvalidKeyCodeException.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 16. April 2002, 23:31
// Created on 16. April 2002, 23:31
//**********************************************************************************************
package de.hardcode.jxinput.keyboard;
@@ -14,22 +14,22 @@ package de.hardcode.jxinput.keyboard;
* @author Herkules
*/
public class InvalidKeyCodeException
extends IllegalArgumentException
extends IllegalArgumentException
{
/**
* Creates a new instance of InvalidKeyCodeException.
*/
public InvalidKeyCodeException()
{
}
/**
* Creates a new instance of InvalidKeyCodeException.
*/
public InvalidKeyCodeException()
{
}
/**
* Creates a new instance of InvalidKeyCodeException.
*/
public InvalidKeyCodeException( String s )
{
super( s );
}
/**
* Creates a new instance of InvalidKeyCodeException.
*/
public InvalidKeyCodeException( String s )
{
super( s );
}
}

304
src/main/java/de/hardcode/jxinput/keyboard/JXKeyboardInputDevice.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 9. April 2002, 22:40
// Created on 9. April 2002, 22:40
//**********************************************************************************************
package de.hardcode.jxinput.keyboard;
@@ -19,157 +19,157 @@ import java.awt.Component;
* @author Herkules
*/
public class JXKeyboardInputDevice
implements JXInputDevice
implements JXInputDevice
{
private static final String DEVICENAME = "Swing Keyboard";
private static final String DEVICENAME = "Swing Keyboard";
/** The driver doing all the real work. */
private final KeyboardDriver mDriver = new KeyboardDriver();
/** The driver doing all the real work. */
private final KeyboardDriver mDriver = new KeyboardDriver();
/** The Component I am listening to. */
private Component mComponent = null;
/** Hold the biggest keycode for which a button has been created. */
private int mMaxIdxCreated = 0;
/**
* Creates a new instance of JXKeyboardInputDevice.
*/
public JXKeyboardInputDevice()
{
}
/** The Component I am listening to. */
private Component mComponent = null;
/** Hold the biggest keycode for which a button has been created. */
private int mMaxIdxCreated = 0;
/**
* Creates a new instance of JXKeyboardInputDevice.
*/
public JXKeyboardInputDevice()
{
}
/**
* Creates a new instance of JXKeyboardInputDevice
* immediately listening to a JComponent.
*/
public JXKeyboardInputDevice( Component comp )
{
listenTo( comp );
}
/**
* Makes this device listen to a certain JComponent.
*/
public final void listenTo( Component comp )
{
shutdown();
mComponent = comp;
mComponent.addKeyListener( mDriver );
}
/**
* Shut down. No longer listen to my JComponent.
*/
public final void shutdown()
{
if ( null != mComponent )
mComponent.removeKeyListener( mDriver );
}
/**
* Create a button object for a certain keycode.
*/
public Button createButton( int keycode )
{
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
/**
* Creates a new instance of JXKeyboardInputDevice
* immediately listening to a JComponent.
*/
public JXKeyboardInputDevice( Component comp )
{
listenTo( comp );
}
/**
* Makes this device listen to a certain JComponent.
*/
public final void listenTo( Component comp )
{
shutdown();
mComponent = comp;
mComponent.addKeyListener( mDriver );
}
/**
* Shut down. No longer listen to my JComponent.
*/
public final void shutdown()
{
if ( null != mComponent )
mComponent.removeKeyListener( mDriver );
}
/**
* Create a button object for a certain keycode.
*/
public Button createButton( int keycode )
{
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
KeyButton b;
if ( null == (b = mDriver.getButton( keycode ) ) )
{
b = new KeyButton( keycode );
mDriver.registerKeyButton( b );
if ( keycode > mMaxIdxCreated )
mMaxIdxCreated = keycode;
}
return b;
}
KeyButton b;
if ( null == (b = mDriver.getButton( keycode ) ) )
{
b = new KeyButton( keycode );
mDriver.registerKeyButton( b );
if ( keycode > mMaxIdxCreated )
mMaxIdxCreated = keycode;
}
return b;
}
public void removeButton( Button b )
{
mDriver.unregisterKeyButton( (KeyButton) b );
}
//*********************************************************************************************
//
// Implement JXInputDevice
//
//*********************************************************************************************
public Axis getAxis(int idx)
{
// No axes on keyboard.
return null;
}
public Button getButton(int idx)
{
// idx is interpreted as the keycode
return mDriver.getButton( idx );
}
public Directional getDirectional(int idx)
{
// No directionals on keyboard.
return null;
}
/** Maximum number of axes as an upper bound for index values. */
public int getMaxNumberOfAxes()
{
// No axes on keyboard.
return 0;
}
/** Maximum number of buttons as an upper bound for index values. */
public int getMaxNumberOfButtons()
{
// Return biggest keycode (inclusive).
return mMaxIdxCreated + 1;
}
/** Maximum number of directional features as an upper bound for index values. */
public int getMaxNumberOfDirectionals()
{
// No directionals on keyboard.
return 0;
}
/**
* Devices may have a name.
* This name might be provided by a system dependant driver.
*/
public String getName()
{
return DEVICENAME;
}
/** Actual number of available axes. */
public int getNumberOfAxes()
{
// No axes on keyboard.
return 0;
}
/** Actual number of available buttons. */
public int getNumberOfButtons()
{
return mDriver.getNumberOfButtons();
}
/** Actual number of available directional features. */
public int getNumberOfDirectionals()
{
// No directionals on keyboard.
return 0;
}
public void removeButton( Button b )
{
mDriver.unregisterKeyButton( (KeyButton) b );
}
//*********************************************************************************************
//
// Implement JXInputDevice
//
//*********************************************************************************************
public Axis getAxis(int idx)
{
// No axes on keyboard.
return null;
}
public Button getButton(int idx)
{
// idx is interpreted as the keycode
return mDriver.getButton( idx );
}
public Directional getDirectional(int idx)
{
// No directionals on keyboard.
return null;
}
/** Maximum number of axes as an upper bound for index values. */
public int getMaxNumberOfAxes()
{
// No axes on keyboard.
return 0;
}
/** Maximum number of buttons as an upper bound for index values. */
public int getMaxNumberOfButtons()
{
// Return biggest keycode (inclusive).
return mMaxIdxCreated + 1;
}
/** Maximum number of directional features as an upper bound for index values. */
public int getMaxNumberOfDirectionals()
{
// No directionals on keyboard.
return 0;
}
/**
* Devices may have a name.
* This name might be provided by a system dependant driver.
*/
public String getName()
{
return DEVICENAME;
}
/** Actual number of available axes. */
public int getNumberOfAxes()
{
// No axes on keyboard.
return 0;
}
/** Actual number of available buttons. */
public int getNumberOfButtons()
{
return mDriver.getNumberOfButtons();
}
/** Actual number of available directional features. */
public int getNumberOfDirectionals()
{
// No directionals on keyboard.
return 0;
}
}

148
src/main/java/de/hardcode/jxinput/keyboard/KeyButton.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 9. April 2002, 22:51
// Created on 9. April 2002, 22:51
//**********************************************************************************************
package de.hardcode.jxinput.keyboard;
@@ -18,77 +18,77 @@ import java.awt.event.KeyEvent;
* @author Herkules
*/
class KeyButton
implements Button
implements Button
{
private final int mKeyCode;
private boolean mIsPressed;
private boolean mHasChanged;
/**
* Creates a new instance of KeyButton.
*/
public KeyButton( int keycode )
{
mKeyCode = keycode;
}
/**
* Return the keycode assigned with this button.
*/
public final int getKeyCode()
{
return mKeyCode;
}
private final int mKeyCode;
private boolean mIsPressed;
private boolean mHasChanged;
/**
* Creates a new instance of KeyButton.
*/
public KeyButton( int keycode )
{
mKeyCode = keycode;
}
/**
* Return the keycode assigned with this button.
*/
public final int getKeyCode()
{
return mKeyCode;
}
final void setIsPressed( boolean flag )
{
mIsPressed = flag;
}
//*********************************************************************************************
//
// Implement Button
//
//*********************************************************************************************
final void setIsPressed( boolean flag )
{
mIsPressed = flag;
}
//*********************************************************************************************
//
// Implement Button
//
//*********************************************************************************************
/**
* Features may have a name provided e.g. by the driver.
*/
public String getName()
{
return KeyEvent.getKeyText( mKeyCode );
}
/**
* Tells the state of the button at last update.
*/
public boolean getState()
{
return mIsPressed;
}
/**
* Retrieve the type of the button.
* Pushbutton will deliver <code>true==getState()</code> as long as they are pressed down.
* Togglebuttons will change their state once they are pressed and keep that state
* until they are pressed again.
* @return [ PUSHBUTTON | TOGGLEBUTTON ]
*/
public int getType()
{
return Button.PUSHBUTTON;
}
/**
* Features may have a name provided e.g. by the driver.
*/
public String getName()
{
return KeyEvent.getKeyText( mKeyCode );
}
/**
* Tells the state of the button at last update.
*/
public boolean getState()
{
return mIsPressed;
}
/**
* Retrieve the type of the button.
* Pushbutton will deliver <code>true==getState()</code> as long as they are pressed down.
* Togglebuttons will change their state once they are pressed and keep that state
* until they are pressed again.
* @return [ PUSHBUTTON | TOGGLEBUTTON ]
*/
public int getType()
{
return Button.PUSHBUTTON;
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
/**
* Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
}

230
src/main/java/de/hardcode/jxinput/keyboard/KeyboardDriver.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 9. April 2002, 22:43
// Created on 9. April 2002, 22:43
//**********************************************************************************************
package de.hardcode.jxinput.keyboard;
@@ -23,119 +23,119 @@ import java.security.InvalidParameterException;
*/
class KeyboardDriver implements KeyListener
{
// HashMap mKeysToObserveMap = new HashMap();
int mNumberOfKeysObserved = 0;
KeyButton [] mKeysObserved = new KeyButton [ 0x100 ];
/**
* Creates a new instance of KeyboardDriver.
*/
public KeyboardDriver()
{
}
// HashMap mKeysToObserveMap = new HashMap();
int mNumberOfKeysObserved = 0;
KeyButton [] mKeysObserved = new KeyButton [ 0x100 ];
/**
* Creates a new instance of KeyboardDriver.
*/
public KeyboardDriver()
{
}
/**
* How many buttons are registered?
*/
final int getNumberOfButtons()
{
return mNumberOfKeysObserved;
// return mKeysToObserveMap.size();
}
/**
* Place a new button under my observation.
*/
final boolean registerKeyButton( KeyButton b )
{
final int keycode = b.getKeyCode();
/**
* How many buttons are registered?
*/
final int getNumberOfButtons()
{
return mNumberOfKeysObserved;
// return mKeysToObserveMap.size();
}
/**
* Place a new button under my observation.
*/
final boolean registerKeyButton( KeyButton b )
{
final int keycode = b.getKeyCode();
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
if ( null == mKeysObserved[ keycode ] )
{
mKeysObserved[ keycode ] = b;
mNumberOfKeysObserved++;
return true;
}
else
{
return false;
}
// Integer code = new Integer( b.getKeyCode() );
// if ( ! mKeysToObserveMap.containsKey( code ) )
// {
// mKeysToObserveMap.put( code, b );
// return true;
// }
// else
// {
// return false;
// }
}
final void unregisterKeyButton( KeyButton b )
{
final int keycode = b.getKeyCode();
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
if ( null == mKeysObserved[ keycode ] )
{
mKeysObserved[ keycode ] = b;
mNumberOfKeysObserved++;
return true;
}
else
{
return false;
}
// Integer code = new Integer( b.getKeyCode() );
// if ( ! mKeysToObserveMap.containsKey( code ) )
// {
// mKeysToObserveMap.put( code, b );
// return true;
// }
// else
// {
// return false;
// }
}
final void unregisterKeyButton( KeyButton b )
{
final int keycode = b.getKeyCode();
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
if ( null != mKeysObserved[ b.getKeyCode() ] )
{
mKeysObserved[ keycode ] = null;
mNumberOfKeysObserved--;
}
// Integer code = new Integer( b.getKeyCode() );
// mKeysToObserveMap.remove( code );
}
/**
* Retrieve the button from its keycode.
*/
final KeyButton getButton( int keycode )
{
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
if ( null != mKeysObserved[ b.getKeyCode() ] )
{
mKeysObserved[ keycode ] = null;
mNumberOfKeysObserved--;
}
// Integer code = new Integer( b.getKeyCode() );
// mKeysToObserveMap.remove( code );
}
/**
* Retrieve the button from its keycode.
*/
final KeyButton getButton( int keycode )
{
if ( 0 > keycode || 0x100 < keycode )
throw new InvalidKeyCodeException();
return mKeysObserved[ keycode ];
return mKeysObserved[ keycode ];
// Integer code = new Integer( keycode );
// return (KeyButton)mKeysToObserveMap.get( code );
}
//*********************************************************************************************
//
// Implement KeyListener
//
//*********************************************************************************************
public void keyPressed( KeyEvent keyEvent )
{
KeyButton b = getButton( keyEvent.getKeyCode() );
if ( null != b )
b.setIsPressed( true );
}
public void keyReleased( KeyEvent keyEvent )
{
KeyButton b = getButton( keyEvent.getKeyCode() );
if ( null != b )
b.setIsPressed( false );
}
public void keyTyped( KeyEvent keyEvent )
{
// Intentionally empty.
}
// Integer code = new Integer( keycode );
// return (KeyButton)mKeysToObserveMap.get( code );
}
//*********************************************************************************************
//
// Implement KeyListener
//
//*********************************************************************************************
public void keyPressed( KeyEvent keyEvent )
{
KeyButton b = getButton( keyEvent.getKeyCode() );
if ( null != b )
b.setIsPressed( true );
}
public void keyReleased( KeyEvent keyEvent )
{
KeyButton b = getButton( keyEvent.getKeyCode() );
if ( null != b )
b.setIsPressed( false );
}
public void keyTyped( KeyEvent keyEvent )
{
// Intentionally empty.
}
}

42
src/main/java/de/hardcode/jxinput/test/AxisListener.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 20. Februar 2002, 22:19
// Created on 20. Februar 2002, 22:19
//**********************************************************************************************
package de.hardcode.jxinput.test;
@@ -19,21 +19,21 @@ import de.hardcode.jxinput.Axis;
* @author Herkules
*/
public class AxisListener
implements JXInputAxisEventListener
implements JXInputAxisEventListener
{
/**
* Creates a new instance of AxisListener.
*/
public AxisListener( Axis axis )
{
JXInputEventManager.addListener( this, axis, 0.1 );
}
public void changed( JXInputAxisEvent ev )
{
System.out.println( "Axis " + ev.getAxis().getName() + " changed : value=" + ev.getAxis().getValue() + ", event causing delta=" + ev.getDelta() );
}
/**
* Creates a new instance of AxisListener.
*/
public AxisListener( Axis axis )
{
JXInputEventManager.addListener( this, axis, 0.1 );
}
public void changed( JXInputAxisEvent ev )
{
System.out.println( "Axis " + ev.getAxis().getName() + " changed : value=" + ev.getAxis().getValue() + ", event causing delta=" + ev.getDelta() );
}
}

40
src/main/java/de/hardcode/jxinput/test/ButtonListener.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 20. Februar 2002, 22:19
// Created on 20. Februar 2002, 22:19
//**********************************************************************************************
package de.hardcode.jxinput.test;
@@ -20,19 +20,19 @@ import de.hardcode.jxinput.Button;
*/
public class ButtonListener implements JXInputButtonEventListener
{
/**
* Creates a new instance of AxisListener.
*/
public ButtonListener( Button button )
{
JXInputEventManager.addListener( this, button );
}
public void changed( JXInputButtonEvent ev )
{
System.out.println( "Button " + ev.getButton().getName() + " changed : state=" + ev.getButton().getState() );
}
/**
* Creates a new instance of AxisListener.
*/
public ButtonListener( Button button )
{
JXInputEventManager.addListener( this, button );
}
public void changed( JXInputButtonEvent ev )
{
System.out.println( "Button " + ev.getButton().getName() + " changed : state=" + ev.getButton().getState() );
}
}

38
src/main/java/de/hardcode/jxinput/test/DirectionalListener.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 20. Februar 2002, 22:19
// Created on 20. Februar 2002, 22:19
//**********************************************************************************************
package de.hardcode.jxinput.test;
@@ -20,18 +20,18 @@ import de.hardcode.jxinput.Directional;
*/
public class DirectionalListener implements JXInputDirectionalEventListener
{
/**
* Creates a new instance of AxisListener.
*/
public DirectionalListener( Directional directional )
{
JXInputEventManager.addListener( this, directional, 1.0 );
}
public void changed( JXInputDirectionalEvent ev )
{
System.out.println( "Directional " + ev.getDirectional().getName() + " changed : direction=" + ev.getDirectional().getDirection() + ", value=" + ev.getDirectional().getValue() + ", event causing delta=" + ev.getDirectionDelta() );
}
/**
* Creates a new instance of AxisListener.
*/
public DirectionalListener( Directional directional )
{
JXInputEventManager.addListener( this, directional, 1.0 );
}
public void changed( JXInputDirectionalEvent ev )
{
System.out.println( "Directional " + ev.getDirectional().getName() + " changed : direction=" + ev.getDirectional().getDirection() + ", value=" + ev.getDirectional().getValue() + ", event causing delta=" + ev.getDirectionDelta() );
}
}

314
src/main/java/de/hardcode/jxinput/test/JXInputDevicePanel.java
View File

@@ -28,34 +28,34 @@ public class JXInputDevicePanel extends javax.swing.JPanel
{
private static final Font AXIS_SLIDER_FONT = new Font( "Verdana", Font.PLAIN, 9 );
private final JXInputDevice mDev;
private final ArrayList mAxisSliders = new ArrayList();
private final ArrayList mButtonCheckboxes = new ArrayList();
private final ArrayList mDirectionalLabels = new ArrayList();
private final JXInputDevice mDev;
private final ArrayList mAxisSliders = new ArrayList();
private final ArrayList mButtonCheckboxes = new ArrayList();
private final ArrayList mDirectionalLabels = new ArrayList();
/** Creates new form JXInputDevicePanel */
public JXInputDevicePanel( JXInputDevice dev )
{
mDev = dev;
mDev = dev;
initComponents();
initFromDevice();
}
/**
* Helper class connecting a JSlider with an Axis.
*/
private class AxisSlider extends JSlider
{
Axis mAxis;
AxisSlider( Axis axis )
{
super( ( Axis.SLIDER == axis.getType() ? 0 : -100 ), 100 );
/**
* Helper class connecting a JSlider with an Axis.
*/
private class AxisSlider extends JSlider
{
Axis mAxis;
AxisSlider( Axis axis )
{
super( ( Axis.SLIDER == axis.getType() ? 0 : -100 ), 100 );
this.setMajorTickSpacing( Axis.SLIDER == axis.getType() ? 25 : 50 );
this.setMinorTickSpacing( 5 );
this.setPaintTicks( true );
this.setPaintLabels( true );
this.setEnabled( false );
this.setEnabled( false );
Dictionary labeldict = this.getLabelTable();
Enumeration labels = labeldict.elements();
@@ -67,166 +67,166 @@ public class JXInputDevicePanel extends javax.swing.JPanel
label.setHorizontalAlignment( SwingConstants.LEFT );
}
mAxis = axis;
}
void update()
{
int ax = (int)(mAxis.getValue() * 100.0);
mAxis = axis;
}
void update()
{
int ax = (int)(mAxis.getValue() * 100.0);
//
// Only if value really changes
//
if ( ax != this.getValue() )
{
this.setValue( ax );
this.setToolTipText( mAxis.getName() + ": " + Double.toString( mAxis.getValue() ) );
}
}
}
private class ButtonCheckbox extends JCheckBox
{
Button mButton;
ButtonCheckbox( Button button )
{
super( button.getName() );
this.setEnabled( false );
mButton = button;
}
void update()
{
boolean state = mButton.getState();
//
// Only if value really changes
//
if ( state != this.isSelected() )
{
this.setSelected( state );
}
}
}
private class DirectionalLabel extends JLabel
{
Directional mDirectional;
int mCurrent = 0;
DirectionalLabel( Directional directional )
{
super( directional.getName() );
mDirectional = directional;
}
void update()
{
int dir = mDirectional.getDirection();
//
// Only if value really changes
//
if ( dir != mCurrent )
{
this.setText( mDirectional.getName() + ": " + ( mDirectional.isCentered() ? "-" : Integer.toString( dir ) ) );
mCurrent = dir;
}
}
}
//
// Only if value really changes
//
if ( ax != this.getValue() )
{
this.setValue( ax );
this.setToolTipText( mAxis.getName() + ": " + Double.toString( mAxis.getValue() ) );
}
}
}
/**
* Setup the dialogs content from the JXInputDevice.
*/
void initFromDevice()
{
if ( null != mDev )
{
((GridLayout)mAxesPanel.getLayout()).setRows( mDev.getNumberOfAxes() );
for ( int i = 0; i < mDev.getMaxNumberOfAxes(); ++i )
{
if ( null != mDev.getAxis( i ) )
{
AxisSlider slider = new AxisSlider( mDev.getAxis( i ) );
private class ButtonCheckbox extends JCheckBox
{
Button mButton;
ButtonCheckbox( Button button )
{
super( button.getName() );
this.setEnabled( false );
mButton = button;
}
void update()
{
boolean state = mButton.getState();
//
// Only if value really changes
//
if ( state != this.isSelected() )
{
this.setSelected( state );
}
}
}
private class DirectionalLabel extends JLabel
{
Directional mDirectional;
int mCurrent = 0;
DirectionalLabel( Directional directional )
{
super( directional.getName() );
mDirectional = directional;
}
void update()
{
int dir = mDirectional.getDirection();
//
// Only if value really changes
//
if ( dir != mCurrent )
{
this.setText( mDirectional.getName() + ": " + ( mDirectional.isCentered() ? "-" : Integer.toString( dir ) ) );
mCurrent = dir;
}
}
}
/**
* Setup the dialogs content from the JXInputDevice.
*/
void initFromDevice()
{
if ( null != mDev )
{
((GridLayout)mAxesPanel.getLayout()).setRows( mDev.getNumberOfAxes() );
for ( int i = 0; i < mDev.getMaxNumberOfAxes(); ++i )
{
if ( null != mDev.getAxis( i ) )
{
AxisSlider slider = new AxisSlider( mDev.getAxis( i ) );
JLabel name = new JLabel( mDev.getAxis( i ).getName() );
JLabel name = new JLabel( mDev.getAxis( i ).getName() );
name.setVerticalAlignment( SwingConstants.TOP );
name.setHorizontalAlignment( SwingConstants.CENTER );
name.setPreferredSize( new java.awt.Dimension( 90, 0 ) );
name.setPreferredSize( new java.awt.Dimension( 90, 0 ) );
JPanel p = new JPanel();
p.setLayout( new BorderLayout() );
p.add( name, BorderLayout.WEST );
p.add( slider, BorderLayout.CENTER );
p.add( slider, BorderLayout.CENTER );
mAxesPanel.add( p );
// Add to list of all AxisSlider controls
mAxisSliders.add( slider );
// Add an event listener:
new AxisListener( mDev.getAxis( i ) );
}
}
// Add an event listener:
new AxisListener( mDev.getAxis( i ) );
}
}
((GridLayout)mButtonsPanel.getLayout()).setRows( mDev.getNumberOfButtons() );
for ( int i = 0; i < mDev.getMaxNumberOfButtons(); ++i )
{
if ( null != mDev.getButton( i ) )
{
ButtonCheckbox chk = new ButtonCheckbox( mDev.getButton( i ) );
mButtonCheckboxes.add( chk );
mButtonsPanel.add( chk );
((GridLayout)mButtonsPanel.getLayout()).setRows( mDev.getNumberOfButtons() );
for ( int i = 0; i < mDev.getMaxNumberOfButtons(); ++i )
{
if ( null != mDev.getButton( i ) )
{
ButtonCheckbox chk = new ButtonCheckbox( mDev.getButton( i ) );
mButtonCheckboxes.add( chk );
mButtonsPanel.add( chk );
// Add an event listener:
new ButtonListener( mDev.getButton( i ) );
}
}
((GridLayout)mDirectionalPanel.getLayout()).setRows( mDev.getNumberOfDirectionals() / 2 );
for ( int i = 0; i < mDev.getMaxNumberOfDirectionals(); ++i )
{
if ( null != mDev.getDirectional( i ) )
{
DirectionalLabel lbl = new DirectionalLabel( mDev.getDirectional( i ) );
mDirectionalLabels.add( lbl );
mDirectionalPanel.add( lbl );
// Add an event listener:
new ButtonListener( mDev.getButton( i ) );
}
}
((GridLayout)mDirectionalPanel.getLayout()).setRows( mDev.getNumberOfDirectionals() / 2 );
for ( int i = 0; i < mDev.getMaxNumberOfDirectionals(); ++i )
{
if ( null != mDev.getDirectional( i ) )
{
DirectionalLabel lbl = new DirectionalLabel( mDev.getDirectional( i ) );
mDirectionalLabels.add( lbl );
mDirectionalPanel.add( lbl );
// Add an event listener:
new DirectionalListener( mDev.getDirectional( i ) );
}
}
}
}
// Add an event listener:
new DirectionalListener( mDev.getDirectional( i ) );
}
}
}
}
public void update()
{
public void update()
{
Iterator it = mAxisSliders.iterator();
while ( it.hasNext() )
{
((AxisSlider)it.next()).update();
}
while ( it.hasNext() )
{
((AxisSlider)it.next()).update();
}
it = mButtonCheckboxes.iterator();
while ( it.hasNext() )
{
((ButtonCheckbox)it.next()).update();
}
it = mButtonCheckboxes.iterator();
while ( it.hasNext() )
{
((ButtonCheckbox)it.next()).update();
}
it = mDirectionalLabels.iterator();
while ( it.hasNext() )
{
((DirectionalLabel)it.next()).update();
}
}
it = mDirectionalLabels.iterator();
while ( it.hasNext() )
{
((DirectionalLabel)it.next()).update();
}
}
/** This method is called from within the constructor to
@@ -276,12 +276,12 @@ public class JXInputDevicePanel extends javax.swing.JPanel
}// </editor-fold>//GEN-END:initComponents
private void OnShow(java.awt.event.ComponentEvent evt)//GEN-FIRST:event_OnShow
{//GEN-HEADEREND:event_OnShow
// Commented: the focus is held by a parent component
// System.out.println("OnShow");
// this.requestFocus();
}//GEN-LAST:event_OnShow
private void OnShow(java.awt.event.ComponentEvent evt)//GEN-FIRST:event_OnShow
{//GEN-HEADEREND:event_OnShow
// Commented: the focus is held by a parent component
// System.out.println("OnShow");
// this.requestFocus();
}//GEN-LAST:event_OnShow

348
src/main/java/de/hardcode/jxinput/test/JXInputTestDialog.java
View File

@@ -22,143 +22,143 @@ import java.awt.event.KeyEvent;
* @author Herkules
*/
public class JXInputTestDialog extends javax.swing.JDialog
implements ActionListener
implements ActionListener
{
private JXKeyboardInputDevice mKeyboardDevice = null;
private JXVirtualInputDevice mVirtualDevice = null;
Button mButtonUp;
Button mButtonDown;
Button mButtonLeft;
Button mButtonRight;
Button mButtonFire;
Button mButtonSpace;
/** Creates new form JXInputTestDialog */
public JXInputTestDialog(java.awt.Frame parent, boolean modal)
{
super(parent, modal);
initComponents();
configureKeyboardInputDevice();
configureVirtualInputDevice();
initDevicePanels();
pack();
// Request the focus so that the keyboarddevice can work
mMainPanel.requestFocus();
private JXKeyboardInputDevice mKeyboardDevice = null;
private JXVirtualInputDevice mVirtualDevice = null;
Button mButtonUp;
Button mButtonDown;
Button mButtonLeft;
Button mButtonRight;
Button mButtonFire;
Button mButtonSpace;
/** Creates new form JXInputTestDialog */
public JXInputTestDialog(java.awt.Frame parent, boolean modal)
{
super(parent, modal);
initComponents();
configureKeyboardInputDevice();
configureVirtualInputDevice();
initDevicePanels();
pack();
// Request the focus so that the keyboarddevice can work
mMainPanel.requestFocus();
new Timer( 50, this ).start();
// Uncomment this line as an alternative to the Timer above.
// Don't use both!!
//JXInputEventManager.setTriggerIntervall( 50 );
}
new Timer( 50, this ).start();
// Uncomment this line as an alternative to the Timer above.
// Don't use both!!
//JXInputEventManager.setTriggerIntervall( 50 );
}
/**
* Implement ActionListener#actionPerformed().
* This is called by the Timer.
* This is called by the Timer.
*/
public void actionPerformed( ActionEvent e )
{
public void actionPerformed( ActionEvent e )
{
JXInputManager.updateFeatures();
SwingUtilities.invokeLater(
new Runnable()
{
public void run()
{
for ( int i = 0; i < mDevicesTabbedPane.getComponentCount(); ++i )
{
((JXInputDevicePanel)mDevicesTabbedPane.getComponent( i )).update();
}
}
}
);
}
SwingUtilities.invokeLater(
new Runnable()
{
public void run()
{
for ( int i = 0; i < mDevicesTabbedPane.getComponentCount(); ++i )
{
((JXInputDevicePanel)mDevicesTabbedPane.getComponent( i )).update();
}
}
}
);
}
/**
* Configure a test JXKeyboardInputdevice.
*/
void configureKeyboardInputDevice()
{
mKeyboardDevice = JXInputManager.createKeyboardDevice();
mKeyboardDevice.createButton( KeyEvent.VK_ESCAPE );
mKeyboardDevice.createButton( KeyEvent.VK_F1 );
mKeyboardDevice.createButton( KeyEvent.VK_F2 );
mKeyboardDevice.createButton( KeyEvent.VK_F3 );
mKeyboardDevice.createButton( KeyEvent.VK_F4 );
mKeyboardDevice.createButton( KeyEvent.VK_LEFT );
mKeyboardDevice.createButton( KeyEvent.VK_RIGHT );
mKeyboardDevice.createButton( KeyEvent.VK_UP );
mKeyboardDevice.createButton( KeyEvent.VK_DOWN );
mKeyboardDevice.createButton( KeyEvent.VK_PAGE_UP );
mKeyboardDevice.createButton( KeyEvent.VK_PAGE_DOWN );
mButtonSpace = mKeyboardDevice.createButton( KeyEvent.VK_SPACE );
mButtonLeft = mKeyboardDevice.createButton( KeyEvent.VK_A );
mButtonRight = mKeyboardDevice.createButton( KeyEvent.VK_D );
mButtonDown = mKeyboardDevice.createButton( KeyEvent.VK_S );
mButtonUp = mKeyboardDevice.createButton( KeyEvent.VK_W );
// Configure it to make it listen to the main panel.
// I try to keep the kbd focus on it.
mKeyboardDevice.listenTo( mMainPanel );
}
/**
* Configure a test JXVirtualInputdevice.
*/
void configureVirtualInputDevice()
{
mVirtualDevice = JXInputManager.createVirtualDevice();
Button firebutton;
//
// Remember 'fire' button of first device for use
// in the virtual device.
// For we ran configureKeyboardInputDevice() before,
// getJXInputDevice( 0 ) should not return null
//
firebutton = JXInputManager.getJXInputDevice( 0 ).getButton( 0 );
VirtualAxis x = mVirtualDevice.createAxis( Axis.ID_X );
x.setButtons( mButtonRight, mButtonLeft );
x.setName( "x: A-D" );
VirtualAxis y = mVirtualDevice.createAxis( Axis.ID_Y );
y.setButtons( mButtonUp, mButtonDown );
y.setSpringSpeed( 0.0 );
y.setName( "y: S|W" );
VirtualAxis slider = mVirtualDevice.createAxis( Axis.ID_SLIDER0 );
slider.setIncreaseButton( mButtonSpace );
slider.setTimeFor0To1( 2000 );
slider.setName( "<space>" );
slider.setType( Axis.SLIDER );
/**
* Configure a test JXKeyboardInputdevice.
*/
void configureKeyboardInputDevice()
{
mKeyboardDevice = JXInputManager.createKeyboardDevice();
if ( null != firebutton )
{
slider = mVirtualDevice.createAxis( Axis.ID_SLIDER1 );
slider.setIncreaseButton( firebutton );
slider.setTimeFor0To1( 2000 );
slider.setName( "JoyButton 0" );
}
mKeyboardDevice.createButton( KeyEvent.VK_ESCAPE );
}
/**
* Initialize one panel for each device available.
*/
void initDevicePanels()
mKeyboardDevice.createButton( KeyEvent.VK_F1 );
mKeyboardDevice.createButton( KeyEvent.VK_F2 );
mKeyboardDevice.createButton( KeyEvent.VK_F3 );
mKeyboardDevice.createButton( KeyEvent.VK_F4 );
mKeyboardDevice.createButton( KeyEvent.VK_LEFT );
mKeyboardDevice.createButton( KeyEvent.VK_RIGHT );
mKeyboardDevice.createButton( KeyEvent.VK_UP );
mKeyboardDevice.createButton( KeyEvent.VK_DOWN );
mKeyboardDevice.createButton( KeyEvent.VK_PAGE_UP );
mKeyboardDevice.createButton( KeyEvent.VK_PAGE_DOWN );
mButtonSpace = mKeyboardDevice.createButton( KeyEvent.VK_SPACE );
mButtonLeft = mKeyboardDevice.createButton( KeyEvent.VK_A );
mButtonRight = mKeyboardDevice.createButton( KeyEvent.VK_D );
mButtonDown = mKeyboardDevice.createButton( KeyEvent.VK_S );
mButtonUp = mKeyboardDevice.createButton( KeyEvent.VK_W );
// Configure it to make it listen to the main panel.
// I try to keep the kbd focus on it.
mKeyboardDevice.listenTo( mMainPanel );
}
/**
* Configure a test JXVirtualInputdevice.
*/
void configureVirtualInputDevice()
{
mVirtualDevice = JXInputManager.createVirtualDevice();
Button firebutton;
//
// Remember 'fire' button of first device for use
// in the virtual device.
// For we ran configureKeyboardInputDevice() before,
// getJXInputDevice( 0 ) should not return null
//
firebutton = JXInputManager.getJXInputDevice( 0 ).getButton( 0 );
VirtualAxis x = mVirtualDevice.createAxis( Axis.ID_X );
x.setButtons( mButtonRight, mButtonLeft );
x.setName( "x: A-D" );
VirtualAxis y = mVirtualDevice.createAxis( Axis.ID_Y );
y.setButtons( mButtonUp, mButtonDown );
y.setSpringSpeed( 0.0 );
y.setName( "y: S|W" );
VirtualAxis slider = mVirtualDevice.createAxis( Axis.ID_SLIDER0 );
slider.setIncreaseButton( mButtonSpace );
slider.setTimeFor0To1( 2000 );
slider.setName( "<space>" );
slider.setType( Axis.SLIDER );
if ( null != firebutton )
{
slider = mVirtualDevice.createAxis( Axis.ID_SLIDER1 );
slider.setIncreaseButton( firebutton );
slider.setTimeFor0To1( 2000 );
slider.setName( "JoyButton 0" );
}
}
/**
* Initialize one panel for each device available.
*/
void initDevicePanels()
{
int cnt = JXInputManager.getNumberOfDevices();
@@ -167,25 +167,25 @@ public class JXInputTestDialog extends javax.swing.JDialog
for ( int i = 0; i < cnt; ++i )
{
JXInputDevice dev = JXInputManager.getJXInputDevice( i );
if ( null != dev )
{
//
// Setup an own panel for each device.
//
JPanel panel = new JXInputDevicePanel( dev );
mDevicesTabbedPane.addTab( dev.getName(), panel );
}
}
JXInputDevice dev = JXInputManager.getJXInputDevice( i );
if ( null != dev )
{
//
// Setup an own panel for each device.
//
JPanel panel = new JXInputDevicePanel( dev );
mDevicesTabbedPane.addTab( dev.getName(), panel );
}
}
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents()
{
@@ -243,44 +243,44 @@ public class JXInputTestDialog extends javax.swing.JDialog
this.mDevicesTabbedPane.removeTabAt( 0 );
JXInputManager.reset();
configureKeyboardInputDevice();
configureVirtualInputDevice();
initDevicePanels();
pack();
// Request the focus so that the keyboarddevice can work
mMainPanel.requestFocus();
configureKeyboardInputDevice();
configureVirtualInputDevice();
initDevicePanels();
pack();
// Request the focus so that the keyboarddevice can work
mMainPanel.requestFocus();
}//GEN-LAST:event_mButtonResetActionPerformed
private void mDevicesTabbedPaneFocusGained(java.awt.event.FocusEvent evt)//GEN-FIRST:event_mDevicesTabbedPaneFocusGained
{//GEN-HEADEREND:event_mDevicesTabbedPaneFocusGained
// Switch focus back to main panel!
this.mMainPanel.requestFocus();
}//GEN-LAST:event_mDevicesTabbedPaneFocusGained
/** Closes the dialog */
private void mDevicesTabbedPaneFocusGained(java.awt.event.FocusEvent evt)//GEN-FIRST:event_mDevicesTabbedPaneFocusGained
{//GEN-HEADEREND:event_mDevicesTabbedPaneFocusGained
// Switch focus back to main panel!
this.mMainPanel.requestFocus();
}//GEN-LAST:event_mDevicesTabbedPaneFocusGained
/** Closes the dialog */
private void closeDialog(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_closeDialog
setVisible(false);
dispose();
System.exit( 0 );
setVisible(false);
dispose();
System.exit( 0 );
}//GEN-LAST:event_closeDialog
/**
* Allow the dialog to run standalone.
* @param args the command line arguments
*/
public static void main(String args[])
{
new JXInputTestDialog(new javax.swing.JFrame(), true).setVisible(true);
}
/**
* Allow the dialog to run standalone.
* @param args the command line arguments
*/
public static void main(String args[])
{
new JXInputTestDialog(new javax.swing.JFrame(), true).setVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton mButtonReset;
private javax.swing.JTabbedPane mDevicesTabbedPane;
private javax.swing.JLabel mLabelNoDevice;
private javax.swing.JPanel mMainPanel;
// End of variables declaration//GEN-END:variables
}

128
src/main/java/de/hardcode/jxinput/util/LatestChangedValueAxis.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 17. April 2002, 23:24
// Created on 17. April 2002, 23:24
//**********************************************************************************************
package de.hardcode.jxinput.util;
@@ -16,62 +16,62 @@ import de.hardcode.jxinput.Axis;
*/
public class LatestChangedValueAxis implements Axis
{
private final Axis mAxis1;
private final Axis mAxis2;
private Axis mAxisInUse;
private final Axis mAxis1;
private final Axis mAxis2;
private Axis mAxisInUse;
private double mSaved1;
private double mSaved2;
/**
* Creates a new instance of MeanValueAxis.
*/
public LatestChangedValueAxis(Axis a1, Axis a2)
{
mAxis1 = a1;
mAxis2 = a2;
/**
* Creates a new instance of MeanValueAxis.
*/
public LatestChangedValueAxis(Axis a1, Axis a2)
{
mAxis1 = a1;
mAxis2 = a2;
mAxisInUse = a1;
mSaved1 = a1.getValue();
mSaved2 = a2.getValue();
}
/**
* Features may have a name provided e.g. by the driver.
*/
public String getName()
{
return mAxis1.getName();
}
/** Inform about the resolution of the axis.
*
* @return resolution, e.g. 2^-16
*/
public double getResolution()
{
return mAxis1.getResolution();
}
/**
* Retrieve the type of the axis.
*
* @return [ TRANSLATION | ROTATION | SLIDER ]
*/
public int getType()
{
return mAxis1.getType();
}
/** Returns the current value of the axis.
* The range of the result depends on the axis type.
*s
* @return value [-1.0,1.0] or [0.0,1.0]
*/
public double getValue()
{
double v1 = mAxis1.getValue();
double v2 = mAxis2.getValue();
}
/**
* Features may have a name provided e.g. by the driver.
*/
public String getName()
{
return mAxis1.getName();
}
/** Inform about the resolution of the axis.
*
* @return resolution, e.g. 2^-16
*/
public double getResolution()
{
return mAxis1.getResolution();
}
/**
* Retrieve the type of the axis.
*
* @return [ TRANSLATION | ROTATION | SLIDER ]
*/
public int getType()
{
return mAxis1.getType();
}
/** Returns the current value of the axis.
* The range of the result depends on the axis type.
*s
* @return value [-1.0,1.0] or [0.0,1.0]
*/
public double getValue()
{
double v1 = mAxis1.getValue();
double v2 = mAxis2.getValue();
if ( Math.abs( v2 - mSaved2 ) > 0.2 )
{
@@ -85,14 +85,14 @@ public class LatestChangedValueAxis implements Axis
}
return mAxisInUse.getValue();
}
/** Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
}
/** Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
}

8
src/main/java/de/hardcode/jxinput/util/OrButton.java
View File

@@ -1,8 +1,8 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 23. Dezember 2002, 19:21
//**********************************************************************************************

240
src/main/java/de/hardcode/jxinput/virtual/JXVirtualInputDevice.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 9. April 2002, 22:40
// Created on 9. April 2002, 22:40
//**********************************************************************************************
package de.hardcode.jxinput.virtual;
@@ -19,122 +19,122 @@ import de.hardcode.jxinput.*;
*/
public class JXVirtualInputDevice implements JXInputDevice
{
private static final String DEVICENAME = "Virtual Device";
private static final String DEVICENAME = "Virtual Device";
/** The driver doing all the real work. */
private final VirtualDriver mDriver = new VirtualDriver();
/**
* Creates a new instance of JXKeyboardInputDevice.
*/
public JXVirtualInputDevice()
{
}
/** The driver doing all the real work. */
private final VirtualDriver mDriver = new VirtualDriver();
/**
* Creates a new instance of JXKeyboardInputDevice.
*/
public JXVirtualInputDevice()
{
}
/**
* The virtual input device needs to be updated regularly.
*/
public final void update( long deltaT )
{
//
// Delegate the update call to the driver.
//
mDriver.update( deltaT );
}
/**
* Create a virtual axis object with a certain ID, e.g. Axis.ID_X.
*/
public VirtualAxis createAxis( int id )
{
VirtualAxis a;
a = new VirtualAxis( id );
mDriver.registerVirtualAxis( id, a );
return a;
}
/**
* The virtual input device needs to be updated regularly.
*/
public final void update( long deltaT )
{
//
// Delegate the update call to the driver.
//
mDriver.update( deltaT );
}
/**
* Create a virtual axis object with a certain ID, e.g. Axis.ID_X.
*/
public VirtualAxis createAxis( int id )
{
VirtualAxis a;
a = new VirtualAxis( id );
mDriver.registerVirtualAxis( id, a );
return a;
}
public void removeAxis( VirtualAxis a )
{
mDriver.unregisterVirtualAxis( a );
}
//*********************************************************************************************
//
// Implement JXInputDevice
//
//*********************************************************************************************
public Axis getAxis(int idx)
{
return mDriver.getAxis( idx );
}
public Button getButton(int idx)
{
// No virtual buttons.
return null;
}
public Directional getDirectional(int idx)
{
// No virtual directionals.
return null;
}
/** Maximum number of axes as an upper bound for index values. */
public int getMaxNumberOfAxes()
{
return Axis.NUMBER_OF_ID;
}
/** Maximum number of buttons as an upper bound for index values. */
public int getMaxNumberOfButtons()
{
// No virtual buttons.
return 0;
}
/** Maximum number of directional features as an upper bound for index values. */
public int getMaxNumberOfDirectionals()
{
// No virtual directionals.
return 0;
}
/**
* Devices may have a name.
* This name might be provided by a system dependant driver.
*/
public String getName()
{
return DEVICENAME;
}
/** Actual number of available axes. */
public int getNumberOfAxes()
{
// No axes on keyboard.
return mDriver.getNumberOfAxes();
}
/** Actual number of available buttons. */
public int getNumberOfButtons()
{
return 0;
}
/** Actual number of available directional features. */
public int getNumberOfDirectionals()
{
// No directionals on keyboard.
return 0;
}
public void removeAxis( VirtualAxis a )
{
mDriver.unregisterVirtualAxis( a );
}
//*********************************************************************************************
//
// Implement JXInputDevice
//
//*********************************************************************************************
public Axis getAxis(int idx)
{
return mDriver.getAxis( idx );
}
public Button getButton(int idx)
{
// No virtual buttons.
return null;
}
public Directional getDirectional(int idx)
{
// No virtual directionals.
return null;
}
/** Maximum number of axes as an upper bound for index values. */
public int getMaxNumberOfAxes()
{
return Axis.NUMBER_OF_ID;
}
/** Maximum number of buttons as an upper bound for index values. */
public int getMaxNumberOfButtons()
{
// No virtual buttons.
return 0;
}
/** Maximum number of directional features as an upper bound for index values. */
public int getMaxNumberOfDirectionals()
{
// No virtual directionals.
return 0;
}
/**
* Devices may have a name.
* This name might be provided by a system dependant driver.
*/
public String getName()
{
return DEVICENAME;
}
/** Actual number of available axes. */
public int getNumberOfAxes()
{
// No axes on keyboard.
return mDriver.getNumberOfAxes();
}
/** Actual number of available buttons. */
public int getNumberOfButtons()
{
return 0;
}
/** Actual number of available directional features. */
public int getNumberOfDirectionals()
{
// No directionals on keyboard.
return 0;
}
}

330
src/main/java/de/hardcode/jxinput/virtual/VirtualAxis.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 11. April 2002, 23:40
// Created on 11. April 2002, 23:40
//**********************************************************************************************
package de.hardcode.jxinput.virtual;
@@ -17,191 +17,191 @@ import java.security.InvalidParameterException;
* @author J<>rg Plewe
*/
public class VirtualAxis
implements Axis
implements Axis
{
private int mType = Axis.TRANSLATION;
private final int mID;
private String mName = "VirtualAxis";
private double mCurrentValue = 0;
private Button mButtonIncrease = null;
private Button mButtonDecrease = null;
private double mSpeed = 1.0 / 500.0;
private double mSpringSpeed = 1.0 / 500.0;
/**
* Creates a new instance of VirtualAxis.
*/
public VirtualAxis( int id )
{
mID = id;
}
private int mType = Axis.TRANSLATION;
private final int mID;
private String mName = "VirtualAxis";
private double mCurrentValue = 0;
private Button mButtonIncrease = null;
private Button mButtonDecrease = null;
private double mSpeed = 1.0 / 500.0;
private double mSpringSpeed = 1.0 / 500.0;
/**
* Creates a new instance of VirtualAxis.
*/
public VirtualAxis( int id )
{
mID = id;
}
/**
* Set the type of this axis to be either <code>Axis.ROTATION</code>,
* <code>Axis.TRANSLATION</code> or <code>Axis.SLIDER</code>.
*/
public void setType( int type )
{
if ( Axis.ROTATION != type
if ( Axis.ROTATION != type
&& Axis.TRANSLATION != type
&& Axis.SLIDER != type
)
throw new InvalidParameterException( "Invalid type for axis!" );
throw new InvalidParameterException( "Invalid type for axis!" );
mType = type;
}
/**
* Update features under my control.
*/
final void update( long deltaT )
{
double change = mSpeed * deltaT;
double springchange = mSpringSpeed * deltaT;
boolean doincrease = ( null != mButtonIncrease && mButtonIncrease.getState() );
boolean dodecrease = ( null != mButtonDecrease && mButtonDecrease.getState() );
boolean iscontrolled = doincrease || dodecrease;
/**
* Update features under my control.
*/
final void update( long deltaT )
{
double change = mSpeed * deltaT;
double springchange = mSpringSpeed * deltaT;
boolean doincrease = ( null != mButtonIncrease && mButtonIncrease.getState() );
boolean dodecrease = ( null != mButtonDecrease && mButtonDecrease.getState() );
boolean iscontrolled = doincrease || dodecrease;
double controlledchange = 0.0;
if ( doincrease )
controlledchange += change;
if ( dodecrease )
controlledchange -= change;
mCurrentValue += controlledchange;
if ( mCurrentValue > 0.0 && ! doincrease )
{
springchange = Math.min( mCurrentValue, springchange );
mCurrentValue -= springchange;
}
if ( mCurrentValue < 0.0 && ! dodecrease )
{
springchange = Math.min( -mCurrentValue, springchange );
mCurrentValue += springchange;
}
//
// Hold value within range
//
if ( mCurrentValue > 1.0 )
mCurrentValue = 1.0;
double lowerlimit = Axis.SLIDER == mType ? 0.0 : -1.0;
if ( mCurrentValue < lowerlimit )
mCurrentValue = lowerlimit;
}
double controlledchange = 0.0;
if ( doincrease )
controlledchange += change;
if ( dodecrease )
controlledchange -= change;
mCurrentValue += controlledchange;
if ( mCurrentValue > 0.0 && ! doincrease )
{
springchange = Math.min( mCurrentValue, springchange );
mCurrentValue -= springchange;
}
if ( mCurrentValue < 0.0 && ! dodecrease )
{
springchange = Math.min( -mCurrentValue, springchange );
mCurrentValue += springchange;
}
//
// Hold value within range
//
if ( mCurrentValue > 1.0 )
mCurrentValue = 1.0;
double lowerlimit = Axis.SLIDER == mType ? 0.0 : -1.0;
if ( mCurrentValue < lowerlimit )
mCurrentValue = lowerlimit;
}
/**
* Set the button to increase the axis for a single button axis.
*/
public final void setIncreaseButton( Button b )
{
if ( null == b )
throw new InvalidParameterException( "Button may not be null!" );
mButtonIncrease = b;
}
public final void setIncreaseButton( Button b )
{
if ( null == b )
throw new InvalidParameterException( "Button may not be null!" );
mButtonIncrease = b;
}
/**
* Set the buttons to increase and descrease the axis.
*/
public final void setButtons( Button increase, Button decrease )
{
if ( null == increase || null == decrease )
throw new InvalidParameterException( "Buttons may not be null!" );
mButtonIncrease = increase;
mButtonDecrease = decrease;
}
public final void setButtons( Button increase, Button decrease )
{
if ( null == increase || null == decrease )
throw new InvalidParameterException( "Buttons may not be null!" );
mButtonIncrease = increase;
mButtonDecrease = decrease;
}
public final void setSpeed( double speed )
{
mSpeed = speed;
}
public final void setSpeed( double speed )
{
mSpeed = speed;
}
public final void setSpringSpeed( double springspeed )
{
mSpringSpeed = springspeed;
}
public final void setSpringSpeed( double springspeed )
{
mSpringSpeed = springspeed;
}
public final void setTimeFor0To1( int ms )
{
if ( 0 >= ms )
mSpeed = 0.0;
else
mSpeed = 1.0/ ms;
}
public final void setTimeFor1To0( int ms )
{
if ( 0 >= ms )
mSpringSpeed = 0.0;
else
mSpringSpeed = 1.0/ ms;
}
public final void setName( String name )
{
mName = name;
}
//*********************************************************************************************
//
// Implement Axis
//
//*********************************************************************************************
/**
* Features may have a name provided e.g. by the driver.
*/
public String getName()
{
return mName;
}
/**
* Inform about the resolution of the axis.
*
* @return resolution, e.g. 2^-16
*/
public double getResolution()
{
return 1.0/65536.0;
}
/**
* Retrieve the type of the axis.
* @return [ TRANSLATION | ROTATION | SLIDER ]
*/
public int getType()
{
return mType;
}
/** Returns the current value of the axis.
* The range of the result depends on the axis type.
*
* @return value [-1.0,1.0] or [0.0,1.0]
*/
public double getValue()
{
return mCurrentValue;
}
/** Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
public final void setTimeFor0To1( int ms )
{
if ( 0 >= ms )
mSpeed = 0.0;
else
mSpeed = 1.0/ ms;
}
public final void setTimeFor1To0( int ms )
{
if ( 0 >= ms )
mSpringSpeed = 0.0;
else
mSpringSpeed = 1.0/ ms;
}
public final void setName( String name )
{
mName = name;
}
//*********************************************************************************************
//
// Implement Axis
//
//*********************************************************************************************
/**
* Features may have a name provided e.g. by the driver.
*/
public String getName()
{
return mName;
}
/**
* Inform about the resolution of the axis.
*
* @return resolution, e.g. 2^-16
*/
public double getResolution()
{
return 1.0/65536.0;
}
/**
* Retrieve the type of the axis.
* @return [ TRANSLATION | ROTATION | SLIDER ]
*/
public int getType()
{
return mType;
}
/** Returns the current value of the axis.
* The range of the result depends on the axis type.
*
* @return value [-1.0,1.0] or [0.0,1.0]
*/
public double getValue()
{
return mCurrentValue;
}
/** Denote wether this feature has changed beyond it's resolution since it got last
* updated.
*/
public boolean hasChanged()
{
return true;
}
}

150
src/main/java/de/hardcode/jxinput/virtual/VirtualDriver.java
View File

@@ -1,10 +1,10 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 9. April 2002, 22:43
// Created on 9. April 2002, 22:43
//**********************************************************************************************
package de.hardcode.jxinput.virtual;
@@ -19,77 +19,77 @@ import de.hardcode.jxinput.Axis;
* @author Herkules
*/
class VirtualDriver
{
{
private final VirtualAxis[] mVAxes = new VirtualAxis[ Axis.NUMBER_OF_ID ];
/**
* Creates a new instance of KeyboardDriver.
*/
VirtualDriver()
{
}
private final VirtualAxis[] mVAxes = new VirtualAxis[ Axis.NUMBER_OF_ID ];
/**
* Creates a new instance of KeyboardDriver.
*/
VirtualDriver()
{
}
/**
* Update features under my control.
*/
final void update( long deltaT )
{
//
// Delegate the update call to the axes in use.
//
for ( int i = 0; i < mVAxes.length; i++ )
{
if ( null != mVAxes[ i ] )
mVAxes[ i ].update( deltaT );
}
}
/**
* Update features under my control.
*/
final void update( long deltaT )
{
//
// Delegate the update call to the axes in use.
//
for ( int i = 0; i < mVAxes.length; i++ )
{
if ( null != mVAxes[ i ] )
mVAxes[ i ].update( deltaT );
}
}
/**
* How many axes are registered?
*/
final int getNumberOfAxes()
{
int ctr = 0;
for ( int i = 0; i < mVAxes.length; i++ )
{
if ( null != mVAxes[ i ] )
ctr++;
}
return ctr;
}
Axis getAxis(int idx)
{
return mVAxes[ idx ];
}
/**
* Place a new axis under my observation.
*/
final void registerVirtualAxis( int id, VirtualAxis a )
{
mVAxes[ id ] = a;
}
/**
* Remove an axis from my control.
*/
final void unregisterVirtualAxis( VirtualAxis a )
{
for ( int i = 0; i < mVAxes.length; ++i )
{
if ( mVAxes[ i ] == a )
{
mVAxes[ i ] = null;
break;
}
}
}
/**
* How many axes are registered?
*/
final int getNumberOfAxes()
{
int ctr = 0;
for ( int i = 0; i < mVAxes.length; i++ )
{
if ( null != mVAxes[ i ] )
ctr++;
}
return ctr;
}
Axis getAxis(int idx)
{
return mVAxes[ idx ];
}
/**
* Place a new axis under my observation.
*/
final void registerVirtualAxis( int id, VirtualAxis a )
{
mVAxes[ id ] = a;
}
/**
* Remove an axis from my control.
*/
final void unregisterVirtualAxis( VirtualAxis a )
{
for ( int i = 0; i < mVAxes.length; ++i )
{
if ( mVAxes[ i ] == a )
{
mVAxes[ i ] = null;
break;
}
}
}
}