mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2036 lines
52 KiB
2036 lines
52 KiB
//****************************************************************************
|
|
//
|
|
// File: joycpl.c
|
|
// Content: Joystick configuration and testing
|
|
// History:
|
|
// Date By Reason
|
|
// ==== == ======
|
|
// 03-oct-94 craige initial implementation
|
|
// 05-nov-94 craige generalized 4 axis joysticks and other improvements
|
|
// 11-nov-94 craige allow multiple copies of tab to run
|
|
// 22-nov-94 craige tweaks to calibration code
|
|
// 29-nov-94 craige small bugs
|
|
// 08-dec-94 craige generalized second joystick
|
|
// 11-dec-94 craige split into component parts
|
|
// 15-dec-94 craige allow N joysticks
|
|
// 18-dec-94 craige process UV
|
|
// 05-jan-95 craige external rudder bug
|
|
// 05-mar-95 craige Bug 9998: pass id -1 to get base dev caps
|
|
// Bug 15334: allow reset of user values for compatiblity
|
|
// 06-mar-95 craige Bug 7608: deleting VxD name if joystick not present
|
|
// caused unplugged joystick to never come back
|
|
// 06-may-96 richj ported to NT
|
|
//
|
|
// Copyright (c) Microsoft Corporation 1994
|
|
//
|
|
//****************************************************************************
|
|
|
|
|
|
#include "joycpl.h"
|
|
|
|
extern HINSTANCE hInstance; // main.c
|
|
|
|
#define cchLENGTH(_sz) (sizeof(_sz)/sizeof(_sz[0]))
|
|
#define GetString(_sz,_ids) LoadString (hInstance, _ids, _sz, cchLENGTH(_sz))
|
|
|
|
|
|
#ifdef DEBUG
|
|
void cdecl MBOX(LPSTR szFormat, ...)
|
|
{
|
|
char ach[256];
|
|
|
|
wvsprintf( ach,szFormat,(LPSTR)(&szFormat+1));
|
|
MessageBox( NULL, ach, "JOYCPL", MB_OK | MB_SYSTEMMODAL );
|
|
|
|
}
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
|
|
|
|
MEMORY MANAGEMENT ROUTINES FOLLOW
|
|
|
|
|
|
***************************************************************************/
|
|
|
|
#ifdef DEBUG
|
|
DWORD allocCount;
|
|
#endif
|
|
|
|
/*
|
|
* DoAlloc - allocate memory
|
|
*/
|
|
LPVOID DoAlloc( DWORD size )
|
|
{
|
|
LPVOID res;
|
|
|
|
res = LocalAlloc( LPTR, size );
|
|
#ifdef DEBUG
|
|
allocCount++;
|
|
#endif
|
|
return res;
|
|
|
|
} /* DoAlloc */
|
|
|
|
/*
|
|
* DoFree - free allocated memory
|
|
*/
|
|
void DoFree( LPVOID ptr )
|
|
{
|
|
if( ptr != NULL ) {
|
|
LocalFree( ptr );
|
|
#ifdef DEBUG
|
|
allocCount--;
|
|
if( allocCount < 0 ) {
|
|
DPF( "JOYCPL: Too many frees, allocCount=%d\r\n", allocCount );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
} /* DoFree */
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
|
|
REGISTRY RELATED ROUTINES FOLLOW
|
|
|
|
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* getDevCaps - get the joystick device caps
|
|
*/
|
|
static void getDevCaps( LPGLOBALVARS pgv )
|
|
{
|
|
JOYCAPS jc;
|
|
|
|
if( joyGetDevCaps( pgv->iJoyId, &jc, sizeof( jc ) ) == JOYERR_NOERROR ) {
|
|
pgv->joyRange.jpMin.dwX = jc.wXmin;
|
|
pgv->joyRange.jpMax.dwX = jc.wXmax;
|
|
pgv->joyRange.jpMin.dwY = jc.wYmin;
|
|
pgv->joyRange.jpMax.dwY = jc.wYmax;
|
|
pgv->joyRange.jpMin.dwZ = jc.wZmin;
|
|
pgv->joyRange.jpMax.dwZ = jc.wZmax;
|
|
pgv->joyRange.jpMin.dwR = jc.wRmin;
|
|
pgv->joyRange.jpMax.dwR = jc.wRmax;
|
|
pgv->joyRange.jpMin.dwU = jc.wUmin;
|
|
pgv->joyRange.jpMax.dwU = jc.wUmax;
|
|
pgv->joyRange.jpMin.dwV = jc.wVmin;
|
|
pgv->joyRange.jpMax.dwV = jc.wVmax;
|
|
pgv->dwMaxAxes = (DWORD) jc.wMaxAxes;
|
|
}
|
|
|
|
} /* getDevCaps */
|
|
|
|
extern MMRESULT WINAPI joyConfigChanged( DWORD dwFlags );
|
|
|
|
/*
|
|
* RegistryUpdated - notify the driver that the registry is updated
|
|
*/
|
|
void RegistryUpdated( LPGLOBALVARS pgv )
|
|
{
|
|
joyConfigChanged( 0 );
|
|
if( pgv != NULL ) {
|
|
getDevCaps( pgv ); // devcaps could change
|
|
}
|
|
|
|
} /* RegistryUpdated */
|
|
|
|
/*
|
|
* createSettingsKeyFromCurr - create a settings key for a specific joystick
|
|
*/
|
|
static void createSettingsKeyFromCurr( LPGLOBALVARS pgv, LPSTR str )
|
|
{
|
|
char tmp[MAX_STR];
|
|
int type;
|
|
LPJOYDATA pjd;
|
|
|
|
pjd = pgv->pjd;
|
|
|
|
if( pgv->joyHWCurr.dwUsageSettings & JOY_US_ISOEM ) {
|
|
type = pgv->joyHWCurr.dwType - JOY_HW_LASTENTRY;
|
|
if( type < 0 || type >= pjd->oemCount ) {
|
|
tmp[0] = 0;
|
|
} else {
|
|
strcpy( tmp, pjd->oemList[type].keyname );
|
|
}
|
|
} else {
|
|
wsprintf( tmp, "predef%d", pgv->joyHWCurr.dwType );
|
|
}
|
|
wsprintf( str, "%s\\%s", pjd->regSettingsCfgKey, tmp );
|
|
|
|
} /* createSettingsKeyFromCurr */
|
|
|
|
/*
|
|
* regSaveSpecificJoyHW - save specific joystick hardware config. to the registry
|
|
*/
|
|
static void regSaveSpecificJoyHW( LPGLOBALVARS pgv )
|
|
{
|
|
char str[MAX_STR];
|
|
HKEY hkey;
|
|
char jcfg[MAX_STR];
|
|
|
|
if( pgv->joyHWCurr.dwType == JOY_HW_NONE ) {
|
|
return;
|
|
}
|
|
if( !(pgv->joyActiveFlags & HASJOY) ) {
|
|
return;
|
|
}
|
|
|
|
createSettingsKeyFromCurr( pgv, str );
|
|
if( !RegCreateKey( HKEY_LOCAL_MACHINE, str, &hkey ) ) {
|
|
GETKEYNAME( pgv, jcfg, REGSTR_VAL_JOYNCONFIG );
|
|
RegSetValueEx( hkey, jcfg, 0, REG_BINARY,
|
|
(CONST LPBYTE)&pgv->joyHWCurr, sizeof( pgv->joyHWCurr ));
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
} /* regSaveSpecificJoyHW */
|
|
|
|
/*
|
|
* regCreateCurrKey - create the current joystick settings key
|
|
*/
|
|
static HKEY regCreateCurrKey( LPGLOBALVARS pgv )
|
|
{
|
|
HKEY hkey;
|
|
|
|
if( !RegCreateKey( HKEY_LOCAL_MACHINE, pgv->pjd->regCurrCfgKey, &hkey ) ) {
|
|
return hkey;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
|
|
} /* regCreateCurrKey */
|
|
|
|
/*
|
|
* RegSaveCurrentJoyHW - save the joystick info to the current entry in
|
|
* the registry
|
|
*/
|
|
void RegSaveCurrentJoyHW( LPGLOBALVARS pgv )
|
|
{
|
|
HKEY hkey;
|
|
LPSTR sptr;
|
|
char vname[MAX_STR];
|
|
char oname[MAX_STR];
|
|
char coname[MAX_STR];
|
|
int type;
|
|
LPJOYDATA pjd;
|
|
|
|
if( pgv->joyHWCurr.dwType == JOY_HW_NONE ) {
|
|
return;
|
|
}
|
|
if( !(pgv->joyActiveFlags & HASJOY) ) {
|
|
return;
|
|
}
|
|
|
|
hkey = regCreateCurrKey( pgv );
|
|
if( hkey == NULL ) {
|
|
DPF( "Could not save current joystick settings!\r\n" );
|
|
return;
|
|
}
|
|
pjd = pgv->pjd;
|
|
if( pgv->joyHWCurr.dwUsageSettings & JOY_US_ISOEM ) {
|
|
sptr = pjd->oemList[ pgv->joyHWCurr.dwType - JOY_HW_LASTENTRY ].keyname;
|
|
}
|
|
GETKEYNAME( pgv, vname, REGSTR_VAL_JOYNCONFIG );
|
|
GETKEYNAME( pgv, oname, REGSTR_VAL_JOYNOEMNAME );
|
|
GETKEYNAME( pgv, coname, REGSTR_VAL_JOYNOEMCALLOUT );
|
|
|
|
RegSetValueEx( hkey, vname, 0, REG_BINARY,
|
|
(CONST LPBYTE)&pgv->joyHWCurr, sizeof( pgv->joyHWCurr ) );
|
|
if( pgv->joyHWCurr.dwUsageSettings & JOY_US_ISOEM ) {
|
|
RegSetValueEx( hkey, oname, 0, REG_SZ, sptr, strlen( sptr ) + 1 );
|
|
|
|
/*
|
|
* set up VxD name for this joystick
|
|
*/
|
|
type = pgv->joyHWCurr.dwType - JOY_HW_LASTENTRY;
|
|
if( (pjd->oemList[type].vxd_name[0] != 0) ) {
|
|
RegSetValueEx( hkey, coname, 0, REG_SZ, pjd->oemList[type].vxd_name,
|
|
strlen( pjd->oemList[type].vxd_name )+1 );
|
|
} else {
|
|
RegDeleteValue( hkey, coname );
|
|
}
|
|
} else {
|
|
RegDeleteValue( hkey, oname );
|
|
RegDeleteValue( hkey, coname );
|
|
}
|
|
|
|
RegCloseKey( hkey );
|
|
|
|
} /* RegSaveCurrentJoyHW */
|
|
|
|
/*
|
|
* regPermSaveAllInfo - save joystick data to the registry for good
|
|
*/
|
|
static void regPermSaveAllInfo( LPGLOBALVARS pgv )
|
|
{
|
|
// save specific hardware settings to the registry
|
|
regSaveSpecificJoyHW( pgv );
|
|
|
|
// save current current hardware to the registry
|
|
RegSaveCurrentJoyHW( pgv );
|
|
|
|
RegistryUpdated( pgv );
|
|
|
|
} /* regPermSaveAllInfo */
|
|
|
|
/*
|
|
* setHWCurrType - set the current hardware type (check for OEM type)
|
|
*/
|
|
static BOOL setHWCurrType( LPGLOBALVARS pgv, HKEY hkey, LPJOYREGHWCONFIG pcfg )
|
|
{
|
|
char str[MAX_STR];
|
|
char pname[MAX_STR];
|
|
int i;
|
|
DWORD regtype;
|
|
DWORD cb;
|
|
LPJOYDATA pjd;
|
|
|
|
if( !(pcfg->dwUsageSettings & JOY_US_ISOEM) ) {
|
|
return TRUE;
|
|
}
|
|
GETKEYNAME( pgv, pname, REGSTR_VAL_JOYNOEMNAME );
|
|
cb = sizeof( str );
|
|
if( RegQueryValueEx( hkey, pname, NULL, ®type, (CONST LPBYTE)str, &cb)) {
|
|
return FALSE;
|
|
}
|
|
if( regtype != REG_SZ ) {
|
|
return FALSE;
|
|
}
|
|
pjd = pgv->pjd;
|
|
for( i=0;i<pjd->oemCount;i++ ) {
|
|
if( !_stricmp( str, pjd->oemList[i].keyname ) ) {
|
|
pcfg->dwType = i + JOY_HW_LASTENTRY;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
|
|
} /* setHWCurrType */
|
|
|
|
/*
|
|
* regGetCurrHW - get the information about the current configuration
|
|
* from the registry
|
|
*/
|
|
static void regGetCurrHW( LPGLOBALVARS pgv )
|
|
{
|
|
DWORD regtype;
|
|
DWORD cb;
|
|
JOYREGHWCONFIG config;
|
|
HKEY hkey;
|
|
char str[MAX_STR];
|
|
JOYCAPS jc;
|
|
|
|
pgv->joyHWCurr = pgv->pjd->joyHWDefaults[ JOY_HW_NONE ];
|
|
|
|
// Give the joystick driver a chance to write its current settings,
|
|
// if there are none.
|
|
//
|
|
joyGetDevCaps( pgv->iJoyId, &jc, sizeof( jc ) );
|
|
|
|
// Read those current settings (if they exist), and use them to determine
|
|
// what type of joystick we've got
|
|
//
|
|
if ((hkey = regCreateCurrKey (pgv)) != NULL)
|
|
{
|
|
cb = sizeof( config );
|
|
GETKEYNAME( pgv, str, REGSTR_VAL_JOYNCONFIG );
|
|
if( !RegQueryValueEx( hkey, str, NULL,
|
|
®type, (CONST LPBYTE)&config, &cb)) {
|
|
if( regtype == REG_BINARY && cb == sizeof( config ) ) {
|
|
if( setHWCurrType( pgv, hkey, &config ) ) {
|
|
pgv->joyHWCurr = config;
|
|
}
|
|
}
|
|
}
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
// Does this joystick match a known type?
|
|
//
|
|
if (pgv->joyHWCurr.hws.dwNumButtons != 0)
|
|
{
|
|
int ii;
|
|
for ( ii=0;ii<pgv->pjd->oemCount;ii++ )
|
|
{
|
|
if ( (pgv->pjd->oemList[ii].hws.dwFlags ==
|
|
pgv->joyHWCurr.hws.dwFlags) &&
|
|
(pgv->pjd->oemList[ii].hws.dwNumButtons ==
|
|
pgv->joyHWCurr.hws.dwNumButtons) )
|
|
{
|
|
pgv->joyHWCurr.dwType = ii + JOY_HW_LASTENTRY;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pgv->joyHWCurr.dwType == JOY_HW_NONE)
|
|
{
|
|
pgv->joyHWCurr.dwType = JOY_HW_CUSTOM;
|
|
}
|
|
}
|
|
} /* regGetCurrHW */
|
|
|
|
/*
|
|
* regGetOEMStr - get an OEM string
|
|
*/
|
|
static BOOL regGetOEMStr( HKEY hkey, LPSTR keyname, LPSTR buff, int size,
|
|
LPSTR *res )
|
|
{
|
|
DWORD cb;
|
|
DWORD type;
|
|
LPSTR str;
|
|
int slen;
|
|
|
|
cb = size;
|
|
slen = 1;
|
|
if( !RegQueryValueEx( hkey, keyname, NULL, &type, (CONST LPBYTE)buff, &cb ) ) {
|
|
if( type == REG_SZ ) {
|
|
slen = strlen( buff ) + 1;
|
|
}
|
|
}
|
|
str = DoAlloc( slen );
|
|
if( str != NULL ) {
|
|
if( slen == 1 ) {
|
|
str[0] = 0;
|
|
} else {
|
|
strcpy( str, buff );
|
|
}
|
|
}
|
|
*res = str;
|
|
if( str == NULL ) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
} /* regGetOEMStr */
|
|
|
|
/*
|
|
* checkNonStandardUserVals
|
|
*/
|
|
static BOOL checkNonStandardUserVals( LPJOYREGUSERVALUES puv )
|
|
{
|
|
if( (puv->jrvRanges.jpMin.dwX != RANGE_MIN) ||
|
|
(puv->jrvRanges.jpMin.dwY != RANGE_MIN) ||
|
|
(puv->jrvRanges.jpMin.dwZ != RANGE_MIN) ||
|
|
(puv->jrvRanges.jpMin.dwR != RANGE_MIN) ||
|
|
(puv->jrvRanges.jpMin.dwU != RANGE_MIN) ||
|
|
(puv->jrvRanges.jpMin.dwV != RANGE_MIN) ||
|
|
(puv->jrvRanges.jpMax.dwX != RANGE_MAX) ||
|
|
(puv->jrvRanges.jpMax.dwY != RANGE_MAX) ||
|
|
(puv->jrvRanges.jpMax.dwZ != RANGE_MAX) ||
|
|
(puv->jrvRanges.jpMax.dwR != RANGE_MAX) ||
|
|
(puv->jrvRanges.jpMax.dwU != RANGE_MAX) ||
|
|
(puv->jrvRanges.jpMax.dwV != RANGE_MAX) ||
|
|
(puv->dwTimeOut != 0x1000) ||
|
|
(puv->jpDeadZone.dwX != 0) ||
|
|
(puv->jpDeadZone.dwY != 0) ) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
} /* checkNonStandardUserVals */
|
|
|
|
/*
|
|
* regSetUserVals - set user values to our defaults
|
|
*/
|
|
static void regSetUserVals( LPJOYDATA pjd, BOOL retest )
|
|
{
|
|
JOYREGUSERVALUES uv;
|
|
JOYREGUSERVALUES ouv;
|
|
HKEY hkey;
|
|
DWORD regtype;
|
|
DWORD cb;
|
|
|
|
if( !RegOpenKey( HKEY_LOCAL_MACHINE, pjd->regCfgKey, &hkey ) ) {
|
|
/*
|
|
* build the default settings
|
|
*/
|
|
memset( &uv, 0, sizeof( uv ) );
|
|
uv.dwTimeOut = 0x1000;
|
|
uv.jpDeadZone.dwX = 0;
|
|
uv.jpDeadZone.dwY = 0;
|
|
uv.jrvRanges.jpMin.dwX = RANGE_MIN;
|
|
uv.jrvRanges.jpMin.dwY = RANGE_MIN;
|
|
uv.jrvRanges.jpMin.dwZ = RANGE_MIN;
|
|
uv.jrvRanges.jpMin.dwR = RANGE_MIN;
|
|
uv.jrvRanges.jpMin.dwU = RANGE_MIN;
|
|
uv.jrvRanges.jpMin.dwV = RANGE_MIN;
|
|
uv.jrvRanges.jpMax.dwX = RANGE_MAX;
|
|
uv.jrvRanges.jpMax.dwY = RANGE_MAX;
|
|
uv.jrvRanges.jpMax.dwZ = RANGE_MAX;
|
|
uv.jrvRanges.jpMax.dwR = RANGE_MAX;
|
|
uv.jrvRanges.jpMax.dwU = RANGE_MAX;
|
|
uv.jrvRanges.jpMax.dwV = RANGE_MAX;
|
|
|
|
if( retest ) {
|
|
/*
|
|
* see if the values have changed since we last set them:
|
|
* if yes, then we need to reset our remembered values
|
|
*/
|
|
DPF( "Looking for USER entries\r\n" );
|
|
cb = sizeof( ouv );
|
|
if( !RegQueryValueEx( hkey, REGSTR_VAL_JOYUSERVALUES, NULL,
|
|
®type, (CONST LPBYTE)&ouv, &cb)) {
|
|
DPF( "found REGSTR_VAL_JOYUSERVALUES\r\n" );
|
|
if( regtype == REG_BINARY && cb == sizeof( ouv ) ) {
|
|
if( memcmp( &uv, &ouv, sizeof( uv ) ) ) {
|
|
DPF( "USER entries changed!\r\n" );
|
|
pjd->bHasUserVals = TRUE;
|
|
pjd->bDeleteUserVals = FALSE;
|
|
pjd->userVals = ouv;
|
|
}
|
|
}
|
|
} else {
|
|
if( pjd->bHasUserVals ) {
|
|
DPF( "USER entries changed, no longer exist!\r\n" );
|
|
pjd->bHasUserVals = FALSE;
|
|
pjd->bDeleteUserVals = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* set our new values
|
|
*/
|
|
RegSetValueEx( hkey, REGSTR_VAL_JOYUSERVALUES, 0, REG_BINARY,
|
|
(CONST LPBYTE)&uv, sizeof( uv ) );
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
} /* regSetUserVals */
|
|
|
|
/*
|
|
* regUserValsInit - save old user values, and init to ones we like
|
|
*/
|
|
static void regUserValsInit( LPJOYDATA pjd )
|
|
{
|
|
HKEY hkey;
|
|
DWORD regtype;
|
|
DWORD cb;
|
|
|
|
pjd->bHasUserVals = FALSE;
|
|
pjd->bDeleteUserVals = FALSE;
|
|
if( !RegOpenKey( HKEY_LOCAL_MACHINE, pjd->regCfgKey, &hkey ) ) {
|
|
cb = sizeof( pjd->userVals );
|
|
if( !RegQueryValueEx( hkey, REGSTR_VAL_JOYUSERVALUES, NULL,
|
|
®type, (CONST LPBYTE)&pjd->userVals, &cb)) {
|
|
if( regtype == REG_BINARY && cb == sizeof( pjd->userVals ) ) {
|
|
pjd->bHasUserVals = TRUE;
|
|
DPF( "USER entries exist!\r\n" );
|
|
}
|
|
pjd->bHasNonStandardUserVals = checkNonStandardUserVals( &pjd->userVals );
|
|
} else {
|
|
pjd->bDeleteUserVals = TRUE;
|
|
pjd->bHasNonStandardUserVals = FALSE;
|
|
DPF( "USER entries don't exist!\r\n" );
|
|
}
|
|
RegCloseKey( hkey );
|
|
}
|
|
regSetUserVals( pjd, FALSE );
|
|
|
|
} /* regUserValsInit */
|
|
|
|
/*
|
|
* regUserValsFini - restore old user values
|
|
*/
|
|
static void regUserValsFini( LPJOYDATA pjd )
|
|
{
|
|
HKEY hkey;
|
|
if( pjd->bResetUserVals ) {
|
|
RegDeleteValue( hkey, REGSTR_VAL_JOYUSERVALUES );
|
|
RegistryUpdated( NULL );
|
|
} else if( pjd->bHasUserVals || pjd->bDeleteUserVals ) {
|
|
if( !RegOpenKey( HKEY_LOCAL_MACHINE, pjd->regCfgKey, &hkey ) ) {
|
|
if( pjd->bHasUserVals ) {
|
|
DPF( "resetting USER entries!\r\n" );
|
|
RegSetValueEx( hkey, REGSTR_VAL_JOYUSERVALUES, 0, REG_BINARY,
|
|
(CONST LPBYTE)&pjd->userVals, sizeof( pjd->userVals ) );
|
|
} else {
|
|
DPF( "deleting USER entries!\r\n" );
|
|
RegDeleteValue( hkey, REGSTR_VAL_JOYUSERVALUES );
|
|
}
|
|
RegistryUpdated( NULL );
|
|
}
|
|
pjd->bHasUserVals = FALSE;
|
|
pjd->bDeleteUserVals = FALSE;
|
|
}
|
|
|
|
} /* regUserValsFini */
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
|
|
CUSTOM JOYSTICK SELECTION FUNCTIONS FOLLOW
|
|
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
/*
|
|
* custom joystick variables
|
|
*/
|
|
typedef struct {
|
|
LPGLOBALVARS pgv;
|
|
BOOL bHasZ;
|
|
BOOL bHasR;
|
|
BOOL bHasPOV;
|
|
BOOL bIsYoke;
|
|
BOOL bIsGamePad;
|
|
BOOL bIsCarCtrl;
|
|
BOOL bHas2Buttons;
|
|
} cust_vars, *LPCUSTVARS;
|
|
|
|
|
|
/*
|
|
* enableCustomSpecial - enable the special section of the custom dialog box
|
|
*/
|
|
static void enableCustomSpecial( HWND hwnd, BOOL on )
|
|
{
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYISYOKE ), on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYISGAMEPAD ), on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYISCARCTRL ), on );
|
|
CheckDlgButton( hwnd, IDC_JOYUSESPECIAL, on );
|
|
if( !on ) {
|
|
CheckDlgButton( hwnd, IDC_JOYISYOKE, FALSE );
|
|
CheckDlgButton( hwnd, IDC_JOYISGAMEPAD, FALSE );
|
|
CheckDlgButton( hwnd, IDC_JOYISCARCTRL, FALSE );
|
|
}
|
|
|
|
} /* enableCustomSpecial */
|
|
|
|
/*
|
|
* context help for the custom settings dialog
|
|
*/
|
|
const static DWORD aCustomHelpIDs[] = { // Context Help IDs
|
|
IDC_GROUPBOX, IDH_JOYSTICK_CUSTOM_AXES,
|
|
IDC_GROUPBOX_2, IDH_JOYSTICK_CUSTOM_BUTTONS,
|
|
IDC_GROUPBOX_3, IDH_JOYSTICK_GROUPBOX,
|
|
IDC_JOY2AXIS, IDH_JOYSTICK_CUSTOM_AXES,
|
|
IDC_JOY3AXIS, IDH_JOYSTICK_CUSTOM_AXES,
|
|
IDC_JOY4AXIS, IDH_JOYSTICK_CUSTOM_AXES,
|
|
IDC_JOY2BUTTON, IDH_JOYSTICK_CUSTOM_BUTTONS,
|
|
IDC_JOY4BUTTON, IDH_JOYSTICK_CUSTOM_BUTTONS,
|
|
IDC_JOYHASPOV, IDH_JOYSTICK_CUSTOM_POV_HAT,
|
|
IDC_JOYISYOKE, IDH_JOYSTICK_CUSTOM_FLIGHT_YOKE,
|
|
IDC_JOYISGAMEPAD, IDH_JOYSTICK_CUSTOM_GAME_PAD,
|
|
IDC_JOYISCARCTRL, IDH_JOYSTICK_CUSTOM_CAR_CONTROL,
|
|
IDC_JOYUSESPECIAL, IDH_JOYSTICK_CUSTOM_CUSTOM_FEATURES,
|
|
|
|
0, 0
|
|
};
|
|
|
|
/*
|
|
* CustomProc - callback procedure for custom joystick setup
|
|
*/
|
|
BOOL CALLBACK CustomProc( HWND hwnd, UINT umsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int id;
|
|
LPGLOBALVARS pgv;
|
|
LPCUSTVARS pcv;
|
|
|
|
switch( umsg ) {
|
|
case WM_DESTROY:
|
|
/*
|
|
* don't free the dialog's variables here, they are returned to the
|
|
* creator; the creator will free them
|
|
*/
|
|
break;
|
|
case WM_INITDIALOG:
|
|
/*
|
|
* create variables for the custom dialog
|
|
*/
|
|
pcv = DoAlloc( sizeof( cust_vars ) );
|
|
SetWindowLong( hwnd, DWL_USER, (LONG) pcv );
|
|
if( pcv == NULL ) {
|
|
EndDialog( hwnd, 0 );
|
|
return FALSE;
|
|
}
|
|
pgv = (LPGLOBALVARS) lParam;
|
|
pcv->pgv = pgv;
|
|
|
|
/*
|
|
* set up initial dialog state
|
|
*/
|
|
pcv->bHasZ = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_HASZ);
|
|
pcv->bHasR = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_HASR);
|
|
pcv->bHas2Buttons = (pgv->joyHWCurr.hws.dwNumButtons == 2);
|
|
pcv->bHasPOV = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_HASPOV);
|
|
pcv->bIsYoke = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_ISYOKE);
|
|
pcv->bIsGamePad = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_ISGAMEPAD);
|
|
pcv->bIsCarCtrl = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_ISCARCTRL);
|
|
if( pcv->bHasZ && pcv->bHasR ) {
|
|
CheckRadioButton( hwnd, IDC_JOY2AXIS, IDC_JOY4AXIS, IDC_JOY4AXIS );
|
|
} else if( pcv->bHasZ ) {
|
|
CheckRadioButton( hwnd, IDC_JOY2AXIS, IDC_JOY4AXIS, IDC_JOY3AXIS );
|
|
} else {
|
|
CheckRadioButton( hwnd, IDC_JOY2AXIS, IDC_JOY4AXIS, IDC_JOY2AXIS );
|
|
}
|
|
if( pcv->bHas2Buttons ) {
|
|
CheckRadioButton( hwnd, IDC_JOY2BUTTON, IDC_JOY4BUTTON, IDC_JOY2BUTTON );
|
|
} else {
|
|
CheckRadioButton( hwnd, IDC_JOY2BUTTON, IDC_JOY4BUTTON, IDC_JOY4BUTTON );
|
|
}
|
|
CheckDlgButton( hwnd, IDC_JOYHASPOV, pcv->bHasPOV );
|
|
id = -1;
|
|
if( pcv->bIsYoke ) {
|
|
id = IDC_JOYISYOKE;
|
|
} else if( pcv->bIsGamePad ) {
|
|
id = IDC_JOYISGAMEPAD;
|
|
} else if( pcv->bIsCarCtrl ) {
|
|
id = IDC_JOYISCARCTRL;
|
|
}
|
|
if( id != -1 ) {
|
|
enableCustomSpecial( hwnd, TRUE );
|
|
CheckRadioButton( hwnd, IDC_JOYISYOKE, IDC_JOYISCARCTRL, id );
|
|
} else {
|
|
enableCustomSpecial( hwnd, FALSE );
|
|
}
|
|
return FALSE;
|
|
|
|
case WM_HELP:
|
|
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, cszHelpFile,
|
|
HELP_WM_HELP, (DWORD)(LPSTR) aCustomHelpIDs);
|
|
return TRUE;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND) wParam, cszHelpFile, HELP_CONTEXTMENU,
|
|
(DWORD)(LPVOID) aCustomHelpIDs);
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
pcv = (LPCUSTVARS) GetWindowLong( hwnd, DWL_USER );
|
|
id = GET_WM_COMMAND_ID(wParam, lParam);
|
|
switch( id ) {
|
|
case IDC_JOY2AXIS:
|
|
case IDC_JOY3AXIS:
|
|
case IDC_JOY4AXIS:
|
|
CheckRadioButton( hwnd, IDC_JOY2AXIS, IDC_JOY4AXIS, id );
|
|
pcv->bHasZ = FALSE;
|
|
pcv->bHasR = FALSE;
|
|
if( id == IDC_JOY3AXIS ) {
|
|
pcv->bHasZ = TRUE;
|
|
} else if( id == IDC_JOY4AXIS ) {
|
|
pcv->bHasZ = TRUE;
|
|
pcv->bHasR = TRUE;
|
|
}
|
|
break;
|
|
case IDC_JOY2BUTTON:
|
|
case IDC_JOY4BUTTON:
|
|
CheckRadioButton( hwnd, IDC_JOY2BUTTON, IDC_JOY4BUTTON, id );
|
|
pcv->bHas2Buttons = (id == IDC_JOY2BUTTON);
|
|
break;
|
|
case IDC_JOYUSESPECIAL:
|
|
enableCustomSpecial( hwnd, IsDlgButtonChecked( hwnd, IDC_JOYUSESPECIAL ) );
|
|
pcv->bIsYoke = FALSE;
|
|
pcv->bIsGamePad = FALSE;
|
|
pcv->bIsCarCtrl = FALSE;
|
|
break;
|
|
case IDC_JOYHASPOV:
|
|
pcv->bHasPOV = !pcv->bHasPOV;
|
|
break;
|
|
case IDC_JOYISYOKE:
|
|
case IDC_JOYISGAMEPAD:
|
|
case IDC_JOYISCARCTRL:
|
|
pcv->bIsYoke = (id == IDC_JOYISYOKE);
|
|
pcv->bIsGamePad = (id == IDC_JOYISGAMEPAD);
|
|
pcv->bIsCarCtrl = (id == IDC_JOYISCARCTRL);
|
|
CheckRadioButton( hwnd, IDC_JOYISYOKE, IDC_JOYISCARCTRL, id );
|
|
break;
|
|
case IDCANCEL:
|
|
pcv = (LPCUSTVARS) GetWindowLong( hwnd, DWL_USER );
|
|
DoFree( pcv );
|
|
EndDialog( hwnd, 0 );
|
|
break;
|
|
case IDOK:
|
|
pcv = (LPCUSTVARS) GetWindowLong( hwnd, DWL_USER );
|
|
EndDialog(hwnd, (int) pcv );
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
|
|
} /* CustomProc */
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
|
|
MAIN DIALOG FUNCTIONS FOLLOW
|
|
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
/*
|
|
* variables used by joystick tab dialog
|
|
*/
|
|
typedef struct {
|
|
LPGLOBALVARS pgv;
|
|
} JTVARS, *LPJTVARS;
|
|
|
|
/*
|
|
* numJoyAxes - get number of axes on a joystick
|
|
*/
|
|
static int numJoyAxes( LPGLOBALVARS pgv )
|
|
{
|
|
DWORD flags;
|
|
int axis_count;
|
|
|
|
flags = pgv->joyHWCurr.hws.dwFlags;
|
|
axis_count = 2;
|
|
if( flags & JOY_HWS_HASZ ) {
|
|
axis_count++;
|
|
}
|
|
if( flags & JOY_HWS_HASR ) {
|
|
axis_count++;
|
|
}
|
|
if( (flags & JOY_HWS_HASPOV) && (flags & JOY_HWS_POVISPOLL) ) {
|
|
axis_count++;
|
|
}
|
|
return axis_count;
|
|
|
|
} /* numJoyAxes */
|
|
|
|
/*
|
|
* saveHWSettings - save the current hardware settings
|
|
*/
|
|
static void saveHWSettings( LPGLOBALVARS pgv )
|
|
{
|
|
pgv->joyHWOrig = pgv->joyHWCurr;
|
|
|
|
} /* saveHWSettings */
|
|
|
|
/*
|
|
* restoreHWSettings - restore current hw settings to saved values
|
|
*/
|
|
static void restoreHWSettings( LPGLOBALVARS pgv )
|
|
{
|
|
pgv->joyHWCurr = pgv->joyHWOrig;
|
|
RegSaveCurrentJoyHW( pgv );
|
|
|
|
} /* restoreHWSettings */
|
|
|
|
/*
|
|
* getActiveFlags - poll and test which joysticks are currently plugged in
|
|
*/
|
|
static unsigned getActiveFlags( LPGLOBALVARS pgv )
|
|
{
|
|
JOYINFOEX ji;
|
|
MMRESULT rc;
|
|
unsigned val;
|
|
|
|
/*
|
|
* check for presense of joystick 1 and joystick 2
|
|
*/
|
|
val = 0;
|
|
ji.dwSize = sizeof( ji );
|
|
ji.dwFlags = JOY_RETURNX|JOY_RETURNY|JOY_CAL_READXYONLY|JOY_CAL_READALWAYS;
|
|
rc = joyGetPosEx( pgv->iJoyId, &ji );
|
|
DPF( "joyGetPosEx = %d\r\n", rc );
|
|
if( rc == JOYERR_NOERROR ) {
|
|
val = HASJOY;
|
|
}
|
|
|
|
/*
|
|
* check if either could have a rudder attached.
|
|
*/
|
|
ji.dwFlags = JOY_RETURNR | JOY_CAL_READRONLY;
|
|
if( (numJoyAxes( pgv ) < 4) &&
|
|
!(pgv->joyHWCurr.hws.dwFlags & JOY_HWS_HASR ) ) {
|
|
rc = joyGetPosEx( pgv->iJoyId, &ji );
|
|
if( rc ==JOYERR_NOERROR ) {
|
|
val |= HASRUDDERMAYBE;
|
|
}
|
|
}
|
|
return val;
|
|
|
|
} /* getActiveFlags */
|
|
|
|
/*
|
|
* enableTestCal - enable/disable test and calibrate buttons
|
|
*/
|
|
static void enableTestCal( HWND hwnd, int hw_type )
|
|
{
|
|
BOOL enable;
|
|
|
|
enable = (hw_type != JOY_HW_NONE);
|
|
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYCALIBRATE ), enable );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYTEST ), enable );
|
|
|
|
} /* enableTestCal */
|
|
|
|
/*
|
|
* cleanUpJoyDlg - clean up allocated stuff
|
|
*/
|
|
static void cleanUpJoyDlg( HWND hwnd )
|
|
{
|
|
LPGLOBALVARS pgv;
|
|
|
|
pgv = (LPGLOBALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
if( pgv == NULL ) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* ditch timer
|
|
*/
|
|
if( pgv->pjd->bHasTimer ) {
|
|
KillTimer( hwnd, TIMER_ID );
|
|
pgv->pjd->bHasTimer = FALSE;
|
|
}
|
|
|
|
/*
|
|
* done with our variables
|
|
*/
|
|
#if defined( WANT_SHEETS )
|
|
DoFree( pgv );
|
|
#endif
|
|
|
|
} /* cleanUpJoyDlg */
|
|
|
|
/*
|
|
* enableJoyWindows - enable controls for a joystick
|
|
*/
|
|
static void enableJoyWindows( LPGLOBALVARS pgv, HWND hwnd, BOOL enable )
|
|
{
|
|
// EnableWindow( GetDlgItem(hwnd,IDC_JOYSELECT), enable );
|
|
// EnableWindow( GetDlgItem(hwnd,IDC_JOYSELECTMSG), enable );
|
|
// EnableWindow( GetDlgItem(hwnd,IDC_JOYSTICK1_FRAME), enable );
|
|
EnableWindow( GetDlgItem(hwnd,IDC_JOYCALIBRATE), enable );
|
|
EnableWindow( GetDlgItem(hwnd,IDC_JOYTEST), enable );
|
|
|
|
} /* enableJoyWindows */
|
|
|
|
/*
|
|
* enableActiveJoystick - enable dialog controls based on presence of joysticks
|
|
*/
|
|
static void enableActiveJoystick( LPGLOBALVARS pgv, HWND hwnd )
|
|
{
|
|
BOOL allowj;
|
|
HINSTANCE hinst;
|
|
char str[MAX_STR];
|
|
unsigned joys;
|
|
LPSTR text;
|
|
|
|
/*
|
|
* check what joysticks are active; if it hasn't changed, just return
|
|
*/
|
|
joys = getActiveFlags( pgv );
|
|
if( pgv->joyActiveFlags == joys ) {
|
|
return;
|
|
}
|
|
pgv->joyActiveFlags = joys;
|
|
|
|
/*
|
|
* turn off the rudder if it is gone
|
|
*/
|
|
if( !(joys & HASRUDDERMAYBE) ) {
|
|
pgv->joyHWCurr.dwUsageSettings &= ~JOY_US_HASRUDDER;
|
|
CheckDlgButton( hwnd, IDC_JOY1HASRUDDER, FALSE );
|
|
}
|
|
|
|
/*
|
|
* enable the appropriate windows
|
|
*/
|
|
allowj = ((joys & HASJOY) != 0);
|
|
enableJoyWindows( pgv, hwnd, allowj );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOY1HASRUDDER ), allowj && (joys & HASRUDDERMAYBE) );
|
|
|
|
/*
|
|
* set message for the user if there is no joystick plugged in, or if
|
|
* there is no joystick driver present
|
|
*/
|
|
if( allowj ) {
|
|
text = "";
|
|
} else {
|
|
str[0] = 0;
|
|
text = str;
|
|
hinst = GetWindowInstance( hwnd );
|
|
if( joyGetNumDevs() ) {
|
|
LoadString( hinst , IDS_JOYUNPLUGGED, str, sizeof( str ) );
|
|
} else {
|
|
LoadString( hinst , IDS_JOYNOTPRESENT, str, sizeof( str ) );
|
|
}
|
|
}
|
|
SetWindowText( GetDlgItem( hwnd, IDC_JOYMSG ), text );
|
|
|
|
if( allowj ) {
|
|
enableTestCal( hwnd, pgv->joyHWCurr.dwType );
|
|
}
|
|
|
|
if( allowj ) {
|
|
pgv->joyHWCurr.dwUsageSettings |= JOY_US_PRESENT;
|
|
} else {
|
|
pgv->joyHWCurr.dwUsageSettings &= ~JOY_US_PRESENT;
|
|
}
|
|
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
|
|
} /* enableActiveJoystick */
|
|
|
|
/*
|
|
* getNewJoyInfo - get information from the registry about a new joystick.
|
|
* If no info, default to joyHWDefault settings
|
|
*/
|
|
static void getNewJoyInfo( LPGLOBALVARS pgv, HWND hwnd )
|
|
{
|
|
UINT index;
|
|
DWORD hw_type;
|
|
HKEY hkey;
|
|
char str[MAX_STR];
|
|
char jcfg[MAX_STR];
|
|
DWORD regtype;
|
|
JOYREGHWCONFIG config;
|
|
DWORD cb;
|
|
BOOL same;
|
|
int rc;
|
|
|
|
GETKEYNAME( pgv, jcfg, REGSTR_VAL_JOYNCONFIG );
|
|
|
|
/*
|
|
* get the hardware type
|
|
*/
|
|
index = SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_GETCURSEL, 0, 0L );
|
|
hw_type = SendDlgItemMessage( hwnd,IDC_JOYSELECT,CB_GETITEMDATA,index,0L );
|
|
same = (hw_type == pgv->joyHWCurr.dwType);
|
|
|
|
/*
|
|
* read the info from the registry if a new hardware type selected
|
|
*/
|
|
if( !same ) {
|
|
pgv->joyHWCurr = pgv->pjd->joyHWDefaults[ hw_type ];
|
|
createSettingsKeyFromCurr( pgv, str );
|
|
if( !RegOpenKey( HKEY_LOCAL_MACHINE, str, &hkey ) ) {
|
|
cb = sizeof( pgv->joyHWCurr );
|
|
if( !RegQueryValueEx( hkey, jcfg, NULL, ®type,
|
|
(CONST LPBYTE)&config, &cb) ) {
|
|
if( regtype == REG_BINARY && cb == sizeof( config ) ) {
|
|
pgv->joyHWCurr.hws = config.hws;
|
|
pgv->joyHWCurr.hwv = config.hwv;
|
|
pgv->joyHWCurr.dwUsageSettings = config.dwUsageSettings;
|
|
}
|
|
}
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
/*
|
|
* set up the rudder bit
|
|
*/
|
|
if( pgv->joyHWCurr.dwUsageSettings & JOY_US_HASRUDDER ) {
|
|
CheckDlgButton( hwnd, IDC_JOY1HASRUDDER, TRUE );
|
|
} else {
|
|
if( IsDlgButtonChecked( hwnd, IDC_JOY1HASRUDDER ) ) {
|
|
pgv->joyHWCurr.dwUsageSettings |= JOY_US_HASRUDDER;
|
|
} else {
|
|
pgv->joyHWCurr.dwUsageSettings &= ~JOY_US_HASRUDDER;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* disable test/calibrate buttons based on hardware picked
|
|
*/
|
|
enableTestCal( hwnd, hw_type );
|
|
|
|
/*
|
|
* if custom selected, go get the data from the user
|
|
*/
|
|
if( hw_type == JOY_HW_CUSTOM ) {
|
|
rc = DialogBoxParam((HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE),
|
|
MAKEINTRESOURCE(IDD_JOYCUSTOM), hwnd,
|
|
CustomProc, (LONG) pgv );
|
|
if( rc ) {
|
|
LPCUSTVARS pcv;
|
|
|
|
pcv = (LPCUSTVARS) rc;
|
|
pgv->joyHWCurr.dwUsageSettings |= JOY_US_PRESENT;
|
|
pgv->joyHWCurr.hws.dwFlags &= ~(JOY_HWS_HASR|JOY_HWS_HASZ|
|
|
JOY_HWS_HASU| JOY_HWS_HASV|
|
|
JOY_HWS_HASPOV|JOY_HWS_ISYOKE| JOY_HWS_ISGAMEPAD|
|
|
JOY_HWS_ISCARCTRL| JOY_HWS_POVISPOLL|
|
|
JOY_HWS_POVISBUTTONCOMBOS );
|
|
/*
|
|
* NOTE: for a custom joystick, we always assume that Z is
|
|
* implemented on J2 Y.
|
|
*/
|
|
if( pcv->bHasZ ) {
|
|
pgv->joyHWCurr.hws.dwFlags |= JOY_HWS_HASZ;
|
|
}
|
|
/*
|
|
* NOTE: for a custom joystick, we always assume that R is
|
|
* implemented on J2 X.
|
|
*/
|
|
if( pcv->bHasR ) {
|
|
pgv->joyHWCurr.hws.dwFlags |= JOY_HWS_HASR;
|
|
}
|
|
if( pcv->bHasPOV ) {
|
|
pgv->joyHWCurr.hws.dwFlags |= JOY_HWS_HASPOV;
|
|
}
|
|
if( pcv->bIsYoke ) {
|
|
pgv->joyHWCurr.hws.dwFlags |= JOY_HWS_ISYOKE;
|
|
}
|
|
if( pcv->bIsGamePad ) {
|
|
pgv->joyHWCurr.hws.dwFlags |= JOY_HWS_ISGAMEPAD;
|
|
}
|
|
if( pcv->bIsCarCtrl ) {
|
|
pgv->joyHWCurr.hws.dwFlags |= JOY_HWS_ISCARCTRL;
|
|
}
|
|
if( pcv->bHas2Buttons ) {
|
|
pgv->joyHWCurr.hws.dwNumButtons = 2;
|
|
} else {
|
|
pgv->joyHWCurr.hws.dwNumButtons = 4;
|
|
}
|
|
DoFree( pcv );
|
|
same = FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* update the registry with the new current joystick
|
|
*/
|
|
if( !same ) {
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
PropSheet_Changed( GetParent(hwnd), hwnd );
|
|
pgv->joyActiveFlags = (unsigned) -1;
|
|
enableActiveJoystick( pgv, hwnd );
|
|
}
|
|
|
|
} /* getNewJoyInfo */
|
|
|
|
/*
|
|
* initCurrentHW - set up the current hardware for the first time
|
|
*/
|
|
static void initCurrentHW( LPGLOBALVARS pgv )
|
|
{
|
|
regGetCurrHW( pgv );
|
|
pgv->joyActiveFlags = (unsigned) -1;
|
|
saveHWSettings( pgv );
|
|
|
|
} /* initCurrentHW */
|
|
|
|
/*
|
|
* newJoyId - set up for a new joystick id
|
|
*/
|
|
static LPGLOBALVARS newJoyId( LPGLOBALVARS pgv, HWND hwnd, int joyid )
|
|
{
|
|
UINT index;
|
|
UINT indexMax;
|
|
|
|
if( joyid == pgv->iJoyId ) {
|
|
return pgv;
|
|
}
|
|
#if !defined( WANT_SHEETS )
|
|
pgv = &pgv->pjd->pgvlist[ joyid ];
|
|
#endif
|
|
pgv->iJoyId = joyid;
|
|
|
|
/*
|
|
* save the pointer to the variables
|
|
*/
|
|
SetWindowLong( hwnd, DWL_USER, (LONG) pgv );
|
|
|
|
#if defined( WANT_SHEETS )
|
|
/*
|
|
* set up current joystick hardware
|
|
*/
|
|
initCurrentHW( pgv );
|
|
#endif
|
|
|
|
/*
|
|
* set up windows
|
|
*/
|
|
pgv->joyActiveFlags = (unsigned) -1;
|
|
enableActiveJoystick( pgv, hwnd );
|
|
if( pgv->joyHWCurr.dwUsageSettings & JOY_US_HASRUDDER ) {
|
|
CheckDlgButton( hwnd, IDC_JOY1HASRUDDER, TRUE );
|
|
} else {
|
|
CheckDlgButton( hwnd, IDC_JOY1HASRUDDER, FALSE );
|
|
}
|
|
|
|
/*
|
|
* select the current info
|
|
*/
|
|
indexMax = SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_GETCOUNT, 0, 0 );
|
|
|
|
for (index = 0; index < indexMax; index++)
|
|
{
|
|
DWORD type;
|
|
type = SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_GETITEMDATA,
|
|
index, 0 );
|
|
if (type == pgv->joyHWCurr.dwType)
|
|
break;
|
|
}
|
|
|
|
if (index == indexMax)
|
|
index = 1; // custom
|
|
|
|
SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_SETCURSEL, index, 0L );
|
|
#if !defined( WANT_SHEETS )
|
|
SendDlgItemMessage( hwnd, IDC_JOYCURRENTID, CB_SETCURSEL, pgv->iJoyId, 0L );
|
|
#endif
|
|
return pgv;
|
|
|
|
|
|
} /* newJoyId */
|
|
|
|
/*
|
|
* showResetInfo
|
|
*/
|
|
static void showResetInfo( HWND hwnd, BOOL show )
|
|
{
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYTROUBLESHOOT_FRAME ), show );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYTROUBLESHOOT_TEXT ), show );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYRESET ), show );
|
|
|
|
} /* showResetInfo */
|
|
|
|
/*
|
|
* doJoyDlgInitDialog - process initialization for joystick tabbed dialog
|
|
*/
|
|
static BOOL doJoyDlgInitDialog( HWND hwnd, LPARAM lParam )
|
|
{
|
|
HINSTANCE hinst;
|
|
LPPROPSHEETPAGE ppsp;
|
|
int i;
|
|
char str[MAX_STR];
|
|
LPGLOBALVARS pgv;
|
|
LPJOYDATA pjd;
|
|
LPJOYDATAPTR pjdp;
|
|
HKEY hkey;
|
|
|
|
/*
|
|
* pointer to data
|
|
*/
|
|
ppsp = (LPPROPSHEETPAGE) lParam;
|
|
pjdp = (LPJOYDATAPTR) ppsp->lParam;
|
|
pjd = pjdp->pjd;
|
|
|
|
/*
|
|
* create global variables. These will be used by all dialogs
|
|
*/
|
|
#if defined( WANT_SHEETS )
|
|
pgv = DoAlloc( sizeof( GLOBALVARS ) );
|
|
if( pgv == NULL ) {
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* get joystick id that this sheet is for
|
|
*/
|
|
pgv->iJoyId = pjdp->iJoyId;
|
|
pgv->pjd = pjd;
|
|
DPF( "Tab for joystick %d started\r\n", pgv->iJoyId );
|
|
#else
|
|
pgv = &pjd->pgvlist[ pjdp->iJoyId ];
|
|
#endif
|
|
|
|
/*
|
|
* get device caps
|
|
*/
|
|
getDevCaps( pgv );
|
|
|
|
/*
|
|
* how many predefined joystick types should we display?
|
|
*/
|
|
pgv->cJoystickTypes = 2; // display None and Custom only
|
|
if( !RegOpenKey( HKEY_LOCAL_MACHINE, REGSTR_PATH_JOYSTICK, &hkey ) ) {
|
|
DWORD type;
|
|
DWORD val = 0;
|
|
DWORD cb = sizeof(val);
|
|
if( !RegQueryValueEx( hkey, REGSTR_VAL_JOYTYPES, NULL,
|
|
&type, (CONST LPBYTE)&val, &cb) ) {
|
|
pgv->cJoystickTypes += val;
|
|
}
|
|
RegCloseKey( hkey );
|
|
}
|
|
pgv->cJoystickTypes = max( pgv->cJoystickTypes, 2 ); // Must have none/cust
|
|
pgv->cJoystickTypes = min( pgv->cJoystickTypes, 12 );
|
|
|
|
/*
|
|
* callback timer for checking if joysticks are plugged/unplugged
|
|
*/
|
|
if( !pjd->bHasTimer ) {
|
|
pjd->bHasTimer = SetTimer( hwnd, TIMER_ID, JOYCHECKTIME, NULL );
|
|
pjd->bUseTimer = TRUE;
|
|
}
|
|
|
|
/*
|
|
* set up pre-defined joystick list
|
|
*/
|
|
hinst = GetWindowInstance( hwnd );
|
|
for( i=IDS_JOYHW0; i<(IDS_JOYHW0 + pgv->cJoystickTypes); i++ ) {
|
|
if( LoadString( hinst , i, str, sizeof( str ) ) ) {
|
|
UINT dwItem;
|
|
dwItem = SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_ADDSTRING, 0,
|
|
(LONG) (LPSTR) str );
|
|
SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_SETITEMDATA, dwItem,
|
|
i -IDS_JOYHW0 + JOY_HW_NONE );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* set up OEM joystick list
|
|
*/
|
|
for( i=0;i<pjd->oemCount;i++ ) {
|
|
UINT dwItem;
|
|
dwItem = SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_ADDSTRING, 0,
|
|
(LONG) (LPSTR) pjd->oemList[i].ident_string );
|
|
SendDlgItemMessage( hwnd, IDC_JOYSELECT, CB_SETITEMDATA,
|
|
dwItem, i +JOY_HW_LASTENTRY);
|
|
}
|
|
|
|
/*
|
|
* set up joystick choices list
|
|
*/
|
|
#if !defined(WANT_SHEETS)
|
|
{
|
|
int numdevs;
|
|
char strid[MAX_STR];
|
|
if( LoadString( hinst, IDS_JOY, str, sizeof( str ) ) ) {
|
|
numdevs = joyGetNumDevs();
|
|
for( i=0;i<numdevs;i++ ) {
|
|
wsprintf( strid, "%s %d", str, i+1 );
|
|
SendDlgItemMessage( hwnd, IDC_JOYCURRENTID, CB_ADDSTRING, 0,
|
|
(LONG) (LPSTR) strid );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
pgv->iJoyId = -1;
|
|
newJoyId( pgv, hwnd, pjdp->iJoyId );
|
|
|
|
/*
|
|
* enable/disable our Reset button
|
|
*/
|
|
showResetInfo( hwnd, pjd->bHasNonStandardUserVals );
|
|
|
|
return TRUE;
|
|
|
|
} /* doJoyDlgInitDialog */
|
|
|
|
/*
|
|
* doJoyDlgCommand - process WM_COMMAND message for main joystick tabbed dialog
|
|
*/
|
|
static void doJoyDlgCommand( HWND hwnd, int id, HWND hctl, UINT code )
|
|
{
|
|
LPGLOBALVARS pgv;
|
|
|
|
pgv = (LPGLOBALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
|
|
switch( id ) {
|
|
/*
|
|
* new joystick has been picked
|
|
*/
|
|
case IDC_JOYSELECT:
|
|
if( code == CBN_SELCHANGE ) {
|
|
getNewJoyInfo( pgv, hwnd );
|
|
}
|
|
break;
|
|
|
|
#if !defined( WANT_SHEET )
|
|
/*
|
|
* new joystick id has been picked
|
|
*/
|
|
case IDC_JOYCURRENTID:
|
|
if( code == CBN_SELCHANGE ) {
|
|
int joyid;
|
|
joyid = SendDlgItemMessage( hwnd, IDC_JOYCURRENTID, CB_GETCURSEL, 0, 0L );
|
|
pgv = newJoyId( pgv, hwnd, joyid );
|
|
regSetUserVals( pgv->pjd, TRUE );
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
/*
|
|
* calibrate current joystick
|
|
*/
|
|
case IDC_JOYCALIBRATE:
|
|
pgv->pjd->bUseTimer = FALSE;
|
|
DoCalibrate( pgv, hwnd );
|
|
pgv->pjd->bUseTimer = TRUE;
|
|
break;
|
|
|
|
/*
|
|
* test either joystick 1 or joystick 2
|
|
*/
|
|
case IDC_JOYTEST:
|
|
pgv->pjd->bUseTimer = FALSE;
|
|
DoTest( pgv, hwnd, NULL, pgv );
|
|
pgv->pjd->bUseTimer = TRUE;
|
|
break;
|
|
|
|
/*
|
|
* reset to user values
|
|
*/
|
|
case IDC_JOYRESET:
|
|
pgv->pjd->bResetUserVals = TRUE;
|
|
PropSheet_Changed( GetParent(hwnd), hwnd );
|
|
break;
|
|
|
|
/*
|
|
* rudder selected/unselected
|
|
*/
|
|
case IDC_JOY1HASRUDDER:
|
|
{
|
|
LPJOYREGHWCONFIG pcfg;
|
|
/*
|
|
* rudder status changed, force recalibration (leave POV alone if
|
|
* it was button based)
|
|
*/
|
|
pcfg = &pgv->joyHWCurr;
|
|
|
|
if( (pcfg->hws.dwFlags & JOY_HWS_HASPOV) &&
|
|
(pcfg->hws.dwFlags & JOY_HWS_POVISBUTTONCOMBOS) ) {
|
|
pcfg->hwv.dwCalFlags &= JOY_ISCAL_POV;
|
|
} else {
|
|
pcfg->hwv.dwCalFlags = 0;
|
|
}
|
|
|
|
if( IsDlgButtonChecked( hwnd, id ) ) {
|
|
pcfg->dwUsageSettings |= JOY_US_HASRUDDER;
|
|
} else {
|
|
pcfg->dwUsageSettings &= ~JOY_US_HASRUDDER;
|
|
}
|
|
pgv->joyActiveFlags = (unsigned) -1;
|
|
enableActiveJoystick( pgv, hwnd );
|
|
PropSheet_Changed( GetParent(hwnd), hwnd );
|
|
break;
|
|
}
|
|
|
|
case ID_APPLY:
|
|
{
|
|
DPF( "ID_APPLY\r\n" );
|
|
|
|
#if !defined( WANT_SHEETS )
|
|
{
|
|
int i;
|
|
int numjoys;
|
|
|
|
numjoys = joyGetNumDevs();
|
|
for( i=0;i<numjoys;i++ ) {
|
|
regPermSaveAllInfo( &pgv->pjd->pgvlist[i] );
|
|
saveHWSettings( &pgv->pjd->pgvlist[i] );
|
|
}
|
|
}
|
|
#else
|
|
regPermSaveAllInfo( pgv );
|
|
saveHWSettings( pgv );
|
|
#endif
|
|
if( pgv->pjd->bResetUserVals ) {
|
|
regUserValsFini( pgv->pjd );
|
|
regUserValsInit( pgv->pjd );
|
|
pgv->pjd->bResetUserVals = FALSE;
|
|
}
|
|
showResetInfo( hwnd, pgv->pjd->bHasNonStandardUserVals );
|
|
break;
|
|
}
|
|
case ID_INIT:
|
|
DPF( "ID_INIT\r\n" );
|
|
/*
|
|
* we've been re-activated, reset the current joystick settings
|
|
*/
|
|
regSetUserVals( pgv->pjd, TRUE );
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
break;
|
|
case IDOK:
|
|
DPF( "IDOK\r\n" );
|
|
EndDialog(hwnd, TRUE );
|
|
break;
|
|
case IDCANCEL:
|
|
DPF( "IDCANCEL\r\n" );
|
|
pgv->pjd->bResetUserVals = FALSE;
|
|
#if !defined( WANT_SHEETS )
|
|
{
|
|
int i;
|
|
int numjoys;
|
|
|
|
numjoys = joyGetNumDevs();
|
|
for( i=0;i<numjoys;i++ ) {
|
|
restoreHWSettings( &pgv->pjd->pgvlist[i] );
|
|
}
|
|
}
|
|
#else
|
|
restoreHWSettings( pgv );
|
|
#endif
|
|
RegistryUpdated( pgv );
|
|
EndDialog(hwnd, FALSE );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
} /* doJoyDlgCommand */
|
|
|
|
/*
|
|
* context help for the main dialog
|
|
*/
|
|
const static DWORD aJoystickHelpIDs[] = { // Context Help IDs
|
|
IDC_JOYCURRENTIDMSG, IDH_JOYSTICK_CURRENT,
|
|
IDC_JOYCURRENTID, IDH_JOYSTICK_CURRENT,
|
|
IDC_JOYSELECTMSG, IDH_JOYSTICK_SELECT,
|
|
IDC_JOYSELECT, IDH_JOYSTICK_SELECT,
|
|
IDC_JOY1HASRUDDER, IDH_JOYSTICK_RUDDER,
|
|
IDC_JOYCALIBRATE, IDH_JOYSTICK_CALIBRATE,
|
|
IDC_JOYTEST, IDH_JOYSTICK_TEST,
|
|
IDC_JOYSTICK1_FRAME, IDH_JOYSTICK_GROUPBOX,
|
|
IDC_JOYMSG, NO_HELP,
|
|
IDC_ICON_1, NO_HELP,
|
|
IDC_ICON_2, NO_HELP,
|
|
IDC_JOYTROUBLESHOOT_FRAME, IDH_JOYSTICK_RESET,
|
|
IDC_JOYRESET, IDH_JOYSTICK_RESET,
|
|
IDC_JOYTROUBLESHOOT_TEXT, NO_HELP,
|
|
|
|
0, 0
|
|
};
|
|
|
|
/*
|
|
* JoystickDlg - dialog procedure for joystick tabbed dialog
|
|
*/
|
|
BOOL CALLBACK JoystickDlg( HWND hwnd, UINT umsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL rc;
|
|
|
|
switch( umsg ) {
|
|
case WM_INITDIALOG:
|
|
rc = doJoyDlgInitDialog( hwnd, lParam );
|
|
if( !rc ) {
|
|
EndDialog( hwnd, 0 );
|
|
}
|
|
return FALSE;
|
|
|
|
case WM_COMMAND:
|
|
HANDLE_WM_COMMAND( hwnd, wParam, lParam, doJoyDlgCommand );
|
|
break;
|
|
|
|
case WM_ACTIVATE:
|
|
/*
|
|
* we've been activated, pretend we were re-selected
|
|
*/
|
|
if( LOWORD( wParam ) != WA_INACTIVE ) {
|
|
FORWARD_WM_COMMAND( hwnd, ID_INIT, 0, 0, SendMessage );
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
cleanUpJoyDlg( hwnd );
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
{
|
|
LPGLOBALVARS pgv;
|
|
pgv = (LPGLOBALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
if( pgv->pjd->bUseTimer ) {
|
|
pgv->pjd->bUseTimer = FALSE;
|
|
enableActiveJoystick( pgv, hwnd );
|
|
pgv->pjd->bUseTimer = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_HELP:
|
|
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, cszHelpFile,
|
|
HELP_WM_HELP, (DWORD)(LPSTR) aJoystickHelpIDs);
|
|
return TRUE;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND) wParam, cszHelpFile, HELP_CONTEXTMENU,
|
|
(DWORD)(LPVOID) aJoystickHelpIDs);
|
|
return TRUE;
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR FAR * lpnm = (NMHDR FAR *)lParam;
|
|
switch(lpnm->code) {
|
|
case PSN_KILLACTIVE:
|
|
FORWARD_WM_COMMAND( hwnd, IDOK, 0, 0, SendMessage );
|
|
return TRUE;
|
|
|
|
case PSN_APPLY:
|
|
FORWARD_WM_COMMAND( hwnd, ID_APPLY, 0, 0, SendMessage );
|
|
return TRUE;
|
|
|
|
case PSN_SETACTIVE:
|
|
FORWARD_WM_COMMAND( hwnd, ID_INIT, 0, 0, SendMessage );
|
|
return TRUE;
|
|
|
|
case PSN_RESET:
|
|
FORWARD_WM_COMMAND( hwnd, IDCANCEL, 0, 0, SendMessage );
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
|
|
} /* JoystickDlg */
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
|
|
GLOBAL JOYSTICK DATA FUNCTIONS FOLLOW
|
|
|
|
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* default joysticks
|
|
*/
|
|
#define TYPE00 0
|
|
#define TYPE01 0
|
|
#define TYPE02 0
|
|
#define TYPE03 0
|
|
#define TYPE04 JOY_HWS_ISGAMEPAD
|
|
#define TYPE05 JOY_HWS_ISYOKE
|
|
#define TYPE06 JOY_HWS_HASZ | JOY_HWS_ISYOKE
|
|
#define TYPE07 JOY_HWS_HASZ
|
|
#define TYPE08 JOY_HWS_HASZ
|
|
#define TYPE09 JOY_HWS_ISGAMEPAD
|
|
#define TYPE10 JOY_HWS_ISYOKE
|
|
#define TYPE11 JOY_HWS_HASZ | JOY_HWS_ISYOKE
|
|
|
|
static JOYREGHWCONFIG _joyHWDefaults[] =
|
|
{
|
|
{ {TYPE00,0},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_NONE},
|
|
{ {TYPE01,2},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_CUSTOM},
|
|
{ {TYPE02,2},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_2A_2B_GENERIC},
|
|
{ {TYPE03,4},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_2A_4B_GENERIC},
|
|
{ {TYPE04,2},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_2B_GAMEPAD},
|
|
{ {TYPE05,2},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_2B_FLIGHTYOKE},
|
|
{ {TYPE06,2},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_2B_FLIGHTYOKETHROTTLE},
|
|
{ {TYPE07,2},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_3A_2B_GENERIC},
|
|
{ {TYPE08,4},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_3A_4B_GENERIC},
|
|
{ {TYPE09,4},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_4B_GAMEPAD},
|
|
{ {TYPE10,4},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_4B_FLIGHTYOKE},
|
|
{ {TYPE11,4},JOY_US_PRESENT,{{0,0,0,0,0,0,0,0,0},{0,0,0,0}},JOY_HW_4B_FLIGHTYOKETHROTTLE},
|
|
};
|
|
|
|
/*
|
|
* registry strings for calibration messages
|
|
*/
|
|
static LPSTR _oemCalRegStrs[] =
|
|
{
|
|
REGSTR_VAL_JOYOEMCAL1,
|
|
REGSTR_VAL_JOYOEMCAL2,
|
|
REGSTR_VAL_JOYOEMCAL3,
|
|
REGSTR_VAL_JOYOEMCAL4,
|
|
REGSTR_VAL_JOYOEMCAL5,
|
|
REGSTR_VAL_JOYOEMCAL6,
|
|
REGSTR_VAL_JOYOEMCAL7,
|
|
REGSTR_VAL_JOYOEMCAL8,
|
|
REGSTR_VAL_JOYOEMCAL9,
|
|
REGSTR_VAL_JOYOEMCAL10,
|
|
REGSTR_VAL_JOYOEMCAL11,
|
|
REGSTR_VAL_JOYOEMCAL12,
|
|
};
|
|
|
|
/*
|
|
* base registry keys
|
|
*/
|
|
static char szCfgKey[] = REGSTR_PATH_JOYCONFIG;
|
|
static char szCurrCfgKey[] = REGSTR_KEY_JOYCURR;
|
|
static char szSettingsCfgKey[] = REGSTR_KEY_JOYSETTINGS;
|
|
|
|
|
|
/*
|
|
* freeOEMListItem - free a list of oem data
|
|
*/
|
|
static void freeOEMListItem( LPJOYDATA pjd, int i )
|
|
{
|
|
int j;
|
|
|
|
DoFree( pjd->oemList[i].keyname );
|
|
DoFree( pjd->oemList[i].ident_string );
|
|
DoFree( pjd->oemList[i].vxd_name );
|
|
DoFree( pjd->oemList[i].xy_label );
|
|
DoFree( pjd->oemList[i].z_label );
|
|
DoFree( pjd->oemList[i].r_label );
|
|
DoFree( pjd->oemList[i].u_label );
|
|
DoFree( pjd->oemList[i].v_label );
|
|
DoFree( pjd->oemList[i].pov_label );
|
|
DoFree( pjd->oemList[i].testmove_desc );
|
|
DoFree( pjd->oemList[i].testbutton_desc );
|
|
DoFree( pjd->oemList[i].testmove_cap );
|
|
DoFree( pjd->oemList[i].testbutton_cap );
|
|
DoFree( pjd->oemList[i].testwin_cap );
|
|
DoFree( pjd->oemList[i].cal_cap );
|
|
DoFree( pjd->oemList[i].calwin_cap );
|
|
for( j=0;j<NUM_CAL_STRS;j++ ) {
|
|
DoFree( pjd->oemList[i].cal_strs[j] );
|
|
}
|
|
|
|
} /* freeOEMListItem */
|
|
|
|
/*
|
|
* initHWDefaults - initialize the hardware list: use defaults + OEM types
|
|
* defined in the registry
|
|
*/
|
|
static void initHWDefaults( LPJOYDATA pjd )
|
|
{
|
|
int list_size;
|
|
int def_size;
|
|
DWORD isubkey;
|
|
DWORD keyidx;
|
|
HKEY hkey;
|
|
HKEY hsubkey;
|
|
char str[MAX_STR];
|
|
DWORD clsize;
|
|
DWORD num_subkeys;
|
|
DWORD dont_care;
|
|
DWORD longest_key;
|
|
FILETIME ftime;
|
|
LPSTR keyname;
|
|
JOYREGHWSETTINGS hws;
|
|
DWORD longest_val;
|
|
DWORD type;
|
|
DWORD cb;
|
|
int i;
|
|
int j;
|
|
int ctype;
|
|
LPSTR tmpstr;
|
|
int fail;
|
|
|
|
def_size = sizeof( _joyHWDefaults )/sizeof( _joyHWDefaults[0] );
|
|
list_size = def_size;
|
|
pjd->oemCount = 0;
|
|
if( !RegOpenKey( HKEY_LOCAL_MACHINE, REGSTR_PATH_JOYOEM, &hkey ) ) {
|
|
clsize = sizeof( str );
|
|
if( !RegQueryInfoKey ( hkey, str, &clsize, NULL, &num_subkeys,
|
|
&longest_key, &dont_care, &dont_care, &dont_care,
|
|
&dont_care, // address of buffer for longest value data length
|
|
&dont_care, &ftime ) ) {
|
|
pjd->oemList = DoAlloc( num_subkeys * sizeof( OEMLIST ));
|
|
if( pjd->oemList != NULL ) {
|
|
pjd->oemCount = num_subkeys;
|
|
list_size += num_subkeys;
|
|
}
|
|
longest_key++;
|
|
}
|
|
}
|
|
|
|
pjd->joyHWDefaults = DoAlloc( list_size * sizeof( JOYREGHWCONFIG ) );
|
|
if( pjd->joyHWDefaults == NULL ) {
|
|
pjd->joyHWDefaults = _joyHWDefaults;
|
|
} else {
|
|
memcpy( pjd->joyHWDefaults, _joyHWDefaults, def_size * sizeof( JOYREGHWCONFIG ) );
|
|
/*
|
|
* if we have keys in the registry, go fetch them
|
|
*/
|
|
if( list_size > def_size ) {
|
|
isubkey = 0;
|
|
keyidx = 0;
|
|
keyname = DoAlloc( longest_key );
|
|
if( keyname == NULL ) {
|
|
keyname = str;
|
|
longest_key = sizeof( str );
|
|
}
|
|
/*
|
|
* run through all keys, getting the info on them
|
|
*/
|
|
while( !RegEnumKey( hkey, keyidx, keyname, longest_key ) ) {
|
|
if( !RegOpenKey( hkey, keyname, &hsubkey ) ) {
|
|
if( !RegQueryInfoKey ( hsubkey, str, &clsize, NULL,
|
|
&dont_care, &dont_care, &dont_care, &dont_care,
|
|
&dont_care, &longest_val, &dont_care, &ftime ) ) {
|
|
pjd->oemList[isubkey].keyname = DoAlloc( strlen( keyname ) +1 );
|
|
tmpstr = DoAlloc( longest_val+1 );
|
|
if( pjd->oemList[isubkey].keyname != NULL && tmpstr != NULL ) {
|
|
strcpy( pjd->oemList[isubkey].keyname, keyname );
|
|
cb = sizeof( hws );
|
|
if( !RegQueryValueEx( hsubkey, REGSTR_VAL_JOYOEMDATA, NULL,
|
|
&type, (CONST LPBYTE)&hws, &cb) ) {
|
|
if( type == REG_BINARY && cb == sizeof( hws ) ) {
|
|
pjd->oemList[isubkey].hws = hws;
|
|
}
|
|
}
|
|
fail = 0;
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMCALLOUT,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].vxd_name );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMNAME,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].ident_string );
|
|
for( j=0;j<NUM_CAL_STRS;j++ ) {
|
|
fail |= regGetOEMStr( hsubkey, _oemCalRegStrs[j],
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].cal_strs[j] );
|
|
}
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMXYLABEL,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].xy_label );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMZLABEL,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].z_label );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMRLABEL,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].r_label );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMULABEL,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].u_label );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMVLABEL,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].v_label );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMPOVLABEL,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].pov_label );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMTESTMOVEDESC,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].testmove_desc );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMTESTBUTTONDESC,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].testbutton_desc );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMTESTMOVECAP,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].testmove_cap );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMTESTBUTTONCAP,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].testbutton_cap );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMTESTWINCAP,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].testwin_cap );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMCALCAP,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].cal_cap );
|
|
fail |= regGetOEMStr( hsubkey, REGSTR_VAL_JOYOEMCALWINCAP,
|
|
tmpstr, longest_val,
|
|
&pjd->oemList[isubkey].calwin_cap );
|
|
if( fail ) {
|
|
freeOEMListItem( pjd, isubkey );
|
|
} else {
|
|
isubkey++;
|
|
}
|
|
} else {
|
|
DoFree( pjd->oemList[isubkey].keyname );
|
|
}
|
|
DoFree( tmpstr );
|
|
RegCloseKey( hsubkey );
|
|
}
|
|
}
|
|
keyidx++;
|
|
}
|
|
pjd->oemCount = isubkey;
|
|
|
|
/*
|
|
* sort the list, and then fill in the joyHWDefault array
|
|
*/
|
|
if( pjd->oemCount > 0 ) {
|
|
for( i=0;i<pjd->oemCount;i++ ) {
|
|
for( j=i;j<pjd->oemCount;j++ ) {
|
|
OEMLIST ol;
|
|
if( strcmp( pjd->oemList[i].ident_string,
|
|
pjd->oemList[j].ident_string ) > 0 ) {
|
|
ol = pjd->oemList[i];
|
|
pjd->oemList[i] = pjd->oemList[j];
|
|
pjd->oemList[j] = ol;
|
|
}
|
|
}
|
|
}
|
|
for( i=0;i<pjd->oemCount;i++ ) {
|
|
ctype = i+JOY_HW_LASTENTRY;
|
|
memset( &pjd->joyHWDefaults[ctype], 0,
|
|
sizeof( pjd->joyHWDefaults[ctype] ) );
|
|
pjd->joyHWDefaults[ctype].hws = pjd->oemList[i].hws;
|
|
pjd->joyHWDefaults[ctype].dwUsageSettings = JOY_US_ISOEM|JOY_US_PRESENT;
|
|
pjd->joyHWDefaults[ctype].dwType = ctype;
|
|
}
|
|
}
|
|
if( keyname != str ) {
|
|
DoFree( keyname );
|
|
}
|
|
}
|
|
}
|
|
|
|
} /* initHWDefaults */
|
|
|
|
/*
|
|
* finiHWList - finished with the hardware list, free it
|
|
*/
|
|
static void finiHWList( LPJOYDATA pjd )
|
|
{
|
|
int i;
|
|
|
|
if( pjd->joyHWDefaults != NULL ) {
|
|
if( pjd->joyHWDefaults != _joyHWDefaults ) {
|
|
DoFree( pjd->joyHWDefaults );
|
|
}
|
|
pjd->joyHWDefaults = NULL;
|
|
}
|
|
if( pjd->oemList != NULL ) {
|
|
for( i=0;i<pjd->oemCount;i++ ) {
|
|
freeOEMListItem( pjd, i );
|
|
}
|
|
DoFree( pjd->oemList );
|
|
pjd->oemList = NULL;
|
|
pjd->oemCount = 0;
|
|
}
|
|
|
|
} /* finiHWList */
|
|
|
|
/*
|
|
* getRegKeys - get the registry keys we need
|
|
*/
|
|
static void getRegKeys( LPJOYDATA pjd )
|
|
{
|
|
int len;
|
|
JOYCAPS jc;
|
|
|
|
if (joyGetDevCaps (0, &jc, sizeof(jc)) != JOYERR_NOERROR)
|
|
lstrcpy (jc.szRegKey, TEXT("joystick.dll<0000>"));
|
|
|
|
/*
|
|
* set up registry keys
|
|
*/
|
|
pjd->regCfgKey = NULL;
|
|
pjd->regCurrCfgKey = NULL;
|
|
pjd->regSettingsCfgKey = NULL;
|
|
|
|
len = sizeof( szCfgKey );
|
|
pjd->regCfgKey = DoAlloc( len );
|
|
if( pjd->regCfgKey != NULL ) {
|
|
strcpy( pjd->regCfgKey, szCfgKey );
|
|
pjd->regCurrCfgKey = DoAlloc( len +1 +1 +lstrlen(jc.szRegKey) +sizeof( szCurrCfgKey ) );
|
|
if( pjd->regCurrCfgKey != NULL ) {
|
|
strcpy( pjd->regCurrCfgKey, pjd->regCfgKey );
|
|
strcat( pjd->regCurrCfgKey, "\\" );
|
|
strcat( pjd->regCurrCfgKey, jc.szRegKey );
|
|
strcat( pjd->regCurrCfgKey, "\\" );
|
|
strcat( pjd->regCurrCfgKey, szCurrCfgKey );
|
|
}
|
|
pjd->regSettingsCfgKey = DoAlloc( len +1 +1 +lstrlen(jc.szRegKey) +sizeof( szSettingsCfgKey ) );
|
|
if( pjd->regSettingsCfgKey != NULL ) {
|
|
strcpy( pjd->regSettingsCfgKey, pjd->regCfgKey );
|
|
strcat( pjd->regSettingsCfgKey, "\\" );
|
|
strcat( pjd->regSettingsCfgKey, jc.szRegKey );
|
|
strcat( pjd->regSettingsCfgKey, "\\" );
|
|
strcat( pjd->regSettingsCfgKey, szSettingsCfgKey );
|
|
}
|
|
}
|
|
|
|
} /* getRegKeys */
|
|
|
|
/*
|
|
* JoystickDataInit
|
|
*/
|
|
LPJOYDATA JoystickDataInit( void )
|
|
{
|
|
LPJOYDATA pjd;
|
|
|
|
pjd = DoAlloc( sizeof( JOYDATA ) );
|
|
if( pjd == NULL ) {
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* go set up all our defaults + oem lists
|
|
*/
|
|
initHWDefaults( pjd );
|
|
|
|
/*
|
|
* get registry keys used by everyone
|
|
*/
|
|
getRegKeys( pjd );
|
|
|
|
/*
|
|
* brushes for use by button display and bar display (z & r info)
|
|
*/
|
|
pjd->hbUp = CreateSolidBrush( ACTIVE_COLOR );
|
|
pjd->hbDown = CreateSolidBrush( INACTIVE_COLOR );
|
|
|
|
/*
|
|
* set up user values we like
|
|
*/
|
|
regUserValsInit( pjd );
|
|
|
|
|
|
#if !defined( WANT_SHEETS )
|
|
{
|
|
/*
|
|
* set up array of "global" vars (global to a joystick id)
|
|
*/
|
|
|
|
int numjoys;
|
|
int i;
|
|
|
|
numjoys = joyGetNumDevs();
|
|
if( numjoys == 0 ) {
|
|
return NULL;
|
|
}
|
|
|
|
pjd->pgvlist = DoAlloc( sizeof( GLOBALVARS ) * numjoys );
|
|
if( pjd->pgvlist == NULL ) {
|
|
return NULL;
|
|
}
|
|
for( i=0;i<numjoys;i++ ) {
|
|
pjd->pgvlist[i].iJoyId = i;
|
|
pjd->pgvlist[i].pjd = pjd;
|
|
initCurrentHW( &pjd->pgvlist[i] );
|
|
}
|
|
}
|
|
#endif
|
|
return pjd;
|
|
|
|
} /* JoystickDataInit */
|
|
|
|
/*
|
|
* JoystickDataFini - finished with DLL wide joystick data data
|
|
*/
|
|
void JoystickDataFini( LPJOYDATA pjd )
|
|
{
|
|
/*
|
|
* ditch brushes
|
|
*/
|
|
if( pjd->hbUp != NULL ) {
|
|
DeleteObject( pjd->hbUp );
|
|
}
|
|
if( pjd->hbDown != NULL ) {
|
|
DeleteObject( pjd->hbDown );
|
|
}
|
|
|
|
/*
|
|
* done with hardware list
|
|
*/
|
|
finiHWList( pjd );
|
|
|
|
/*
|
|
* restore user values in registry
|
|
*/
|
|
regUserValsFini( pjd );
|
|
|
|
/*
|
|
* done with registry keys
|
|
*/
|
|
DoFree( pjd->regCfgKey );
|
|
DoFree( pjd->regCurrCfgKey );
|
|
DoFree( pjd->regSettingsCfgKey );
|
|
|
|
#if !defined( WANT_SHEETS )
|
|
DoFree( pjd->pgvlist );
|
|
#endif
|
|
|
|
/*
|
|
* free up the joystick data
|
|
*/
|
|
DoFree( pjd );
|
|
#ifdef DEBUG
|
|
if( allocCount != 0 ) {
|
|
MBOX( "Memory left unfreed: %d allocations", allocCount );
|
|
}
|
|
#endif
|
|
|
|
} /* JoystickDataFini */
|