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 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 RandKeysUtil::SetStates()
{
if (doTime) {
iPosTime->Enable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_POSTIMELABEL),TRUE);
iNegTime->Enable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_NEGTIMELABEL),TRUE);
} else {
iPosTime->Disable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_POSTIMELABEL),FALSE);
iNegTime->Disable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_NEGTIMELABEL),FALSE);
}
if (doVal) {
iPosVal->Enable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_POSVALLABEL),TRUE);
iNegVal->Enable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_NEGVALLABEL),TRUE);
} else {
iPosVal->Disable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_POSVALLABEL),FALSE);
iNegVal->Disable();
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_NEGVALLABEL),FALSE);
}
switch (iu->GetMajorMode()) {
case TVMODE_EDITKEYS:
case TVMODE_EDITFCURVE:
SetDlgItemText(hWnd,IDC_RANDKEYS_TEXT,
GetString(IDS_RANDKEYS_KEYTEXT));
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_APPLY),TRUE);
break;
case TVMODE_EDITTIME: {
Interval iv = iu->GetTimeSelection();
TSTR buf, start, end;
TimeToString(iv.Start(),start);
TimeToString(iv.End(),end);
buf.printf(GetString(IDS_RANDKEYS_TIMETEXT),start,end);
SetDlgItemText(hWnd,IDC_RANDKEYS_TEXT,buf);
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_APPLY),TRUE);
break;
}
case TVMODE_EDITRANGES:
case TVMODE_POSRANGES:
SetDlgItemText(hWnd,IDC_RANDKEYS_TEXT,_T(""));
EnableWindow(GetDlgItem(hWnd,IDC_RANDKEYS_APPLY),FALSE);
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 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 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 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 );
}
void BombObject::EnableControls()
{
if (falloffSpin)
{
BOOL fallOffOn;
pblock->GetValue(PB_FALLOFFON, 0, fallOffOn, FOREVER);
falloffSpin->Enable(fallOffOn);
}
}
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 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 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 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 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 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 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 );
}
void
FooControl::set_enable()
{
if (parent_rollout != NULL && parent_rollout->page != NULL)
{
// set spinner enable
ISpinnerControl *spin = GetISpinner(GetDlgItem(parent_rollout->page, control_ID));
if (enabled) spin->Enable();
else spin->Disable();
ReleaseISpinner(spin);
// set editbox enable
ICustEdit *edit = GetICustEdit(GetDlgItem(parent_rollout->page, control_ID+2));
if (enabled) edit->Enable();
else edit->Disable();
ReleaseICustEdit(edit);
// set caption enable
HWND ctrl = GetDlgItem(parent_rollout->page, control_ID+1);
if (ctrl)
EnableWindow(ctrl, enabled);
}
}
void PFOperatorSimpleSpeedDlgProc::SetCtlByDir(IParamMap2* map, HWND hWnd)
{
BOOL bReverse, bDivergence;
if(map && hWnd) {
IParamBlock2* ppb = map->GetParamBlock();
if(ppb) {
int iDir = ppb->GetInt(kSimpleSpeed_direction, 0);
if(iDir == kSS_Rand_3D)
bReverse = bDivergence = FALSE;
else if(iDir == kSS_Rand_Horiz) {
bReverse = FALSE;
bDivergence = TRUE;
}
else
bReverse = bDivergence = TRUE;
EnableWindow(GetDlgItem(hWnd, IDC_REVERSE), bReverse);
ISpinnerControl* psc = GetISpinner(GetDlgItem(hWnd, IDC_DIVERGENCE));
psc->Enable(bDivergence);
ReleaseISpinner(psc);
}
}
}
// options dialog message handler
INT_PTR Options::ExportOptionsDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM)
{
ISpinnerControl* spin;
// int ticksPerFrame = GetTicksPerFrame();
Interval animRange = mMaxInterface->GetAnimRange();
int sceneStart = animRange.Start();
int sceneEnd = animRange.End();
switch (message)
{
case WM_INITDIALOG: {
CenterWindow(hWnd, GetParent(hWnd));
// grab scene timing details & clip anim start & end if needed
if (mAnimationStart < sceneStart)
mAnimationStart = sceneStart;
if (mAnimationStart > sceneEnd)
mAnimationStart = sceneEnd;
if (mAnimationEnd < sceneStart)
mAnimationEnd = sceneStart;
if (mAnimationEnd > sceneEnd)
mAnimationEnd = sceneEnd;
// setup checkboxes
CheckDlgButton(hWnd, IDC_GEOM_NORMALS, mNormals);
CheckDlgButton(hWnd, IDC_GEOM_TRIANGLES, mTriangulate);
CheckDlgButton(hWnd, IDC_GEOM_XREFS, mIncludeXrefs);
CheckDlgButton(hWnd, IDC_GEOM_TANGENTS, mTangents);
CheckDlgButton(hWnd, IDC_ANIM_ENABLE, mAnimations);
CheckDlgButton(hWnd, IDC_ANIM_SAMPLE, mSampleAnimation);
CheckDlgButton(hWnd, IDC_ANIM_CLIP, mCreateClip);
CheckDlgButton(hWnd, IDC_LAYERS_TO_CLIPS, mLayersAsClips);
CheckDlgButton(hWnd, IDC_BAKE_MATRICES, mBakeMatrices);
CheckDlgButton(hWnd, IDC_RELATIVE_PATHS, mRelativePaths);
CheckDlgButton(hWnd, IDC_COPY_IMAGES, mCopyImages);
CheckDlgButton(hWnd, IDC_EXPORT_USER_PROPERTIES, mExportUserDefinedProperties);
// Animation checkboxes depend on the enable button.
EnableDlgControl(hWnd, IDC_ANIM_SAMPLE, mAnimations);
EnableDlgControl(hWnd, IDC_ANIM_CLIP, mAnimations);
#if defined(MAX_RELEASE_R17) && (MAX_RELEASE >= MAX_RELEASE_R17)
EnableDlgControl(hWnd, IDC_LAYERS_TO_CLIPS, mAnimations);
#else
EnableDlgControl(hWnd, IDC_LAYERS_TO_CLIPS, false);
#endif
// setup spinners
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_START_SPIN));
spin->LinkToEdit(GetDlgItem(hWnd,IDC_ANIM_START), EDITTYPE_TIME);
spin->SetLimits(sceneStart, sceneEnd, true);
spin->SetScale(1.0f);
spin->SetValue(mAnimationStart, true);
spin->Enable(mSampleAnimation && mAnimations);
EnableWindow(GetDlgItem(hWnd, IDC_START_LABEL), mSampleAnimation && mAnimations);
ReleaseISpinner(spin);
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_END_SPIN));
spin->LinkToEdit(GetDlgItem(hWnd,IDC_ANIM_END), EDITTYPE_TIME);
spin->SetLimits(sceneStart, sceneEnd, true);
spin->SetScale(1.0f);
spin->SetValue(mAnimationEnd, false);
spin->Enable(mSampleAnimation && mAnimations);
EnableWindow(GetDlgItem(hWnd, IDC_END_LABEL), mSampleAnimation && mAnimations);
ReleaseISpinner(spin);
return true;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_ANIM_ENABLE:
mAnimations = IsDlgButtonChecked(hWnd, IDC_ANIM_ENABLE) == BST_CHECKED;
EnableDlgControl(hWnd, IDC_ANIM_SAMPLE, mAnimations);
EnableDlgControl(hWnd, IDC_ANIM_CLIP, mAnimations);
#if defined(MAX_RELEASE_R17) && (MAX_RELEASE >= MAX_RELEASE_R17)
EnableDlgControl(hWnd, IDC_LAYERS_TO_CLIPS, mAnimations);
#else
EnableDlgControl(hWnd, IDC_LAYERS_TO_CLIPS, false);
#endif
/*spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_START_SPIN));
//spin->LinkToEdit(GetDlgItem(hWnd,IDC_ANIM_START), EDITTYPE_INT);
spin->Enable(sampleAnim && animations);
EnableWindow(GetDlgItem(hWnd, IDC_START_LABEL), sampleAnim && animations);
ReleaseISpinner(spin);
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_END_SPIN));
//spin->LinkToEdit(GetDlgItem(hWnd,IDC_ANIM_END), EDITTYPE_INT);
spin->Enable(sampleAnim && animations);
EnableWindow(GetDlgItem(hWnd, IDC_END_LABEL), sampleAnim && animations);
ReleaseISpinner(spin);
break; */
case IDC_ANIM_SAMPLE:
mSampleAnimation = IsDlgButtonChecked(hWnd, IDC_ANIM_SAMPLE) == BST_CHECKED;
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_START_SPIN));
spin->Enable(mSampleAnimation && mAnimations);
EnableWindow(GetDlgItem(hWnd, IDC_START_LABEL), mSampleAnimation && mAnimations);
ReleaseISpinner(spin);
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_END_SPIN));
spin->Enable(mSampleAnimation && mAnimations);
EnableWindow(GetDlgItem(hWnd, IDC_END_LABEL), mSampleAnimation && mAnimations);
ReleaseISpinner(spin);
break;
case IDOK:
// hit OK, pick up control values & end dialog
mBakeMatrices = IsDlgButtonChecked(hWnd, IDC_BAKE_MATRICES) == BST_CHECKED;
mRelativePaths = IsDlgButtonChecked(hWnd, IDC_RELATIVE_PATHS) == BST_CHECKED;
mAnimations = IsDlgButtonChecked(hWnd, IDC_ANIM_ENABLE) == BST_CHECKED;
mSampleAnimation = IsDlgButtonChecked(hWnd, IDC_ANIM_SAMPLE) == BST_CHECKED;
mCreateClip = IsDlgButtonChecked(hWnd, IDC_ANIM_CLIP) == BST_CHECKED;
mLayersAsClips = IsDlgButtonChecked(hWnd, IDC_LAYERS_TO_CLIPS) == BST_CHECKED;
mNormals = IsDlgButtonChecked(hWnd, IDC_GEOM_NORMALS) == BST_CHECKED;
mTriangulate = IsDlgButtonChecked(hWnd, IDC_GEOM_TRIANGLES) == BST_CHECKED;
mIncludeXrefs = IsDlgButtonChecked(hWnd, IDC_GEOM_XREFS) == BST_CHECKED;
mTangents = IsDlgButtonChecked(hWnd, IDC_GEOM_TANGENTS) == BST_CHECKED;
mCopyImages = IsDlgButtonChecked(hWnd, IDC_COPY_IMAGES) == BST_CHECKED;
mExportUserDefinedProperties = IsDlgButtonChecked(hWnd, IDC_EXPORT_USER_PROPERTIES) == BST_CHECKED;
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_START_SPIN));
mAnimationStart = mSampleAnimation ? spin->GetIVal() : sceneStart;
ReleaseISpinner(spin);
spin = GetISpinner(GetDlgItem(hWnd, IDC_ANIM_END_SPIN));
mAnimationEnd = mSampleAnimation ? spin->GetIVal() : sceneEnd;
ReleaseISpinner(spin);
EndDialog(hWnd, 1);
break;
case IDCANCEL:
EndDialog(hWnd, 0);
break;
}
default:
return false;
}
return true;
}
BOOL SceneViewer::DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
fhDlg = hDlg;
// Set the exe to use
HWND hExeCombo = GetDlgItem(hDlg, IDC_EXE);
ComboBox_AddString(hExeCombo, "Release");
ComboBox_AddString(hExeCombo, "Debug");
ComboBox_SetCurSel(hExeCombo, fReleaseExe ? 0 : 1);
// Set the client path
const char *path = plMaxConfig::GetClientPath(false, true);
ICustEdit *edit = GetICustEdit(GetDlgItem(hDlg, IDC_CLIENT_PATH));
edit->SetText((char*)path);
// Set the "Load old data" checkbox
HWND hLoadOld = GetDlgItem(hDlg, IDC_REUSE_DATA);
Button_SetCheck(hLoadOld, fLoadOld ? BST_CHECKED : BST_UNCHECKED);
Button_Enable(hLoadOld, SceneSync::Instance().CanLoadOldResMgr());
// Set the update controls
float val = float(fUpdateFreq) / 1000.f;
ISpinnerControl *spin = SetupFloatSpinner(hDlg, IDC_SPINNER, IDC_EDIT, 0.1, 1.f, val);
spin->Enable(fUpdate);
CheckDlgButton(hDlg, IDC_UPDATE, fUpdate ? BST_CHECKED : BST_UNCHECKED);
IEnableSetupControls(!SceneSync::Instance().IsClientRunning());
}
return TRUE;
case WM_COMMAND:
// Start/Stop SceneViewer
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_START)
{
IToggleRunning();
IEnableSetupControls(!SceneSync::Instance().IsClientRunning());
return TRUE;
}
// Close dialog
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDCANCEL)
{
DestroyWindow(hDlg);
fhDlg = NULL;
return TRUE;
}
// Browse for directory
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_DIR)
{
const char *path = plMaxConfig::GetClientPath(true);
if (path)
{
ICustEdit *edit = GetICustEdit(GetDlgItem(hDlg, IDC_CLIENT_PATH));
edit->SetText((char*)path);
}
return TRUE;
}
// "Load old data" selection changed
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_REUSE_DATA)
{
fLoadOld = (Button_GetCheck((HWND)lParam) == BST_CHECKED);
return TRUE;
}
// Release/Debug exe selection changed
else if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_EXE)
{
int sel = ComboBox_GetCurSel((HWND)lParam);
fReleaseExe = (sel == 0);
return TRUE;
}
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_UPDATE)
{
fUpdate = (SendMessage((HWND)lParam, BM_GETCHECK, 0, 0) == BST_CHECKED);
ISpinnerControl *spin = GetISpinner(GetDlgItem(hDlg, IDC_SPINNER));
spin->Enable(fUpdate);
ReleaseISpinner(spin);
// If update was turned on, send out an update message so any dirty objects
// will be reconverted right away
if (fUpdate)
SceneSync::Instance().SetUpdateFreq(fUpdateFreq);
return TRUE;
}
break;
// Update frequency changed
case CC_SPINNER_CHANGE:
if (LOWORD(wParam) == IDC_SPINNER)
{
ISpinnerControl *spin = (ISpinnerControl*)lParam;
float val = spin->GetFVal();
fUpdateFreq = int(val*1000.f);
SceneSync::Instance().SetUpdateFreq(fUpdateFreq);
}
return TRUE;
// Type in directory
case WM_CUSTEDIT_ENTER:
if (wParam == IDC_CLIENT_PATH)
{
ICustEdit *edit = GetICustEdit((HWND)lParam);
char path[MAX_PATH];
edit->GetText(path, sizeof(path));
plMaxConfig::SetClientPath(path);
}
return TRUE;
}
return FALSE;
}
void PFOperatorSimpleShapeDlgProc::UpdateScaleDlg( HWND hWnd, int useScale )
{
ISpinnerControl* spin = GetISpinner( GetDlgItem( hWnd, IDC_MESHSCALESPIN ) );
spin->Enable( useScale != 0 );
ReleaseISpinner( spin );
}
//----------------------------------------------------------------------------
BOOL PX2SceneExport::OnInitDialog (HWND hWnd)
{
// 当对话框获得WM_INITDIALOG消息时，进行初始化。
// 设置用户定义的导出选项。如果配置文件存在，这些导出选项和用户最后一次
// 使用导出插件的选项一样。否则，使用缺省的设置。
CheckDlgButton(hWnd,IDC_CHECK_OBJECTS,mSettings.IncludeObjects);
CheckDlgButton(hWnd,IDC_CHECK_LIGHTS,mSettings.IncludeLights);
CheckDlgButton(hWnd,IDC_CHECK_MESHES,mSettings.IncludeMeshes);
CheckDlgButton(hWnd,IDC_CHECK_VERTEXCOLORS,mSettings.IncludeVertexColors);
CheckDlgButton(hWnd,IDC_CHECK_NORMALS,mSettings.IncludeNormals);
CheckDlgButton(hWnd, IDC_CHECK_TANGENTBINORMAL,
mSettings.IncludeTargentBiNormal);
CheckDlgButton(hWnd,IDC_CHECK_TEXTURECOORDS,mSettings.IncludeTexCoords);
SendMessage(GetDlgItem(hWnd,IDC_COMMBO_NUMTCS),CB_ADDSTRING,0,(LPARAM)"1");
SendMessage(GetDlgItem(hWnd,IDC_COMMBO_NUMTCS),CB_ADDSTRING,0,(LPARAM)"2");
SendMessage(GetDlgItem(hWnd,IDC_COMMBO_NUMTCS), CB_SETCURSEL,
mSettings.NumTexCoords-1,0);
CheckDlgButton(hWnd,IDC_CHECK_MODIFIERS,mSettings.IncludeModifiers);
CheckDlgButton(hWnd,IDC_CHECK_SKINS,mSettings.IncludeSkins);
CheckDlgButton(hWnd,IDC_RADIO_CURRENTFRAME,mSettings.IncludeCurrentFrame);
CheckDlgButton(hWnd,IDC_RADIO_KEYFRAMES,mSettings.IncludeKeyFrames);
CheckDlgButton(hWnd,IDC_RADIO_ALLFRAMES,mSettings.IncludeAllFrames);
CheckDlgButton(hWnd,IDC_CHECK_USELOCALTIME,mSettings.UseLocalTime);
if(!mSettings.IncludeObjects)
{
// 取消激活“Objects”选择框
OnObjectsChecked(hWnd, FALSE);
}
else if (!mSettings.IncludeMeshes)
{
// 取消激活“Mesh”选择框
OnMeshChecked(hWnd, FALSE);
}
// 取消激活"Modifiers"选择框
if (!mSettings.IncludeModifiers)
OnModifiersChecked(hWnd, FALSE);
// 获得max场景中的帧数
int numFrames = mMax->GetAnimRange().Duration()/GetTicksPerFrame();
// spinner controls
ISpinnerControl* spinner = GetISpinner(GetDlgItem(hWnd,
IDC_SPINNER_STARTFRAME));
spinner->LinkToEdit(GetDlgItem(hWnd,IDC_EDIT_STARTFRAME), EDITTYPE_INT);
spinner->SetLimits(0,numFrames,TRUE);
spinner->SetScale(1.0f);
spinner->SetValue(0,FALSE);
if ( mSettings.IncludeCurrentFrame )
{
spinner->Enable(FALSE);
}
ReleaseISpinner(spinner);
spinner = GetISpinner(GetDlgItem(hWnd,IDC_SPINNER_ENDFRAME));
spinner->LinkToEdit(GetDlgItem(hWnd,IDC_EDIT_ENDFRAME),EDITTYPE_INT);
spinner->SetLimits(0,numFrames,TRUE);
spinner->SetScale(1.0f);
spinner->SetValue(numFrames,FALSE);
if (mSettings.IncludeCurrentFrame)
{
spinner->Enable(FALSE);
}
ReleaseISpinner(spinner);
SetDlgItemText(hWnd, IDC_EDIT_SRCROOTDIR, mSettings.SrcRootDir);
SetDlgItemText(hWnd, IDC_EDIT_DSTROOTDIR, mSettings.DstRootDir);
return TRUE;
}
void PFOperatorMaterialDynamicDlgProc::UpdateDlg( HWND hWnd, IParamBlock2* pblock, TimeValue t)
{
int assign = pblock->GetInt(kMaterialDynamic_assignMaterial, t);
int assignID = pblock->GetInt(kMaterialDynamic_assignID, t);
int type = pblock->GetInt(kMaterialDynamic_type, t);
int randAge = pblock->GetInt(kMaterialDynamic_randomizeAge, t);
int randOffset = pblock->GetInt(kMaterialDynamic_randomizeRotoscoping, t);
ICustButton* but = GetICustButton(GetDlgItem(hWnd, IDC_MATERIAL));
but->Enable( assign != 0);
ReleaseICustButton(but);
BOOL enable = ((assign != 0) && (assignID == 0))
|| ((assignID != 0) && (type != kMaterialDynamic_type_particleID));
EnableWindow( GetDlgItem( hWnd, IDC_TEXT_MTLIDOFFSET), enable);
ISpinnerControl* spin = GetISpinner(GetDlgItem(hWnd, IDC_MTLIDOFFSETSPIN));
spin->Enable( enable );
ReleaseISpinner( spin );
bool enableAssign = (assignID != 0);
EnableWindow( GetDlgItem( hWnd, IDC_SHOWINVIEWPORT), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_ANIMATEDFRAME), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_TYPE_PARTID), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_SUBMTLSFRAME), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_TYPE_MTLID), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_TYPE_CYCLE), enableAssign);
EnableWindow( GetDlgItem( hWnd, IDC_TYPE_RANDOM), enableAssign);
bool enableAnimated = (enableAssign && (type == kMaterialDynamic_type_particleID));
bool enableMaxOffset = (enableAnimated && (randAge != 0));
EnableWindow( GetDlgItem( hWnd, IDC_RESETAGE), enableAnimated);
EnableWindow( GetDlgItem( hWnd, IDC_RANDOMIZEAGE), enableAnimated);
EnableWindow( GetDlgItem( hWnd, IDC_MAXOFFSETTEXT), enableMaxOffset);
spin = GetISpinner(GetDlgItem(hWnd, IDC_MAXOFFSETSPIN));
spin->Enable( enableMaxOffset );
ReleaseISpinner( spin );
bool enableMtlID = (enableAssign && (type == kMaterialDynamic_type_materialID));
spin = GetISpinner(GetDlgItem(hWnd, IDC_MATERIALIDSPIN));
spin->Enable( enableMtlID );
ReleaseISpinner( spin );
bool enableRoto = (enableAssign && (type >= kMaterialDynamic_type_cycle));
EnableWindow( GetDlgItem( hWnd, IDC_NUMSUBSTEXT), enableRoto);
EnableWindow( GetDlgItem( hWnd, IDC_RATETEXT), enableRoto);
spin = GetISpinner(GetDlgItem(hWnd, IDC_NUMSUBSSPIN));
spin->Enable( enableRoto );
ReleaseISpinner( spin );
spin = GetISpinner(GetDlgItem(hWnd, IDC_RATESPIN));
spin->Enable( enableRoto );
ReleaseISpinner( spin );
EnableWindow( GetDlgItem( hWnd, IDC_LOOP), enableAssign && (type == kMaterialDynamic_type_cycle));
bool enableSync = (enableAssign && ((type == kMaterialDynamic_type_materialID)
|| ( type == kMaterialDynamic_type_cycle)) );
EnableWindow( GetDlgItem( hWnd, IDC_SYNCBYTEXT), enableSync);
EnableWindow( GetDlgItem( hWnd, IDC_SYNC), enableSync);
EnableWindow( GetDlgItem( hWnd, IDC_SYNCRANDOM), enableSync);
spin = GetISpinner(GetDlgItem(hWnd, IDC_SYNCOFFSETSPIN));
spin->Enable( enableSync && (randOffset != 0) );
ReleaseISpinner( spin );
}
void EditPolyPaintDeformDlgProc::SetEnables (HWND hWnd) {
PaintModeID paintMode = mpEPoly->GetPaintMode();
bool isModelingMode = (mpEPoly->getParamBlock()->GetInt(epm_animation_mode) == 0);
BOOL isPaintPushPull = (paintMode==PAINTMODE_PAINTPUSHPULL? TRUE:FALSE);
BOOL isPaintRelax = (paintMode==PAINTMODE_PAINTRELAX? TRUE:FALSE);
BOOL isErasing = (paintMode==PAINTMODE_ERASEDEFORM? TRUE:FALSE);
BOOL isActive = (mpEPoly->IsPaintDataActive(PAINTMODE_DEFORM)? TRUE:FALSE);
ICustButton* but = GetICustButton (GetDlgItem (hWnd, IDC_PAINTDEFORM_PUSHPULL));
but->Enable (isModelingMode);
but->SetCheck( isPaintPushPull );
ReleaseICustButton (but);
but = GetICustButton (GetDlgItem (hWnd, IDC_PAINTDEFORM_RELAX));
but->Enable (isModelingMode);
but->SetCheck( isPaintRelax );
ReleaseICustButton (but);
but = GetICustButton (GetDlgItem (hWnd, IDC_PAINTDEFORM_REVERT));
but->Enable( isActive && isModelingMode );
but->SetCheck( isErasing );
ReleaseICustButton (but);
ISpinnerControl *spin = GetISpinner (GetDlgItem (hWnd, IDC_PAINTDEFORM_VALUE_SPIN));
spin->Enable ((!isPaintRelax) && (!isErasing) && isModelingMode);
ReleaseISpinner (spin);
BOOL enablePushPull = (((!isPaintRelax) && (!isErasing) && isModelingMode)? TRUE:FALSE);
HWND hDlgItem = GetDlgItem (hWnd, IDC_PAINTDEFORM_VALUE_LABEL);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_BORDER);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_ORIGNORMS);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_DEFORMEDNORMS);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_XFORM);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_XFORM_X);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_XFORM_Y);
EnableWindow( hDlgItem, enablePushPull );
hDlgItem = GetDlgItem (hWnd, IDC_PAINTAXIS_XFORM_Z);
EnableWindow( hDlgItem, enablePushPull );
EnableWindow (GetDlgItem (hWnd, IDC_PAINTDEFORM_SIZE_LABEL), isModelingMode);
EnableWindow (GetDlgItem (hWnd, IDC_PAINTDEFORM_STRENGTH_LABEL), isModelingMode);
spin = GetISpinner (GetDlgItem (hWnd, IDC_PAINTDEFORM_SIZE_SPIN));
spin->Enable (isModelingMode);
ReleaseISpinner (spin);
spin = GetISpinner (GetDlgItem (hWnd, IDC_PAINTDEFORM_STRENGTH_SPIN));
spin->Enable (isModelingMode);
ReleaseISpinner (spin);
but = GetICustButton (GetDlgItem (hWnd, IDC_PAINTDEFORM_OPTIONS));
but->Enable (isModelingMode);
ReleaseICustButton (but);
but = GetICustButton (GetDlgItem (hWnd, IDC_PAINTDEFORM_APPLY));
but->Enable( isActive && isModelingMode );
ReleaseICustButton (but);
but = GetICustButton (GetDlgItem (hWnd, IDC_PAINTDEFORM_CANCEL));
but->Enable( isActive && isModelingMode );
ReleaseICustButton (but);
}
void PAOperatorObjectDlgProc::UpdateDlg(IParamMap2* map, HWND hWnd)
{
// BOOL bAxes, bDivergence, bRandom;
// bool varAnimated, divAnimated;
if(map && hWnd) {
IParamBlock2* ppb = map->GetParamBlock();
if(ppb) {
bool enableGeometry = true;
bool enableSubMtl = false;
bool enableMapping = false;
bool enableLockClosest = false;
int type = ppb->GetInt(kObject_channelType, 0);
bool isFloatType = (type == kObject_channelType_float);
EnableWindow( GetDlgItem(hWnd, IDC_FLOATTYPE), isFloatType );
int showControl = isFloatType ? SW_SHOW : SW_HIDE;
ShowWindow( GetDlgItem( hWnd, IDC_FLOATTYPE), showControl);
if (isFloatType) {
switch(ppb->GetInt(kObject_propertyFloat, 0)) {
case kObject_propertyFloat_distanceToPivot:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_DISTANCETOPIVOT));
break;
case kObject_propertyFloat_distanceToVertex:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_DISTANCETOVERTEX));
break;
case kObject_propertyFloat_distanceToSurface:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_DISTANCETOSURFACE));
break;
case kObject_propertyFloat_objectSpinRate:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSPINRATE));
break;
case kObject_propertyFloat_pointLuminance:
enableSubMtl = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_POINTLUMINANCE));
break;
case kObject_propertyFloat_pointOpacity:
enableSubMtl = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_POINTOPACITY));
break;
case kObject_propertyFloat_faceSquare:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_FACESQUARE));
break;
case kObject_propertyFloat_softSelection:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_SOFTSELECTION));
break;
}
}
bool isIntType = (type == kObject_channelType_integer);
EnableWindow( GetDlgItem(hWnd, IDC_INTTYPE), isIntType );
showControl = isIntType ? SW_SHOW : SW_HIDE;
ShowWindow( GetDlgItem( hWnd, IDC_INTTYPE), showControl);
if (isIntType) {
switch (ppb->GetInt(kObject_propertyInteger, 0)) {
case kObject_propertyInteger_objectIndexByPivot:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTINDEXBYPIVOT));
break;
case kObject_propertyInteger_objectIndexByVertex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTINDEXBYVERTEX));
break;
case kObject_propertyInteger_objectIndexBySurface:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTINDEXBYSURFACE));
break;
case kObject_propertyInteger_vertexIndex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_VERTEXINDEX));
break;
case kObject_propertyInteger_faceIndex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_FACEINDEX));
break;
case kObject_propertyInteger_materialIndex:
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MATERIALINDEX));
break;
}
}
bool isVectorType = (type == kObject_channelType_vector);
EnableWindow( GetDlgItem(hWnd, IDC_VECTORTYPE2), isVectorType );
showControl = isVectorType ? SW_SHOW : SW_HIDE;
ShowWindow( GetDlgItem( hWnd, IDC_VECTORTYPE2), showControl);
if (isVectorType) {
int vectorType = ppb->GetInt(kObject_propertyVector, 0);
switch(vectorType) {
case kObject_propertyVector_objectPosition:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTPOSITION));
break;
case kObject_propertyVector_objectSpeed:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSPEED));
break;
case kObject_propertyVector_objectScale:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSCALE));
break;
case kObject_propertyVector_objectEuclideRotation:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTEUCLIDEROTATION));
break;
case kObject_propertyVector_objectSpinAxis:
enableGeometry = false;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_OBJECTSPINAXIS));
break;
case kObject_propertyVector_nearestColor:
enableSubMtl = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTCOLOR));
break;
case kObject_propertyVector_nearestMapping:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTMAPPING));
break;
case kObject_propertyVector_mappingUVector:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MAPPINGUVECTOR));
break;
case kObject_propertyVector_mappingVVector:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MAPPINGVVECTOR));
break;
case kObject_propertyVector_mappingWVector:
enableMapping = true;
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_MAPPINGWVECTOR));
break;
case kObject_propertyVector_nearestSurfacePoint:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTSURFACEPOINT));
break;
case kObject_propertyVector_nearestVertex:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTVERTEX));
break;
case kObject_propertyVector_nearestNormal:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_NEARESTNORMAL));
break;
case kObject_propertyVector_localSpeed:
enableLockClosest = true;
SetDlgItemText( hWnd, IDC_TEXT_PROPERTY, GetString(IDS_DESCRIPTION_LOCALSPEED));
break;
}
}
ISpinnerControl* spin = NULL;
bool useSubMtl = (ppb->GetInt(kObject_useSubMtl, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_USESUBMATERIAL), enableSubMtl );
spin = GetISpinner( GetDlgItem( hWnd, IDC_SUBMATERIALSPIN) );
spin->Enable(enableSubMtl && useSubMtl);
ReleaseISpinner(spin);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_MAPPINGCHANNEL), enableMapping );
spin = GetISpinner( GetDlgItem( hWnd, IDC_MAPPINGCHANNELSPIN) );
spin->Enable(enableMapping);
ReleaseISpinner(spin);
// if (enableLockClosest) // lockClosest is not used at the moment
// if (ppb->GetInt(kObject_assignOnce, 0) != 0) enableLockClosest = false;
// EnableWindow( GetDlgItem(hWnd, IDC_LOCK), enableLockClosest );
int numObjects = ppb->Count(kObject_objects);
EnableWindow( GetDlgItem(hWnd, IDC_REMOVENODE), numObjects > 0 );
bool useDesignate = (ppb->GetInt(kObject_useDesignate, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_CUSTOMNAME2), useDesignate);
EnableWindow( GetDlgItem(hWnd, IDC_CHANNELNAME2), useDesignate);
bool useSyncChannel = (ppb->GetInt(kObject_sync, 0) == kObject_sync_channel);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_CUSTOMNAME3), useSyncChannel);
EnableWindow( GetDlgItem(hWnd, IDC_CHANNELNAME3), useSyncChannel);
EnableWindow( GetDlgItem(hWnd, IDC_ANIMATED), enableGeometry);
bool animatedShape = (ppb->GetInt(kObject_animated, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_GEOMETRY), enableGeometry && animatedShape);
bool useFilter = (ppb->GetInt(kObject_useCondition, 0) != 0);
EnableWindow( GetDlgItem(hWnd, IDC_TEXT_CONDITIONNAME2), useFilter);
EnableWindow( GetDlgItem(hWnd, IDC_CONDITIONNAME2), useFilter);
}
}
}
void RendSplineParamsMapDlgProc::Update(HWND hWnd, TimeValue t, ParamID id)
{
if (hWnd != NULL && mod != NULL)
{
Interval valid;
switch (id)
{
case rnd_ViewportOrRender:
{
if(mod->UseViewOrRenderParams(t)== rbViewport)
{
mod->pblock->GetMap()->ReplaceParam(rnd_thickness,rnd_viewThickness);
mod->pblock->GetMap()->ReplaceParam(rnd_sides,rnd_viewSides);
mod->pblock->GetMap()->ReplaceParam(rnd_angle,rnd_viewAngle);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_width,rnd_v2_vpt_width);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_length,rnd_v2_vpt_length);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_angle2,rnd_v2_vpt_angle2);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_aspect_lock,rnd_v2_vpt_aspect_lock);
// NS: 10/21/04 This is kind of a hack. We need to have 2 Radio Button Sets in the dialog.
// One for Renderer and one for Viewport settings. Depening on which set we're editing
// We need to hide the other set. Unfortunately ReplaceParam doesn't work with Radio Buttons
//mod->pblock->GetMap()->ReplaceParam(rnd_v2_symm_or_rect,rnd_v2_vpt_symm_or_rect);
ShowWindow(GetDlgItem(hWnd,IDC_SYMMETRICAL),SW_HIDE);
ShowWindow(GetDlgItem(hWnd,IDC_RECTANGULAR),SW_HIDE);
ShowWindow(GetDlgItem(hWnd,IDC_VIEW_SYMMETRICAL),SW_SHOW);
ShowWindow(GetDlgItem(hWnd,IDC_VIEW_RECTANGULAR),SW_SHOW);
}
else
{
mod->pblock->GetMap()->ReplaceParam(rnd_thickness,rnd_thickness);
mod->pblock->GetMap()->ReplaceParam(rnd_sides,rnd_sides);
mod->pblock->GetMap()->ReplaceParam(rnd_angle,rnd_angle);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_width,rnd_v2_width);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_length,rnd_v2_length);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_angle2,rnd_v2_angle2);
mod->pblock->GetMap()->ReplaceParam(rnd_v2_aspect_lock,rnd_v2_aspect_lock);
// NS: 10/21/04 This is kind of a hack. We need to have 2 Radio Button Sets in the dialog.
// One for Renderer and one for Viewport settings. Depening on which set we're editing
// We need to hide the other set. Unfortunately ReplaceParam doesn't work with Radio Buttons
//mod->pblock->GetMap()->ReplaceParam(rnd_v2_vpt_symm_or_rect,rnd_v2_symm_or_rect);
ShowWindow(GetDlgItem(hWnd,IDC_VIEW_SYMMETRICAL),SW_HIDE);
ShowWindow(GetDlgItem(hWnd,IDC_VIEW_RECTANGULAR),SW_HIDE);
ShowWindow(GetDlgItem(hWnd,IDC_SYMMETRICAL),SW_SHOW);
ShowWindow(GetDlgItem(hWnd,IDC_RECTANGULAR),SW_SHOW);
}
break;
}
case rnd_display:
case rnd_useView:
{
BOOL display, useView;
mod->pblock->GetValue(rnd_display,t,display, valid); // sets value
mod->pblock->GetValue(rnd_useView,t,useView, valid); // sets value
EnableButtons(hWnd, t, display, useView);
} break;
case rnd_v2_symm_or_rect:
case rnd_v2_vpt_symm_or_rect:
{
int rectangular;
BOOL aspectLock;
BOOL viewport = (mod->UseViewOrRenderParams(t) == rbViewport);
if(viewport)
{
mod->pblock->GetValue(rnd_v2_vpt_symm_or_rect,t,rectangular,valid);
mod->pblock->GetValue(rnd_v2_vpt_aspect_lock,t,aspectLock,valid);
}
else
{
mod->pblock->GetValue(rnd_v2_symm_or_rect,t,rectangular,valid);
mod->pblock->GetValue(rnd_v2_aspect_lock,t,aspectLock,valid);
}
BOOL sym = (rectangular == rbSymmetrical);
mod->pblock->GetMap()->Enable(rnd_thickness,sym);
mod->pblock->GetMap()->Enable(rnd_sides,sym);
mod->pblock->GetMap()->Enable(rnd_angle,sym);
mod->pblock->GetMap()->Enable(rnd_v2_width,!sym);
mod->pblock->GetMap()->Enable(rnd_v2_length,!sym);
mod->pblock->GetMap()->Enable(rnd_v2_angle2,!sym);
if(!sym)
mod->CheckAspectLock(t);
else
mod->pblock->GetMap()->Enable(rnd_v2_aspect_lock,FALSE);
EnableWindow(GetDlgItem(hWnd,IDC_THICKTEXT), sym);
EnableWindow(GetDlgItem(hWnd,IDC_SIDESTEXT), sym);
EnableWindow(GetDlgItem(hWnd,IDC_ANGLETEXT), sym);
EnableWindow(GetDlgItem(hWnd,IDC_WIDTHTEXT), !sym);
EnableWindow(GetDlgItem(hWnd,IDC_LENGTHTEXT), !sym);
EnableWindow(GetDlgItem(hWnd,IDC_ANGLE2TEXT), !sym);
EnableWindow(GetDlgItem(hWnd,IDC_ASPECTTEXT), !sym);
ISpinnerControl *iSpin = GetISpinner(GetDlgItem(hWnd, IDC_ASPECTSPIN));
iSpin->Enable(!sym);
if(!aspectLock)
{
mod->mAspect = mod->GetAspect(t,viewport);
iSpin->SetValue(mod->mAspect,FALSE);
}
else
{
if(!mod->mAspectValidity.InInterval(t))
{
mod->mAspect = mod->GetAspect(t,viewport);
iSpin->SetValue(mod->mAspect,FALSE);
}
}
ReleaseISpinner(iSpin);
} break;
//case rnd_v2_width:
// mod->OnSetWidthLength(hWnd, rnd_v2_length, rnd_v2_width, t, TRUE);
// break;
//case rnd_v2_vpt_width:
// mod->OnSetWidthLength(hWnd, rnd_v2_vpt_length, rnd_v2_vpt_width, t, TRUE);
// break;
//case rnd_v2_length:
// mod->OnSetWidthLength(hWnd, rnd_v2_length, rnd_v2_width, t, FALSE);
// break;
//case rnd_v2_vpt_length:
// mod->OnSetWidthLength(hWnd, rnd_v2_vpt_length, rnd_v2_vpt_width, t, FALSE);
// break;
case rnd_v2_aspect_lock:
case rnd_v2_vpt_aspect_lock:
mod->OnAspectLock(hWnd,t);
break;
}
}
}
