// ===========================================================================
// Copyright 2018 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
//
//
//  Creation Date:  Jan 2000
//
//  Description:
//      The procedures in this file are used to update (set the
//		correct values for) the UI controls in the Preferences
//		window.  The updates should be done from the pref
//		optionVars to make the window work correctly after a
//		reset or revert to factory settings.
//
//	Note: If adding preferences, make sure to read
//	http://torw3/maya/TechDoc/CodingGuides/addingPreferences.html
//
source workingTimeUtil;


global proc prefsUpdate()
{
	prefsUpdateAppearance();
	prefsUpdateElements();
	prefsUpdateWindows();
	prefsUpdateDisplay();
	prefsUpdateKin();
	prefsUpdateAnimDisplay();
	prefsUpdateManips();
	prefsUpdateNURBS();
	prefsUpdatePolys();
	prefsUpdateSubdivs();
	prefsUpdateFonts();
	prefsUpdateSettings();
	prefsUpdateAnim();
	prefsUpdateCamera();
	if (exists("steeringWheel")) prefsUpdateSteeringWheel();
	prefsUpdateKeys();
	prefsUpdateModeling();
	prefsUpdateNodeEditor();
	prefsUpdateSelect();
	prefsUpdateSnap();
	prefsUpdateSound();

	// ADSK_CLR_MGT_BEGIN
	prefsUpdateColorManagement();
	// ADSK_CLR_MGT_END

	prefsUpdateAdvanced();
	prefsUpdateFileIO();
	if (isLegacyViewportEnabled())
		prefsUpdateViewCube();
	prefsUpdateDyn();
	prefsUpdateRendering();
    prefsUpdateFileReferences();
    prefsUpdateAssets();
    prefsUpdateModules();
    prefsUpdateOpenMaya();
	python( "from maya.plugin.evaluator.cache_ui import cache_ui_preferences_tab_update" );
	python( "cache_ui_preferences_tab_update()" );

	global string $gPrefsCustomTabCtrlUpdate[];
	string $ctrlUpdate;
	for($ctrlUpdate in $gPrefsCustomTabCtrlUpdate) {
		eval $ctrlUpdate;
	}

	prefsUpdateSaveActions();
	prefsUpdateExternalApps();
	prefsUpdateCommandPortDefaults();
}

global proc prefsUpdateAppearance()
{
	global string $gPreferenceWindow;
	global string $gMainWindow;
	global string $gCommandWindow;
	global string $gMayaMode;

	setParent $gPreferenceWindow;
	string $parent = "prefAppearCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	// select the mode in the drop down
	global string $gModeOptionsMenu;
	if (size($gModeOptionsMenu) > 0) {
		updateDropDownMenu($gModeOptionsMenu, true);
	}

	checkBoxGrp -e
		-value1 `optionVar -query mainWindowMenubarVis`
		mainMenubarCheck1;

	checkBoxGrp -e
		-value1 (!`optionVar -query collapseIconBarsInPanels`)
		panelToolbarCheck1;

	checkBoxGrp -e
		-value1 `optionVar -query allowMenusInPanels`
		showMenuBarChk;

	checkBoxGrp -e
		-value1 `optionVar -query mainWindowTitleBarVis`
		mainTitleCheck1;

	checkBoxGrp -e
		-value1 `optionVar -query cmdWindowTitleBarVis`
		cmdTitleCheck1;

	checkBoxGrp -e
		-value1 `optionVar -query commandLineHoldFocus`
		focusCheck;

	checkBoxGrp -e
		-value1 `optionVar -query showIconsInMenus`
		iconsInMenusCheck;

	checkBoxGrp -e
		-value1 `optionVar -query saveWindowPos`
		winPrefChk;
	optionMenuGrp -e
		-sl `optionVar -q EEexprEdTextEditor`
		textEdOpts;

	prefExprEdTextEditor(1);


	checkBoxGrp -e
		-value1 `optionVar -query displayNewFeatureHighlights`
		highlightWhatsNewChk;

	checkBoxGrp -e
		-value1 `optionVar -query showHighlightNewFeaturesWindowOnStartup`
		whatsNewStartupDialogChk;

	float $color[] = `optionVar -query newFeatureHighlightColor`;
	colorSliderGrp -e
		-rgbValue $color[0] $color[1] $color[2]
		whatsNewHighlightColorSlider;

	if( `about -mac` ) {
		radioButtonGrp -e -sl `optionVar -q mayaMacButtonMap` mouseTracking;
	}

	checkBoxGrp -e
		-value1 `optionVar -query useScrollWheel`
		wheelPrefChk;

	checkBoxGrp -e
		-value1 `optionVar -query useMultiTouchGestures`
		multiTouchGesturesChk;

	if (`about -mac`) {
		optionMenuGrp -e
			-select `optionVar -query trackpadSetting`
			multiTouchTrackpadOpt;
	}

	// DPI Scaling
	int $scaleMode = `optionVar -q interfaceScalingMode` + 1;
	if ($scaleMode < 3)
	{
		radioButtonGrp -e -select $scaleMode dpiSettingOpt;
	}
	else
	{
		radioButtonGrp -e -select 1 dpiSettingOpt2; // Select "Do not scale."
	}
	optionMenuGrp -e -enable ($scaleMode == 2) customScaleOpt;
	float $scaleValue = `optionVar -q interfaceScalingValue`;
	string $scaleString = (string)((int)($scaleValue * 100)) + "%";
	optionMenuGrp -edit -value $scaleString customScaleOpt;
}


global proc prefsUpdateElements()
{
	global string $gPreferenceWindow;
	//***********
	global string $gNewScenePanelConfig;
	global int	  $gUseNewScenePanelConfig;
	global int	  $gUseScenePanelConfig;
	global int	  $gUseSaveScenePanelConfig;
	//***********
	setParent $gPreferenceWindow;
	string $parent = "prefElementsCol";
	if (`columnLayout -query -numberOfChildren $parent` == 0) return;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Status Line")`
		statusLineCheckBox;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Shelf")`
		shelfCheckBox;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Time Slider")`
		timeSliderCheckBox;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Range Slider")`
		playbackRangeCheckBox;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Command Line")`
		commandLineCheckBox;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Help Line")`
		helpLineCheckBox;

	checkBoxGrp -edit
		-value1 `isUIComponentVisible("Tool Box")`
		toolboxCheckBox;

	prefsUpdateElementsEditors();

	checkBoxGrp -edit
		-value1 (!`optionVar -q channelsLayersSeparate`)
		channelsLayersSeparatePrefChk;

	//*******************
	//
	//  update menu items.
	//

	// This is a fix to get around the optionMenuGrp bug (#81337)
	string $fullName = `setParent "configOpts"`;
	string $menuName = ($fullName+"|OptionMenu");
	setParent -m $menuName;

	$currSelect = $gNewScenePanelConfig;
	$configs = `getPanel -allConfigs`;
	$nConfigs = size($configs);
	$items = `optionMenuGrp -q -ill configOpts`;
	$nItems = `optionMenuGrp -q -ni configOpts`;
	$count = 0;
	for ($i = 0; $i < $nConfigs; $i++) {
		if (!`panelConfiguration -q -sc $configs[$i]` &&
		(localizedPanelLabel("Current Layout")) != `panelConfiguration -q -l $configs[$i]`)
		{
			if ($count < $nItems) {
				menuItem -e -l `panelConfiguration -q -l $configs[$i]` $items[$count];
			} else {
				menuItem -l `panelConfiguration -q -l $configs[$i]`;
			}
			$count++;
		}
	}
	//  remove any extra items
	for ($i = $count; $i < $nItems; $i++) {
		deleteUI -menuItem $items[$i];
	}

	checkBoxGrp -edit
		-value1 `optionVar -query useSaveScenePanelConfig`
		saveConfig;

	checkBoxGrp -edit
		-value1 `optionVar -query useScenePanelConfig`
		openConfig;

	if (`optionVar -q "useNewScenePanelConfig"`) {
		radioButtonGrp -e -sl 1 newConfig2;
	} else {
		radioButtonGrp -e -sl 1 newConfig1;
	}

	$count = 0;
	$currSelect = `optionVar -q "newScenePanelConfiguration"`;
	for ($config in $configs) {
		if( !`panelConfiguration -q -sc $config`
		&&(	localizedPanelLabel("Current Layout") != `panelConfiguration -q -l $config` ) )
		{
			$count++;
			if ($currSelect == `panelConfiguration -q -l $config`) {
				optionMenuGrp -e -sl $count configOpts;
				break;
			}
		}
	}

	checkBoxGrp -edit
		-value1 `optionVar -query ResetModelViewsOnNewScene`
		ResetModelViewsOnNewScene;
}

global proc prefsUpdateElementsEditors()
{
	// Enable check box group in case one of the editors is visible
	int $attrEditorVisible = `isUIComponentVisible("Attribute Editor")`;
	int $toolSettingsVisible = `isUIComponentVisible("Tool Settings")`;
	int $channelLayerVisible = `isUIComponentVisible("Channel Box / Layer Editor")`;
	int $channelBoxVisible = `isUIComponentVisible("Channel Box")`;
	int $layerEditorVisible = `isUIComponentVisible("Layer Editor")`;

	int $enableCheckBoxGroup = $attrEditorVisible + $toolSettingsVisible + $channelLayerVisible + $channelBoxVisible + $layerEditorVisible;
	int $enableSeparateChannelsLayers = ($enableCheckBoxGroup && `optionVar -q channelsLayersSeparate`);
	int $enableChannelsLayersTogether = ($enableCheckBoxGroup && !`optionVar -q channelsLayersSeparate`);

	checkBoxGrp -edit
		-value1 $enableCheckBoxGroup
		editorCheckBox;

	// Set enabled state
	checkBoxGrp -edit
		-enable $enableCheckBoxGroup
		attributeEditorCheckBox;
	checkBoxGrp -edit
		-enable $enableCheckBoxGroup
		toolSettingsCheckBox;
	checkBoxGrp -edit
		-enable $enableSeparateChannelsLayers
		channelsCheckBox;
	checkBoxGrp -edit
		-enable $enableSeparateChannelsLayers
		layersCheckBox;
	checkBoxGrp -edit
		-enable $enableChannelsLayersTogether
		channelsLayersCheckBox;

	// Set select state
	checkBoxGrp -edit
		-value1 $attrEditorVisible
		attributeEditorCheckBox;
	checkBoxGrp -edit
		-value1 $toolSettingsVisible
		toolSettingsCheckBox;
	checkBoxGrp -edit
		-value1 $layerEditorVisible
		layersCheckBox;
	checkBoxGrp -edit
		-value1 $channelBoxVisible
		channelsCheckBox;
	checkBoxGrp -edit
		-value1 $channelLayerVisible
		channelsLayersCheckBox;
}

global proc prefsUpdateWindows()
{
	global string $gPreferenceWindow;
	global int    $gRaiseHelpBrowserWin;
	global string $gHelpLanguage;
	global string $gMayaVersionYear;
	global string $gAvailableLanguages[];

	setParent $gPreferenceWindow;
	string $parent = "prefWindowsCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	//
	// Help
	//
	int $enableInViewMessage = `optionVar -query inViewMessageEnable`;

	checkBoxGrp -edit
		-value1 $enableInViewMessage
		prefsInViewMessageEnable;

	checkBoxGrp -edit
		-value1 `optionVar -query inViewMessageAssistEnable`
		-enable $enableInViewMessage
		prefsInViewMessageAssistEnable;

	checkBoxGrp -edit
		-value1 `optionVar -query inViewMessageStatusEnable`
		-enable $enableInViewMessage
		prefsInViewMessageStatusEnable;

	floatField -edit
		-value `optionVar -query inViewMessageDisplayTime`
		-enable $enableInViewMessage
		prefsInViewMessageDisplayTime;

	intSliderGrp -edit
		-value `optionVar -query inViewMessageFontSize`
		-enable $enableInViewMessage
		prefsInViewMessageFontSize;

	int $enableInViewMessageOpacity = `about -compositingManager`;
	intSliderGrp -edit
		-value `optionVar -query inViewMessageOpacity`
		-enable ($enableInViewMessage && $enableInViewMessageOpacity)
		prefsInViewMessageOpacity;

	int $enablePopup = `optionVar -query popUpHelpMode`;

	checkBoxGrp -edit
		-value1 $enablePopup
		popupHelpMode;

	checkBoxGrp -edit
		-value1 `optionVar -query popUpSimpleHelpMode`
		-enable $enablePopup
		popupSimpleHelpMode;

	string $helpMode = `optionVar -query helpMode`;
	if($helpMode == "Autodesk Web Site")
	{
		radioButton -e -select adskWebSiteBtn;
	}
	else
	{
		radioButton -e -select customPathBtn;
	}

	prefWndHelpLocationModeUpdate();
	// If helpLanguage is not a valid language, by default, select en_US.
	string $lang = `optionVar -q helpLanguage`;

	optionMenu -e -v "English" helpLanguagePopup;

	for ($language in $gAvailableLanguages) {
		string $a[];
		tokenize $language ":" $a;
		if($lang == $a[0])
		{
			optionMenu -e -v $a[1] helpLanguagePopup;
			break;
		}
	}
	textField -e -text (`optionVar -q ("customPathHelpUrl" + $gMayaVersionYear)`) helpDirectoryField;
}

global proc prefsUpdateDisplay()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefDisplayCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	if (isLegacyViewportEnabled())
	{
		radioButtonGrp -e
			-sl (`optionVar -q fastInteraction` ? 1 : 2) fastRBG;

		if (`optionVar -exists maxTextureResolution`)
		{
			int $maxResolution = `optionVar -query maxTextureResolution`;
			intSliderGrp -edit -value $maxResolution maxTextureResolutionSlider;
		}
		int $resolution = `optionVar -query defaultTextureResolution`;
		int $viewportTexture = 0;
		if ( $resolution <= 32 )
		{
			$viewportTexture = 0;
		}
		else if ( $resolution <= 64 )
		{
			$viewportTexture = 1;
		}
		else if ( $resolution <= 128 )
		{
			$viewportTexture = 2;
		}
		else if ( $resolution <= 256 )
		{
			$viewportTexture = 3;
		}
		else if ( $resolution <= 512 )
		{
			$viewportTexture = 4;
		}
		else if ( $resolution <= 1024 )
		{
			$viewportTexture = 5;
		}
		else if ( $resolution <= 2048 )
		{
			$viewportTexture = 6;
		}
		intSliderGrp -edit
			-value $viewportTexture fastViewportTextures;
	}

	checkBoxGrp -e -value1 `optionVar -q enableSwatchRendering`
		swatchRenderingCBG;

	int $val = `optionVar -q maxImageSizeForSwatchGen`;
	string $items[] = `optionMenuGrp -q -itemListShort swatchGenSizeMenu`;
	int $length = size($items);
	int $i=0;
	for ($i=0; $i<$length-1; $i++) {
		if (`menuItem -q -data $items[$i]` == $val) {
			optionMenuGrp -edit -select ($i+1) swatchGenSizeMenu;
			intFieldGrp -edit -enable false swatchGenSizeField;
			break;
		}
	}
	if ($i >= $length-1) {
		// not found, must be custom (last item)
		optionMenuGrp -edit -select ($length) swatchGenSizeMenu;
		intFieldGrp -edit -enable true -v1 $val swatchGenSizeField;
	}

	int $materialLoadingMode = `optionVar -q materialLoadingMode`;
	if ($materialLoadingMode < 1 || $materialLoadingMode > 3){
		$materialLoadingMode = 3;
	}
	optionMenuGrp -e -select $materialLoadingMode materialLoadingModeMenuGrp;

	checkBoxGrp -edit
		-value1 `optionVar -q generateUVTilePreviewsOnSceneLoad`
		generateUvTilePreviewCBG;

	checkBoxGrp -edit
		-value1 `optionVar -q vp2PauseState`
		startVp2PausedCBG;	

	checkBoxGrp -edit
		-value1 `optionVar -query viewAxisVisibility` axisCBG;
	checkBoxGrp -edit
		-value2 `optionVar -query toggleOriginAxis` axisCBG;
	radioButtonGrp -e
		-sl (`optionVar -q showGrid` ? 1 : 2) gridRBG;
    radioButtonGrp -e
		-sl (`optionVar -q activeObjectPivots` ? 1 : 2) activeObjectPivotsRBG;
	radioButtonGrp -e
		-sl (`optionVar -q displayRegionOfEffect` ? 1 : 2) regionOfEffectRBG;
	radioButtonGrp -e
		-sl `optionVar -q wireframeOnShadedActive` wireframeOnShadedActiveRBG;
	radioButtonGrp -e
		-sl (`optionVar -q shadeTemplates` ? 1 : 2) shadeTemplatesRBG;
	radioButtonGrp -e
		-sl (`optionVar -q displayViewportGradient` ? 1 : 2) displayGradientRBG;

	if (`optionVar -exists lineWidth`)
	{
		float $lineWidth = `optionVar -query lineWidth`;
		floatSliderGrp -edit -value $lineWidth lineWidthSlider;
	}

	// Get the rendering
	string $renderingEngineAndOverrideFlag[2] = getPreferredRenderingEngineAndOverrideFlag();
	string $renderingEngine = $renderingEngineAndOverrideFlag[0];
	int $canChangeEngine = ($renderingEngineAndOverrideFlag[1] != "true");

	string $renderingEngineLabel = renderingEngine_LabelFromPreference($renderingEngine);

	optionMenuGrp -edit
		-enable $canChangeEngine
		-value $renderingEngineLabel
		vp2RenderingEngineMenu;

	updateViewportRendererMenu $renderingEngine;
}

global proc updateViewportRendererMenu(string $renderingEngine)
{
	// If we hide all Legacy Viewports, "Viewport 2.0" will be the only choice.
	if (!isLegacyViewportEnabled())
		return;

	// Update viewportRendererMenu, which is only defined for non-Bolt version.
	int $viewportRenderer = `optionVar -query viewportRenderer`;
	int $canChangeRenderer = true;

	// When GL Core Profile the viewport renderer selection is disabled (only VP2.0 can be used)
	if( $renderingEngine == "OpenGLCoreProfile" )
	{
		$viewportRenderer = 2;
		$canChangeRenderer = false;
		optionVar -iv viewportRenderer $viewportRenderer;
	}

	optionMenuGrp -edit
		-enable $canChangeRenderer
		-select $viewportRenderer
		viewportRendererMenu;
}

global proc prefsUpdateKin()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefKinCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	floatSliderGrp -e
		-v (`optionVar -q ikJointDisplayScale`) jdsPrefWidget;
	floatSliderGrp -e
		-v (`optionVar -q ikIkFkJointDisplayScale`) jdsIkFkPrefWidget;
	floatSliderGrp -e
		-v (`optionVar -q ikHandleDisplayScale`) hdsPrefWidget;

	int $dm = 4;
	string $display = `optionVar -q ikIkFkDisplayMethod`;
	if ($display == "none") $dm = 1;
	else if ($display == "ik") $dm = 2;
	else if ($display == "fk") $dm = 3;
	radioButtonGrp -edit -select $dm ikfkDisplay;
}

global proc prefsUpdateAnimDisplay()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefAnimDispCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	intSliderGrp -e
		-v (`optionVar -q ghostFramesBefore`) ghostFramesBeforeSlider;
	intSliderGrp -e
		-v (`optionVar -q ghostFramesAfter`) ghostFramesAfterSlider;
	intSliderGrp -e
		-v (`optionVar -q ghostFrameStep`) ghostFrameStepSlider;
}

global proc prefsUpdateAssets()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefAssetsCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBoxGrp -e
		-value1 (`optionVar -q containerSelRootsInOutliner`) containerSelectionCheckBox;
	intFieldGrp -e -value1 `optionVar -q containerChanBoxMaxNoTemplate` containerMaxWithoutTemplate;
	intFieldGrp -e -value1 `optionVar -q containerChanBoxMaxWithTemplate` containerMaxWithTemplate;
	intFieldGrp -e -value1 `optionVar -q containerFlatViewCap` containerAeGroupSize;
}

global proc prefsUpdateManips()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;

	string $parent = "prefManipsCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	optionMenuGrp -edit
		-select `optionVar -query defaultShowManipulator`
		defaultManipOpts;

	floatSliderGrp -e -v `optionVar -q manipGlobalScale` manipScale;
	floatSliderGrp -e -v `optionVar -q manipHandleSize` manipHS;
	intSliderGrp -e -v `optionVar -q manipLineSize` manipLS;
	floatSliderGrp -e -v `optionVar -q manipLinePickSize` manipLP;
	floatSliderGrp -e -v `optionVar -q manipPreviousStateSize` manipPS;
    radioButtonGrp -edit -sl (`optionVar -q manipsRememberActiveHandle` ? 2 : 1) manipHandleSelectionChange;
    radioButtonGrp -edit -sl (`optionVar -q manipsRememberActiveHandleAfterToolSwitch` ? 2 : 1) manipHandleMRSSwitch;
	intSliderGrp -e -v `optionVar -q manipClickBoxSize` manipPickRange;
	intSliderGrp -e -v `optionVar -q manipPlaneHandleOffset` manipPHO;
	checkBoxGrp -edit -value1 `optionVar -q manipShowPlaneHandles` manipSPH;
	intSliderGrp -e -v `optionVar -q manipPivotRotateHandleOffset` manipPRO;
	checkBoxGrp -edit -value1 `optionVar -q manipShowPivotRotateHandle` manipSPR;
	checkBoxGrp  -edit -value1 `manipOptions -q -hideManipOnCtrl` manipHideOnCtrl_CB;
	checkBoxGrp  -edit -value1 `manipOptions -q -hideManipOnShift` manipHideOnShift_CB;
	checkBoxGrp  -edit -value1 `manipOptions -q -hideManipOnShiftCtrl` manipHideOnShiftCtrl_CB;
	checkBoxGrp -edit -value1 `optionVar -q manipShowPenumbraDecayRegions` penumbraDecayRegions;
}


global proc prefsUpdateNURBS()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefNURBSCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	int $hasSurfaces = `isTrue SurfaceUIExists`;

	checkBoxGrp -e
		-value1 `optionVar -query  newCurveDisplayEP`
		-value2 `optionVar -query  newCurveDisplayHull`
		-value3 `optionVar -query  newCurveDisplayCV`
		controlCBG1;

	if ( $hasSurfaces ) {
		checkBoxGrp -e
			-value1 `optionVar -query  newSurfaceDisplayEP`
			-value2 `optionVar -query  newSurfaceDisplayHull`
			controlNewSurface1;

		checkBoxGrp -e
			-value1 `optionVar -query  newSurfaceDisplayCV`
			-value2 `optionVar -query  newSurfaceDisplayOrigin`
			controlNewSurface2;

		intSliderGrp -e -v `optionVar -q newNurbsIsoparms` nurbsDivUV;
		intSliderGrp -e -v `optionVar -q newNurbsPointsShaded` nurbsDivS;
	}
	intSliderGrp -e -v `optionVar -q newNurbsPointsWire` nurbsDivW;

	displaySmoothness -dc -du `optionVar -q newNurbsIsoparms`;
	displaySmoothness -dc -pw `optionVar -q newNurbsPointsWire`;
	displaySmoothness -dc -ps `optionVar -q newNurbsPointsShaded`;

	radioButtonGrp -e -sl (`optionVar -q highPrecisionNurbs` + 1)  highPrecisionNurbsRadio;
}

global proc prefsUpdatePolys()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefPolysCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;
	if (!`isTrue "PolygonsExists"`) return;

	checkBoxGrp -e
		-value1 `optionVar -query  newPolyVtxDisp`
		-value2 `optionVar -query  newPolyVertexNormals`
		-value3 `optionVar -query  newPolyVtxBackCull`
		polyVertDispCheck;

	floatSliderGrp -e
		-v `optionVar -q newPolyVertexSize` polyVertexSizeSlider;
	polyOptions -np -sv `optionVar -q newPolyVertexSize`;

	radioButtonGrp -e
		-sl (`optionVar -q newPolyEdgeDisp` + 1) polyEdgeDispRadio;

	checkBoxGrp -e
		-value1 `optionVar -query  newPolyBorderEdgeHilite`
		-value2 `optionVar -query  newPolyBorderMapHilite`
		-value3 `optionVar -query  newPolyCreaseEdgeHilite`
		polyEdgeHiliteDispCheck;

	floatSliderGrp -e
		-v `optionVar -q newPolyBorderEdgeSize` polyBordEdgeSizeSlider;
	polyOptions -np -sb `optionVar -q newPolyBorderEdgeSize`;

	checkBoxGrp -e
		-value1 `optionVar -query  newPolyFacetCentreDisp`
		-value2 `optionVar -query  newPolyFacetNormalDisp`
		polyFacetDispCheck1;

	checkBoxGrp -e
		-value1 `optionVar -query  newPolyFacetTrngleDisp`
		-value2 `optionVar -query  newPolyFacetWarpDisp`
		polyFacetDispCheck2;

	checkBoxGrp -e
		-value1 `optionVar -query  newPolyNumVertexDisp`
		-value2 `optionVar -query  newPolyNumEdgeDisp`
		polyItemDispCheck1;

	checkBoxGrp -e
		-value1 `optionVar -query  newPolyNumFacetDisp`
		-value2 `optionVar -query  newPolyNumUvDisp`
		polyItemDispCheck2;

	floatSliderGrp -e
		-v `optionVar -q newPolyNormalSize` polyNormalSizeSlider;
	polyOptions -np -sn `optionVar -q newPolyNormalSize`;

	floatSliderGrp -e
		-v `optionVar -q newPolyUVSize` polyUVSizeSlider;
	polyOptions -np -suv `optionVar -q newPolyUVSize`;

	optionMenuGrp -e
		-sl (`optionVar -q newPolyBackFaceCull` + 1) polyFBackCullPopup;

	checkBoxGrp -e
		 -value1 `optionVar -query newPolyColorShaded` colorShadedDisplayCheck;
	optionMenuGrp -e -sl
		`optionVar -q newPolyColorChannel` colorMaterialPopup;

	optionMenuGrp -e -sl
		`optionVar -q newPolyMaterialBlend` materialBlendPopup;

	prefPolyUpdateCulling();

	checkBoxGrp -e
		 -value1 `optionVar -query displayAlphaAsGreyScale` displayAlphaAsGreyScaleCheck;
	polyOptions -np -dal `optionVar -q displayAlphaAsGreyScale`;

	int $options[] = `polyOptions -q -newPolymesh -smoothDrawType`;
	optionMenuGrp -edit -select ($options[0] + 1) polyDefaultSmoothDrawType_OMG;

}

global proc prefsUpdateSubdivs()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSubdivsCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	int $style = `optionVar -query subdivComponentDisplayStyle`+1;
	radioButtonGrp -e -select $style subdivDisplayRBG;
}

global proc prefsUpdateFonts()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefFontsCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	int $mode = `optionVar -q fontSetOpt`;
	if ($mode == 0) {
		radioButtonGrp -e -sl 1 defaultFontOpt;
	} else if ($mode == 1) {
		radioButtonGrp -e -sl 1 mediumFontOpt;
	} else {
		radioButtonGrp -e -sl 1 customFontOpt;
	}

	if ($mode == 2)
	{
		intSliderGrp -e
			-en true -v `optionVar -q smallFontSize` SmallFontsSizeSlider;
		displayPref -sfs `optionVar -q smallFontSize`;

		intSliderGrp -e
			-en true -v `optionVar -q defaultFontSize` DefaultFontsSizeSlider;
		displayPref -dfs `optionVar -q defaultFontSize`;
	}
	else
	{
		intSliderGrp -e
			-en false -v `optionVar -q smallFontSize` SmallFontsSizeSlider;
		displayPref -sfs `optionVar -q smallFontSize`;

		intSliderGrp -e
			-en false -v `optionVar -q defaultFontSize` DefaultFontsSizeSlider;
		displayPref -dfs `optionVar -q defaultFontSize`;
	}
}

global proc prefsUpdateSettings()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSettingsCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	string $type;
	int $which;

	//  coordinate system
	//
	radioButtonGrp -e
		-sl ((`optionVar -q upAxisDirection` == "y") ? 1 : 2)
		upAxisRBG;

	//  linear units
	//
	$type = `optionVar -q workingUnitLinear`;
	if ("mm" == $type || "millimeter" == $type) {
		$which = 1;
	} else if ("cm" == $type || "centimeter" == $type) {
		$which = 2;
	} else if ("m" == $type || "meter" == $type) {
		$which = 3;
// re-number next menus after removing this one
//	} else if ("km" == $type || "kilometer" == $type) {
//		$which = 4;
	} else if ("in" == $type || "inch" == $type) {
		$which = 4;
	} else if ("ft" == $type || "foot" == $type) {
		$which = 5;
	} else if ("yd" == $type || "yard" == $type) {
		$which = 6;
//	} else if ("mi" == $type || "mile" == $type) {
//		$which = 8;
	} else {
		$which = 1;
	}
	optionMenuGrp -e -sl $which linearOpts;

	//  angular
	//
	$type = `optionVar -q workingUnitAngular`;
	if ("deg" == $type || "degree" == $type) {
		$which = 1;
	} else if ("rad" == $type || "radian" == $type) {
		$which = 2;
	} else {
		$which = 1;
	}
	optionMenuGrp -e -sl $which angularOpts;

	//  time
	//
	$type = `optionVar -q workingUnitTime`;
    $which = getIndexFromCurrentUnitCmdValue($type);
    
	optionMenuGrp -e -sl $which timeOpts;
    
	// tolerance
	//
	floatSliderGrp -e
		-v `optionVar -q positionalTolerance` posTolFloatSliderGrp;
	floatSliderGrp -e
		-v `optionVar -q tangentialTolerance` tanTolFloatSliderGrp;
}


global proc prefsUpdateAnim()
{
	global string $gPreferenceWindow;
	global string $gPlayBackSlider;

	setParent $gPreferenceWindow;
	string $parent = "prefAnimCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	int    $which;
	int    $size;
	string $type;

	// Playback Start/End
	//
	timeFieldGrp -e
		-value1 `optionVar -query playbackMin`
		-value2 `optionVar -query playbackMax`
		timeSliderBounds;

	// Animation Start/End
	//
	timeFieldGrp -e
		-value1 `optionVar -query playbackMinRange`
		-value2 `optionVar -query playbackMaxRange`
		rangeSliderBounds;

	// Height
	//
	$base = `optionVar -q timeSliderBaseHeight`;
	$size = `optionVar -q timeSliderHeight`;
	$which = ($size <= $base) ? 1 : (($size <= ($base *2)) ? 2 : 3);
	radioButtonGrp -e -sl $which timeLineSize;

	//  Frame rate
	//
	$type = `optionVar -q workingUnitTime`;
    $which = getIndexFromCurrentUnitCmdValue($type);
    
	optionMenuGrp -e -sl $which timeSliderTimeOpts;    
        
    // Key Ticks
	//
	$type = `optionVar -q timeSliderShowKeys`;
	int $combined = `optionVar -q timeSliderShowKeysCombined`;
	if( $type == "active" ) {
		radioButtonGrp -e -sl 2 showTicks;
	} else if( $type == "none" ) {
		radioButtonGrp -e -sl 1 showTicks;
	} else if ($combined == 0) {
		radioButtonGrp -e -sl 3 showTicks;
	} else {
		radioButtonGrp -e -sl 4 showTicks;
	}

	// Key tick size (value should be in range 1 to 5
	int $tickSize = `optionVar -q timeSliderTickSize`;
    $tickSize = $tickSize - 1;
    
    string $radioButtonNames[] = `radioCollection -q -collectionItemArray keyTickSizeRadioButton`;
    int $nbRadioButton = size($radioButtonNames);
    
    // Make sure we have a valid value
    if($tickSize < 0 || $tickSize >  $nbRadioButton)
        $tickSize = 1;
    
    radioCollection -e -select $radioButtonNames[$tickSize] keyTickSizeRadioButton;
  

	// Tick Span Size
	int $timeLabelSpacing = `optionVar -q timeSliderTickSpan`;
	intFieldGrp -edit -value1 $timeLabelSpacing timeLabelSpacing;

	// Grease Frames
	//
	$type = `optionVar -q timeSliderShowFrames`;
	if( $type == "none" ) {
		radioButtonGrp -e -sl 1 showFrames;
	} else if( $type == "active" ) {
		radioButtonGrp -e -sl 2 showFrames;
	} else if ($type == "all") {
		radioButtonGrp -e -sl 3 showFrames;
	} else {
		radioButtonGrp -e -sl 2 showFrames;
	}
    
    
	// Options: Snapping
	//
	checkBoxGrp -e -value1 `optionVar -query timeSliderSnapping` timeLine;

	// Update View
	//
	radioButtonGrp -e
		-sl (("active" == `optionVar -q timeSliderPlayView`) ? 1 : 2)
		playbackView;

	// Looping
	//
	$type = `optionVar -q timeSliderPlayLoop`;
	$which = ($type == "once") ? 1 : (($type == "oscillate") ? 2 : 3);
	radioButtonGrp -e -sl $which playbackLooping;

	// Playback Speed
	//
	float $speed = `optionVar -query timeSliderPlaySpeed`;
	if ($speed == 1.0) {
		$which = 2;
	} else if ($speed == 0.5) {
		$which = 3;
	} else if ($speed == 2.0) {
		$which = 4;
	} else if ($speed == 0.0) {
		$which = 1;
	} else {
		$which = 5;
	}

	optionMenu -e -sl $which speedOpts;
	text -edit -enable ($which == 5) playbackSpeedT;

	float $fps = currentTimeUnitToFPS();
	floatField -edit
		-enable ($which == 5)
		-value ($which == 5 ? $speed * $fps : 0)
		playbackSpeedFF;

	// Max Playback Speed
	//
	$speed = `optionVar -query timeSliderMaxPlaySpeed`;
	int $whichMax = 1;
	if ($speed == 1.0) {
		$whichMax = 2;
	} else if ($speed == 0.5) {
		$whichMax = 3;
	} else if ($speed == 2.0) {
		$whichMax = 4;
	} else if ($speed == 0.0) {
		$whichMax = 1;
	}

	optionMenuGrp -e -sl $whichMax maxSpeedOpts;

	// Playback By: value only applicable if the speed is
	// "free" ($which == 1)
	//
	floatField -e -v `optionVar -q timeSliderPlayBy` playbackByFF;
	rowLayout -edit -enable ($which == 1) playbackByRow;
	optionMenuGrp -edit -enable ($which == 1) maxSpeedOpts;

	prefWndAnimOptionChanged (false);
}

global proc prefsUpdateViewCube()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefViewCubeCol";

	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBoxGrp -e -v1 (`optionVar -q viewCubeShowCube`)
		viewCubeShow;

	// The option var for position is in command arg form ie "topRight",
	// "topLeft", so we have to convert it to UI string "Top Right", "Top Left" etc
	string $positionPref = `optionVar -q viewCubeScreenPosition`;
	string $positionValue = uiRes("m_createPrefWndUI.kViewCubeTopRight");
	if ($positionPref == "topRight")
	{
		$positionValue = uiRes("m_createPrefWndUI.kViewCubeTopRight");
	} else if ($positionPref == "bottomRight")
	{
		$positionValue = uiRes("m_createPrefWndUI.kViewCubeBottomRight");
	} else if ($positionPref == "topLeft")
	{
		$positionValue = uiRes("m_createPrefWndUI.kViewCubeTopLeft");
	} else if ($positionPref == "bottomLeft")
	{
		$positionValue = uiRes("m_createPrefWndUI.kViewCubeBottomLeft");
	}
	optionMenuGrp -edit -value $positionValue
		ViewCubeScreenPosMenu;

	// Screen size:
	// Need to convert the English screen size value taken by the viewManip
	// command to the localized string.
	string $sizePref = `optionVar -query viewCubeSize`;
	string $sizeString = uiRes("m_createPrefWndUI.kViewCubeNormal");
	switch ($sizePref)
	{
		case "small":  $sizeString = uiRes("m_createPrefWndUI.kViewCubeSmall"); break;
		case "normal": $sizeString = uiRes("m_createPrefWndUI.kViewCubeNormal"); break;
		case "large": $sizeString = uiRes("m_createPrefWndUI.kViewCubeLarge"); break;
	}
	optionMenuGrp -edit -value $sizeString
		ViewCubeSizeMenu;

	// Inactive opacity:
	// Need to convert opacity pref from float to string eg 0.25 to "25%"
	float $opacityPref = `optionVar -query viewCubeInactiveOpacity`;
	string $opacityString = (string)($opacityPref * 100) + "%";
	optionMenuGrp -edit -value $opacityString
		ViewCubeOpacityMenu;

	checkBoxGrp -e -v1 (`optionVar -q viewCubeSnapToClosest`)
		viewCubeSnapToClosestLabel;

	checkBoxGrp -e -v1 (`optionVar -q viewCubeFitToView`)
		viewCubeFitToView;

	checkBoxGrp -e -v1 (`optionVar -q animateRollViewCompass`)
		viewCubeAnimatedTransitions;

	checkBoxGrp -e -v1 (`optionVar -q viewCubePreserveSceneUp`)
		viewCubePreserveSceneUp;

	int	$compassVisible = `optionVar -q viewCubeShowCompass`;

	checkBoxGrp -e -v1 $compassVisible viewCubeShowCompass;

	floatSliderGrp -e -enable $compassVisible
		-value (`optionVar -q viewCubeCompassAngle`) viewCubeCompassAngle;
}
global proc prefsUpdateSteeringWheel()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSteeringWheelCol";

	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	floatSliderGrp -e -value (`optionVar -q steeringWheelBigSize`)
		steeringWheelBigSize;
	intSliderGrp -e -value (`optionVar -q steeringWheelBigOpacity`)
		steeringWheelBigOpacity;
	floatSliderGrp -e -value (`optionVar -q steeringWheelMiniSize`)
		steeringWheelMiniSize;
	intSliderGrp -e -value (`optionVar -q steeringWheelMiniOpacity`)
		steeringWheelMiniOpacity;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelShowToolMessages`)
		steeringWheelShowToolMessages;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelShowToolTips`)
		steeringWheelShowToolTips;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelShowPinnedOnStartup`)
		steeringWheelShowPinnedWheel;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelInvertLookAxis`)
		steeringWheelInvertLookAxis;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelConstrainWalkToGround`)
		steeringWheelConstrainWalk;
	floatSliderGrp -e -value (`optionVar -q steeringWheelWalkSpeedFactor`)
		steeringWheelWalkSpeedFactor;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelIncrementalZoom`)
		steeringWheelIncrementalZoom;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelKeepSceneUpright`)
		steeringWheelKeepSceneUpright;
	checkBoxGrp -e -v1 (`optionVar -q steeringWheelSelectionSensitivity`)
		steeringWheelSelectionSensitivity;
}
global proc prefsUpdateDyn()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefDynCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;
	if (!`isTrue "DynamicsExists"`) return;

	checkBoxGrp -e -v1 (`optionVar -q dynPrefAutoCreate`)
		dynAutoCreate;

	checkBoxGrp -e -v1 (`optionVar -q dynPrefRunupToCurrentTime`)
		dynRunupToCurrentTime;

	radioButtonGrp -e -select (`optionVar -q dynPrefRunupFrom`)
		dynRunupFrom;

	checkBoxGrp -e -v1 (`optionVar -q dynPrefSaveRuntimeState`)
		dynSaveRuntimeState;

	checkBoxGrp -e -v1 (`optionVar -q dynPrefEchoCollision`)
		dynEchoCollisionState;

	// Enable the dynRunupFrom radioButtonoGrp only if
	// dynRunupToCurrentTime is on.
	//
	int $state = `checkBoxGrp -q -v1 dynRunupToCurrentTime`;
	radioButtonGrp -e -enable $state dynRunupFrom;
}

global proc prefsUpdateCamera()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefCameraCol";

	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	floatSliderGrp -e
        -v `optionVar -q defaultCameraNearClipValue`
        DefaultCameraNearClipValue;

	floatSliderGrp -e
        -v `optionVar -q defaultCameraFarClipValue`
        DefaultCameraFarClipValue;

	checkBoxGrp -e -value1 `optionVar -q animateRoll`
		animatedCameraFitViewCheckBox;

	checkBoxGrp -e -value1 `optionVar -q animateRollFitAll`
		animatedCameraFitViewAllCheckBox;

	checkBoxGrp -e -value1 `optionVar -q animateRollGotoBookmark`
		animatedCameraBookmarksCheckBox;

	checkBoxGrp -e -value1 `optionVar -q animateRollNextLastCameraView`
 		animatedCameraNextLastCameraViewCheckBox;

	floatSliderGrp -e -value `optionVar -q totalAnimateRollTime`
		animatedCameraTotalAnimateTimeFloatField;

	floatSliderGrp -e -value `optionVar -q defaultFitFactor`
		viewFitDefaultFactorFloatField;
}

global proc prefsUpdateKeys()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefKeysCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	int $evalMode = `optionVar -q evaluationMode`;
	if ($evalMode < 1 || $evalMode > 3){
		$evalMode = 1;
	}
	checkBoxGrp -e -en ($evalMode != 1) gpuOverrideChkBx;
	checkBoxGrp -e -v1 `optionVar -q gpuOverride` gpuOverrideChkBx;
	
	checkBoxGrp -e -en ($evalMode != 1) controllerPrePopCbx;
	checkBoxGrp -e -v1 `optionVar -q prepopulateController` controllerPrePopCbx;

	optionMenuGrp -e -select $evalMode evaluationModeMenuGrp;

	// Auto Key
	//
	int $autoKeyVal = `optionVar -q autoKeyframeState`;
	checkBoxGrp -e -v1 $autoKeyVal autoKey;
	string $characterAutoKey = `optionVar -q autoKeyCharacterState`;
	int    $which = 1;
	if ($characterAutoKey == "all") {
		$which = 2;
	}
	optionMenuGrp -e -select $which -enable $autoKeyVal autoKeyCharacter;

	optionMenuGrp -edit
		-select `optionVar -query rotationInterpolationDefault`
		rotationInterpolationDefaultOptions;

	optionMenuGrp -edit
		-select `optionVar -query hikRotationInterpolationDefault`
		hikRotationInterpolationDefaultOptions;

	// Weighted Tangents
	//
	int $weighted = `optionVar -q weightedTangents`;
	checkBoxGrp -e -v1 $weighted weightedTangents;

	// Default in tangent
	//
	string $tangentType = `optionVar -q inTangentType`;
	$which = 1;
	if ($tangentType == "spline") {
		$which = 1;
	} else if ($tangentType == "linear") {
		$which = 2;
	} else if ($tangentType == "clamped") {
		$which = 3;
	} else if ($tangentType == "flat") {
		$which = 4;
	} else if ($tangentType == "plateau") {
		$which = 5;
	} else if ($tangentType == "auto") {
		$which = 6;
	}
	optionMenuGrp -edit -select $which inTangentType;

	// Default out tangent
	//
	$tangentType = `optionVar -q outTangentType`;
	$which = 1;
	if ($tangentType == "spline") {
		$which = 1;
	} else if ($tangentType == "linear") {
		$which = 2;
	} else if ($tangentType == "clamped") {
		$which = 3;
	} else if ($tangentType == "flat") {
		$which = 4;
	} else if ($tangentType == "step") {
		$which = 5;
	} else if ($tangentType == "plateau") {
		$which = 6;
	} else if ($tangentType == "auto") {
		$which = 7;
	}
	optionMenuGrp -edit -select $which outTangentType;

	// animation and constraint blending
	//
	int $blending = `optionVar -q animBlendingOpt`;
	if ($blending == 1) {
		radioButtonGrp -e -sl 1 alwaysBlendOpt;
	} else if ($blending == 2) {
		radioButtonGrp -e -sl 1 blendExceptConstraintsOpt;
	} else {
		radioButtonGrp -e -sl 1 neverBlendOpt;
	}

	// animBlendNode 
	//
	int $animBlend = `optionVar -q animBlendBrokenInputOpt`;
	if ($animBlend == 1) {
		radioButtonGrp -e -sl 1 animBlendToCurrentValueOpt;
	} else {
		radioButtonGrp -e -sl 1 animBlendToIdentityOpt;
	}

	// Graph Editor
	//
	checkBoxGrp -e
		-v1 (`optionVar -q graphEdSnapToAdjacentValues`)
		graphEdSnapToAdjacentValuesChk;

	checkBoxGrp -e
		-v1 (`optionVar -q graphEdLmbMovesSelections` )
		graphEdLmbMovesSelectionsChk;

	// graph editor stacked view spacing
	floatFieldGrp -edit -value1 `optionVar -query stackedCurvesSpace` graphEdStackedViewSpace;

	// Autoframe option is a preference only when the modern GE is part of the build.
	checkBoxGrp -e
		-v1 (`optionVar -q graphEditorAutoFit` )
		graphEdAutoFrameChk;

	// AutoframeTime option checkbox is only enabled when AutoFit is checked.
	checkBoxGrp -e
		-v1 (`optionVar -q graphEditorAutoFitTime` )
		graphEdAutoFrameTimeChk;
	checkBoxGrp -e -enable (`checkBoxGrp -q -v1 graphEdAutoFrameChk`) graphEdAutoFrameTimeChk;

		
	// Set the correct radio button to indicate which graph editor version is being used.
	// The active graph editor version is stored in the graphEditorUI option variable.
	// The classic graph editor has a value of 1. 
	// The modern graph editor has a value other than 1.
	// The modern graph editor is the default.
	// This is also the value that will be returned if the graphEditorUI option variable does not exist.
	radioButtonGrp -e -sl ((`optionVar -q graphEditorUI` == 1 ) ? 1 : 2 ) graphEditorUI;

	// Other
	//
	$which = `optionVar -q animEdCadenceLineType`;
	if ( $which != 1 && $which != 2 ) {
		$which = 1;   // Force to Working Units if invalid value
	}
	optionMenu -e -sl $which animEdCadenceLineType;

	floatField -e 
		-v (`optionVar -q animEdCadenceLineFreq` )
		animEdCadenceLineFreq;

	$type = `optionVar -q graphEdValueLineDisplay`;
	if ("On" == $type) {
		$which = 1;
	} else if ("Off" == $type) {
		$which = 2;
	} else {
		$which = 1;
	}
	optionMenuGrp -e -sl $which graphEdValueLineDisplayOpts;

	floatFieldGrp -e 
		-v1 (`optionVar -q graphEdValueLineInterval` )
		graphEdValueLineInterval;

	intFieldGrp -e 
		-v1 (`optionVar -q graphEdValueMinLines` )
		graphEdValueMinLines;

// TEMPORARILY DISABLING THE SHORT LINES FEATURE

	intField -e
		-v (`optionVar -q timeEditorGranularity` )
		timeEditorGranularity;

	intField -e
		-v (`optionVar -q timeEditorSnapTolerance` )
		timeEditorSnapTolerance;

	intField -e
		-v (`optionVar -q timeEditorMinimumClipWidth` )
		timeEditorMinimumClipWidth;
		
	checkBoxGrp -e
		-v1 (`optionVar -q timeEditorHUD` )
		timeEditorHUDChk;

	checkBoxGrp -e
		-v1 (`optionVar -q timeEditorAllowConstraintsOverride`)
		timeEditorAllowConstraintsOverrideChk;


	// Sequencer
	//
	checkBoxGrp -e
		-v1 (`optionVar -q seqDoubleClickMayaFrameRange`)
		seqMayaFrameRangeChk;

	checkBoxGrp -e
		-v1 (`optionVar -q seqDoubleClickSelectCamera`)
		seqSelectCamChk;

	checkBoxGrp -e
		-v1 (`optionVar -q seqDoubleClickFrameShot`)
		seqFrameShotChk;

	checkBoxGrp -e
		-v1 (`optionVar -q seqDoubleClickSoloTrack`)
		seqSoloTrackChk;

	int $seqTime = `optionVar -q seqDoubleClickSetSequenceTime`;
	if ($seqTime == 1)
		radioButtonGrp -e -sl 1 sequenceTimeCursorOpt;
	else if ($seqTime == 2)
		radioButtonGrp -e -sl 1 sequenceTimeShotStartOpt;
	else
		radioButtonGrp -e -sl 1 sequenceTimeOpt;

	int $maxMinTime = `optionVar -q seqDoubleClickSetTimeRange`;
	if ($maxMinTime == 1)
	{
		radioButtonGrp -e -sl 1 sequenceTRShotOpt;
	}
	else if ($maxMinTime == 2)
	{
		radioButtonGrp -e -sl 1 sequenceTRSeqOpt;
	}
	else // do nothing
	{
		radioButtonGrp -e -sl 1 sequenceTRDoNothningOpt;
	}
}

global proc prefsUpdateModeling()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefModelingCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	int $curType = `modelWithType -1`;
	if ($curType == 0) {
		radioButtonGrp -e -sl 1 modelWithType1;
		radioButtonGrp -e -enable 0 modelWithType5;
	} else if ($curType == 1) {
		radioButtonGrp -e -sl 1 modelWithType2;
		radioButtonGrp -e -enable 0 modelWithType5;
	} else if ($curType == 3) {
		radioButtonGrp -e -sl 1 modelWithType3;
		radioButtonGrp -e -enable 0 modelWithType5;
	} else if ($curType == 2) {
		radioButtonGrp -e -sl 1 modelWithType4;
		radioButtonGrp -e -enable 0 modelWithType5;
	} else if ($curType == -1) {
		radioButtonGrp -e -sl 1 -enable 1 modelWithType5;
	}

	$curType = `modelWithToolsAll -1`;
	if ($curType == 0) {
		radioButtonGrp -e -sl 1 modelWithTools2;
		radioButtonGrp -e -enable 0 modelWithTools3;
	} else if ($curType == 1) {
		radioButtonGrp -e -sl 1 modelWithTools1;
		radioButtonGrp -e -enable 0 modelWithTools3;
	} else if ($curType == -1) {
		radioButtonGrp -e -sl 1 -enable 1 modelWithTools3;
	}

	checkBoxGrp -edit -value1 `optionVar -query polyAutoConvertAction` polyAutoConvert;
	checkBoxGrp -edit -value1 `optionVar -query polyCreateMeshesSingleSided` polyCreateMeshSingleSided;
	checkBoxGrp -edit -value1 `optionVar -query polyAutoInstallAction` polySmartCommandSettings;
	checkBoxGrp -edit -value1 `optionVar -query polyAutoShowColorPerVertex` polyConvertDisplay;
	checkBoxGrp -edit -value1 `optionVar -query polyKeepFacetsGrouped` polyKeepFacesTogether;
	checkBoxGrp -edit -value1 `optionVar -query bump2dUseTangentSpaceNormalsByDefault` polyDefaultTangentSpaceNormals;

	$curType = `optionVar -query polyDefaultTangentSpace`;
	if( $curType < 2)
		radioButtonGrp -edit -select 1 polyDefaultRightHandedTangentSpace;
	else
		radioButtonGrp -edit -select 1 polyDefaultLeftHandedTangentSpace;
	if( $curType % 2)
		radioButtonGrp -edit -select 1 polyDefaultTangentsIgnoreUVWindingOrder;
	else
		radioButtonGrp -edit -select 1 polyDefaultTangentsDetectUVWindingOrder;

	floatSliderGrp -edit -value `optionVar -query polyDefaultTangentSmoothingAngle` polyDefaultTangentSmoothingAngle;

	int $options[] = `polyOptions -q -newPolymesh -vertexNormalMethod -smoothDrawType`;
	optionMenuGrp -edit -select ($options[0] + 1) polyDefaultVertexNormalMethod_OMG;

	int $globalSmooth[] = `polyOptions -q -smoothDrawType`;
	optionMenuGrp -edit -select ($globalSmooth[0] + 1) polyGlobalSmoothDrawType_OMG;

	checkBoxGrp -edit -value1 (!`optionVar -query disableRenaming3dPaintTextures`) threeDeePaintRenameTextures;
}

global proc prefsUpdateNodeEditor()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefNodeEditorCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	if (`optionVar -q nodeEdShowShapes`) {
		if (`optionVar -q nodeEdShowSGShapes`)
			radioButtonGrp -e -sl 1 nodeEdPrefShapesOMG;
		else
			radioButtonGrp -e -sl 2 nodeEdPrefShapesOMG;
	}
	else {
		radioButtonGrp -e -sl 3 nodeEdPrefShapesOMG;
	}
	// radioButtonGrp selection is 1-4, which correspond to

	// view modes 0-3
	int $ix = `optionVar -q nodeEdDefaultNodeViewMode`;
	radioButtonGrp -e -sl ($ix + 1) nodeEdPrefViewModeRBG;

	checkBoxGrp -e -v1 `optionVar -q nodeEdGridVisibility` nodeEdPrefDisplayG;
	checkBoxGrp -e -v1 `optionVar -q nodeEdGridSnapping` nodeEdPrefDisplayGS;

	checkBoxGrp -e -v1 `optionVar -q nodeEdShowTransforms` nodeEdPrefDisplayT;
	checkBoxGrp -e -v1 `optionVar -q nodeEdExtendToShapes` nodeEdPrefDisplayETS;
	checkBoxGrp -e -v1 `optionVar -q nodeEdShowNamespace` nodeEdPrefDisplaySN;
	checkBoxGrp -e -v1 `optionVar -q nodeEdUseAssetsAndPublishedAttributes` nodeEdPrefDisplayUA;

	checkBoxGrp -e -v1 `optionVar -q nodeEdSyncedSelection` nodeEdPrefUpdateOS;
	checkBoxGrp -e -v1 `optionVar -q nodeEdAddNewNodes` nodeEdPrefUpdateONC;
}

global proc prefsUpdateFileReferences()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefFileReferencesCol";

	if (`columnLayout -q -numberOfChildren $parent` == 0) {
		return;
	}


	// Referenced Animation Curves
	checkBoxGrp -e
		-v1 (`optionVar -q refAnimCurvesEditable`)
		refAnimCurvesEditableChk;

	// lock editable
	checkBoxGrp -e
		-v1 (`optionVar -q refLockEditable`)
		refLockEditableChk;

}

global proc prefsUpdateSelect()
{
	global int $gCustomSelPriority[];
	global string $gSelectPriorityMode;
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSelectCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBoxGrp -e
		-value1 `optionVar -query selectSingleMarquee`
		-value2 `optionVar -query selectClickDrag`
		modsCBG1;
	checkBoxGrp -e
		-value1 `optionVar -query selectAffectsActive`
		-value2 `optionVar -query popupMenuSelection`
		modsCBG2;
	checkBoxGrp -e
		-value1 `optionVar -query ignoreSelectionPriority`
		-value2 `optionVar -query expandPopupList`
		modsCBG3;
	checkBoxGrp -e
		-value1	`optionVar -query preSelectHilite`
		-value2 `optionVar -query disableComponentPopups`
		modsCBG4;
	checkBoxGrp -e
		-value1 `optionVar -query selectPrefAutoUseDepth`
		-value2	`optionVar -query selectPrefUseDepth`
		modsCBG5;
	checkBoxGrp -e
		-enable2 (!`optionVar -query selectPrefAutoUseDepth`)
		modsCBG5;
	checkBoxGrp -e
		-value1	`optionVar -query containerCentricSelection`
		-value2 `optionVar -query containerAutoSelectContainer`
		modsCBG6;
	checkBoxGrp -e
		-value1 `optionVar -query TrackSelectionOrder`
		-value2 `optionVar -query PreserveComponentSelections`
		modsCBG7;
	checkBoxGrp -e
		-value1 `optionVar -query ChannelBox_ClearSelectionOnObjectSelectionChange`
		modsCBG8;

	optionMenuGrp -e
		-sl (`optionVar -q selectionChildHighlightMode` + 1)
		prefSelChildHighlightMode;

	intSliderGrp -e
		-v `optionVar -q clickBoxSize`
		clickBoxSizeS;

	intSliderGrp -e
		-v `selectPref -q -preSelectSize`
		MT_preSelectSize_ISG;
	intSliderGrp -e
		-v `selectPref -q -preSelectTweakDeadSpace`
		MT_tweakDeadSpaceRange_ISG;
	intSliderGrp -e
		-v `selectPref -q -preSelectDeadSpace`
		MT_selectDeadSpaceRange_ISG;

	if (`isTrue "PolygonsExists"`) {
		radioButtonGrp -e
			-sl (`optionVar -q polyFaceSensitive` ? 2 : 1)
			polyFaceSensitiveRadio;
	}

	$gSelectPriorityMode = `optionVar -q selectPrefPriorityMode`;

	if ("custom" == $gSelectPriorityMode) {
		optionMenuGrp -e -sl 1 presetOpts;
		intFieldGrp -e -en true priorVal;
	} else if ("animation" == $gSelectPriorityMode) {
		optionMenuGrp -e -sl 2 presetOpts;
		intFieldGrp -e -en false priorVal;
	} else if ("nurbs" == $gSelectPriorityMode) {
		optionMenuGrp -e -sl 3 presetOpts;
		intFieldGrp -e -en false priorVal;
	} else if ("rendering" == $gSelectPriorityMode) {
		optionMenuGrp -e -sl 4 presetOpts;
		intFieldGrp -e -en false priorVal;
	} else if ("dynamics" == $gSelectPriorityMode) {
		optionMenuGrp -e -sl 5 presetOpts;
		intFieldGrp -e -en false priorVal;
	}

	$gCustomSelPriority = `optionVar -q customSelectPriority`;
	selPriority( $gSelectPriorityMode );

	textScrollList -e -da -sii 1 priorList;
	prefSelectPriorListChanged;
}

global proc prefsUpdateSnap()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSnapCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBoxGrp -e
		-value1 `optionVar -query useSnapTolerance`
		useSnapCBG1;

	intSliderGrp -e
		-v `optionVar -q snapTolerance`
		snapToleranceSG;

	intSliderGrp -e
		-v `optionVar -q snapUVTolerance`
		snapUVToleranceSG;

	intSliderGrp -e
		-v `optionVar -q snapMagnet`
		snapMagnetSG;

	floatSliderGrp -e
		-v `optionVar -q snapMagnetTolerance`
		snapMagnetToleranceSG;
}

global proc prefsUpdateSound()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSoundCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	// Waveform display
	//
	string $waveform = `optionVar -q timeSliderSoundDisplay` ;
	if( $waveform == "bottom" ) {
		radioButtonGrp -e -sl 2 soundDisplay;
	} else if( $waveform == "both" ) {
		radioButtonGrp -e -sl 3 soundDisplay;
	} else {
		radioButtonGrp -e -sl 1 soundDisplay;
	}

	// Repeat on Hold
	//
	int $doRepeat = `optionVar -q timeSliderRepeatOnHold` ;
	checkBoxGrp -e -v1 $doRepeat soundRepeat;

	// Repeat Size
	//
	float $chunk = `optionVar -q timeSliderRepeatChunk`;
	int   $canDisplayChunk = ( $chunk == 1.0 || $chunk == 2.0 ||
							   $chunk == 3.0 );

	rowLayout -e -enable $doRepeat soundRepeatChunkLayout;
	floatField -e -value $chunk soundRepeatChunkValue;

	if( $canDisplayChunk ) {
		radioButton -e -sl ( "soundRepeatChunk" + int( $chunk ) );
	} else {
		radioButton -e -sl "soundRepeatChunk4";
	}
}

// ADSK_CLR_MGT_BEGIN
global proc prefsUpdateColorManagement()
{
    global string $gPreferenceWindow;
    setParent $gPreferenceWindow;
    string $parent = "prefColorManagementCol";
    if (`columnLayout -q -numberOfChildren $parent` == 0) return;

    // Update manage pots UI
	if (`control -exists colorManagedPotsEnableCheckBox`)
	{
	    int $doPots = `colorManagementPrefs -q -colorManagePots`;
	    checkBoxGrp -edit -value1 $doPots colorManagedPotsEnableCheckBox;
	}
}
// ADSK_CLR_MGT_END

global proc prefsUpdateAdvanced()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefAdvancedCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	//  undo
	int $isInfinite = `optionVar -q undoIsInfinite`;
	radioButtonGrp -e
		-sl (`optionVar -q undoIsEnabled` == on ? 1 : 2)
		undoEnableRBG;
	radioButtonGrp -e
		-sl ($isInfinite ? 1 : 2)
		queueLimitRBG;
	intFieldGrp -e
		-enable (!$isInfinite)
		-value1 `optionVar -query undoLength`
		queueSizeIFG;
	checkBoxGrp -e
		-v1 `optionVar -q timeChangeUndoConsolidation`
		timeChangeUndoConsolidationCB;
}

// Description: Update the rendering pref UI to reflect
//				the current status of the option variables
// Returns:		None
//
global proc prefsUpdateRendering()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefRenderingCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	string $prefRen = `preferredRenderer -query`;

	// Update the Renderer selection option box to reflect current renderer
	//
	string $renderers[] = `renderer -query -namesOfAvailableRenderers`;

	for ($i = 0; $i < size($renderers); $i += 1)
	{
		if($renderers[$i] == $prefRen)
		{
			optionMenuGrp -edit -select ($i+1) prefRendererOptionMenu;
		}
	}

	int $renderLayerSystem = 1;
	string $envEnableLegacyRenderLayers = `getenv "MAYA_ENABLE_LEGACY_RENDER_LAYERS"`;
	if ($envEnableLegacyRenderLayers == "1")
	{
		$renderLayerSystem = 0;
	}
	else if ($envEnableLegacyRenderLayers == "0")
	{
		$renderLayerSystem = 1;
	}
	else if ( `optionVar -exists "renderSetupEnable"` )
	{
		$renderLayerSystem = `optionVar -q "renderSetupEnable"`;
	}
	string $renderLayerSystemLabel = renderLayerSystem_LabelFromPreference($renderLayerSystem);
	optionMenuGrp -edit
		-value $renderLayerSystemLabel
		preferredRenderLayerSystemMenu;
	
	// Giving the chance to third parties to update their rendering preferences
	//
	callbacks -executeCallbacks -hook "updateMayaRenderingPreferences";

}

global proc prefsUpdateExternalApps()
// Description: Update the External Application's pref UI to reflect
//				the current status of the option variables
// Returns:		None
{
	// Name of textfields to update
	//
	string $controls[] = {
		"viewImageDir",
		"viewImageCmdFmt",
		"viewSequenceDir",
		"viewSequenceCmdFmt",
		"photoshopDir",
		"editimageDir",
		"playblastCmdAvi",
		"playblastCmdFmtAvi",
		"playblastCmdQuicktime",
		"playblastCmdFmtQuicktime"
		};

	// Name of option vars that store the textfield's value
	//
	string $varName[]  = {
		"ViewImageDir",
		"ViewImageCmdFormat",
		"ViewSequenceDir",
		"ViewSequenceCmdFormat",
		"PhotoshopDir",
		"EditImageDir",
		"PlayblastCmdAvi",
		"PlayblastCmdFormatAvi",
		"PlayblastCmdQuicktime",
		"PlayblastCmdFormatQuicktime"
		};

	// Traverse the array of controls/varnames and repopulate control with
	// related optionVar
	//
	for ($i=0; $i<size($controls); $i++)
	{
		if (`optionVar -exists $varName[$i]` == false)
			continue;

		string $path = `optionVar -q $varName[$i]`;
		catchQuiet(`textField -e -tx $path $controls[$i]`);
	}
}

global proc prefsUpdateFileIO()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefFileIOCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	// If MAYA_PROJECTS_DIR env var is set, we won't allow
	// this to be set from the UI
	string $envVar = `getenv MAYA_PROJECTS_DIR`;
	if ( size($envVar) > 0 )
	{
		textField -e -ed false -tx $envVar projectsDir;
		button -e -en false projectsDirBrowser;
	}
	else
	{
		if ( `optionVar -ex ProjectsDir` )
		{
			textField -e -tx `optionVar -q ProjectsDir` projectsDir;
		}
	}

	// Same for MAYA_PROJECT
	$envVar = `getenv MAYA_PROJECT`;
	if ( size($envVar) > 0 )
	{
		textField -e -ed false -tx $envVar initialProject;
		button -e -en false initialProjectBrowser;
	}
	else
	{
		if ( `optionVar -ex InitialProject` )
		{
			textField -e -tx `optionVar -q InitialProject` initialProject;
		}
	}

	//  recent files maximum history size
	intSliderGrp -e -v `optionVar -q RecentFilesMaxSize` RecentFilesMaxSize;

	//  recent backups maximum history size
	intSliderGrp -e -v `optionVar -q RecentBackupsMaxSize` RecentBackupsMaxSize;

	//  recent projects maximum history size
	intSliderGrp -e -v `optionVar -q RecentProjectsMaxSize` RecentProjectsMaxSize;

	// autosave settings
	int $autoSaveEnable = `optionVar -q autoSaveEnable`;
	checkBoxGrp -e -v1 $autoSaveEnable autoSaveEnable;
	checkBoxGrp -e -v1 `optionVar -q autoSavePrompt` autoSavePrompt;
	checkBoxGrp -e -v1 `optionVar -q autoSaveLimitBackups` autoSaveLimitBackups;
	intSliderGrp -e -v `optionVar -q autoSaveMaxBackups` autoSaveMaxBackups;
	intSliderGrp -e -v `optionVar -q autoSaveInterval` autoSaveInterval;
	int $autoSaveDestination = `optionVar -q autoSaveDestination`;
	radioButtonGrp -e -sl (1+$autoSaveDestination) autoSaveDestination;
	if ( `optionVar -ex autoSaveFolder` )
	{
		textField -e -tx `optionVar -q autoSaveFolder` autoSaveFolder;
	}
	int $autoSaveBrowseLayoutEnable = ( $autoSaveDestination == 1 );
	layout -e -en $autoSaveEnable autoSaveLayout1;
	layout -e -en $autoSaveEnable autoSaveLayout2;
	layout -e -en $autoSaveBrowseLayoutEnable autoSaveBrowseLayout;

	checkBoxGrp -e
       -value1 (`optionVar -q displayCrashInfo`)
       crashDisplayInfoCBG;
	
	//  file save compression
	string $mode = `optionVar -q fileCompressionMode`;
	if ("compressed" == $mode) {
		radioButtonGrp -e -sl 1 compressionRBG;
	} else if ("uncompressed" == $mode) {
		radioButtonGrp -e -sl 2 compressionRBG;
	} else {
		radioButtonGrp -e -sl 3 compressionRBG;
	}

	// Display Layers
	radioButtonGrp -e
		-sl (`optionVar -q displayLayerMerge` + 1)
		layerMerge;

	// Render Layers
	radioButtonGrp -e
		-sl (`editRenderLayerGlobals -q -mergeType` + 1)
		renderLayerMerge;

	radioButtonGrp -e
		-select (`optionVar -q FileDialogStyle`)
		fileDialogPrefsRBG;

    checkBoxGrp -e
        -value1 (`optionVar -q FileDialogHideExtension`)
        fileDialogHideExtensionsCBG;

   checkBoxGrp -e
       -value1 (`optionVar -q fileIgnoreVersion`)
       fileIgnoreVersionCBG;


   checkBoxGrp -e
       -value1 (`optionVar -q canSuppressFileOpenErrorDialog`)
       fileSuppressErrorDialogCBG;

	if (`pluginInfo -q -loaded "modelingToolkit"`)
	{
	   checkBoxGrp -e
		   -value1 (`nexOpt -q autoloadTextures`)
		   MT_autoloadTexturesCBG;
	}
}
global proc prefsUpdateModules()
{
	// Modules prefs are not available on Mac
	if (`about -mac`) return;

	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefModulesCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBoxGrp -e
		-value1 `optionVar -query loadDynamics`
		packCBG1;

	checkBoxGrp -e
		-value1 `optionVar -query loadUrchin`
		packCBG8;
}

global proc prefsUpdateOpenMaya()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefOpenMayaCol";

	// openMaya prefs are not available on Windows and Macintosh
	if (`about -win` || `about -mac`) return;

	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	radioButtonGrp -e
		-sl (`optionVar -q apiPrefLazyLoading` ? 1 : 2)
		lazyLoadingCheck;

	radioButtonGrp -e
		-sl (`optionVar -q apiPrefOldPluginWarning` ? 1 : 2)
		oldPluginWarningCheck;
}

global proc prefsUpdateSaveActions()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefSaveActionsCol";

	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBox -e -value `optionVar -q saveActionsPreferences`
		saveActionsPreferencesOption;
	checkBox -e -value `optionVar -q saveActionsScriptEditor`
		saveActionsScriptEditorOption;
}

global proc prefsUpdateCommandPortDefaults()
{
	global string $gPreferenceWindow;
	setParent $gPreferenceWindow;
	string $parent = "prefExternalAppCol";
	if (`columnLayout -q -numberOfChildren $parent` == 0) return;

	checkBoxGrp -e
		-value1 `optionVar -query commandportOpenByDefault`
		commandportOpenByDefaultCheckBox;

	string $defaultName = `optionVar -q commandportDefaultName`;
	textFieldGrp -edit -text $defaultName commandportDefaultNameTextField;
}