StraussShaderDlg::~StraussShaderDlg()
{
HDC hdc = GetDC(hRollup);
GetGPort()->RestorePalette(hdc, hOldPal);
ReleaseDC(hRollup, hdc);
if( pShader ) pShader->SetParamDlg(NULL,0);
for (long i=0; i < NMBUTS; i++ ){
ReleaseICustButton( texMBut[i] );
texMBut[i] = NULL;
}
for (long i=0; i<STRAUSS_NCOLBOX; i++)
if (cs[i]) ReleaseIColorSwatch(cs[i]); // mjm - 5.10.99
ReleaseISpinner(glSpin);
ReleaseISpinner(mtSpin);
ReleaseISpinner(trSpin);
DLSetWindowLongPtr(hRollup, NULL);
DLSetWindowLongPtr(hwHilite, NULL);
if(pShader){
IRollupWindow* pRollup = pMtlPar->GetMtlEditorRollup();
pShader->SetPanelOpen(pRollup->IsPanelOpen(pRollup->GetPanelIndex(hRollup)));
}
hwHilite = hRollup = NULL;
}
WardShaderDlg::~WardShaderDlg()
{
HDC hdc = GetDC(hRollup);
GetGPort()->RestorePalette(hdc, hOldPal);
ReleaseDC(hRollup, hdc);
if( pShader ) pShader->SetParamDlg(NULL,0);
for (long i=0; i < NMBUTS; i++ ){
ReleaseICustButton( texMBut[i] );
texMBut[i] = NULL;
}
for (i=0; i<WARD_NCOLBOX; i++)
if (cs[i]) ReleaseIColorSwatch(cs[i]); // mjm - 5.10.99
ReleaseISpinner(slevSpin);
ReleaseISpinner(dlevSpin);
ReleaseISpinner(glxSpin);
ReleaseISpinner(glySpin);
ReleaseISpinner(trSpin);
SetWindowLongPtr(hRollup, GWLP_USERDATA, NULL);
SetWindowLongPtr(hwHilite, GWLP_USERDATA, NULL);
hwHilite = hRollup = NULL;
}
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 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 ConvexApproximationObject::DestroyUI(HWND hWnd)
{
ReleaseICustEdit (m_maxConcavity);
ReleaseISpinner (m_maxConcavitySpinner);
ReleaseICustEdit (m_maxSegments);
ReleaseISpinner (m_maxSegmentsSpinner);
}
void RandKeysUtil::Destroy()
{
ReleaseISpinner(iPosTime);
ReleaseISpinner(iNegTime);
ReleaseISpinner(iPosVal);
ReleaseISpinner(iNegVal);
if (iu) iu->TVUtilClosing(this);
}
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);
}
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;
}
FloatLimitControlDlg::~FloatLimitControlDlg()
{
ReleaseISpinner(mUpperLimitSpin);
ReleaseISpinner(mLowerLimitSpin);
ReleaseISpinner(mUpperWidthSpin);
ReleaseISpinner(mLowerWidthSpin);
LimitControlDlgManager::GetLimitCtrlDlgManager()->RemoveDialog(this);
theHold.Suspend();
DeleteAllRefsFromMe();
theHold.Resume();
GetCOREInterface()->UnRegisterTimeChangeCallback(this);
}
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 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 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 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 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 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);
}
}
}
//----------------------------------------------------------------------------
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
CIN_ControlDialog::RemoveSpinners()
{
if (mWhitePtSpinner) {
ReleaseISpinner(mWhitePtSpinner);
mWhitePtSpinner = NULL;
}
if (mBlackPtSpinner) {
ReleaseISpinner(mBlackPtSpinner);
mBlackPtSpinner = NULL;
}
/*
if (mWhiteXPtSpinner) {
ReleaseISpinner(mWhiteXPtSpinner);
mWhiteXPtSpinner = NULL;
}
if (mWhiteYPtSpinner) {
ReleaseISpinner(mWhiteYPtSpinner);
mWhiteYPtSpinner = NULL;
}
if (mRedXPtSpinner) {
ReleaseISpinner(mRedXPtSpinner);
mRedXPtSpinner = NULL;
}
if (mRedYPtSpinner) {
ReleaseISpinner(mRedYPtSpinner);
mRedYPtSpinner = NULL;
}
if (mGreenXPtSpinner) {
ReleaseISpinner(mGreenXPtSpinner);
mGreenXPtSpinner = NULL;
}
if (mGreenYPtSpinner) {
ReleaseISpinner(mGreenYPtSpinner);
mGreenYPtSpinner = NULL;
}
if (mBlueXPtSpinner) {
ReleaseISpinner(mBlueXPtSpinner);
mBlueXPtSpinner = NULL;
}
if (mBlueYPtSpinner) {
ReleaseISpinner(mBlueYPtSpinner);
mBlueYPtSpinner = NULL;
}
*/
}
CIN_ControlDialog::~CIN_ControlDialog()
{
if (mDensityLUT) free(mDensityLUT);
if (mWhitePtSpinner) {
ReleaseISpinner(mWhitePtSpinner);
mWhitePtSpinner = NULL;
}
if (mBlackPtSpinner) {
ReleaseISpinner(mBlackPtSpinner);
mBlackPtSpinner = NULL;
}
/*
if (mWhiteXPtSpinner) {
ReleaseISpinner(mWhiteXPtSpinner);
mWhiteXPtSpinner = NULL;
}
if (mWhiteYPtSpinner) {
ReleaseISpinner(mWhiteYPtSpinner);
mWhiteYPtSpinner = NULL;
}
if (mRedXPtSpinner) {
ReleaseISpinner(mRedXPtSpinner);
mRedXPtSpinner = NULL;
}
if (mRedYPtSpinner) {
ReleaseISpinner(mRedYPtSpinner);
mRedYPtSpinner = NULL;
}
if (mGreenXPtSpinner) {
ReleaseISpinner(mGreenXPtSpinner);
mGreenXPtSpinner = NULL;
}
if (mGreenYPtSpinner) {
ReleaseISpinner(mGreenYPtSpinner);
mGreenYPtSpinner = NULL;
}
if (mBlueXPtSpinner) {
ReleaseISpinner(mBlueXPtSpinner);
mBlueXPtSpinner = NULL;
}
if (mBlueYPtSpinner) {
ReleaseISpinner(mBlueYPtSpinner);
mBlueYPtSpinner = NULL;
}
*/
}
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);
}
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 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 );
}
//----------------------------------------------------------------------------
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;
}
AudioP3Dlg::~AudioP3Dlg()
{
DeleteAllRefsFromMe();
ReleaseISpinner(iBaseX);
ReleaseISpinner(iBaseY);
ReleaseISpinner(iBaseZ);
ReleaseISpinner(iTargetX);
ReleaseISpinner(iTargetY);
ReleaseISpinner(iTargetZ);
ReleaseISpinner(iSamples);
ReleaseISpinner(iThreshold);
}
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);
}
