自学教程：C++ GetISpinner函数代码示例

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 procstatic 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 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);}

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);	}}

intFixed32::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 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 );}