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 );
}
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));
}
void WardShaderDlg::LoadDialog(BOOL draw)
{
if (pShader && hRollup) {
dlevSpin->SetValue(FracToPc(pShader->GetDiffuseLevel()),FALSE);
dlevSpin->SetKeyBrackets(KeyAtCurTime(PB_DIFFUSE_LEV));
slevSpin->SetValue(FracToPc(pShader->GetSpecularLevel()/SPEC_MAX),FALSE);
slevSpin->SetKeyBrackets(KeyAtCurTime(PB_SPECULAR_LEV));
glxSpin->SetValue( 100.0f * ((ALPHA_MAX - pShader->GetGlossiness())/ALPHA_SZ),FALSE);
glxSpin->SetKeyBrackets(KeyAtCurTime(PB_GLOSSINESS_X));
glySpin->SetValue(100.0f * ((ALPHA_MAX - pShader->GetGlossinessY())/ALPHA_SZ),FALSE);
glySpin->SetKeyBrackets(KeyAtCurTime(PB_GLOSSINESS_Y));
trSpin->SetValue(FracToPc(pMtl->GetOpacity( curTime )),FALSE);
trSpin->SetKeyBrackets(pMtl->KeyAtTime(OPACITY_PARAM, curTime));
CheckButton(hRollup, IDC_LOCK_AD, pShader->GetLockAD() );
CheckButton(hRollup, IDC_LOCK_DS, pShader->GetLockDS() );
SetCheckBox(hRollup, IDC_NORMALIZE_CHECK, !pShader->GetNormalizeOn() );
UpdateLockADTex( FALSE ); //don't send to mtl
UpdateColSwatches();
UpdateHilite();
}
}
// Fill in all the data in the polygon counter dialog.
void
PolygonCounter::DrawBars()
{
TSTR buf;
int val;
GetAppData(thePolyCounter.ip, MAX_POLYS_ID, _T("10000"), buf);
if (atoi(buf, val))
thePolyCounter.maxPolys->SetValue(val, FALSE);
GetAppData(thePolyCounter.ip, MAX_SELECTED_ID, _T("1000"), buf);
if (atoi(buf, val))
thePolyCounter.maxSelected->SetValue(val, FALSE);
HWND hName = GetDlgItem(thePolyCounter.hDlg, IDC_POLY_COUNT);
TCHAR str[256];
_stprintf(str, _T("%d"), faceCount);
Static_SetText(hName, str);
hName = GetDlgItem(thePolyCounter.hDlg, IDC_SEL_COUNT);
_stprintf(str, _T("%d"), selFaceCount);
Static_SetText(hName, str);
HWND hPolyBar = GetDlgItem(hDlg, IDC_POLY_BAR);
int maxFaces = maxPolys->GetIVal();
DrawBar(hPolyBar, faceCount, maxFaces);
HWND hSelBar = GetDlgItem(hDlg, IDC_SELECTED_BAR);
int maxSel = maxSelected->GetIVal();
DrawBar(hSelBar, selFaceCount, maxSel);
}
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 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 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 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 );
}
static INT_PTR CALLBACK MouseDeviceDlgProc(
HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
IMCParamDlg *dlg = DLGetWindowLongPtr<IMCParamDlg*>(hWnd);
if (!dlg && msg!=WM_INITDIALOG) return FALSE;
switch (msg) {
case WM_INITDIALOG:
dlg = (IMCParamDlg*)lParam;
dlg->binding->UpdateRollup(dlg->iRoll);
DLSetWindowLongPtr(hWnd, lParam);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_MOUSE_X: {
MouseDeviceBinding *b = (MouseDeviceBinding*)dlg->binding;
b->which = MC_MOUSE_X;
b->NotifyDependents(FOREVER,0,REFMSG_CHANGE);
break;
}
case IDC_MOUSE_Y: {
MouseDeviceBinding *b = (MouseDeviceBinding*)dlg->binding;
b->which = MC_MOUSE_Y;
b->NotifyDependents(FOREVER,0,REFMSG_CHANGE);
break;
}
case IDC_MOUSE_FLIP: {
MouseDeviceBinding *b = (MouseDeviceBinding*)dlg->binding;
b->invert = IsDlgButtonChecked(hWnd,IDC_MOUSE_FLIP);
b->NotifyDependents(FOREVER,0,REFMSG_CHANGE);
break;
}
}
break;
case CC_SPINNER_CHANGE: {
ISpinnerControl *spin = (ISpinnerControl *)lParam;
MouseDeviceBinding *b = (MouseDeviceBinding*)dlg->binding;
b->scale = spin->GetFVal();
b->NotifyDependents(FOREVER,0,REFMSG_CHANGE);
break;
}
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MOUSEMOVE:
dlg->iRoll->DlgMouseMessage(hWnd,msg,wParam,lParam);
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);
}
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;
}
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 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);
}
void TestSpawnOnCollisionDlgProc::UpdateRandomSeedDlg( HWND hWnd, float affects, float multVar, float speedVar, float divergence, float scaleVar )
{
bool hasChaos = !(((affects==0.0f) || (affects==1.0f)) && (multVar==0.0f) && (speedVar==0.0f) && (divergence==0.0f) && (scaleVar==0.0f));
EnableWindow( GetDlgItem(hWnd, IDC_UNIQUENESSBOX), hasChaos );
EnableWindow( GetDlgItem(hWnd, IDC_SEEDTEXT), hasChaos );
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_SEEDSPIN ) );
spin->Enable(hasChaos);
ReleaseISpinner(spin);
ICustButton* but = GetICustButton( GetDlgItem( hWnd, IDC_NEW ) );
but->Enable(hasChaos);
ReleaseICustButton(but);
}
void RandKeysUtil::SpinnerChange(int id)
{
switch (id) {
case IDC_RANDKEYS_POSTIMESPIN:
posTime = iPosTime->GetIVal(); break;
case IDC_RANDKEYS_NEGTIMESPIN:
negTime = iNegTime->GetIVal(); break;
case IDC_RANDKEYS_POSVALSPIN:
posVal = iPosVal->GetFVal(); break;
case IDC_RANDKEYS_NEGVALSPIN:
negVal = iNegVal->GetFVal(); break;
}
}
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 );
}
//void RendSpline::UpdateAspect(HWND hWnd, TimeValue t)
//{
//
// //ISpinnerControl *iSpin = GetISpinner(GetDlgItem(hWnd, IDC_ASPECTSPIN));
// //
// //iSpin->SetValue(this->GetAspect((UseViewOrRenderParams(t)== rbViewport)),FALSE);
// //ReleaseISpinner(iSpin);
//}
void RendSpline::OnSetWidthLength(HWND hWnd, ParamID lengthID, ParamID widthID, TimeValue t, BOOL widthSet)
{
static BOOL reenter = FALSE;
if(reenter)
return;
reenter = TRUE;
ISpinnerControl *iSpin = GetISpinner(GetDlgItem(hWnd, IDC_ASPECTSPIN));
BOOL aspectlocked;
float length, width;
if(UseViewOrRenderParams(t) == rbViewport)
pblock->GetValue(rnd_v2_vpt_aspect_lock,t,aspectlocked,FOREVER);
else
pblock->GetValue(rnd_v2_aspect_lock,t,aspectlocked,FOREVER);
pblock->GetValue(lengthID,t,length,FOREVER);
pblock->GetValue(widthID,t,width,FOREVER);
if(!aspectlocked)
{
CheckAspectLock(t);
if(width == 0.0f)
{
width = EPS;
//iSpin->SetValue(0.0f, FALSE);
//iSpin->SetIndeterminate(TRUE);
}
else
iSpin->SetValue(length/width, FALSE);
}
else
{
if(widthSet)
{
pblock->SetValue(lengthID,t,mAspect*width);
}
else
{
if(mAspect == 0.0f)
mAspect = EPS;
//pblock->SetValue(widthID,t,0.0f);
pblock->SetValue(widthID,t,length/mAspect);
}
}
ReleaseISpinner(iSpin);
reenter = FALSE;
}
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 TestDurationDlgProc::UpdateVariationDlg( HWND hWnd, TimeValue variation )
{
bool useRandom = (variation != 0);
ISpinnerControl* spin;
EnableWindow( GetDlgItem( hWnd, IDC_UNIQUENESSBOX ), useRandom );
EnableWindow( GetDlgItem( hWnd, IDC_SEEDTEXT ), useRandom );
spin = GetISpinner( GetDlgItem( hWnd, IDC_SEEDSPIN ) );
spin->Enable( useRandom );
ReleaseISpinner( spin );
ICustButton* button = GetICustButton( GetDlgItem( hWnd, IDC_NEW ) );
button->Enable( useRandom );
ReleaseICustButton( button );
}
void StraussShaderDlg::LoadDialog(BOOL draw)
{
if (pShader && hRollup) {
glSpin->SetValue( FracToPc( pShader->GetGlossiness() ),FALSE);
glSpin->SetKeyBrackets(KeyAtCurTime(st_glossiness));
mtSpin->SetValue( FracToPc( pShader->GetMetalness() ), FALSE);
mtSpin->SetKeyBrackets(KeyAtCurTime(st_metalness));
trSpin->SetValue(FracToPc(pMtl->GetOpacity(curTime)),FALSE);
trSpin->SetKeyBrackets(pMtl->KeyAtTimeByID(OPACITY_PARAM, curTime));
UpdateColSwatches();
UpdateHilite();
IParamBlock2 * shaderpblock = pShader->pblock;
if ( shaderpblock ) {
cs[0]->UpdateEnableState( shaderpblock, shaderpblock->GetAnimNum( st_diffuse ) );
glSpin->UpdateEnableState( shaderpblock, shaderpblock->GetAnimNum( st_glossiness ) );
mtSpin->UpdateEnableState( shaderpblock, shaderpblock->GetAnimNum( st_metalness ) );
}
// trSpin: opacity is accessed through the material: only handle StdMat2.
EnableMtl2OpacityControl( pMtl, trSpin );
}
}
void RendSpline::OnSetAspect(HWND hWnd, TimeValue t, ParamID widthID, ParamID lengthID)
{
CheckAspectLock(t);
ISpinnerControl *iSpin = GetISpinner(GetDlgItem(hWnd, IDC_ASPECTSPIN));
mAspect = iSpin->GetFVal();
float width;
pblock->GetValue(widthID,t,width,FOREVER);
pblock->SetValue(lengthID,t,mAspect*width);
ReleaseISpinner(iSpin);
}
void plMultipassMtlDlg::IGetSpinnerVal()
{
ISpinnerControl *spin = GetISpinner(GetDlgItem(fhRollup, IDC_LAYER_SPIN));
if (!spin)
return;
// If new number of layers is invalid, set to current num
if (!ISetNumLayers(spin->GetIVal()))
{
int nLayers = fPBlock->GetInt(kMultCount);
spin->SetValue(nLayers, FALSE);
}
ReleaseISpinner(spin);
}
void PFOperatorInstanceShapeDlgProc::UpdateAnimatedSahpeDlg( HWND hWnd, BOOL animatedShape, BOOL addRandomOffset )
{
ISpinnerControl *spin;
BOOL enableOffset = animatedShape && addRandomOffset;
EnableWindow( GetDlgItem( hWnd, IDC_ACQUIRE ), !animatedShape );
EnableWindow( GetDlgItem( hWnd, IDC_SYNCFRAME ), animatedShape );
EnableWindow( GetDlgItem( hWnd, IDC_SYNCBYTEXT ), animatedShape );
EnableWindow( GetDlgItem( hWnd, IDC_SYNC ), animatedShape );
EnableWindow( GetDlgItem( hWnd, IDC_SYNCRANDOM ), animatedShape );
EnableWindow( GetDlgItem( hWnd, IDC_SYNCOFFSET ), enableOffset );
spin = GetISpinner( GetDlgItem( hWnd, IDC_SYNCOFFSETSPIN ) );
spin->Enable( enableOffset );
ReleaseISpinner( spin );
}
void MouseDeviceBinding::UpdateRollup(IRollupWindow *iRoll)
{
if (iRoll->GetNumPanels()>1) {
HWND hWnd = iRoll->GetPanelDlg(1);
CheckDlgButton(hWnd,IDC_MOUSE_X,which==MC_MOUSE_X);
CheckDlgButton(hWnd,IDC_MOUSE_Y,which==MC_MOUSE_Y);
CheckDlgButton(hWnd,IDC_MOUSE_FLIP,invert);
ISpinnerControl *spin = GetISpinner(GetDlgItem(hWnd,IDC_MOUSE_SCALESPIN));
spin->SetLimits(0.0f, float(999999), FALSE);
spin->SetScale(0.01f);
spin->LinkToEdit(GetDlgItem(hWnd,IDC_MOUSE_SCALE), EDITTYPE_FLOAT);
spin->SetValue(scale,FALSE);
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;
}
//----------------------------------------------------------------------------
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 PFOperatorMaterialFrequencyDlgProc::UpdateAssignIDDlg( HWND hWnd, int assign)
{
ISpinnerControl *spin;
bool enableAssign = (assign != 0);
EnableWindow( GetDlgItem( hWnd, IDC_SHOWINVIEWPORT), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_NUMSUBSTEXT), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_NUMSUBS), enableAssign);
int textIDC[] = { IDC_ID1TEXT, IDC_ID2TEXT, IDC_ID3TEXT, IDC_ID4TEXT, IDC_ID5TEXT, IDC_ID6TEXT, IDC_ID7TEXT, IDC_ID8TEXT, IDC_ID9TEXT, IDC_ID10TEXT };
int spinIDC[] = { IDC_ID1SPIN, IDC_ID2SPIN, IDC_ID3SPIN, IDC_ID4SPIN, IDC_ID5SPIN, IDC_ID6SPIN, IDC_ID7SPIN, IDC_ID8SPIN, IDC_ID9SPIN, IDC_ID10SPIN };
for(int i=0; i<10; i++) {
EnableWindow( GetDlgItem( hWnd, textIDC[i]), enableAssign);
spin = GetISpinner( GetDlgItem(hWnd, spinIDC[i]) );
spin->Enable( enableAssign );
ReleaseISpinner( spin );
}
}
void PFOperatorMaterialFrequencyDlgProc::UpdateAssignMaterialDlg( HWND hWnd, int assign, int assignID, Mtl *mtl )
{
ICustButton* but = GetICustButton(GetDlgItem(hWnd, IDC_MATERIAL));
but->Enable( assign != 0);
ReleaseICustButton(but);
BOOL enable = (assign != 0) || (assignID != 0);
EnableWindow( GetDlgItem( hWnd, IDC_TEXT_MTLIDOFFSET), enable);
ISpinnerControl* spin = GetISpinner(GetDlgItem(hWnd, IDC_MTLIDOFFSETSPIN));
spin->Enable( enable );
ReleaseISpinner( spin );
int numSubs = (mtl != NULL) ? mtl->NumSubMtls() : 0;
TCHAR buf[32];
_stprintf_s(buf, 32, _T("%d"), numSubs);
SetWindowText( GetDlgItem( hWnd, IDC_NUMSUBS ), buf );
}
