void ConvexApproximationObject::InitUI(HWND hWnd)
{
m_UI_initalizationCompleted = false;
HWND maxConcavityUI = GetDlgItem(hWnd, IDC_MAX_CONCAVITY);
HWND maxConcavitySpinnerUI = GetDlgItem(hWnd, IDC_MAX_CONCAVITY_SPINNER);
m_maxConcavity = GetICustEdit(maxConcavityUI);
m_maxConcavitySpinner = GetISpinner (maxConcavitySpinnerUI);
m_maxConcavitySpinner->LinkToEdit (maxConcavityUI, EDITTYPE_POS_FLOAT);
m_maxConcavitySpinner->SetScale (0.01f);
m_maxConcavitySpinner->SetLimits(0.01f, 100.0f);
m_maxConcavitySpinner->SetValue(m_currentConcavity, TRUE);
HWND maxSegmentsUI = GetDlgItem(hWnd, IDC_MAX_SEGMENTS);
HWND maxSegmentsSpinnerUI = GetDlgItem(hWnd, IDC_MAX_SEGMENTS_SPINNER);
m_maxSegments = GetICustEdit(maxSegmentsUI);
m_maxSegmentsSpinner = GetISpinner (maxSegmentsSpinnerUI);
m_maxSegmentsSpinner->LinkToEdit (maxSegmentsUI, EDITTYPE_POS_INT);
m_maxSegmentsSpinner->SetScale (1.0f);
m_maxSegmentsSpinner->SetLimits(1, 256);
m_maxSegmentsSpinner->SetValue(m_currentMaxCount, TRUE);
m_UI_initalizationCompleted = true;
}
void RandKeysUtil::SetupWindow(HWND hWnd)
{
this->hWnd = hWnd;
CheckDlgButton(hWnd,IDC_RANDKEYS_TIME,doTime);
CheckDlgButton(hWnd,IDC_RANDKEYS_VAL,doVal);
iPosTime = GetISpinner(GetDlgItem(hWnd,IDC_RANDKEYS_POSTIMESPIN));
iPosTime->SetLimits(0, TIME_PosInfinity, FALSE);
iPosTime->SetScale(10.0f);
iPosTime->LinkToEdit(GetDlgItem(hWnd,IDC_RANDKEYS_POSTIME), EDITTYPE_TIME);
iPosTime->SetValue(posTime,FALSE);
iNegTime = GetISpinner(GetDlgItem(hWnd,IDC_RANDKEYS_NEGTIMESPIN));
iNegTime->SetLimits(0, TIME_PosInfinity, FALSE);
iNegTime->SetScale(10.0f);
iNegTime->LinkToEdit(GetDlgItem(hWnd,IDC_RANDKEYS_NEGTIME), EDITTYPE_TIME);
iNegTime->SetValue(negTime,FALSE);
iPosVal = GetISpinner(GetDlgItem(hWnd,IDC_RANDKEYS_POSVALSPIN));
iPosVal->SetLimits(0.0f, 999999999.9f, FALSE);
iPosVal->SetScale(0.1f);
iPosVal->LinkToEdit(GetDlgItem(hWnd,IDC_RANDKEYS_POSVAL), EDITTYPE_FLOAT);
iPosVal->SetValue(posVal,FALSE);
iNegVal = GetISpinner(GetDlgItem(hWnd,IDC_RANDKEYS_NEGVALSPIN));
iNegVal->SetLimits(0.0f, 999999999.0f, FALSE);
iNegVal->SetScale(0.1f);
iNegVal->LinkToEdit(GetDlgItem(hWnd,IDC_RANDKEYS_NEGVAL), EDITTYPE_FLOAT);
iNegVal->SetValue(negVal,FALSE);
SetStates();
}
void TestSplitByAmountDlgProc::UpdateTypeDlg( HWND hWnd, int type )
{
bool enable = (type == kSplitByAmount_testType_fraction);
bool bRandom = enable;
EnableWindow( GetDlgItem( hWnd, IDC_RATIOTEXT ), enable );
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_RATIO2SPIN ) );
spin->Enable( enable );
ReleaseISpinner( spin );
enable = (type == kSplitByAmount_testType_everyN);
EnableWindow( GetDlgItem( hWnd, IDC_EVERYNTEXT ), enable );
spin = GetISpinner( GetDlgItem( hWnd, IDC_EVERYNSPIN ) );
spin->Enable( enable );
ReleaseISpinner( spin );
enable = (type >= kSplitByAmount_testType_firstN);
EnableWindow( GetDlgItem( hWnd, IDC_FIRSTNTEXT ), enable );
EnableWindow( GetDlgItem( hWnd, IDC_PERSOURCE ), enable );
spin = GetISpinner( GetDlgItem( hWnd, IDC_FIRSTNSPIN ) );
spin->Enable( enable );
ReleaseISpinner( spin );
EnableWindow( GetDlgItem( hWnd, IDC_UNIQUENESSBOX ), bRandom );
EnableWindow( GetDlgItem( hWnd, IDC_SEEDTEXT ), bRandom );
spin = GetISpinner( GetDlgItem( hWnd, IDC_SEEDSPIN ) );
spin->Enable( bRandom );
ReleaseISpinner( spin );
ICustButton* button = GetICustButton( GetDlgItem( hWnd, IDC_NEW ) );
button->Enable( bRandom );
ReleaseICustButton( button );
}
// Dialog proc
static INT_PTR CALLBACK ExportDlgProc(HWND hWnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
Interval animRange;
ISpinnerControl *spin;
AscOut *exp = (AscOut*)GetWindowLongPtr(hWnd,GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG:
exp = (AscOut*)lParam;
SetWindowLongPtr(hWnd,GWLP_USERDATA,lParam);
CenterWindow(hWnd, GetParent(hWnd));
// Setup the spinner controls for the floating point precision
spin = GetISpinner(GetDlgItem(hWnd, IDC_PREC_SPIN));
spin->LinkToEdit(GetDlgItem(hWnd,IDC_PREC), EDITTYPE_INT );
spin->SetLimits(1, 10, TRUE);
spin->SetScale(1.0f);
spin->SetValue(exp->GetPrecision() ,FALSE);
ReleaseISpinner(spin);
// Setup the spinner control for the static frame#
// We take the frame 0 as the default value
animRange = exp->GetInterface()->GetAnimRange();
spin = GetISpinner(GetDlgItem(hWnd, IDC_STATIC_FRAME_SPIN));
spin->LinkToEdit(GetDlgItem(hWnd,IDC_STATIC_FRAME), EDITTYPE_INT );
spin->SetLimits(animRange.Start() / GetTicksPerFrame(), animRange.End() / GetTicksPerFrame(), TRUE);
spin->SetScale(1.0f);
spin->SetValue(0, FALSE);
ReleaseISpinner(spin);
break;
case CC_SPINNER_CHANGE:
spin = (ISpinnerControl*)lParam;
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
spin = GetISpinner(GetDlgItem(hWnd, IDC_PREC_SPIN));
exp->SetPrecision(spin->GetIVal());
ReleaseISpinner(spin);
spin = GetISpinner(GetDlgItem(hWnd, IDC_STATIC_FRAME_SPIN));
exp->SetStaticFrame(spin->GetIVal() * GetTicksPerFrame());
ReleaseISpinner(spin);
EndDialog(hWnd, 1);
break;
case IDCANCEL:
EndDialog(hWnd, 0);
break;
}
break;
default:
return FALSE;
}
return TRUE;
}
void TestSpawnOnCollisionDlgProc::UpdateSpeedTypeDlg( HWND hWnd, int speedType )
{
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_SPEEDSPIN ) );
spin->Enable(speedType == kSpawnCollision_speedType_units);
ReleaseISpinner(spin);
spin = GetISpinner( GetDlgItem( hWnd, IDC_INHERITEDSPIN ) );
spin->Enable(speedType == kSpawnCollision_speedType_inherited);
ReleaseISpinner(spin);
}
//----------------------------------------------------------------------------
BOOL PX2SceneExport::OnEnableFrameSpinners (HWND hWnd, BOOL bEnabled)
{
ISpinnerControl* spinner = GetISpinner(GetDlgItem(hWnd,
IDC_SPINNER_STARTFRAME));
spinner->Enable(bEnabled);
ReleaseISpinner(spinner);
spinner = GetISpinner(GetDlgItem(hWnd, IDC_SPINNER_ENDFRAME));
spinner->Enable(bEnabled);
return TRUE;
}
void PFOperatorInstanceShapeDlgProc::UpdateScaleDlg( HWND hWnd, BOOL setScale)
{
ISpinnerControl *spin;
bool enable = (setScale != 0);
EnableWindow( GetDlgItem( hWnd, IDC_VARIATIONTEXT ), enable );
spin = GetISpinner( GetDlgItem( hWnd, IDC_PARTICLESCALESPIN ) );
spin->Enable( enable );
ReleaseISpinner( spin );
spin = GetISpinner( GetDlgItem( hWnd, IDC_VARIATIONSPIN ) );
spin->Enable( enable );
ReleaseISpinner( spin );
}
Value*
FooControl::set_property(Value** arg_list, int count)
{
Value* val = arg_list[0];
Value* prop = arg_list[1];
if (prop == n_value)
{
value = val->to_float();
if (parent_rollout != NULL && parent_rollout->page != NULL)
{
ISpinnerControl* spin = GetISpinner(GetDlgItem(parent_rollout->page, control_ID));
if (spin_type == EDITTYPE_INT)
spin->SetValue((int)value, FALSE);
else
spin->SetValue(value, FALSE);
ReleaseISpinner(spin);
}
}
else if (prop == n_range)
{
Point3 p;
if (is_point3(val))
p = val->to_point3();
else
throw TypeError (MaxSDK::GetResourceStringAsMSTR(IDS_SPINNER_RANGE_MUST_BE_A_VECTOR), val);
min = p.x; max = p.y; value = p.z;
if (parent_rollout != NULL && parent_rollout->page != NULL)
{
ISpinnerControl* spin = GetISpinner(GetDlgItem(parent_rollout->page, control_ID));
if (spin_type == EDITTYPE_INT)
{
spin->SetLimits((int)p.x, (int)p.y, FALSE);
spin->SetScale(1.0F);
spin->SetValue((int)p.z, FALSE);
}
else
{
spin->SetLimits(p.x, p.y, FALSE);
spin->SetScale(0.1F);
spin->SetValue(p.z, FALSE);
}
ReleaseISpinner(spin);
}
}
else
return RolloutControl::set_property(arg_list, count);
return val;
}
void RendSpline::CheckAspectLock(TimeValue t)
{
ParamID lengthID;
ParamID widthID;
ParamID aspectlockID;
float length, width, aspect = 1.0f;
BOOL aspectlocked = FALSE;
if(UseViewOrRenderParams(t) == rbViewport)
{
widthID = rnd_v2_vpt_width;
lengthID = rnd_v2_vpt_length;
aspectlockID = rnd_v2_vpt_aspect_lock;
}
else
{
widthID = rnd_v2_width;
lengthID = rnd_v2_length;
aspectlockID = rnd_v2_aspect_lock;
}
pblock->GetValue(lengthID,t,length,FOREVER);
pblock->GetValue(widthID,t,width,FOREVER);
pblock->GetValue(aspectlockID,t,aspectlocked,FOREVER);
IParamMap2 *map = pblock->GetMap(0);
if(map)
{
ISpinnerControl *iSpin = GetISpinner(GetDlgItem(map->GetHWnd(), IDC_ASPECTSPIN));
aspect = iSpin->GetFVal();
}
pblock->GetMap()->Enable(aspectlockID,((length != 0.0f && width != 0.0f && aspect != 0.0f) || aspectlocked));
}
static INT_PTR CALLBACK NumMapsDlgProc(
HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG: {
ISpinnerControl *spin =
SetupIntSpinner(
hWnd,IDC_COMP_NUMMAPSSPIN,IDC_COMP_NUMMAPS,
2,1000,(int)lParam);
ReleaseISpinner(spin);
CenterWindow(hWnd,GetParent(hWnd));
break;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK: {
ISpinnerControl *spin =
GetISpinner(GetDlgItem(hWnd,IDC_COMP_NUMMAPSSPIN));
EndDialog(hWnd,spin->GetIVal());
ReleaseISpinner(spin);
break;
}
case IDCANCEL:
EndDialog(hWnd,-1);
break;
}
break;
default:
return FALSE;
}
return TRUE;
}
void FixHeight(IParamBlock *pblock,TimeValue t,HWND hWnd,BOOL increate)
{ float radius,height,r2,minh;
BOOL con,minush;
pblock->GetValue(PB_RADIUS,t,radius,FOREVER);
pblock->GetValue(PB_CENTERS,t,con,FOREVER);
pblock->GetValue(PB_HEIGHT,(increate?0:t),height,FOREVER);
r2=2.0f*radius;
minush=height<0.0f;
minh=((minush)?-r2:r2);
height=(float)fabs(height);
if (con) height+=r2;
if (hWnd)
{ ISpinnerControl *spin2 = GetISpinner(GetDlgItem(hWnd,IDC_SC_HEIGHTSPIN));
if (minush) spin2->SetLimits(MIN_HEIGHT,minh);
else spin2->SetLimits(minh,BMAX_HEIGHT,FALSE);
ReleaseISpinner(spin2);
}
//O.Z. *** begin fix for bug# 175299
if (height<r2)
pblock->SetValue(PB_HEIGHT,(increate?0:t),minh+DEF_HEIGHT);
else if ( (fabs(height)-fabs(2.0f * radius)) <= .001f)
pblock->SetValue(PB_HEIGHT,(increate?0:t),(height+DEF_HEIGHT));
//O.Z. *** end bug fix
}
void PFOperatorForceSpaceWarpDlgProc::UpdateInfluenceDlg( HWND hWnd, bool enable )
{
EnableWindow( GetDlgItem( hWnd, IDC_INFLUENCETEXT), enable );
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_INFLUENCESPIN ) );
spin->Enable(enable);
ReleaseISpinner( spin );
}
void RendSplineParamsMapDlgProc::Initialize(HWND hWnd, TimeValue t)
{
if (hWnd == NULL) return;
else
{
ISpinnerControl *iSpin = GetISpinner(GetDlgItem(hWnd, IDC_ASPECTSPIN));
iSpin->LinkToEdit(GetDlgItem(hWnd, IDC_ASPECT), EDITTYPE_FLOAT);
iSpin->SetLimits(0.0f,99999999.0f);
iSpin->SetAutoScale(TRUE);
ReleaseISpinner(iSpin);
if (RendSpline::hLockButton == NULL) {
HBITMAP hBitmap, hMask;
RendSpline::hLockButton = ImageList_Create(16, 15, TRUE, 2, 0);
hBitmap = LoadBitmap(RendSplineDesc.HInstance(), MAKEINTRESOURCE(IDB_LOCK));
hMask = LoadBitmap(RendSplineDesc.HInstance(), MAKEINTRESOURCE(IDB_LOCKMASK));
ImageList_Add(RendSpline::hLockButton,hBitmap,hMask);
DeleteObject(hBitmap);
DeleteObject(hMask);
}
ICustButton *lockAspect = GetICustButton(GetDlgItem(hWnd,IDC_ASPECTLOCK));
lockAspect->SetImage(RendSpline::hLockButton,0,0,1,1,16,15);
lockAspect->SetType(CBT_CHECK);
ReleaseICustButton(lockAspect);
CheckRadioButton(hWnd, IDC_VIEWPORT, IDC_RENDERER, IDC_RENDERER);
BOOL usePhysUVs = mod->GetUsePhysicalScaleUVs();
CheckDlgButton(hWnd, IDC_REAL_WORLD_MAP_SIZE, usePhysUVs);
}
}
void TurnSpinner(HWND hWnd,int SpinNum,BOOL ison)
{
ISpinnerControl *spin2 = GetISpinner(GetDlgItem(hWnd,SpinNum));
if (ison) spin2->Enable();else spin2->Disable();
ReleaseISpinner(spin2);
};
void MaterialUIHandler::ValidateUINameCombo (HWND hWnd, EPolyMod *pMod) {
SetupMtlSubNameCombo (hWnd, pMod);
ISpinnerControl* spin = NULL;
spin = GetISpinner(GetDlgItem(hWnd,IDC_MAT_IDSPIN));
if (spin) UpdateNameCombo (hWnd, spin);
ReleaseISpinner(spin);
}
void EllipseObject::UpdateUI(HWND hwnd)
{
Interval valid;
BOOL build_outine = FALSE;
TimeValue t = ip? ip->GetTime() : 0;
myParamBlock->GetValue(PB_OUTLINE, t, build_outine, valid);
ICustEdit *thickness_edit = GetICustEdit(GetDlgItem(hwnd, IDC_THICKNESSEDIT));
ISpinnerControl *thickness_spin = GetISpinner(GetDlgItem(hwnd, IDC_THICKSPINNER));
if(!thickness_edit || !thickness_spin)
return;
if(build_outine)
{
EnableWindow(GetDlgItem(hwnd,IDC_THICKNESS_TEXT),TRUE);
thickness_edit->Enable();
thickness_spin->Enable();
}
else
{
EnableWindow(GetDlgItem(hwnd,IDC_THICKNESS_TEXT),FALSE);
thickness_edit->Disable();
thickness_spin->Disable();
}
ReleaseICustEdit(thickness_edit);
ReleaseISpinner(thickness_spin);
}
void TestGoToRotationDlgProc::UpdateMatchDlg( HWND hWnd, int matchSpin )
{
bool enable = (matchSpin == 0);
EnableWindow( GetDlgItem(hWnd, IDC_SPINTEXT), enable );
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_SPINRATESPIN ) );
spin->Enable(enable);
ReleaseISpinner(spin);
}
//----------------------------------------------------------------------------
BOOL PX2SceneExport::OnStartFrameSpinnerChanged (HWND hWnd)
{
// start frame
ISpinnerControl* spinner = GetISpinner(GetDlgItem(hWnd,
IDC_SPINNER_STARTFRAME));
int startFrame = spinner->GetIVal();
ReleaseISpinner(spinner);
// end frame
spinner = GetISpinner(GetDlgItem(hWnd,IDC_SPINNER_ENDFRAME));
int endFrame = spinner->GetIVal();
if ( endFrame < startFrame )
spinner->SetValue(startFrame,FALSE);
ReleaseISpinner(spinner);
return TRUE;
}
void PFOperatorSimpleOrientationDlgProc::SetCtlByDir(IParamMap2* map, HWND hWnd)
{
BOOL bEulerSpinOn = false;
if(map && hWnd) {
IParamBlock2* ppb = map->GetParamBlock();
if(ppb) {
int iDir = ppb->GetInt(kSimpleOrientation_direction, 0);
if((iDir == kSO_World) || (iDir == kSO_Speed) || (iDir == kSO_SpeedFollow))
bEulerSpinOn = true;
EnableWindow(GetDlgItem(hWnd, IDC_XTEXT), bEulerSpinOn);
ISpinnerControl* psc = GetISpinner(GetDlgItem(hWnd, IDC_XSPIN));
psc->Enable(bEulerSpinOn);
ReleaseISpinner(psc);
EnableWindow(GetDlgItem(hWnd, IDC_YTEXT), bEulerSpinOn);
psc = GetISpinner(GetDlgItem(hWnd, IDC_YSPIN));
psc->Enable(bEulerSpinOn);
ReleaseISpinner(psc);
EnableWindow(GetDlgItem(hWnd, IDC_ZTEXT), bEulerSpinOn);
psc = GetISpinner(GetDlgItem(hWnd, IDC_ZSPIN));
psc->Enable(bEulerSpinOn);
ReleaseISpinner(psc);
bool bDivergenceAvailable = ((iDir != kSO_Rand_3D) && (iDir != kSO_SpeedFollow));
EnableWindow(GetDlgItem(hWnd, IDC_DIVERGENCETEXT), bDivergenceAvailable);
psc = GetISpinner(GetDlgItem(hWnd, IDC_DIVERGENCESPIN));
psc->Enable(bDivergenceAvailable);
ReleaseISpinner(psc);
EnableWindow(GetDlgItem(hWnd, IDC_RESTRICTTOAXIS), bDivergenceAvailable);
bool bRestrictToAxis = (ppb->GetInt(kSimpleOrientation_restrictToAxis, 0) != 0) && bDivergenceAvailable;
EnableWindow(GetDlgItem(hWnd, IDC_DIVERGENCEAXISBOX), bRestrictToAxis);
EnableWindow(GetDlgItem(hWnd, IDC_AXISXTEXT), bRestrictToAxis);
psc = GetISpinner(GetDlgItem(hWnd, IDC_AXISXSPIN));
psc->Enable(bRestrictToAxis);
ReleaseISpinner(psc);
EnableWindow(GetDlgItem(hWnd, IDC_AXISYTEXT), bRestrictToAxis);
psc = GetISpinner(GetDlgItem(hWnd, IDC_AXISYSPIN));
psc->Enable(bRestrictToAxis);
ReleaseISpinner(psc);
EnableWindow(GetDlgItem(hWnd, IDC_AXISZTEXT), bRestrictToAxis);
psc = GetISpinner(GetDlgItem(hWnd, IDC_AXISZSPIN));
psc->Enable(bRestrictToAxis);
ReleaseISpinner(psc);
bool bChaosAvailable = (iDir != kSO_SpeedFollow);
EnableWindow(GetDlgItem(hWnd, IDC_UNIQUENESSBOX), bChaosAvailable);
EnableWindow(GetDlgItem(hWnd, IDC_SEEDTEXT), bChaosAvailable);
psc = GetISpinner(GetDlgItem(hWnd, IDC_SEEDSPIN));
psc->Enable(bChaosAvailable);
ReleaseISpinner(psc);
ICustButton* but = GetICustButton(GetDlgItem(hWnd, IDC_NEW));
but->Enable(bChaosAvailable);
ReleaseICustButton(but);
}
}
}
void PFOperatorSimplePositionDlgProc::UpdateInheritSpeedDlg( HWND hWnd, BOOL lock, BOOL inherit )
{
EnableWindow( GetDlgItem( hWnd, IDC_INHERIT ), !lock );
bool useInherit = ((lock == 0) && (inherit != 0));
EnableWindow( GetDlgItem( hWnd, IDC_MULTIPLIERTEXT ), useInherit);
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_MULTIPLIERSPIN ) );
spin->Enable(useInherit);
ReleaseISpinner( spin );
}
INT_PTR CALLBACK TrackPropDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
BlockControl *blk = (BlockControl*)GetWindowLongPtr(hWnd,GWLP_USERDATA);
ISpinnerControl *spin;
static TSTR zero = FormatUniverseValue(0.0f);
Rect rect;
switch (msg) {
case WM_INITDIALOG:
{
blk = (BlockControl*)lParam;
SetWindowLongPtr(hWnd,GWLP_USERDATA,lParam);
Interval range = GetCOREInterface()->GetAnimRange();
spin = GetISpinner(GetDlgItem(hWnd,IDC_STARTSPIN));
spin->SetLimits(-999999.0f,9999999.0f, FALSE);
spin->SetAutoScale();
spin->LinkToEdit(GetDlgItem(hWnd,IDC_START), EDITTYPE_INT);
spin->SetValue(range.Start()/GetTicksPerFrame(),FALSE);
ReleaseISpinner(spin);
blk->propStart = range.Start()/GetTicksPerFrame();
CenterWindow(hWnd,GetParent(hWnd));
break;
}
case CC_SPINNER_CHANGE:
spin = (ISpinnerControl*)lParam;
switch (LOWORD(wParam)) {
case IDC_STARTSPIN: blk->propStart = spin->GetIVal(); break;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
{
EndDialog(hWnd,1);
blk->NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
break;
}
case IDCANCEL:
EndDialog(hWnd,0);
break;
}
break;
default:
return FALSE;
}
return TRUE;
}
void FloatLimitControlDlg::SetupUI()
{
// Set the control labels
::SetWindowText(GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPERBOX), GetString(IDS_FLOATLIMITCTRL_UPPERLIMITUI));
::SetWindowText(GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWERBOX), GetString(IDS_FLOATLIMITCTRL_LOWERLIMITUI));
::SetWindowText(GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPERLIMITCHECK), GetString(IDS_FLOATLIMITCTRL_ENABLED_UI));
::SetWindowText(GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWERLIMITCHECK), GetString(IDS_FLOATLIMITCTRL_ENABLED_UI));
::SetWindowText(GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPER_WIDTH_STATIC), GetString(IDS_FLOATLIMITCTRL_SMOOTHING_UI));
::SetWindowText(GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWER_WIDTH_STATIC), GetString(IDS_FLOATLIMITCTRL_SMOOTHING_UI));
mUpperLimitSpin = GetISpinner(GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPERLIMITSPIN));
if (mUpperLimitSpin)
{
mUpperLimitSpin->SetLimits(s_minLimit, s_maxLimit, FALSE);
mUpperLimitSpin->SetScale(1.0f);
mUpperLimitSpin->LinkToEdit(
GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPERLIMIT), EDITTYPE_FLOAT);
}
mLowerLimitSpin = GetISpinner(GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWERLIMITSPIN));
if (mLowerLimitSpin)
{
mLowerLimitSpin->SetLimits(s_minLimit, s_maxLimit, FALSE);
mLowerLimitSpin->SetScale(1.0f);
mLowerLimitSpin->LinkToEdit(
GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWERLIMIT), EDITTYPE_FLOAT);
}
mUpperWidthSpin = GetISpinner(GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPERLIMIT_W_SPIN));
if (mUpperWidthSpin)
{
mUpperWidthSpin->SetLimits(0.0f, s_maxLimit, FALSE);
mUpperWidthSpin->SetScale(1.0f);
mUpperWidthSpin->LinkToEdit(
GetDlgItem(mHWnd, IDC_LIMITCTRL_UPPERLIMIT_W), EDITTYPE_FLOAT);
}
mLowerWidthSpin = GetISpinner(GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWERLIMIT_W_SPIN));
if (mLowerWidthSpin)
{
mLowerWidthSpin->SetLimits(0.0f, s_maxLimit, FALSE);
mLowerWidthSpin->SetScale(1.0f);
mLowerWidthSpin->LinkToEdit(
GetDlgItem(mHWnd, IDC_LIMITCTRL_LOWERLIMIT_W), EDITTYPE_FLOAT);
}
}
int
Fixed32::make_dialog_gadgets( HWND hPanel )
{
int x;
int width;
assert( _td );
assert( hPanel );
assert( hInstance );
assert( _td->name );
int wLabel = uiDialog::make_dialog_gadgets( hPanel );
x = 5 + wLabel;
width = min( LAST_BUTTON_WIDTH( x + 12 + 1 ), 55 );
hwndEdit = theAttributes.CreateWindowEx(
0,
"CustEdit",
_td->name,
0 | WS_TABSTOP,
x,
theAttributes.y,
width, 16,
hPanel,
NULL,
hInstance,
NULL );
assert( hwndEdit );
_edit = GetICustEdit( hwndEdit );
assert( _edit );
hwndSpinner = theAttributes.CreateWindowEx(
0,
"SpinnerControl",
"",
0x50000000,
x + width + 1,
theAttributes.y,
7,
10,
hPanel,
NULL,
hInstance,
NULL );
assert( hwndSpinner );
_spinner = GetISpinner( hwndSpinner );
assert( _spinner );
reset();
_spinner->LinkToEdit( hwndEdit, EDITTYPE_FLOAT );
_spinner->SetAutoScale();
return x + width + 1 + 7;
}
void PFOperatorSimplePositionDlgProc::UpdateDistinctPointsDlg( HWND hWnd, int locationType, int useDistinct )
{
BOOL enable = (locationType != kSimplePosition_locationType_pivot);
EnableWindow( GetDlgItem( hWnd, IDC_DISTINCT ), enable );
EnableWindow( GetDlgItem( hWnd, IDC_TOTALTEXT ), enable && (useDistinct != 0));
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_TOTALDISTINCTSPIN ) );
spin->Enable( enable && (useDistinct != 0));
ReleaseISpinner( spin );
}
void OrientConstTimeChangeCallback :: TimeChanged(TimeValue t){
int selection = SendDlgItemMessage(orient_controller->hWnd, IDC_ORIENT_TARG_LIST, LB_GETCURSEL, 0, 0);
ISpinnerControl* spin = GetISpinner(GetDlgItem(orient_controller->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER));
spin = GetISpinner(GetDlgItem(orient_controller->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER));
Control* cont = orient_controller->pblock->GetControllerByID(orientation_target_weight, selection);
// until it is animated, paramblock doesn't have a controller assigned in it yet.
if (spin && (cont !=NULL)) {
if (cont->IsKeyAtTime(t,KEYAT_ROTATION)) {
spin->SetKeyBrackets(TRUE);
}
else {
spin->SetKeyBrackets(FALSE);
}
}
ReleaseISpinner(spin);
orient_controller->RedrawListbox(t);
}
void TestSpawnOnCollisionDlgProc::UpdateSpawnTypeDlg( HWND hWnd, int spawnType, int deleteParent )
{
bool multType = (spawnType == kSpawnCollision_spawnType_multiple);
bool sentParent = (multType || (deleteParent == 0));
EnableWindow( GetDlgItem(hWnd, IDC_PARTICLESCOLLIDED), sentParent );
EnableWindow( GetDlgItem(hWnd, IDC_DELETEPARENT), spawnType == kSpawnCollision_spawnType_once );
EnableWindow( GetDlgItem(hWnd, IDC_UNTILTEXT), multType);
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_UNTILSPIN ) );
spin->Enable(multType);
ReleaseISpinner(spin);
}
void SpinnerOn(HWND hWnd,int SpinNum,int Winnum, BOOL enable)
{
ISpinnerControl *spin2 = GetISpinner(GetDlgItem(hWnd,SpinNum));
if (spin2 != NULL)
{
spin2->Enable(enable);
EnableWindow(GetDlgItem(hWnd,Winnum),enable);
ReleaseISpinner(spin2);
}
};
void EditFaceDataMod::UpdateDialog () {
TSTR buf;
int numFaces=0, whichFace=0;
float value = 1.0f;
bool valueDetermined = true;
if (!hParams) return;
ModContextList mcList;
INodeTab nodes;
ip->GetModContexts(mcList,nodes);
if (selLevel) {
for (int i = 0; i < mcList.Count(); i++) {
EditFaceDataModData *meshData = (EditFaceDataModData*)mcList[i]->localData;
if (!meshData) continue;
int numSelectedHere;
meshData->DescribeSelection (numSelectedHere, whichFace, value, valueDetermined);
numFaces += numSelectedHere;
}
}
ISpinnerControl *spin = GetISpinner (GetDlgItem (hParams, IDC_VALUE_SPIN));
ICustButton *but = GetICustButton (GetDlgItem (hParams, IDC_RESET_SELECTION));
switch (selLevel) {
case SEL_FACE:
if (numFaces==1) {
buf.printf (GetString(IDS_FACE_SELECTED), whichFace+1);
} else {
if (numFaces) buf.printf (GetString (IDS_FACES_SELECTED), numFaces);
else buf = GetString (IDS_NO_FACE_SELECTED);
}
but->Enable (numFaces);
spin->Enable (numFaces);
if (numFaces && valueDetermined) {
spin->SetIndeterminate (false);
spin->SetValue (value, FALSE);
} else {
spin->SetIndeterminate (true);
}
break;
case SEL_OBJECT:
buf = GetString (IDS_OBJECT_SELECTED);
spin->Disable();
but->Disable ();
break;
}
SetDlgItemText(hParams,IDC_FACE_SELECTED,buf);
ReleaseISpinner (spin);
ReleaseICustButton (but);
}
void PFOperatorSpeedCopyDlgProc::UpdateDlg( HWND hWnd, IParamBlock2* pblock )
{
if (pblock == NULL) return;
bool useSpeedVar = ( pblock->GetInt(kSpeedCopy_useSpeedVariation, 0) != 0);
bool useSteer = ( pblock->GetInt(kSpeedCopy_steer, 0) != 0);
EnableWindow( GetDlgItem( hWnd, IDC_MINTEXT ), useSpeedVar);
EnableWindow( GetDlgItem( hWnd, IDC_MAXTEXT ), useSpeedVar);
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_MINSPEEDSPIN ) );
spin->Enable( useSpeedVar );
ReleaseISpinner( spin );
spin = GetISpinner( GetDlgItem( hWnd, IDC_MAXSPEEDSPIN ) );
spin->Enable( useSpeedVar );
ReleaseISpinner( spin );
EnableWindow( GetDlgItem( hWnd, IDC_DISTANCETEXT ), useSteer);
spin = GetISpinner( GetDlgItem( hWnd, IDC_DISTANCESPIN ) );
spin->Enable( useSteer );
ReleaseISpinner( spin );
}
void TestGoToRotationDlgProc::UpdateVariationDlg( HWND hWnd, TimeValue timeVar, float spinVar )
{
bool enable = ((timeVar != 0) || (spinVar != 0.0f));
EnableWindow( GetDlgItem(hWnd, IDC_UNIQUENESSBOX), enable );
EnableWindow( GetDlgItem(hWnd, IDC_SEEDTEXT), enable );
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_SEEDSPIN ) );
spin->Enable(enable);
ReleaseISpinner(spin);
ICustButton* but = GetICustButton( GetDlgItem( hWnd, IDC_NEW ) );
but->Enable(enable);
ReleaseICustButton(but);
}
