1948 lines
55 KiB
C++
1948 lines
55 KiB
C++
//****************************************************************************
|
|
//
|
|
// File: joycal.c
|
|
// Content: Joystick calibration dialog
|
|
// History:
|
|
// Date By Reason
|
|
// ==== == ======
|
|
// 11-dec-94 craige split out of joycpl.c; some tweaks
|
|
// 15-dec-94 craige allow N joysticks
|
|
// 17-dec-94 craige new UI as requested by ChrisB
|
|
// 18-dec-94 craige process UV
|
|
// 05-jan-95 craige new centering confirmation messages
|
|
// 04-mar-95 craige bug 10761 - separate strings for pluralization
|
|
// bug 12036 - now works when "Back" clicked off of
|
|
// custom 4-axis with POV hat
|
|
//
|
|
// Copyright (c) Microsoft Corporation 1994-1995
|
|
//
|
|
//****************************************************************************
|
|
|
|
#pragma pack (8)
|
|
|
|
#include "stdafx.h"
|
|
#include "joycpl.h"
|
|
#include "resource.h"
|
|
#include "pov.h"
|
|
#include "assert.h"
|
|
|
|
#include "baseids.h"
|
|
|
|
#include "comstr.h"
|
|
|
|
#undef NewLoadString
|
|
#define NewLoadString(a, b, c, d) \
|
|
pszCommonString->LoadString(b); \
|
|
lstrcpy( c, (LPCTSTR)*pszCommonString )
|
|
|
|
// Context sensitive help stuff!
|
|
static void OnContextMenu(WPARAM wParam);
|
|
static void OnHelp (LPARAM);
|
|
|
|
static const DWORD CalibrateHelpIDs[] =
|
|
{
|
|
IDC_JOYLIST1, IDC_JOYLIST1,
|
|
IDC_JOYLIST2, IDC_JOYLIST2,
|
|
IDC_JOYLIST3, IDC_JOYLIST3,
|
|
IDC_JOYLIST4, IDC_JOYLIST4,
|
|
0, 0
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
* This has the look and feel of a wizard, but isn't This leads to the
|
|
* obvious...
|
|
*
|
|
* Q: Why isn't this a "real" wizard?
|
|
*
|
|
* A: - it doesn't have multiple pages, it has a single page. the user
|
|
* sees different joystick items activate and de-activate on the dialog
|
|
* as he/she calibrates each axis. fussing with multiple sheets for each
|
|
* axis would be confusing and unnecessary.
|
|
*/
|
|
|
|
/*
|
|
* calibration states
|
|
*/
|
|
// %%% debug %%% alpha days
|
|
extern "C"
|
|
{
|
|
typedef enum
|
|
{
|
|
JCS_INIT=-1,
|
|
JCS_XY_CENTER1,
|
|
JCS_XY_MOVE,
|
|
JCS_XY_CENTER2,
|
|
JCS_Z_MOVE,
|
|
JCS_Z_PLACEHOLDER,
|
|
JCS_R_MOVE,
|
|
JCS_R_PLACEHOLDER,
|
|
JCS_U_MOVE,
|
|
JCS_U_PLACEHOLDER,
|
|
JCS_V_MOVE,
|
|
JCS_V_PLACEHOLDER,
|
|
JCS_POV_MOVEUP,
|
|
JCS_POV_MOVERIGHT,
|
|
JCS_POV_MOVEDOWN,
|
|
JCS_POV_MOVELEFT,
|
|
JCS_FINI
|
|
} cal_states;
|
|
|
|
typedef enum
|
|
{
|
|
JC_XY=0,
|
|
JC_Z,
|
|
JC_POV_UP,
|
|
JC_POV_RIGHT,
|
|
JC_POV_DOWN,
|
|
JC_POV_LEFT,
|
|
JC_R,
|
|
JC_U,
|
|
JC_V,
|
|
JC_FINI
|
|
} cal_wins;
|
|
|
|
// variables used in calibration
|
|
typedef struct
|
|
{
|
|
LPGLOBALVARS pgv;
|
|
cal_states cState;
|
|
BOOL bHasTimer;
|
|
BOOL bUseTimer;
|
|
HINSTANCE hinst;
|
|
JOYINFOEX ji;
|
|
JOYRANGE jr;
|
|
DWORD pov[JOY_POV_NUMDIRS];
|
|
int iAxisCount;
|
|
BOOL bPOVdone;
|
|
} CALVARS, *LPCALVARS;
|
|
|
|
extern "C" WINMMAPI MMRESULT WINAPI joyConfigChanged(DWORD);
|
|
|
|
|
|
#define JOY_CALIB_FLAGS JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | \
|
|
JOY_RETURNR | JOY_RETURNU | JOY_RETURNV | \
|
|
JOY_RETURNBUTTONS | JOY_RETURNRAWDATA
|
|
|
|
/*
|
|
* we use raw data during calibration; RAW_SHIFT allows us to convert to
|
|
* a reasonable "real" value
|
|
*/
|
|
#define RAW_SHIFT 100
|
|
} // extern "C"
|
|
|
|
// setDefaultButton - make a button the default window
|
|
static void setDefaultButton( HWND hwnd, HWND hwdb )
|
|
{
|
|
// Optimized New Method
|
|
SendMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)hwdb, (LPARAM)TRUE);
|
|
|
|
/* Optimized Old Method
|
|
DWORD style;
|
|
HWND hCtrl;
|
|
int idList[] = { IDC_JOYCALDONE, IDC_JOYCALNEXT,
|
|
IDC_JOYCALBACK, IDC_JOYPICKPOV };
|
|
#define SIZEOF_LIST 4
|
|
|
|
// turn off the current default push button
|
|
for (short i=0; i < SIZEOF_LIST; i++ )
|
|
{
|
|
hCtrl = GetDlgItem( hwnd, idList[i] );
|
|
|
|
if (hCtrl)
|
|
{
|
|
style = GetWindowLong( hCtrl, GWL_STYLE );
|
|
|
|
if ( style & BS_DEFPUSHBUTTON )
|
|
{
|
|
style &= ~BS_DEFPUSHBUTTON;
|
|
style |= BS_PUSHBUTTON;
|
|
SetWindowLong( hCtrl, GWL_STYLE, style );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// make the specified button the default
|
|
style = GetWindowLong( hwdb, GWL_STYLE );
|
|
style &= ~(BS_PUSHBUTTON|BS_DEFPUSHBUTTON);
|
|
style |= BS_DEFPUSHBUTTON;
|
|
SetWindowLong( hwdb, GWL_STYLE, style );
|
|
*/
|
|
|
|
} // setDefaultButton
|
|
|
|
/*
|
|
* setLabel
|
|
*
|
|
* set the label for an axis based on current calibration state
|
|
*/
|
|
static void setLabel(
|
|
LPGLOBALVARS pgv,
|
|
HWND hwnd,
|
|
UINT id,
|
|
LPJOYREGHWCONFIG pcfg,
|
|
DWORD bit )
|
|
{
|
|
char str[MAX_STR];
|
|
int type;
|
|
HINSTANCE hinst;
|
|
HWND hwtext;
|
|
|
|
hinst = GetResourceInstance( );
|
|
assert(hinst);
|
|
|
|
// get text for this axis label...
|
|
if( pcfg->dwUsageSettings & JOY_US_ISOEM )
|
|
{
|
|
type = pcfg->dwType - JOY_HW_LASTENTRY;
|
|
if( type < 0 || type >= pgv->pjd->oemCount )
|
|
{
|
|
type = -1;
|
|
}
|
|
} else
|
|
{
|
|
type = -1;
|
|
}
|
|
|
|
switch( id )
|
|
{
|
|
case IDC_JOYLIST1_LABEL:
|
|
if( (type == -1) || (pgv->pjd->oemList[type].xy_label[0] == 0) )
|
|
{
|
|
NewLoadString( hinst, IDS_XYAXIS_LABEL, str, sizeof( str ) );
|
|
if( !lstrlen(str) ) return;
|
|
} else lstrcpy( str, pgv->pjd->oemList[type].xy_label );
|
|
break;
|
|
|
|
case IDC_JOYLIST2_LABEL:
|
|
if( (type == -1) || (pgv->pjd->oemList[type].z_label[0] == 0 ) )
|
|
{
|
|
NewLoadString( hinst, IDS_ZAXIS_LABEL, str, sizeof( str ) );
|
|
if( !lstrlen(str) ) return;
|
|
} else lstrcpy( str, pgv->pjd->oemList[type].z_label );
|
|
break;
|
|
|
|
case IDC_JOYLIST3_LABEL:
|
|
if( (type == -1) || (pgv->pjd->oemList[type].r_label[0] == 0) )
|
|
{
|
|
NewLoadString( hinst, IDS_RAXIS_LABEL, str, sizeof( str ) );
|
|
if( !lstrlen(str) ) return;
|
|
} else lstrcpy( str, pgv->pjd->oemList[type].r_label );
|
|
break;
|
|
|
|
case IDC_JOYLIST4_LABEL:
|
|
if( (type == -1) || (pgv->pjd->oemList[type].u_label[0] == 0) )
|
|
{
|
|
NewLoadString( hinst, IDS_UAXIS_LABEL, str, sizeof( str ) );
|
|
if( !lstrlen(str) ) return;
|
|
} else lstrcpy( str, pgv->pjd->oemList[type].u_label );
|
|
break;
|
|
|
|
case IDC_JOYLIST5_LABEL:
|
|
if( (type == -1) || (pgv->pjd->oemList[type].v_label[0] == 0) )
|
|
{
|
|
NewLoadString( hinst, IDS_VAXIS_LABEL, str, sizeof( str ) );
|
|
if( !lstrlen(str) ) return;
|
|
} else lstrcpy( str, pgv->pjd->oemList[type].v_label );
|
|
break;
|
|
|
|
case IDC_JOYPOV_LABEL:
|
|
if( (type == -1) || (pgv->pjd->oemList[type].pov_label[0] == 0) )
|
|
{
|
|
NewLoadString( hinst, IDS_POVAXIS_LABEL, str, sizeof( str ) );
|
|
if( !lstrlen(str) ) return;
|
|
} else lstrcpy( str, pgv->pjd->oemList[type].pov_label );
|
|
break;
|
|
}
|
|
|
|
hwtext = GetDlgItem( hwnd, id );
|
|
ASSERT (::IsWindow(hwtext));
|
|
|
|
if( hwtext != NULL )
|
|
SetWindowText( hwtext, str );
|
|
|
|
} /* setLabel */
|
|
|
|
// enableCalWindows - enable or disable specific calibration windows
|
|
static void enableCalWindows(
|
|
LPGLOBALVARS pgv,
|
|
LPJOYREGHWCONFIG pcfg,
|
|
HWND hwnd,
|
|
cal_wins id )
|
|
{
|
|
BOOL on;
|
|
HWND hwlb;
|
|
HWND hwb;
|
|
int iid;
|
|
|
|
// set up the buttons
|
|
hwb = GetDlgItem( hwnd,IDC_JOYCALDONE );
|
|
ASSERT (hwb);
|
|
|
|
if( id == JC_FINI )
|
|
{
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYCALNEXT );
|
|
ASSERT (::IsWindow(hwlb));
|
|
ShowWindow(hwlb, SW_HIDE );
|
|
|
|
EnableWindow( hwb, TRUE );
|
|
ShowWindow( hwb, SW_NORMAL );
|
|
SetFocus( hwb );
|
|
setDefaultButton( hwnd, hwb );
|
|
} else
|
|
{
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYCALNEXT );
|
|
ASSERT (::IsWindow(hwlb));
|
|
ShowWindow( hwlb, SW_NORMAL );
|
|
|
|
EnableWindow( hwb, FALSE );
|
|
ShowWindow( hwb, SW_HIDE );
|
|
}
|
|
|
|
setLabel( pgv, hwnd, IDC_JOYLIST1_LABEL, pcfg, JOY_ISCAL_XY );
|
|
|
|
// set up the XY window
|
|
on = FALSE;
|
|
|
|
if( id == JC_XY )
|
|
on = TRUE;
|
|
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYLIST1 );
|
|
ASSERT (::IsWindow(hwlb));
|
|
|
|
if( !on )
|
|
InvalidateRect( hwlb, NULL, TRUE );
|
|
|
|
EnableWindow( hwlb, on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYLIST1_LABEL ), on );
|
|
|
|
/*
|
|
* set up the Z window
|
|
*/
|
|
on = FALSE;
|
|
if( id == JC_Z )
|
|
on = TRUE;
|
|
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYLIST2 );
|
|
if( !on )
|
|
{
|
|
InvalidateRect( hwlb, NULL, TRUE );
|
|
}
|
|
EnableWindow( hwlb, on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYLIST2_LABEL ), on );
|
|
|
|
/*
|
|
* set up the R window
|
|
*/
|
|
on = FALSE;
|
|
if( id == JC_R )
|
|
{
|
|
on = TRUE;
|
|
}
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYLIST3 );
|
|
if( !on )
|
|
{
|
|
InvalidateRect( hwlb, NULL, TRUE );
|
|
}
|
|
EnableWindow( hwlb, on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYLIST3_LABEL ), on );
|
|
|
|
/*
|
|
* set up the U window
|
|
*/
|
|
on = FALSE;
|
|
if( id == JC_U )
|
|
{
|
|
on = TRUE;
|
|
}
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYLIST4 );
|
|
if( hwlb != NULL )
|
|
{
|
|
if( !on )
|
|
{
|
|
InvalidateRect( hwlb, NULL, TRUE );
|
|
}
|
|
EnableWindow( hwlb, on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYLIST4_LABEL ), on );
|
|
}
|
|
|
|
/*
|
|
* set up the V window
|
|
*/
|
|
on = FALSE;
|
|
if( id == JC_V )
|
|
{
|
|
on = TRUE;
|
|
}
|
|
hwlb = GetDlgItem( hwnd, IDC_JOYLIST5 );
|
|
if( hwlb != NULL )
|
|
{
|
|
if( !on )
|
|
{
|
|
InvalidateRect( hwlb, NULL, TRUE );
|
|
}
|
|
EnableWindow( hwlb, on );
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYLIST5_LABEL ), on );
|
|
}
|
|
|
|
/*
|
|
* set up the POV icon
|
|
*/
|
|
on = FALSE;
|
|
if( id >= JC_POV_UP && id <= JC_POV_LEFT )
|
|
{
|
|
on = TRUE;
|
|
}
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYPOV_LABEL ), on );
|
|
hwb = GetDlgItem( hwnd, IDC_JOYPICKPOV );
|
|
EnableWindow( hwb, on );
|
|
if( on )
|
|
{
|
|
ShowWindow( hwb, SW_NORMAL );
|
|
SetFocus( hwb );
|
|
setDefaultButton( hwnd, hwb );
|
|
switch( id )
|
|
{
|
|
case JC_POV_UP:
|
|
iid = IDI_JOYPOV_UP;
|
|
break;
|
|
case JC_POV_RIGHT:
|
|
iid = IDI_JOYPOV_RIGHT;
|
|
break;
|
|
case JC_POV_LEFT:
|
|
iid = IDI_JOYPOV_LEFT;
|
|
break;
|
|
case JC_POV_DOWN:
|
|
iid = IDI_JOYPOV_DOWN;
|
|
break;
|
|
}
|
|
} else
|
|
{
|
|
ShowWindow( hwb, SW_HIDE );
|
|
UpdateWindow( hwb );
|
|
iid = IDI_JOYPOV_GRAYED;
|
|
}
|
|
ChangeIcon( hwnd, iid, IDC_JOYPOV );
|
|
|
|
} /* enableCalWindows */
|
|
|
|
|
|
/*
|
|
* getJoyName - get the name of a joystick
|
|
*/
|
|
static int getJoyName( LPJOYREGHWCONFIG pcfg, BOOL plural )
|
|
{
|
|
int str2id;
|
|
|
|
if( pcfg->hws.dwFlags & JOY_HWS_ISYOKE )
|
|
{
|
|
str2id = ( plural ) ? IDS_JOYCAL_YOKES : IDS_JOYCAL_YOKE;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISCARCTRL )
|
|
{
|
|
str2id = ( plural ) ? IDS_JOYCAL_CARS : IDS_JOYCAL_CAR;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISGAMEPAD )
|
|
{
|
|
str2id = ( plural ) ? IDS_JOYCAL_GAMEPADS : IDS_JOYCAL_GAMEPAD;
|
|
} else
|
|
{
|
|
str2id = ( plural ) ? IDS_JOY2S : IDS_JOY2;
|
|
}
|
|
|
|
return(str2id);
|
|
|
|
} /* getJoyName */
|
|
|
|
/*
|
|
* joyCalStateChange - calibration state change
|
|
*/
|
|
static BOOL joyCalStateChange( LPCALVARS pcv, HWND hwnd, BOOL back )
|
|
{
|
|
HINSTANCE hinst;
|
|
HWND hwtext;
|
|
int strid;
|
|
int stridx = 0; // BUG FIX: CML 6/21/96 (FLASH RAID 270)
|
|
int str2id;
|
|
int str3id;
|
|
int str4id;
|
|
char str[2*MAX_STR];
|
|
char buff[2*MAX_STR];
|
|
char str2[64];
|
|
char str3[64];
|
|
char str4[64];
|
|
BOOL done;
|
|
LPJOYREGHWCONFIG pcfg;
|
|
BOOL rc;
|
|
int type;
|
|
LPGLOBALVARS pgv;
|
|
BOOL isdone;
|
|
|
|
assert(pcv);
|
|
assert(hwnd);
|
|
|
|
/*
|
|
* move to the next state: get the appropriate string
|
|
* to display, and enable the correct controls
|
|
*/
|
|
pgv = pcv->pgv;
|
|
assert(pgv);
|
|
rc = TRUE;
|
|
done = FALSE;
|
|
pcfg = &pgv->joyHWCurr;
|
|
str2id = -1;
|
|
str3id = -1;
|
|
str4id = -1;
|
|
(pcv->cState) = (cal_states) (pcv->cState + ((cal_states) 1));
|
|
EnableWindow( GetDlgItem( hwnd, IDC_JOYCALBACK ), back );
|
|
|
|
while( !done )
|
|
{
|
|
done = TRUE;
|
|
|
|
switch( pcv->cState )
|
|
{
|
|
case JCS_XY_CENTER1:
|
|
/*
|
|
* init. range variables
|
|
*/
|
|
pcv->jr.jpMin.dwX = (DWORD) -1;
|
|
pcv->jr.jpMin.dwY = (DWORD) -1;
|
|
pcv->jr.jpMin.dwZ = (DWORD) -1;
|
|
pcv->jr.jpMin.dwR = (DWORD) -1;
|
|
pcv->jr.jpMin.dwU = (DWORD) -1;
|
|
pcv->jr.jpMin.dwV = (DWORD) -1;
|
|
pcv->jr.jpMax.dwX = 0;
|
|
pcv->jr.jpMax.dwY = 0;
|
|
pcv->jr.jpMax.dwZ = 0;
|
|
pcv->jr.jpMax.dwR = 0;
|
|
pcv->jr.jpMax.dwU = 0;
|
|
pcv->jr.jpMax.dwV = 0;
|
|
|
|
// set strings to display
|
|
stridx = CALSTR1;
|
|
|
|
if( pcfg->hws.dwFlags & JOY_HWS_ISYOKE )
|
|
{
|
|
strid = IDS_JOYCALXY_CENTERYOKE;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISCARCTRL )
|
|
{
|
|
strid = IDS_JOYCALXY_CENTERCAR;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISGAMEPAD )
|
|
{
|
|
strid = IDS_JOYCALXY_CENTERGAMEPAD;
|
|
} else
|
|
{
|
|
strid = IDS_JOYCALXY_CENTER;
|
|
}
|
|
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_XY );
|
|
break;
|
|
|
|
case JCS_XY_MOVE:
|
|
stridx = CALSTR2;
|
|
if( pcfg->hws.dwFlags & JOY_HWS_ISYOKE )
|
|
{
|
|
strid = IDS_JOYCALXY_MOVEYOKE;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISCARCTRL )
|
|
{
|
|
strid = IDS_JOYCALXY_MOVECAR;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISGAMEPAD )
|
|
{
|
|
strid = IDS_JOYCALXY_MOVEGAMEPAD;
|
|
} else
|
|
{
|
|
strid = IDS_JOYCALXY_MOVE;
|
|
}
|
|
break;
|
|
|
|
case JCS_XY_CENTER2:
|
|
stridx = CALSTR3;
|
|
if( pcfg->hws.dwFlags & JOY_HWS_ISYOKE )
|
|
{
|
|
strid = IDS_JOYCALXY_CENTERYOKE2;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISCARCTRL )
|
|
{
|
|
strid = IDS_JOYCALXY_CENTERCAR2;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_ISGAMEPAD )
|
|
{
|
|
strid = IDS_JOYCALXY_CENTERGAMEPAD2;
|
|
} else
|
|
{
|
|
strid = IDS_JOYCALXY_CENTER2;
|
|
}
|
|
break;
|
|
|
|
case JCS_Z_MOVE:
|
|
stridx = CALSTR4;
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_HASZ) )
|
|
{
|
|
pcv->cState = JCS_R_MOVE;
|
|
done = FALSE;
|
|
} else
|
|
{
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_Z );
|
|
strid = IDS_JOYCALZ_MOVE;
|
|
str2id = getJoyName( pcfg, TRUE );
|
|
}
|
|
break;
|
|
|
|
case JCS_Z_PLACEHOLDER:
|
|
pcv->cState = JCS_R_MOVE;
|
|
done = FALSE;
|
|
break;
|
|
|
|
case JCS_R_MOVE:
|
|
stridx = CALSTR5;
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_HASR) && !(pcfg->dwUsageSettings & JOY_US_HASRUDDER) )
|
|
{
|
|
pcv->cState = JCS_U_MOVE;
|
|
done = FALSE;
|
|
} else
|
|
{
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_R );
|
|
strid = IDS_JOYCALRUDDER_MOVE;
|
|
str2id = getJoyName( pcfg, TRUE );
|
|
}
|
|
break;
|
|
|
|
case JCS_R_PLACEHOLDER:
|
|
pcv->cState = JCS_U_MOVE;
|
|
done = FALSE;
|
|
break;
|
|
|
|
case JCS_U_MOVE:
|
|
stridx = CALSTR6;
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_HASU) )
|
|
{
|
|
pcv->cState = JCS_V_MOVE;
|
|
done = FALSE;
|
|
} else
|
|
{
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_U );
|
|
strid = IDS_JOYCALU_MOVE;
|
|
str2id = getJoyName( pcfg, TRUE );
|
|
}
|
|
break;
|
|
|
|
case JCS_U_PLACEHOLDER:
|
|
pcv->cState = JCS_V_MOVE;
|
|
done = FALSE;
|
|
break;
|
|
|
|
case JCS_V_MOVE:
|
|
stridx = CALSTR7;
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_HASV) )
|
|
{
|
|
pcv->cState = JCS_POV_MOVEUP;
|
|
done = FALSE;
|
|
} else
|
|
{
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_V );
|
|
strid = IDS_JOYCALV_MOVE;
|
|
str2id = getJoyName( pcfg, TRUE );
|
|
}
|
|
break;
|
|
|
|
case JCS_V_PLACEHOLDER:
|
|
pcv->cState = JCS_POV_MOVEUP;
|
|
done = FALSE;
|
|
break;
|
|
|
|
case JCS_POV_MOVEUP:
|
|
stridx = CALSTR8;
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_HASPOV) )
|
|
{
|
|
pcv->cState = JCS_FINI;
|
|
done = FALSE;
|
|
} else
|
|
{
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_POV_UP );
|
|
strid = IDS_JOYCALPOV_MOVE;
|
|
str2id = IDS_JOYCAL_UP;
|
|
str3id = getJoyName( pcfg, TRUE );
|
|
str4id = IDS_JOYCAL_UP;
|
|
}
|
|
break;
|
|
|
|
case JCS_POV_MOVERIGHT:
|
|
stridx = CALSTR9;
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_POV_RIGHT );
|
|
strid = IDS_JOYCALPOV_MOVE;
|
|
str2id = IDS_JOYCAL_RIGHT;
|
|
str3id = getJoyName( pcfg, TRUE );
|
|
str4id = IDS_JOYCAL_RIGHT;
|
|
break;
|
|
|
|
case JCS_POV_MOVEDOWN:
|
|
stridx = CALSTR10;
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_POV_DOWN );
|
|
strid = IDS_JOYCALPOV_MOVE;
|
|
str2id = IDS_JOYCAL_DOWN;
|
|
str3id = getJoyName( pcfg, TRUE );
|
|
str4id = IDS_JOYCAL_DOWN;
|
|
break;
|
|
|
|
case JCS_POV_MOVELEFT:
|
|
stridx = CALSTR11;
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_POV_LEFT );
|
|
strid = IDS_JOYCALPOV_MOVE;
|
|
str2id = IDS_JOYCAL_LEFT;
|
|
str3id = getJoyName( pcfg, TRUE );
|
|
str4id = IDS_JOYCAL_LEFT;
|
|
break;
|
|
|
|
case JCS_FINI:
|
|
/*
|
|
* see if everything that needs to be calibrated
|
|
* was actually calibrated
|
|
*/
|
|
if( !(pcfg->hwv.dwCalFlags & JOY_ISCAL_XY) )
|
|
{
|
|
isdone = FALSE;
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASZ) &&
|
|
!(pcfg->hwv.dwCalFlags & JOY_ISCAL_Z) )
|
|
{
|
|
isdone = FALSE;
|
|
} else if( ((pcfg->hws.dwFlags & JOY_HWS_HASR) ||
|
|
(pcfg->dwUsageSettings & JOY_US_HASRUDDER)) &&
|
|
!(pcfg->hwv.dwCalFlags & JOY_ISCAL_R) )
|
|
{
|
|
isdone = FALSE;
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASPOV) &&
|
|
!(pcfg->hwv.dwCalFlags & JOY_ISCAL_POV) )
|
|
{
|
|
isdone = FALSE;
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASU) &&
|
|
!(pcfg->hwv.dwCalFlags & JOY_ISCAL_U) )
|
|
{
|
|
isdone = FALSE;
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASV) &&
|
|
!(pcfg->hwv.dwCalFlags & JOY_ISCAL_V) )
|
|
{
|
|
isdone = FALSE;
|
|
} else
|
|
{
|
|
isdone = TRUE;
|
|
}
|
|
|
|
strid = ( isdone ) ? IDS_JOYCAL_DONE : IDS_JOYCAL_NOTDONE;
|
|
|
|
str2id = getJoyName( pcfg, FALSE );
|
|
str3id = getJoyName( pcfg, TRUE );
|
|
stridx = CALSTR12;
|
|
enableCalWindows( pgv, pcfg, hwnd, JC_FINI );
|
|
rc = FALSE;
|
|
break;
|
|
} // END OF SWITCH
|
|
} // END OF WHILE
|
|
|
|
|
|
// see if there is any OEM text specified
|
|
hinst = GetResourceInstance( );
|
|
assert(hinst);
|
|
hwtext = GetDlgItem( hwnd, IDC_JOYCALMSG );
|
|
|
|
if( pcfg->dwUsageSettings & JOY_US_ISOEM )
|
|
{
|
|
LPJOYDATA pjd;
|
|
pjd = pgv->pjd;
|
|
assert(pjd);
|
|
type = pcfg->dwType - JOY_HW_LASTENTRY;
|
|
if( pjd->oemList[type].cal_strs[ stridx ][0] != 0 )
|
|
{
|
|
SetWindowText( hwtext, pjd->oemList[type].cal_strs[ stridx] );
|
|
return(rc);
|
|
}
|
|
}
|
|
|
|
// no OEM text, use the defaults
|
|
LoadString( hinst, strid, str, sizeof(str));
|
|
|
|
if( lstrlen(str) )
|
|
{
|
|
if( str2id != -1 )
|
|
{
|
|
NewLoadString( hinst, str2id, str2, sizeof( str2 ) );
|
|
|
|
if( str2 )
|
|
{
|
|
if( str3id != -1 )
|
|
{
|
|
NewLoadString( hinst, str3id, str3, sizeof( str3 ) );
|
|
|
|
if( lstrlen(str3) )
|
|
{
|
|
if( str4id != -1 )
|
|
{
|
|
NewLoadString( hinst, str4id, str4, sizeof( str4 ) );
|
|
|
|
if( lstrlen(str4) )
|
|
{
|
|
// wsprintf( buff, str, str2, str3, str4 );
|
|
assert(str2);
|
|
assert(str3);
|
|
assert(str4);
|
|
LPSTR lpargs[] = {str2, str3, str4};
|
|
|
|
FormatMessage(FORMAT_MESSAGE_FROM_STRING |
|
|
FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
(LPSTR) str,
|
|
0, 0,
|
|
buff,
|
|
sizeof(buff),
|
|
lpargs);
|
|
|
|
SetWindowText( hwtext, buff );
|
|
}
|
|
} else
|
|
{
|
|
wsprintf( buff, str, str2, str3 );
|
|
SetWindowText( hwtext, buff );
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
wsprintf( buff, str, str2, str2 );
|
|
SetWindowText( hwtext, buff );
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
SetWindowText( hwtext, str );
|
|
}
|
|
}
|
|
|
|
return(rc);
|
|
|
|
} /* joyCalStateChange */
|
|
|
|
/*
|
|
* joyCalStateSkip - skip the current state, move to the next one
|
|
*/
|
|
static void joyCalStateSkip( LPCALVARS pcv, HWND hwnd )
|
|
{
|
|
|
|
assert(pcv);
|
|
assert(hwnd);
|
|
|
|
#if 0
|
|
/*
|
|
* if we're calibrating XY, skip to Z
|
|
*/
|
|
if( pcv->cState <= JCS_XY_CENTER2 )
|
|
{
|
|
pcv->cState = JCS_XY_CENTER2;
|
|
/*
|
|
* if we're calibrating Z, skip to R
|
|
*/
|
|
} else if( pcv->cState < JCS_Z_PLACEHOLDER )
|
|
{
|
|
pcv->cState = JCS_Z_PLACEHOLDER;
|
|
/*
|
|
* if we're calibrating R, skip to U
|
|
*/
|
|
} else if( pcv->cState < JCS_R_PLACEHOLDER )
|
|
{
|
|
pcv->cState = JCS_R_PLACEHOLDER;
|
|
/*
|
|
* if we're calibrating U, skip to V
|
|
*/
|
|
} else if( pcv->cState < JCS_U_PLACEHOLDER )
|
|
{
|
|
pcv->cState = JCS_U_PLACEHOLDER;
|
|
/*
|
|
* if we're calibrating V, skip to POV
|
|
*/
|
|
} else if( pcv->cState < JCS_V_PLACEHOLDER )
|
|
{
|
|
pcv->cState = JCS_V_PLACEHOLDER;
|
|
/*
|
|
* we must be calibration POV, skip to the end
|
|
*/
|
|
} else
|
|
{
|
|
pcv->cState = JCS_POV_MOVELEFT;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* state changed, reset to the new one
|
|
*/
|
|
CauseRedraw( &pcv->ji, FALSE );
|
|
joyCalStateChange( pcv, hwnd, TRUE );
|
|
|
|
} /* joyCalStateSkip */
|
|
|
|
/*
|
|
* resetCustomPOVFlags - set POV flags based on original values for custom joystick
|
|
*/
|
|
static void resetCustomPOVFlags( LPGLOBALVARS pgv, LPJOYREGHWCONFIG pcfg )
|
|
{
|
|
assert(pgv);
|
|
assert(pcfg);
|
|
|
|
if( pcfg->dwType == JOY_HW_CUSTOM )
|
|
{
|
|
pcfg->hws.dwFlags &= ~(JOY_HWS_POVISPOLL|JOY_HWS_POVISBUTTONCOMBOS);
|
|
|
|
if( pgv->bOrigPOVIsPoll )
|
|
pcfg->hws.dwFlags |= JOY_HWS_POVISPOLL;
|
|
|
|
if( pgv->bOrigPOVIsButtonCombos )
|
|
pcfg->hws.dwFlags |= JOY_HWS_POVISBUTTONCOMBOS;
|
|
}
|
|
|
|
} /* resetCustomPOVFlags */
|
|
|
|
|
|
/*
|
|
* joyCalStateBack - move back to start the previous state
|
|
*/
|
|
static void joyCalStateBack( LPCALVARS pcv, HWND hwnd )
|
|
{
|
|
assert(pcv);
|
|
assert(hwnd);
|
|
|
|
BOOL back;
|
|
LPJOYREGHWCONFIG pcfg;
|
|
LPGLOBALVARS pgv;
|
|
|
|
pgv = pcv->pgv;
|
|
assert(pgv);
|
|
back = TRUE;
|
|
pcfg = &pgv->joyHWCurr;
|
|
assert(pcfg);
|
|
/*
|
|
* at the end, backup
|
|
*/
|
|
if( pcv->cState == JCS_FINI )
|
|
{
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALBACK));
|
|
// END ADD
|
|
|
|
/*
|
|
* if there is POV, back up to it
|
|
*/
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASPOV )
|
|
{
|
|
pcv->cState = JCS_V_PLACEHOLDER;
|
|
resetCustomPOVFlags( pgv, pcfg );
|
|
/*
|
|
* if there is V, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASV )
|
|
{
|
|
pcv->cState = JCS_U_PLACEHOLDER;
|
|
/*
|
|
* if there is U, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASU )
|
|
{
|
|
pcv->cState = JCS_R_PLACEHOLDER;
|
|
/*
|
|
* if there is R, back up to it
|
|
*/
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASR) || (pcfg->dwUsageSettings & JOY_US_HASRUDDER) )
|
|
{
|
|
pcv->cState = JCS_Z_PLACEHOLDER;
|
|
/*
|
|
* if there is Z, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASZ )
|
|
{
|
|
pcv->cState = JCS_XY_CENTER2;
|
|
/*
|
|
* no where else to go, back up to XY
|
|
*/
|
|
} else
|
|
{
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALNEXT));
|
|
// END ADD
|
|
// pcv->cState = JCS_INIT;
|
|
pcv->cState = JCS_XY_MOVE;
|
|
// back = FALSE;
|
|
}
|
|
/*
|
|
* doing POV, so restart it
|
|
*/
|
|
} else if( pcv->cState > JCS_POV_MOVEUP )
|
|
{
|
|
pcv->cState = JCS_V_PLACEHOLDER;
|
|
// pcfg->hws.dwFlags &= ~(JOY_HWS_POVISPOLL|JOY_HWS_POVISBUTTONCOMBOS);
|
|
resetCustomPOVFlags( pgv, pcfg );
|
|
/*
|
|
* just starting POV, back up
|
|
*/
|
|
} else if( pcv->cState == JCS_POV_MOVEUP )
|
|
{
|
|
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALBACK));
|
|
// END ADD
|
|
|
|
/*
|
|
* if there is V, back up to it
|
|
*/
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASV )
|
|
{
|
|
pcv->cState = JCS_U_PLACEHOLDER;
|
|
/*
|
|
* if there is U, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASU )
|
|
{
|
|
pcv->cState = JCS_R_PLACEHOLDER;
|
|
/*
|
|
* if there is R, back up to it
|
|
*/
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASR) ||
|
|
(pcfg->dwUsageSettings & JOY_US_HASRUDDER) )
|
|
{
|
|
pcv->cState = JCS_Z_PLACEHOLDER;
|
|
/*
|
|
* if there is Z, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASZ )
|
|
{
|
|
pcv->cState = JCS_XY_CENTER2;
|
|
/*
|
|
* no where else to go, back up to XY
|
|
*/
|
|
} else
|
|
{
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALNEXT));
|
|
// END ADD
|
|
// pcv->cState = JCS_INIT;
|
|
pcv->cState = JCS_XY_MOVE;
|
|
// back = FALSE;
|
|
}
|
|
/*
|
|
* doing V, backup
|
|
*/
|
|
} else if( pcv->cState == JCS_V_MOVE )
|
|
{
|
|
/*
|
|
* if there is U, back up to it
|
|
*/
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASU )
|
|
{
|
|
pcv->cState = JCS_R_PLACEHOLDER;
|
|
/*
|
|
* if there is R, back up to it
|
|
*/
|
|
} else if( (pcfg->hws.dwFlags & JOY_HWS_HASR) ||
|
|
(pcfg->dwUsageSettings & JOY_US_HASRUDDER) )
|
|
{
|
|
pcv->cState = JCS_Z_PLACEHOLDER;
|
|
/*
|
|
* if there is Z, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASZ )
|
|
{
|
|
pcv->cState = JCS_XY_CENTER2;
|
|
/*
|
|
* no where else to go, back up to XY
|
|
*/
|
|
} else
|
|
{
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALNEXT));
|
|
// END ADD
|
|
// pcv->cState = JCS_INIT;
|
|
pcv->cState = JCS_XY_MOVE;
|
|
// back = FALSE;
|
|
}
|
|
/*
|
|
* doing U, backup
|
|
*/
|
|
} else if( pcv->cState == JCS_U_MOVE )
|
|
{
|
|
/*
|
|
* if there is R, back up to it
|
|
*/
|
|
if( (pcfg->hws.dwFlags & JOY_HWS_HASR) ||
|
|
(pcfg->dwUsageSettings & JOY_US_HASRUDDER) )
|
|
{
|
|
pcv->cState = JCS_Z_PLACEHOLDER;
|
|
/*
|
|
* if there is Z, back up to it
|
|
*/
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_HASZ )
|
|
{
|
|
pcv->cState = JCS_XY_CENTER2;
|
|
/*
|
|
* no where else to go, back up to XY
|
|
*/
|
|
} else
|
|
{
|
|
// pcv->cState = JCS_INIT;
|
|
pcv->cState = JCS_XY_MOVE;
|
|
// back = FALSE;
|
|
}
|
|
/*
|
|
* doing R, backup
|
|
*/
|
|
} else if( pcv->cState == JCS_R_MOVE )
|
|
{
|
|
/*
|
|
* if there is Z, back up to it
|
|
*/
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASZ )
|
|
{
|
|
pcv->cState = JCS_XY_CENTER2;
|
|
/*
|
|
* no where else to go, back up to XY
|
|
*/
|
|
} else
|
|
{
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALNEXT));
|
|
// END ADD
|
|
// pcv->cState = JCS_INIT;
|
|
pcv->cState = JCS_XY_MOVE;
|
|
// back = FALSE;
|
|
}
|
|
/*
|
|
* if we're doing Z or in the middle of XY, backup to XY
|
|
*/
|
|
} else if( pcv->cState == JCS_XY_MOVE )
|
|
{
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALNEXT));
|
|
pcv->cState = JCS_INIT;
|
|
back = FALSE;
|
|
} else
|
|
{
|
|
// ADDED BY CML 6/21/96 TO FIX LOST FOCUS BUG (FLASH RAID 167)
|
|
SetFocus(GetDlgItem(hwnd, IDC_JOYCALNEXT));
|
|
// END ADD
|
|
pcv->cState = (cal_states)(pcv->cState - 2);
|
|
// pcv->cState = JCS_INIT;
|
|
// back = FALSE;
|
|
}
|
|
|
|
/*
|
|
* state changed, reset to the new one
|
|
*/
|
|
CauseRedraw( &pcv->ji, FALSE );
|
|
joyCalStateChange( pcv, hwnd, back );
|
|
|
|
} /* joyCalStateBack */
|
|
|
|
// macro to get new max/min data for an axis
|
|
#define NEWMINMAX( a ) \
|
|
if( pji->dw##a##pos > pcv->jr.jpMax.dw##a ) { \
|
|
pcv->jr.jpMax.dw##a = pji->dw##a##pos; \
|
|
} \
|
|
if( pji->dw##a##pos < pcv->jr.jpMin.dw##a ) { \
|
|
pcv->jr.jpMin.dw##a = pji->dw##a##pos; \
|
|
} \
|
|
pji->dw##a##pos *= RAW_SHIFT;
|
|
|
|
// joyCollectCalInfo - record calibration info
|
|
static BOOL joyCollectCalInfo( LPCALVARS pcv, HWND hwnd, LPJOYINFOEX pji )
|
|
{
|
|
assert(pcv);
|
|
assert(hwnd);
|
|
assert(pji);
|
|
|
|
LPGLOBALVARS pgv;
|
|
LPJOYREGHWCONFIG pcfg;
|
|
|
|
pgv = pcv->pgv;
|
|
assert(pgv);
|
|
switch( pcv->cState )
|
|
{
|
|
// remember XY center
|
|
case JCS_XY_CENTER1:
|
|
case JCS_XY_CENTER2:
|
|
#ifdef _DEBUG
|
|
TRACE("%s: %d: dwXpos is %d dwYpos is %d\n", __FILE__, __LINE__, pji->dwXpos, pji->dwYpos);
|
|
#endif // _DEBUG
|
|
if( !pcv->jr.jpCenter.dwY )
|
|
{
|
|
pgv->joyRange.jpMax.dwY = pji->dwYpos << 1;
|
|
pcv->jr.jpCenter.dwY = pji->dwYpos;
|
|
}
|
|
|
|
if( !pcv->jr.jpCenter.dwX )
|
|
{
|
|
pgv->joyRange.jpMax.dwX = pji->dwXpos << 1;
|
|
pcv->jr.jpCenter.dwX = pji->dwXpos;
|
|
}
|
|
|
|
pgv->joyRange.jpMin.dwX = 0;
|
|
pgv->joyRange.jpMin.dwY = 0;
|
|
|
|
DoJoyMove( pgv, hwnd, pji, &pcv->ji, JOYMOVE_DRAWXY );
|
|
break;
|
|
|
|
// remember max/min XY values
|
|
case JCS_XY_MOVE:
|
|
if( pji->dwXpos > pcv->jr.jpMax.dwX )
|
|
{
|
|
pcv->jr.jpMax.dwX = pji->dwXpos;
|
|
}
|
|
|
|
if( pji->dwXpos < pcv->jr.jpMin.dwX )
|
|
{
|
|
pcv->jr.jpMin.dwX = pji->dwXpos;
|
|
}
|
|
|
|
if( pji->dwYpos > pcv->jr.jpMax.dwY )
|
|
{
|
|
pcv->jr.jpMax.dwY = pji->dwYpos;
|
|
}
|
|
|
|
if( pji->dwYpos < pcv->jr.jpMin.dwY )
|
|
{
|
|
pcv->jr.jpMin.dwY = pji->dwYpos;
|
|
}
|
|
|
|
DoJoyMove( pgv, hwnd, pji, &pcv->ji, JOYMOVE_DRAWXY );
|
|
break;
|
|
|
|
// remember max/min Z value
|
|
case JCS_Z_MOVE:
|
|
NEWMINMAX( Z );
|
|
DoJoyMove( pgv, hwnd, pji, &pcv->ji, JOYMOVE_DRAWZ );
|
|
break;
|
|
|
|
// remember max/min R value
|
|
case JCS_R_MOVE:
|
|
NEWMINMAX( R );
|
|
DoJoyMove( pgv, hwnd, pji, &pcv->ji, JOYMOVE_DRAWR );
|
|
break;
|
|
|
|
// remember max/min U value
|
|
case JCS_U_MOVE:
|
|
NEWMINMAX( U );
|
|
DoJoyMove( pgv, hwnd, pji, &pcv->ji, JOYMOVE_DRAWU );
|
|
break;
|
|
|
|
// remember max/min V value
|
|
case JCS_V_MOVE:
|
|
NEWMINMAX( V );
|
|
DoJoyMove( pgv, hwnd, pji, &pcv->ji, JOYMOVE_DRAWV );
|
|
break;
|
|
}
|
|
|
|
// if a button was pressed, move to the next state
|
|
if( ((pcv->ji.dwButtons & ALL_BUTTONS) != (pji->dwButtons & ALL_BUTTONS)) &&
|
|
((pji->dwButtons & JOY_BUTTON1) ||
|
|
(pji->dwButtons & JOY_BUTTON2) ||
|
|
(pji->dwButtons & JOY_BUTTON3) ||
|
|
(pji->dwButtons & JOY_BUTTON4) ||
|
|
(pji->dwButtons & JOY_BUTTON5) ||
|
|
(pji->dwButtons & JOY_BUTTON6) ||
|
|
(pji->dwButtons & JOY_BUTTON7) ||
|
|
(pji->dwButtons & JOY_BUTTON8) ||
|
|
(pji->dwButtons & JOY_BUTTON9) ||
|
|
(pji->dwButtons & JOY_BUTTON10) ||
|
|
(pji->dwButtons & JOY_BUTTON11) ||
|
|
(pji->dwButtons & JOY_BUTTON12) ||
|
|
(pji->dwButtons & JOY_BUTTON13) ||
|
|
(pji->dwButtons & JOY_BUTTON14) ||
|
|
(pji->dwButtons & JOY_BUTTON15) ||
|
|
(pji->dwButtons & JOY_BUTTON16) ||
|
|
(pji->dwButtons & JOY_BUTTON17) ||
|
|
(pji->dwButtons & JOY_BUTTON18) ||
|
|
(pji->dwButtons & JOY_BUTTON19) ||
|
|
(pji->dwButtons & JOY_BUTTON20) ||
|
|
(pji->dwButtons & JOY_BUTTON21) ||
|
|
(pji->dwButtons & JOY_BUTTON22) ||
|
|
(pji->dwButtons & JOY_BUTTON23) ||
|
|
(pji->dwButtons & JOY_BUTTON24) ||
|
|
(pji->dwButtons & JOY_BUTTON25) ||
|
|
(pji->dwButtons & JOY_BUTTON26) ||
|
|
(pji->dwButtons & JOY_BUTTON27) ||
|
|
(pji->dwButtons & JOY_BUTTON28) ||
|
|
(pji->dwButtons & JOY_BUTTON29) ||
|
|
(pji->dwButtons & JOY_BUTTON30) ||
|
|
(pji->dwButtons & JOY_BUTTON31) ||
|
|
(pji->dwButtons & JOY_BUTTON32) ) )
|
|
{
|
|
// check and see if we are leaving one calibration to the next;
|
|
// if yes, take time to stop and remember what the user just did
|
|
pcfg = &pgv->joyHWCurr;
|
|
assert(pcfg);
|
|
|
|
switch( pcv->cState )
|
|
{
|
|
case JCS_XY_CENTER1:
|
|
pcv->jr.jpCenter.dwX = pji->dwXpos;
|
|
pcv->jr.jpCenter.dwY = pji->dwYpos;
|
|
DPF( "Center 1: %d,%d\r\n", pji->dwXpos, pji->dwYpos );
|
|
break;
|
|
|
|
case JCS_XY_CENTER2:
|
|
DPF( "Center 2: %d,%d\r\n", pji->dwXpos, pji->dwYpos );
|
|
pcv->jr.jpCenter.dwX += pji->dwXpos;
|
|
pcv->jr.jpCenter.dwY += pji->dwYpos;
|
|
pcv->jr.jpCenter.dwX /= 2;
|
|
pcv->jr.jpCenter.dwY /= 2;
|
|
DPF( "Center Avg: %d,%d\r\n", pcv->jr.jpCenter.dwX, pcv->jr.jpCenter.dwY );
|
|
pcfg->hwv.jrvHardware.jpMin.dwX = pcv->jr.jpMin.dwX;
|
|
pcfg->hwv.jrvHardware.jpMin.dwY = pcv->jr.jpMin.dwY;
|
|
pcfg->hwv.jrvHardware.jpMax.dwX = pcv->jr.jpMax.dwX;
|
|
pcfg->hwv.jrvHardware.jpMax.dwY = pcv->jr.jpMax.dwY;
|
|
pcfg->hwv.jrvHardware.jpCenter.dwX = pcv->jr.jpCenter.dwX;
|
|
pcfg->hwv.jrvHardware.jpCenter.dwY = pcv->jr.jpCenter.dwY;
|
|
pcfg->hwv.dwCalFlags |= JOY_ISCAL_XY;
|
|
break;
|
|
case JCS_Z_MOVE:
|
|
pcfg->hwv.jrvHardware.jpMin.dwZ = pcv->jr.jpMin.dwZ;
|
|
pcfg->hwv.jrvHardware.jpMax.dwZ = pcv->jr.jpMax.dwZ;
|
|
pcfg->hwv.dwCalFlags |= JOY_ISCAL_Z;
|
|
break;
|
|
case JCS_R_MOVE:
|
|
pcfg->hwv.jrvHardware.jpMin.dwR = pcv->jr.jpMin.dwR;
|
|
pcfg->hwv.jrvHardware.jpMax.dwR = pcv->jr.jpMax.dwR;
|
|
pcfg->hwv.dwCalFlags |= JOY_ISCAL_R;
|
|
break;
|
|
case JCS_U_MOVE:
|
|
pcfg->hwv.jrvHardware.jpMin.dwU = pcv->jr.jpMin.dwU;
|
|
pcfg->hwv.jrvHardware.jpMax.dwU = pcv->jr.jpMax.dwU;
|
|
pcfg->hwv.dwCalFlags |= JOY_ISCAL_U;
|
|
break;
|
|
case JCS_V_MOVE:
|
|
pcfg->hwv.jrvHardware.jpMin.dwV = pcv->jr.jpMin.dwV;
|
|
pcfg->hwv.jrvHardware.jpMax.dwV = pcv->jr.jpMax.dwV;
|
|
pcfg->hwv.dwCalFlags |= JOY_ISCAL_V;
|
|
break;
|
|
}
|
|
|
|
pcv->ji.dwButtons = pji->dwButtons;
|
|
return(joyCalStateChange( pcv, hwnd, TRUE ));
|
|
}
|
|
pcv->ji.dwButtons = pji->dwButtons;
|
|
return(TRUE);
|
|
|
|
} /* joyCollectCalInfo */
|
|
|
|
/*
|
|
* joyCalibrateInitDialog - init the calibration dialog
|
|
*/
|
|
static BOOL joyCalibrateInitDialog( HWND hwnd, LPARAM lParam )
|
|
{
|
|
LPJOYREGHWCONFIG pcfg;
|
|
LPCALVARS pcv = NULL;
|
|
LPGLOBALVARS pgv = NULL;
|
|
|
|
ASSERT (::IsWindow(hwnd));
|
|
|
|
// set up calibration variables
|
|
pcv = (CALVARS *) DoAlloc( sizeof( CALVARS ) );
|
|
ASSERT(pcv);
|
|
|
|
if( pcv == NULL ) return(FALSE);
|
|
|
|
SetWindowLong( hwnd, DWL_USER, (LONG) pcv );
|
|
assert(pcv);
|
|
|
|
pgv = (LPGLOBALVARS) lParam;
|
|
assert(pgv);
|
|
|
|
pcv->pgv = pgv;
|
|
|
|
//
|
|
// set labels
|
|
//
|
|
LPSTR psz1 = new char[MAX_STR_LEN];
|
|
ASSERT (psz1);
|
|
|
|
LPSTR psz2 = new char[MAX_STR_LEN];
|
|
ASSERT (psz2);
|
|
|
|
if( !LoadString(GetResourceInstance(), IDS_JOYCALCAPN, psz1, MAX_STR_LEN) )
|
|
{
|
|
TRACE( "%s: %s - LoadString Failure!\n", __FILE__, __LINE__);
|
|
}
|
|
|
|
wsprintf(psz2, psz1, pgv->iJoyId+1);
|
|
SetWindowText(hwnd, psz2);
|
|
|
|
if( psz1 )
|
|
delete[] (psz1);
|
|
|
|
if( psz2 )
|
|
delete[] (psz2);
|
|
|
|
|
|
// init state info
|
|
pcv->cState = JCS_INIT;
|
|
|
|
// set dialog text based on OEM strings
|
|
SetOEMText( pgv, hwnd, FALSE );
|
|
|
|
// customize dialog based on Z axis, R axis, and POV hat
|
|
pcfg = &pgv->joyHWCurr;
|
|
assert(pcfg);
|
|
|
|
pcv->iAxisCount = 2;
|
|
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASZ )
|
|
pcv->iAxisCount++;
|
|
|
|
if( (pcfg->hws.dwFlags & JOY_HWS_HASR) || (pcfg->dwUsageSettings & JOY_US_HASRUDDER) )
|
|
pcv->iAxisCount++;
|
|
|
|
if( (pcfg->hws.dwFlags & JOY_HWS_HASPOV) && (pcfg->hws.dwFlags & JOY_HWS_POVISPOLL) )
|
|
pcv->iAxisCount++;
|
|
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASU )
|
|
pcv->iAxisCount++;
|
|
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASV )
|
|
pcv->iAxisCount++;
|
|
|
|
ShowControls( pcfg, hwnd );
|
|
|
|
HWND hCtrl = GetDlgItem( hwnd, IDC_JOYPOV_LABEL );
|
|
ASSERT (::IsWindow(hCtrl));
|
|
ShowWindow(hCtrl, pcfg->hws.dwFlags & JOY_HWS_HASPOV ? SW_SHOW : SW_HIDE);
|
|
|
|
// if all axes are used and we have POV then it MUST be buttons
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASPOV )
|
|
{
|
|
if( pgv->dwMaxAxes == 4 && pcv->iAxisCount == 4 )
|
|
pcfg->hws.dwFlags |= JOY_HWS_POVISBUTTONCOMBOS;
|
|
}
|
|
|
|
// other misc setup
|
|
pcv->bPOVdone = FALSE;
|
|
pcv->bHasTimer = SetTimer( hwnd, TIMER_ID, JOYPOLLTIME, NULL );
|
|
pcv->bUseTimer = TRUE;
|
|
|
|
if( !pcv->bHasTimer )
|
|
{
|
|
DPF( "No timer for joystick calibration!\r\n" );
|
|
return(FALSE);
|
|
}
|
|
|
|
if( !joyCalStateChange( pcv, hwnd, FALSE ) )
|
|
{
|
|
DPF( "Could not initialize joystick calibration\r\n" );
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
|
|
} /* joyCalibrateInitDialog */
|
|
|
|
/*
|
|
* setJIFlagsForPOV - get joyinfo flags to allow a raw POV poll
|
|
*/
|
|
static void setJIFlagsForPOV( LPCALVARS pcv, LPJOYREGHWCONFIG pcfg, DWORD *pflags )
|
|
{
|
|
/*
|
|
* for polled POV, we need to specifiy JOY_CAL_READ(3|4) to make
|
|
* the driver give us position values back instead of trying to
|
|
* give us a POV value back
|
|
*/
|
|
// if( pcfg->hws.dwFlags & JOY_HWS_HASPOV )
|
|
{
|
|
if( pcfg->hws.dwFlags & JOY_HWS_POVISPOLL )
|
|
{
|
|
switch( pcv->iAxisCount )
|
|
{
|
|
case 6:
|
|
(*pflags) |= JOY_CAL_READ6;
|
|
break;
|
|
case 5:
|
|
(*pflags) |= JOY_CAL_READ5;
|
|
break;
|
|
|
|
case 4:
|
|
(*pflags) |= JOY_CAL_READ4;
|
|
break;
|
|
|
|
case 3:
|
|
(*pflags) |= JOY_CAL_READ3;
|
|
break;
|
|
}
|
|
// If we don't have a 3rd or 4th axis on this joystick, try reading
|
|
// another axis anyway to see if the POV hat is on it
|
|
} else if( !(pcfg->hws.dwFlags & (JOY_HWS_POVISPOLL|JOY_HWS_POVISBUTTONCOMBOS)) )
|
|
{
|
|
switch( pcv->iAxisCount )
|
|
{
|
|
case 5:
|
|
(*pflags) |= JOY_CAL_READ6;
|
|
break;
|
|
|
|
case 4:
|
|
(*pflags) |= JOY_CAL_READ5;
|
|
break;
|
|
|
|
case 3:
|
|
(*pflags) |= JOY_CAL_READ4;
|
|
break;
|
|
|
|
case 2:
|
|
(*pflags) |= JOY_CAL_READ3;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
} /* setJIFlagsForPOV */
|
|
|
|
// tryPOV - try for a POV access
|
|
static BOOL tryPOV( LPCALVARS pcv, HWND hwnd )
|
|
{
|
|
assert(pcv);
|
|
assert(hwnd);
|
|
|
|
int rc;
|
|
BOOL ispoll;
|
|
BOOL isb;
|
|
BOOL nowaypoll;
|
|
JOYINFOEX ji;
|
|
DWORD val;
|
|
LPJOYREGHWCONFIG pcfg;
|
|
LPGLOBALVARS pgv;
|
|
int i;
|
|
|
|
pgv = pcv->pgv;
|
|
assert(pgv);
|
|
|
|
// reject call if not in a POV state
|
|
if( !(pcv->cState == JCS_POV_MOVEUP || pcv->cState == JCS_POV_MOVEDOWN ||
|
|
pcv->cState == JCS_POV_MOVELEFT || pcv->cState == JCS_POV_MOVERIGHT) )
|
|
return(FALSE);
|
|
|
|
// take a snapshot of the current joystick state
|
|
pcfg = &pgv->joyHWCurr;
|
|
assert(pcfg);
|
|
nowaypoll = FALSE;
|
|
ji.dwSize = sizeof( ji );
|
|
while( 1 )
|
|
{
|
|
// get joystick info
|
|
ji.dwFlags = JOY_CALIB_FLAGS;
|
|
|
|
// if you have a POV, set the flags for it!
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASPOV )
|
|
setJIFlagsForPOV( pcv, pcfg, &ji.dwFlags );
|
|
|
|
rc = joyGetPosEx( pgv->iJoyId, &ji );
|
|
if( rc == JOYERR_NOERROR )
|
|
break;
|
|
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_POVISPOLL) && (ji.dwFlags & (JOY_CAL_READ3|JOY_CAL_READ4|JOY_CAL_READ5|JOY_CAL_READ6)) )
|
|
{
|
|
// try again, but don't ask for extra axis
|
|
ji.dwFlags &= ~(JOY_CAL_READ6 | JOY_CAL_READ5 | JOY_CAL_READ4 | JOY_CAL_READ3);
|
|
rc = joyGetPosEx( pgv->iJoyId, &ji );
|
|
if( rc == JOYERR_NOERROR )
|
|
{
|
|
nowaypoll = TRUE; // pov can't possibly be polled
|
|
break;
|
|
} else return(JoyError( hwnd )) ? TRUE : FALSE; // have to wait for next "Select POV" to retry
|
|
} else return(JoyError( hwnd )) ? TRUE : FALSE; // have to wait for next "Select POV" to retry
|
|
}
|
|
|
|
/*
|
|
* here is where we determine if POV is polled or is button combos.
|
|
*
|
|
* See if we already know the answer (bits in joyHWCurr):
|
|
* if yes:
|
|
* we're done.
|
|
* if no:
|
|
* We see if there are currently multiple buttons down.
|
|
* if yes:
|
|
* POV is assumed to be button combos.
|
|
* if no:
|
|
* POV is assumed to be done with polling
|
|
*/
|
|
ispoll = FALSE;
|
|
isb = FALSE;
|
|
if( pcfg->hws.dwFlags & JOY_HWS_POVISPOLL )
|
|
{
|
|
ispoll = TRUE;
|
|
} else if( pcfg->hws.dwFlags & JOY_HWS_POVISBUTTONCOMBOS )
|
|
{
|
|
isb = TRUE;
|
|
}
|
|
|
|
if( !isb && !ispoll )
|
|
{
|
|
// the type is indeterminate, so we identify it
|
|
if( nowaypoll ||((ji.dwButtons != 0) &&
|
|
(ji.dwButtons != JOY_BUTTON1) &&
|
|
(ji.dwButtons != JOY_BUTTON2) &&
|
|
(ji.dwButtons != JOY_BUTTON3) &&
|
|
(ji.dwButtons != JOY_BUTTON4) &&
|
|
(ji.dwButtons != JOY_BUTTON5) &&
|
|
(ji.dwButtons != JOY_BUTTON6) &&
|
|
(ji.dwButtons != JOY_BUTTON7) &&
|
|
(ji.dwButtons != JOY_BUTTON8) &&
|
|
(ji.dwButtons != JOY_BUTTON9) &&
|
|
(ji.dwButtons != JOY_BUTTON10) &&
|
|
(ji.dwButtons != JOY_BUTTON11) &&
|
|
(ji.dwButtons != JOY_BUTTON12) &&
|
|
(ji.dwButtons != JOY_BUTTON13) &&
|
|
(ji.dwButtons != JOY_BUTTON14) &&
|
|
(ji.dwButtons != JOY_BUTTON15) &&
|
|
(ji.dwButtons != JOY_BUTTON16) &&
|
|
(ji.dwButtons != JOY_BUTTON17) &&
|
|
(ji.dwButtons != JOY_BUTTON18) &&
|
|
(ji.dwButtons != JOY_BUTTON19) &&
|
|
(ji.dwButtons != JOY_BUTTON20) &&
|
|
(ji.dwButtons != JOY_BUTTON21) &&
|
|
(ji.dwButtons != JOY_BUTTON22) &&
|
|
(ji.dwButtons != JOY_BUTTON23) &&
|
|
(ji.dwButtons != JOY_BUTTON24) &&
|
|
(ji.dwButtons != JOY_BUTTON25) &&
|
|
(ji.dwButtons != JOY_BUTTON26) &&
|
|
(ji.dwButtons != JOY_BUTTON27) &&
|
|
(ji.dwButtons != JOY_BUTTON28) &&
|
|
(ji.dwButtons != JOY_BUTTON29) &&
|
|
(ji.dwButtons != JOY_BUTTON30) &&
|
|
(ji.dwButtons != JOY_BUTTON31) &&
|
|
(ji.dwButtons != JOY_BUTTON32) ) )
|
|
{
|
|
isb = TRUE;
|
|
pcfg->hws.dwFlags |= JOY_HWS_POVISBUTTONCOMBOS;
|
|
} else
|
|
{
|
|
// we always assume J2 Y for a polling POV if unspecified
|
|
ispoll = TRUE;
|
|
pcfg->hws.dwFlags |= JOY_HWS_POVISPOLL;
|
|
}
|
|
|
|
// the driver needs to notified that we've made this decision
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
}
|
|
|
|
// record the data value for this POV reading
|
|
if( isb )
|
|
val = ji.dwButtons;
|
|
else
|
|
val = (pcfg->hws.dwFlags & JOY_HWS_HASZ) ? ji.dwRpos : ji.dwZpos;
|
|
|
|
switch( pcv->cState )
|
|
{
|
|
case JCS_POV_MOVEUP:
|
|
pcv->pov[JOY_POVVAL_FORWARD] = val;
|
|
break;
|
|
|
|
case JCS_POV_MOVERIGHT:
|
|
pcv->pov[JOY_POVVAL_RIGHT] = val;
|
|
break;
|
|
|
|
case JCS_POV_MOVEDOWN:
|
|
pcv->pov[JOY_POVVAL_BACKWARD] = val;
|
|
break;
|
|
|
|
case JCS_POV_MOVELEFT:
|
|
pcv->pov[JOY_POVVAL_LEFT] = val;
|
|
|
|
// since this was the last POV thing to calibrate, we need to save the calibration info
|
|
for( i=0;i<JOY_POV_NUMDIRS;i++ )
|
|
pcfg->hwv.dwPOVValues[i] = pcv->pov[i];
|
|
|
|
pcfg->hwv.dwCalFlags |= JOY_ISCAL_POV;
|
|
pcv->bPOVdone = TRUE;
|
|
break;
|
|
}
|
|
return(joyCalStateChange( pcv, hwnd, TRUE ));
|
|
|
|
} /* tryPOV */
|
|
|
|
#ifdef DEAD_CODE
|
|
// FixCustomPOVType - fix custom POV type info if POV wasn't calibrated; called by test dlg to update config
|
|
void FixCustomPOVType( LPCALVARS pcv )
|
|
{
|
|
assert(pcv);
|
|
|
|
if( !pcv->bPOVdone )
|
|
resetCustomPOVFlags( pcv->pgv, &pcv->pgv->joyHWCurr );
|
|
|
|
} /* FixCustomPOVType */
|
|
#endif // DEAD_CODE
|
|
|
|
|
|
// CalibrateProc - calibrate a joystick
|
|
BOOL CALLBACK CalibrateProc( HWND hwnd, UINT umsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch( umsg )
|
|
{
|
|
case WM_CONTEXTMENU:
|
|
OnContextMenu(wParam);
|
|
return(1);
|
|
|
|
case WM_HELP:
|
|
OnHelp(lParam);
|
|
return(1);
|
|
|
|
case WM_TIMER:
|
|
{
|
|
LPCALVARS pcv = (LPCALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
assert(pcv);
|
|
|
|
if( pcv->bUseTimer )
|
|
{
|
|
JOYINFOEX *ji = new JOYINFOEX;
|
|
ASSERT (ji);
|
|
|
|
MMRESULT rc;
|
|
LPJOYREGHWCONFIG pcfg;
|
|
LPGLOBALVARS pgv;
|
|
|
|
pgv = pcv->pgv;
|
|
assert(pgv);
|
|
|
|
pcv->bUseTimer = FALSE;
|
|
ji->dwSize = sizeof( JOYINFOEX );
|
|
|
|
while( 1 )
|
|
{
|
|
// get current joystick info
|
|
ji->dwFlags = JOY_CALIB_FLAGS;
|
|
pcfg = &pgv->joyHWCurr;
|
|
ASSERT(pcfg);
|
|
|
|
// if there is a POV, set the flags for it!
|
|
if( pcfg->hws.dwFlags & JOY_HWS_HASPOV )
|
|
setJIFlagsForPOV( pcv, pcfg, &ji->dwFlags );
|
|
|
|
rc = joyGetPosEx( pgv->iJoyId, ji );
|
|
|
|
if( rc == JOYERR_NOERROR )
|
|
break;
|
|
|
|
// didn't work, try without extra POV axis
|
|
if( !(pcfg->hws.dwFlags & JOY_HWS_POVISPOLL) && (ji->dwFlags & (JOY_CAL_READ3|JOY_CAL_READ4|JOY_CAL_READ5|JOY_CAL_READ6)) )
|
|
{
|
|
ji->dwFlags &= ~(JOY_CAL_READ6 | JOY_CAL_READ5 | JOY_CAL_READ4 | JOY_CAL_READ3);
|
|
|
|
rc = joyGetPosEx( pgv->iJoyId, ji );
|
|
|
|
if( rc == JOYERR_NOERROR )
|
|
break;
|
|
}
|
|
|
|
if( !JoyError( hwnd ) )
|
|
{
|
|
// return now if cancel selected; don't turn back on the timer
|
|
PostMessage(hwnd, WM_COMMAND, IDCANCEL, 0); // ADDED CML 7/05/96
|
|
return(FALSE);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// how could you get here and rc != JOYERR_NOERROR?
|
|
if( rc == JOYERR_NOERROR )
|
|
joyCollectCalInfo( pcv, hwnd, ji );
|
|
|
|
if( ji )
|
|
delete (ji);
|
|
|
|
/*
|
|
* If we've started POV calibration, we need to look at the
|
|
* keyboard and ignore joystick, so don't turn the timer
|
|
* back on if we've started the POV calibration
|
|
*/
|
|
if( pcv->cState < JCS_POV_MOVEUP )
|
|
pcv->bUseTimer = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
case WM_DESTROY:
|
|
{
|
|
LPCALVARS pcv = (LPCALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
assert(pcv);
|
|
DoFree( pcv );
|
|
break;
|
|
}
|
|
|
|
case WM_INITDIALOG:
|
|
if( !joyCalibrateInitDialog( hwnd, lParam ) )
|
|
{
|
|
LPCALVARS pcv = (LPCALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
assert(pcv);
|
|
|
|
if( pcv != NULL && pcv->bHasTimer )
|
|
{
|
|
KillTimer( hwnd, TIMER_ID );
|
|
pcv->bHasTimer = FALSE;
|
|
}
|
|
|
|
EndDialog( hwnd, 0 );
|
|
}
|
|
return(FALSE);
|
|
|
|
case WM_PAINT:
|
|
{
|
|
LPCALVARS pcv = (LPCALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
assert(pcv);
|
|
CauseRedraw( &pcv->ji, FALSE );
|
|
return(FALSE);
|
|
}
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
LPCALVARS pcv = (LPCALVARS) GetWindowLong( hwnd, DWL_USER );
|
|
assert(pcv);
|
|
int id = GET_WM_COMMAND_ID(wParam, lParam);
|
|
|
|
switch( id )
|
|
{
|
|
#ifdef DEAD_CODE
|
|
case IDC_JOYTEST:
|
|
{
|
|
BOOL timeon;
|
|
|
|
timeon = pcv->bUseTimer;
|
|
pcv->bUseTimer = FALSE;
|
|
DoTest( pcv->pgv, hwnd, (void (__cdecl *)(void *)) FixCustomPOVType, pcv );
|
|
pcv->bUseTimer = timeon;
|
|
break;
|
|
}
|
|
#endif //DEAD_CODE
|
|
|
|
case IDCANCEL:
|
|
// fall through
|
|
case IDC_JOYCALDONE:
|
|
if( pcv->bHasTimer )
|
|
{
|
|
KillTimer( hwnd, TIMER_ID );
|
|
pcv->bHasTimer = FALSE;
|
|
}
|
|
|
|
// {
|
|
// LPJOYREGHWCONFIG pcfg = &pcv->pgv->joyHWCurr;
|
|
// assert(pcfg);
|
|
// }
|
|
EndDialog( hwnd, (id == IDC_JOYCALDONE) );
|
|
break;
|
|
|
|
case IDC_JOYPICKPOV:
|
|
if( !tryPOV( pcv, hwnd ) )
|
|
{
|
|
ASSERT (::IsWindow(hwnd));
|
|
HWND hwb = GetDlgItem( hwnd, IDC_JOYPICKPOV );
|
|
ASSERT (::IsWindow(hwb));
|
|
|
|
ShowWindow( hwb, SW_HIDE );
|
|
EnableWindow( hwb, FALSE );
|
|
}
|
|
break;
|
|
|
|
case IDC_JOYCALNEXT:
|
|
pcv->bUseTimer = TRUE;
|
|
joyCalStateSkip( pcv, hwnd );
|
|
break;
|
|
|
|
case IDC_JOYCALBACK:
|
|
pcv->bUseTimer = TRUE;
|
|
joyCalStateBack( pcv, hwnd );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return(FALSE);
|
|
|
|
} // CalibrateProc
|
|
|
|
// DoCalibrate - do the calibration dialog
|
|
void DoCalibrate( LPGLOBALVARS pgv, HWND hwnd )
|
|
{
|
|
assert(pgv);
|
|
|
|
JOYREGHWCONFIG save_joycfg;
|
|
int rc;
|
|
int id;
|
|
|
|
// save the current config, and then add the rudder if it is present
|
|
save_joycfg = pgv->joyHWCurr;
|
|
|
|
// if this is a custom joystick, then don't assume anything
|
|
// about how the POV is set up
|
|
if( pgv->joyHWCurr.dwType == JOY_HW_CUSTOM )
|
|
{
|
|
pgv->bOrigPOVIsPoll = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_POVISPOLL);
|
|
pgv->bOrigPOVIsButtonCombos = (pgv->joyHWCurr.hws.dwFlags & JOY_HWS_POVISBUTTONCOMBOS);
|
|
pgv->joyHWCurr.hws.dwFlags &= ~(JOY_HWS_POVISPOLL|JOY_HWS_POVISBUTTONCOMBOS);
|
|
}
|
|
|
|
// update the registry with our new joystick info
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
|
|
// Fix for 8738, missing IDD_JOYCALIBRATE1 in resource table!
|
|
id = ( pgv->joyHWCurr.hws.dwFlags & (JOY_HWS_HASU|JOY_HWS_HASV)) ? IDD_JOYCALIBRATE1 : IDD_CAL;
|
|
|
|
rc = DialogBoxParam(GetResourceInstance(), MAKEINTRESOURCE( id ), hwnd,
|
|
(int (__stdcall *)(struct HWND__ *,unsigned int,unsigned int,long)) CalibrateProc, (LONG) pgv );
|
|
|
|
// update the registry with the new info or the old info
|
|
if( rc )
|
|
PropSheet_Changed( GetParent(hwnd), hwnd );
|
|
else
|
|
pgv->joyHWCurr = save_joycfg;
|
|
|
|
RegSaveCurrentJoyHW( pgv );
|
|
RegistryUpdated( pgv );
|
|
|
|
} /* DoCalibrate */
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
// OnContextMenu(WPARAM wParam)
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
void OnContextMenu(WPARAM wParam)
|
|
{
|
|
short nSize = STR_LEN_32;
|
|
|
|
// point to help file
|
|
char *pszHelpFileName = new char[nSize];
|
|
ASSERT (pszHelpFileName);
|
|
|
|
// returns help file name and size of string
|
|
GetHelpFileName(pszHelpFileName, &nSize);
|
|
|
|
WinHelp((HWND)wParam, pszHelpFileName, HELP_CONTEXTMENU, (DWORD)CalibrateHelpIDs);
|
|
|
|
if( pszHelpFileName ) delete[] (pszHelpFileName);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
// OnHelp(LPARAM lParam)
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
void OnHelp(LPARAM lParam)
|
|
{
|
|
short nSize = STR_LEN_32;
|
|
|
|
// point to help file
|
|
char *pszHelpFileName = new char[nSize];
|
|
ASSERT (pszHelpFileName);
|
|
|
|
// returns help file name and size of string
|
|
GetHelpFileName(pszHelpFileName, &nSize);
|
|
|
|
LPHELPINFO lphi = (LPHELPINFO)lParam;
|
|
if( lphi->iContextType==HELPINFO_WINDOW )
|
|
WinHelp((HWND)lphi->hItemHandle, pszHelpFileName, HELP_WM_HELP, (DWORD)CalibrateHelpIDs);
|
|
|
|
if( pszHelpFileName ) delete[] (pszHelpFileName);
|
|
}
|
|
|
|
|
|
|