// ===========================================================================
// 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.
// ===========================================================================
// Copyright 2007-2012 dRaster, Inc.
// dRaster.com
{
	global proc showModelingToolkit()
	{
		setUIComponentVisibility("NEXDockControl", true);
	}

	global proc string modelingToolkit_melToUI(string $mel, string $controlLabel) {
		string $result = $mel;

		if ($controlLabel == "manipCoordSpaceText") {
			if ($mel == "World") {
				$result = (getPluginResource("modelingToolkit", "kWorld"));
			} else if ($mel == "Object") {
				$result = (getPluginResource("modelingToolkit", "kObject"));
			} else if ($mel == "Local") {
				$result = (getPluginResource("modelingToolkit", "kLocal"));
			} else if ($mel == "Custom") {
				$result = (getPluginResource("modelingToolkit", "kCustom"));
			}
		} else if ($controlLabel == "selConstDropdown") {
			if ($mel =="Off") {
				$result = (getPluginResource("modelingToolkit", "kOff"));
			} else if ($mel == "Angle") {
				$result = (getPluginResource("modelingToolkit", "kAngle"));
			} else if ($mel == "Border") {
				$result = (getPluginResource("modelingToolkit", "kBorder"));
			} else if ($mel == "Shell") {
				$result = (getPluginResource("modelingToolkit", "kShell"));
			}
		} else if ($controlLabel == "nexSlideText") {
			if ($mel == "None") {
				$result = (getPluginResource("modelingToolkit", "kOff"));
			} else if ($mel == "Grid") {
				$result = (getPluginResource("modelingToolkit", "kGrid"));
			} else if ($mel == "Edge") {
				$result = (getPluginResource("modelingToolkit", "kEdge"));
			} else if ($mel == "Surface") {
				$result = (getPluginResource("modelingToolkit", "kSurface"));
			}
		} else if ($controlLabel == "manipType") {
			if ($mel == "Connect") {
				$result = (getPluginResource("modelingToolkit", "kConnect"));
			} else if ($mel == "Bridge") {
				$result = (getPluginResource("modelingToolkit", "kBridge"));
			} else if ($mel == "Bevel") {
				$result = (getPluginResource("modelingToolkit", "kBevel"));
			} else if ($mel == "Extrude") {
				$result = (getPluginResource("modelingToolkit", "kExtrude"));
			} else if ($mel == "Cut") {
				$result = (getPluginResource("modelingToolkit", "kMultiCut"));
			} else if ($mel == "Weld") {
				$result = (getPluginResource("modelingToolkit", "kTargetWeld"));
			} else if ($mel == "Quadraw") {
				$result = (getPluginResource("modelingToolkit", "kQuadDraw"));
			} else if ($mel == "Select") {
				$result = (getPluginResource("modelingToolkit", "kSelect"));
			} else if ($mel == "Move") {
				$result = (getPluginResource("modelingToolkit", "kMove"));
			} else if ($mel == "Rotate") {
				$result = (getPluginResource("modelingToolkit", "kRotate"));
			} else if ($mel == "Scale") {
				$result = (getPluginResource("modelingToolkit", "kScale"));
			}
		}
		return $result;
	}
	global proc string modelingToolkit_uiToMel(string $ui, string $controlLabel, string $additionalOperation) {
		string $result = $ui;
		// note, perhaps may need to be updated post-rebranding due to the usage of "nex" prefix?
		if ($controlLabel == "manipCoordSpaceText") {
			if ($ui == (getPluginResource("modelingToolkit", "kWorld"))) {
				$result = "World";
			} else if ($ui == (getPluginResource("modelingToolkit", "kObject"))) {
				$result = "Object";
			} else if ($ui == (getPluginResource("modelingToolkit", "kLocal"))) {
				$result = "Local";
			} else if ($ui == (getPluginResource("modelingToolkit", "kCustom"))) {
				$result = "Custom";
			}
		} else if ($controlLabel == "selConstDropdown") {
			if ($ui == (getPluginResource("modelingToolkit", "kOff"))) {
				$result = "Off";
			} else if ($ui == (getPluginResource("modelingToolkit", "kAngle"))) {
				$result = "Angle";
			} else if ($ui == (getPluginResource("modelingToolkit", "kBorder"))) {
				$result = "Border";
			} else if ($ui == (getPluginResource("modelingToolkit", "kShell"))) {
				$result = "Shell";
			}
		}
		if ($additionalOperation != "") {
			return eval($additionalOperation + " \"" + $result + "\"");
		}
		return $result;
	}
	global proc MTcbButtonOff(string $parent, string $self) {
		setParent $parent;
		if (`iconTextButton -ex $self`) {
			iconTextButton -e -bgc 0.37 0.37 0.37 $self;
			// off the background and then turn it on to reset it
			iconTextButton -e -nbg 1 $self;
			iconTextButton -e -nbg 0 $self;
		}
	}
	global proc MTcbButtonOn(string $parent, string $self) {
		setParent $parent;
		if (`iconTextButton -ex $self`) {
			global float $gActiveControlColor[];
			iconTextButton -e -bgc $gActiveControlColor[0] $gActiveControlColor[1] $gActiveControlColor[2] $self;
		}
	}
	global proc string dR_xpmToPng(string $xpmFileStr) {
		global string $gNexIconPath;
		$gNexIconPath = `nexCtx -q -ico`;
		$baseStr = startString( $xpmFileStr, size($xpmFileStr) - 4);
		$theIcon = $gNexIconPath + "/" + $baseStr + ".png";
		//print $theIcon;
		return $theIcon;
	}
	global proc dR_refreshCapsLockHUD() {
		if (`headsUpDisplay -ex HUDCapsLock`) {
			headsUpDisplay -r HUDCapsLock;
		}
	}
	global proc int dR_symmetryEnabled() {
		return (`symmetricModelling -q -symmetry` && `symmetricModelling -q -about` == "topo" && `symmetricModelling -q -topoSymmetry` != "");
	}
	global proc dR_buildCameraBasedSelectionMenu(string $menu) {
		menu -e -dai $menu;
		menuItem -label (getPluginResource("modelingToolkit", "kOff")) -p $menu -c "dR_setCameraBasedSelection \"off\"";
		menuItem -label (getPluginResource("modelingToolkit", "kOn")) -p $menu -c "dR_setCameraBasedSelection \"on\"";
		menuItem -label (getPluginResource("modelingToolkit", "kAuto")) -ann (getPluginResource("modelingToolkit", "kCameraBasedSelectionAutoAnn")) -p $menu -c "dR_setCameraBasedSelection \"auto\"";
	}
	global proc dR_toggleCameraBasedSelection() {
		global string $gPrevCamBasedSelType;
		dR_setCameraBasedSelection(dR_getCameraBasedSelection() == "off" ? $gPrevCamBasedSelType : "off");
	}
	global proc string dR_getCameraBasedSelection() {
		if (`selectPref -q -autoUseDepth`) return "auto";
		if (`selectPref -q -paintSelect`)  return `selectPref -q -paintSelectWithDepth` ? "on" : "off";
		return `selectPref -q -useDepth` ? "on" : "off";
	}
	global proc dR_setCameraBasedSelection(string $mode) {
		global string $gPrevCamBasedSelType;
		if ($mode != "off") $gPrevCamBasedSelType = $mode;

		if ($mode == "auto") {
			selectPref -autoUseDepth 1;
		} else {
			int $enable = ($mode == "on");
			if (`selectPref -q -paintSelect`) {
				selectPref -paintSelectWithDepth $enable -autoUseDepth 0;
			} else {
				selectPref -useDepth $enable -autoUseDepth 0;
			}
		}
		dR_updateCameraBasedSelectionField;
	}
	global proc dR_updateCameraBasedSelectionField() {
		global string $gNexCamSelText;
		string $label;
		string $mode = dR_getCameraBasedSelection();
		if ($mode == "auto") $label = getPluginResource("modelingToolkit", "kAuto");
		else if ($mode == "on") $label = getPluginResource("modelingToolkit", "kOn");
		else $label = getPluginResource("modelingToolkit", "kOff");
		textField -edit -tx $label $gNexCamSelText;
	}
	global proc dR_addRepeatManip(string $manipType) {
		repeatLast -ac ("dR_repeatManip(\"" + $manipType + "\")");
	}
	global proc dR_repeatManip(string $manipType) {
		if(`nexOpt -q manipType` == $manipType) {
			nexOpt -e manipType $manipType;
			nexOpt -e manipType $manipType;
		} else {
			nexOpt -e manipType $manipType;
		}
		dR_updateCommandPanel;
	}
	global proc string[] dR_execObjStrings(string $objStrings[], string $cmd, string $extraCmd) {
		string $allResults[];
		string $theseResults[];
		int $numObjStrings = size($objStrings);
		if( $numObjStrings > 0 ) {
			int $i;
			string $thisCmd;
			for( $i=0; $i<$numObjStrings; $i+=1 ) {
				$thisCmd = `substitute "%s" $cmd $objStrings[$i]`;
				if( !catch( $theseResults = evalEcho( $thisCmd ) )) {
					int $numResults = size( $theseResults );
					int $numTotalResults = size( $allResults );
					for( $n = 0; $n < $numResults; $n ++ ) {
						$allResults[$numTotalResults + $n] = $theseResults[$n];
					}
				}
			}
		}
		if($extraCmd != "") {
			eval($extraCmd);
		}
		return $allResults;
	}
	global proc dR_extrudePrompt(string $extrudeNode, string $extrudeNodesStr) {
		global string $gNexRefreshCmd;
		string $thisDlg = `setParent -q`;
		//formLayout -e -width 260 $thisDlg;
		float $curExtrudeVal = `getAttr ($extrudeNode + ".localTranslateZ")`;
		float $maxExtrudeSlider = 5;
		if($curExtrudeVal > 5) {
			$maxExtrudeSlider = $curExtrudeVal;
		}
		string $setTranslateCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.localTranslateZ #1; " + $gNexRefreshCmd + "\", \"\")";
		string $extrudeField = `floatSliderGrp -pre 3 -minValue 0 -maxValue $maxExtrudeSlider -fieldMinValue -1000 -fieldMaxValue 1000 -step .01 -field true -label (getPluginResource("modelingToolkit", "kLocalZ")+": ") -dc $setTranslateCmd -cc $setTranslateCmd -v $curExtrudeVal -cw3 60 60 120 -p $thisDlg`;
		string $setOffsetCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.offset #1; " + $gNexRefreshCmd + "\", \"\")";
		string $offsetField = `floatSliderGrp -pre 4 -minValue -1.0 -maxValue 1 -fieldMinValue -1000 -fieldMaxValue 1000 -step .001 -field true -label (getPluginResource("modelingToolkit", "kOffset")+": ") -dc $setOffsetCmd -cc $setOffsetCmd -v 0 -cw3 60 60 120 -p $thisDlg`;
		string $setDivCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.divisions #1; " + $gNexRefreshCmd + "\", \"\")";
		string $divisionsField = `intSliderGrp -min 1 -max 10 -fieldMinValue 1 -fieldMaxValue 1000 -step 1 -field true -label (getPluginResource("modelingToolkit", "kDivisions")+": ") -cw3 60 60 120 -v 1 -p $thisDlg -cc $setDivCmd -dc $setDivCmd`;
		float $kftValue = `getAttr ($extrudeNode + ".keepFacesTogether")`;
		string $kftCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.keepFacesTogether #1; " + $gNexRefreshCmd + "\", \"\")";
		string $kftCheckbox = `checkBox -l (getPluginResource("modelingToolkit", "kKeepFacesTogether")) -cc $kftCmd -v $kftValue`;
		string $extrudeBtn = `button -l (getPluginResource("modelingToolkit", "kOk")) -w 50 -c "layoutDialog -dismiss \"extrude\""`;
		string $cancelBtn = `button -l (getPluginResource("modelingToolkit", "kCancel")) -w 50 -c "layoutDialog -dismiss \"\""`;
		formLayout -e
			-attachForm $extrudeField "left" 0
			-attachForm $extrudeField "right" 6
			-attachControl $offsetField "top"   0 $extrudeField
			-attachForm $offsetField    "left"  0
			-attachForm $offsetField    "right" 6
			-attachControl $divisionsField "top"   0 $offsetField
			-attachForm $divisionsField    "left"  0
			-attachForm $divisionsField    "right" 6
			-attachControl $kftCheckbox "top"   4 $divisionsField
			-attachForm $kftCheckbox    "left"  61
			-attachForm $kftCheckbox    "right" 6
			
			-attachControl $cancelBtn "top" 6 $kftCheckbox
			-attachForm    $cancelBtn "right" 6
			-attachControl $extrudeBtn "top" 6 $kftCheckbox
			-attachControl $extrudeBtn "right" 6 $cancelBtn
			$thisDlg;
		setFocus $extrudeField;
	}
	global proc dR_bevelPrompt(string $bevelNode, string $bevelNodesStr) {
		global string $gNexRefreshCmd;
		string $thisDlg = `setParent -q`;
		//formLayout -e -width 120 $thisDlg;
		float $curOffsetVal = `getAttr ($bevelNode + ".fraction")`;
		string $setOffsetCmd = "dR_execObjStrings(" + $bevelNodesStr + ",  \"setAttr %s.fraction #1; " + $gNexRefreshCmd + "\", \"\")";
		string $bevelField = `floatSliderGrp -pre 3 -minValue 0 -maxValue 1 -step .01 -field true -label (getPluginResource("modelingToolkit", "kOffset")+": ") -dc $setOffsetCmd -cc $setOffsetCmd -v $curOffsetVal -cw3 70 60 120 -p $thisDlg`;
		string $setDivCmd = "dR_execObjStrings(" + $bevelNodesStr + ",  \"setAttr %s.segments #1; " + $gNexRefreshCmd + "\", \"\")";
		string $divisionsField = `intSliderGrp -min 1 -max 10 -fieldMinValue 1 -fieldMaxValue 1000 -step 1 -field true -label (getPluginResource("modelingToolkit", "kSegments")+": ") -cw3 70 60 120 -v 1 -p $thisDlg -cc $setDivCmd -dc $setDivCmd`;
		string $bevelBtn = `button -l (getPluginResource("modelingToolkit", "kOk")) -w 50 -c "layoutDialog -dismiss \"bevel\""`;
		string $cancelBtn = `button -l (getPluginResource("modelingToolkit", "kCancel")) -w 50 -c "layoutDialog -dismiss \"\""`;
		formLayout -e
			-attachForm $bevelField "left" 0
			-attachForm $bevelField "right" 6
			-attachControl 	$divisionsField 	"top" 0 $bevelField
			-attachForm 	$divisionsField 	"left" 0
			-attachForm 	$divisionsField 	"right" 6
			-attachControl $cancelBtn "top" 6 $divisionsField
			-attachForm    $cancelBtn "right" 6
			-attachControl $bevelBtn "top" 6 $divisionsField
			-attachControl $bevelBtn "right" 6 $cancelBtn
			$thisDlg;
		setFocus $bevelField;
	}
	global proc dR_vertExtrudePrompt(string $extrudeNode, string $extrudeNodesStr) {
		global string $gNexRefreshCmd;
		string $thisDlg = `setParent -q`;
		//formLayout -e -width 120 $thisDlg;
		float $curWidthVal = `getAttr ($extrudeNode + ".width")`;
		string $setWidthCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.width #1; " + $gNexRefreshCmd + "\", \"\")";
		string $widthField = `floatSliderGrp -pre 3 -field true -min 0 -max 1 -label (getPluginResource("modelingToolkit", "kWidth")+": ") -dc $setWidthCmd -cc $setWidthCmd -v $curWidthVal -cw3 60 60 120 -p $thisDlg`;
		float $curLengthVal = `getAttr ($extrudeNode + ".length")`;
		string $setLengthCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.length #1; " + $gNexRefreshCmd + "\", \"\")";
		string $lengthField = `floatSliderGrp -pre 3 -minValue -2 -maxValue 5 -fieldMinValue -1000 -fieldMaxValue 1000 -step .01 -field true -label (getPluginResource("modelingToolkit", "kLength")+": ") -cw3 60 60 120 -v $curLengthVal -dc $setLengthCmd -cc $setLengthCmd -p $thisDlg`;
		float $curDivisionsVal = `getAttr ($extrudeNode + ".divisions")`;
		string $setDivCmd = "dR_execObjStrings(" + $extrudeNodesStr + ",  \"setAttr %s.divisions #1; " + $gNexRefreshCmd + "\", \"\")";
		string $divisionsField = `intSliderGrp -min 1 -max 10 -fieldMinValue 1 -fieldMaxValue 1000 -step 1 -field true -label (getPluginResource("modelingToolkit", "kDivisions")+": ") -cw3 60 60 120 -dc $setDivCmd -cc $setDivCmd -v $curDivisionsVal -p $thisDlg`;
		string $vertExtrudeBtn = `button -l (getPluginResource("modelingToolkit", "kOk")) -w 50 -c "layoutDialog -dismiss \"extrude\""`;
		string $cancelBtn = `button -l (getPluginResource("modelingToolkit", "kCancel")) -w 50 -c "layoutDialog -dismiss \"\""`;
		formLayout -e
			-attachForm $widthField "left" 0
			-attachForm $widthField "right" 6
			-attachControl $lengthField "top"   0 $widthField
			-attachForm $lengthField    "left"  0
			-attachForm $lengthField    "right" 6
			-attachControl $divisionsField "top"   0 $lengthField
			-attachForm $divisionsField    "left"  0
			-attachForm $divisionsField    "right" 6
			-attachControl $cancelBtn "top" 6 $divisionsField
			-attachForm $cancelBtn "right" 6
			-attachControl $vertExtrudeBtn "top" 6 $divisionsField
			-attachControl $vertExtrudeBtn "right" 6 $cancelBtn
			$thisDlg;
		setFocus $widthField;
	}
	global proc float gbl_float_round(float $f, int $n) {
		if($n > 0) {
			float $roundScale = pow(10, $n);
			if($f > 0) {
				return(((float)(int)($f * $roundScale + 0.5)) / $roundScale);
			} else {
				return(((float)(int)($f * $roundScale - 0.5)) / $roundScale);
			}
		} else {
			float $roundScale = pow(10, -$n);
			if($f > 0) {
				return(((float)(int)($f/$roundScale + 0.5)) * $roundScale);
			} else {
				return(((float)(int)($f/$roundScale - 0.5)) * $roundScale);
			}
		}
	}
	global proc int dR_createHUDElements() {
		int $didCreate = false;
		if(!`isTrue nexHUDCondition`) {
			condition -st true nexHUDCondition;
		}
		if(!`headsUpDisplay -q -ex HUDNEXCurMode`) {
			headsUpDisplay -s 2
				-b (`headsUpDisplay -lastOccupiedBlock 2` + 1)
				-vis false
				-label (getPluginResource("modelingToolkit", "kMTName")+":")
				-c "modelingToolkit_melToUI(interToUI(`nexOpt -q manipType`), \"manipType\")"
				-cc "nexHUDCondition"
				HUDNEXCurMode;
			$didCreate = true;
		}
		if(!`headsUpDisplay -q -ex HUDNEXCoordSpace`) {
			headsUpDisplay -s 2
				-b (`headsUpDisplay -lastOccupiedBlock 2` + 1)
				-vis false
				-label (getPluginResource("modelingToolkit", "kCoordSpace")+":")
				-c "modelingToolkit_melToUI(interToUI(`nexOpt -q manipCoordSpace`), \"manipCoordSpaceText\")"
				-cc "nexHUDCondition"
				HUDNEXCoordSpace;
			$didCreate = true;
		}
		return $didCreate;
	}
	global proc dR_refreshHUD() {
		dR_createHUDElements;
		int $gNexActive = modelingTookitActive();
		if(`headsUpDisplay -q -ex HUDNEXCurMode`) {
			if(!$gNexActive) {
				headsUpDisplay -e -vis false HUDNEXCurMode;
			} else {
				headsUpDisplay -e -vis (`nexOpt -q hudShowMode`) HUDNEXCurMode;
			}
		}
		if(`headsUpDisplay -q -ex HUDNEXCoordSpace`) {
			if(!$gNexActive) {
				headsUpDisplay -e -vis false HUDNEXCoordSpace;
			} else {
				headsUpDisplay -e -vis (`nexOpt -q hudShowCoordSpace`) HUDNEXCoordSpace;
			}
		}
	}
	global proc dR_updateHUD() {
		if(`dR_createHUDElements`) {
			dR_refreshHUD;
		}
		if(`headsUpDisplay -q -ex HUDNEXCurMode`) {
			headsUpDisplay -refresh HUDNEXCurMode;
		}
		if(`headsUpDisplay -q -ex HUDNEXCoordSpace`) {
			headsUpDisplay -refresh HUDNEXCoordSpace;
		}
	}
    global proc int dR_isCtrlHeld() {
	    if(`about -mac`)  {
            return (getModifiers()/16) % 2; // check for Apple key instead of CTRL
        } else {
            return (getModifiers()/4) % 2;
	    }
	}	
	global proc int dR_isShiftHeld() {
		return (getModifiers()/1) % 2;
	}
	global proc dR_setSymMesh() {
		global string $gNexSymText;
		textField -e -tx (dR_getSymmetryLabel()) $gNexSymText;
		if (dR_getSymmetryMode() == "none") {
			global float $gDefaultFieldBgColor[];
			textField -e -backgroundColor $gDefaultFieldBgColor[0] $gDefaultFieldBgColor[1] $gDefaultFieldBgColor[2] $gNexSymText;
		} else {
			global float $gActiveControlColor[];
			textField -e -backgroundColor $gActiveControlColor[0] $gActiveControlColor[1] $gActiveControlColor[2] $gNexSymText;
		}
	}
	global proc dR_validateSymMesh() {
		// Warn if topo symmetry is enabled and symmetry object is not valid
		if (`symmetricModelling -q -symmetry` && `symmetricModelling -q -about` == "topo" && `symmetricModelling -q -topoSymmetry` == "") {
			warning -n (getPluginResource("modelingToolkit", "kSTRMTErrorTopologyChangeSignificantly"));
		}
		dR_setSymMesh();
	}
	global proc int dR_liveSurfaceActive() {
		string $liveList[] = `ls -live`;
		return (size($liveList) > 0);
	}
	global proc dR_conformToLiveSurface() {
		string $liveList[] = `ls -live`;
		if (size($liveList) == 0) {
			error -n (getPluginResource("modelingToolkit", "kConformNoLiveSurface"));
		} else if (size(`ls -sl`) == 0) {
			error -n (getPluginResource("modelingToolkit", "kConformNoSelection"));
		} else if (`optionVar -query polyConformAlongNormals`) {
			mtkShrinkWrap -an -o `optionVar -query polyConformOffset` -t $liveList[0];
		} else {
			mtkShrinkWrap -o `optionVar -query polyConformOffset` -t $liveList[0];
		}
	}
	global proc string dR_getParent(string $child) {
		string $parent;
		string $parents[] = `listRelatives -f -p $child`;
		return $parents[0];
	}
	global proc dR_toggleSlide() {
		global string $gPrevSlideType;
		dR_setSlideType(`xformConstraint -q -type` == "none" ? $gPrevSlideType : "none");
	}
	global proc dR_setSlideType(string $slideType) {
		global string $gPrevSlideType;
		if ($slideType != "none") $gPrevSlideType = $slideType;
		setXformConstraint $slideType;
		dR_updateCommandPanel();
	}
	global proc dR_updateSlideField() {
		global float $gDefaultFieldBgColor[];
		global float $gActiveControlColor[];
		global string $gNexSlideText;
		global string $gNexSlideButton;
		string $liveList[] = `ls -live`;
		if (size($liveList) > 0) {
			iconTextButton -e -en 0 $gNexSlideButton;
			textField -edit -backgroundColor $gActiveControlColor[0] $gActiveControlColor[1] $gActiveControlColor[2] -ann "" -tx (getPluginResource("modelingToolkit", "kUsingLiveSurface")) $gNexSlideText;
		} else {
			string $curSlideType = `xformConstraint -q -type`;
			string $tempSlideCaps = `capitalizeString $curSlideType`;
			iconTextButton -e -en 1 $gNexSlideButton;
			textField -edit
				-tx `modelingToolkit_melToUI $tempSlideCaps "nexSlideText"`
				-ann (getPluginResource("modelingToolkit", "kTransformConstraintAnn")) $gNexSlideText;
			if (`textField -q -tx $gNexSlideText` == getPluginResource("modelingToolkit", "kOff")) {
				textField -e -backgroundColor $gDefaultFieldBgColor[0] $gDefaultFieldBgColor[1] $gDefaultFieldBgColor[2] $gNexSlideText;
			} else {
				textField -e -backgroundColor $gActiveControlColor[0] $gActiveControlColor[1] $gActiveControlColor[2] $gNexSlideText;
			}
		}
	}
	global proc dR_buildSlideMenu(string $menu) {
		menu -e -dai $menu;
		menuItem -label (getPluginResource("modelingToolkit", "kOff")) -p $menu -c "dR_slideOff";
		menuItem -label (getPluginResource("modelingToolkit", "kEdgeSlide")) -ann (getPluginResource("modelingToolkit", "kTransformConstraintEdgesAnn")) -p $menu -c "dR_slideEdge";
		menuItem -label (getPluginResource("modelingToolkit", "kSurfaceSlide")) -ann (getPluginResource("modelingToolkit", "kTransformConstraintSurfaceAnn")) -p $menu -c "dR_slideSurface";
	}
	global proc dR_buildSymMenu(string $menu) {
		reflectionBuildMenu($menu);
	}
	global proc dR_toggleSym() {
		reflectionToggle();
	}
	global proc dR_setSymmetryMode(string $mode) {
		reflectionSetMode($mode);
	}
	global proc string dR_getSymmetryMode() {
		int $symOn = `symmetricModelling -q -symmetry`;
		if ($symOn) {
			string $sym = `symmetricModelling -q -about`;
			if ($sym != "topo") return ($sym + `symmetricModelling -q -axis`);

			string $object = `symmetricModelling -q -topoSymmetry`;
			if ($object != "") return $sym;
		}
		return "none";
	}
	global proc string dR_getSymmetryLabel() {
		return reflectionGetModeString();
	}
	global proc int dR_haveSelectedComponents() {
		return (`nexCtx -cnt "vertex"` > 0 || `nexCtx -cnt "edge"` > 0 || `nexCtx -cnt "face"` > 0);
	}
	global proc dR_performSymmetrize() {
		if (!`dR_haveSelectedComponents`) {
			error -n (getPluginResource("modelingToolkit", "kSTRMTErrorSymNoComponents"));
		} else if (!`dR_symmetryEnabled`) {
			pickTopoSymmetryEdge("dR_symmetrize", 1);
		} else {
			dR_symmetrize;
		}
	}
	global proc dR_performSymmetryFlip() {
		if (!`dR_haveSelectedComponents`) {
			error -n (getPluginResource("modelingToolkit", "kSTRMTErrorSymFlipNoComponents"));
		} else if (!`dR_symmetryEnabled`) {
			pickTopoSymmetryEdge("dR_symmetryFlip", 1);
		} else {
			dR_symmetryFlip;
		}
	}
	global proc dR_setSliceMode(string $mode, int $enable) {
		nexOpt -e $mode $enable;
		if ($enable) {
			// Disable any other incompatible options
			string $modes[] = { "sliceIgnoreBackfaces", "useDeleteFaces", "useExtractFaces" };
			for ($otherMode in $modes) {
				if ($mode != $otherMode && `nexOpt -q $otherMode`) {
					nexOpt -e $otherMode 0;
				}
			}
		}
		refresh -f; // update the tool in the 3D view
	}
	global proc dR_updateSelConstField() { 
		global string $gNexPickSelConstText, $gSelConstField; 
		global float $gDefaultFieldBgColor[]; 
		global float $gActiveControlColor[]; 
		textField -e -backgroundColor $gActiveControlColor[0] $gActiveControlColor[1] $gActiveControlColor[2] $gNexPickSelConstText; 
		if (`polySelectConstraint -q -bp`) 
			textField -edit -tx(getPluginResource("modelingToolkit", "kBorder")) $gNexPickSelConstText; 
		else if (`polySelectConstraint -q -ap`) 
			textField -edit -tx(getPluginResource("modelingToolkit", "kAngle")) $gNexPickSelConstText; 
		else if (`polySelectConstraint -q -sh`) 
			textField -edit -tx(getPluginResource("modelingToolkit", "kShell")) $gNexPickSelConstText; 
		else if (`polySelectConstraint -q -lp`) 
			textField -edit -tx(getPluginResource("modelingToolkit", "kEdgeLoop")) $gNexPickSelConstText; 
		else if (`polySelectConstraint -q -rp`) 
			textField -edit -tx(getPluginResource("modelingToolkit", "kEdgeRing")) $gNexPickSelConstText; 
		else if (`polySelectConstraint -q -ulp`)
			textField -edit -tx(getPluginResource("modelingToolkit", "kUVEdgeLoop")) $gNexPickSelConstText;
		else { 
			textField -edit -tx(getPluginResource("modelingToolkit", "kOff")) $gNexPickSelConstText; 
			textField -e -backgroundColor $gDefaultFieldBgColor[0] $gDefaultFieldBgColor[1] $gDefaultFieldBgColor[2] $gNexPickSelConstText; 
		} 
 
		if (`nexOpt -q selectOption` == "" && `polySelectConstraint -q -ap`) 
			control -e -en true $gSelConstField; 
		else 
			control -e -en false $gSelConstField; 
	}
	global proc dR_toggleSelConst() {
		global string $gPrevSelConsType;
		int $enabled  = (
			`polySelectConstraint -q -bp` ||
			`polySelectConstraint -q -ap` ||
			`polySelectConstraint -q -sh` ||
			`polySelectConstraint -q -lp` ||
			`polySelectConstraint -q -rp` ||
			`polySelectConstraint -q -ulp`
		);
		dR_setSelConst($enabled ? "off" : $gPrevSelConsType);
	}
	global proc dR_setSelConst(string $selType) {
		global string $gPrevSelConsType;
		if ($selType != "off") $gPrevSelConsType = $selType;

		if($selType == "off")
			polySelectConstraint -bo false -bp false -sh false -cr false -ap false -lp false -rp false -ulp false;
		if($selType == "angle")
			polySelectConstraint -bo false -bp false -sh false -cr false -ap true -lp false -rp false -ulp false;
		if($selType == "border")
			polySelectConstraint -bo true -bp true -sh false -cr false -ap false -lp false -rp false -ulp false;
		if($selType == "shell")
			polySelectConstraint -bo false -bp false -sh true -cr false -ap false -lp false -rp false -ulp false;
		if($selType == "loop")
			polySelectConstraint -bo false -bp false -sh false -cr false -ap false -lp true -rp false -ulp false;
		if($selType == "ring")
			polySelectConstraint -bo false -bp false -sh false -cr false -ap false -lp false -rp true -ulp false;
		if ($selType == "uvEdgeLoop")
			polySelectConstraint -bo false -bp false -sh false -cr false -ap false -lp false -rp false -ulp true;
		dR_updateSelConstField();
	}
	global proc dR_updateSelConstAngle() {
		floatField -e -v `polySelectConstraint -q -at` nexselConstField;
	}
	global proc dR_setSelConstAngle(float $angle) {
		polySelectConstraint -bo false -bp false -sh false -cr false -at $angle;
	}
	global proc dR_updateRelaxAffectsField() {
		dR_setRelaxAffects `nexOpt -q relaxAffects`;
	}
	global proc dR_setRelaxAffects(int $relaxAffects) {
		global string $gNexPickRelaxAffectsText;
		nexOpt -e relaxAffects $relaxAffects;

		switch($relaxAffects)
		{
			case 1:
				textField -edit -tx `getPluginResource "modelingToolkit" "kRelaxAffectsInterior"` $gNexPickRelaxAffectsText;
				break;
			case 2:
				textField -edit -tx `getPluginResource "modelingToolkit" "kRelaxAffectsBorders"` $gNexPickRelaxAffectsText;
				break;
			case 3:
				textField -edit -tx `getPluginResource "modelingToolkit" "kRelaxAffectsAuto"` $gNexPickRelaxAffectsText;
				break;
			default:
				textField -edit -tx `getPluginResource "modelingToolkit" "kRelaxAffectsAll"` $gNexPickRelaxAffectsText;
				break;
		}
	}
	global proc dR_updateExtendField() {
		dR_setExtend `nexOpt -q extendType`;
	}
	global proc dR_setExtend(int $extendType) {
		global string $gNexPickExtendText;
		nexOpt -e extendType $extendType;

		switch($extendType)
		{
			case 1:
				textField -edit -tx `getPluginResource "modelingToolkit" "kExtendLoop"` $gNexPickExtendText;
				break;
			case 2:
				textField -edit -tx `getPluginResource "modelingToolkit" "kExtendBorder"` $gNexPickExtendText;
				break;
			default:
				textField -edit -tx `getPluginResource "modelingToolkit" "kExtendEdge"` $gNexPickExtendText;
				break;
		}
	}
	global proc dR_buildSelConstMenu(string $theMenu) {
		menu -e -dai $theMenu;
		menuItem -label (getPluginResource("modelingToolkit", "kOff")) -p $theMenu -c "dR_selConstraintOff";
		menuItem -label (getPluginResource("modelingToolkit", "kAngle")) -p $theMenu -c "dR_selConstraintAngle";
		menuItem -label (getPluginResource("modelingToolkit", "kBorder")) -p $theMenu -c "dR_selConstraintBorder";
		menuItem -label (getPluginResource("modelingToolkit", "kEdgeLoop")) -p $theMenu -c "dR_selConstraintEdgeLoop";
		menuItem -label (getPluginResource("modelingToolkit", "kEdgeRing")) -p $theMenu -c "dR_selConstraintEdgeRing";
		menuItem -label (getPluginResource("modelingToolkit", "kShell")) -p $theMenu -c "dR_selConstraintElement";
		menuItem -label (getPluginResource("modelingToolkit", "kUVEdgeLoop")) -p $theMenu -c "dR_selConstraintUVEdgeLoop";
	}
	global proc dR_buildRelaxAffectsMenu(string $theMenu) {
		menu -e -dai $theMenu;
		menuItem -label (getPluginResource("modelingToolkit", "kRelaxAffectsAuto")) -p $theMenu -c "dR_setRelaxAffectsAuto";
		menuItem -label (getPluginResource("modelingToolkit", "kRelaxAffectsInterior")) -p $theMenu -c "dR_setRelaxAffectsInterior";
		menuItem -label (getPluginResource("modelingToolkit", "kRelaxAffectsBorders")) -p $theMenu -c "dR_setRelaxAffectsBorders";
		menuItem -label (getPluginResource("modelingToolkit", "kRelaxAffectsAll")) -p $theMenu -c "dR_setRelaxAffectsAll";
	}
	global proc dR_buildExtendMenu(string $theMenu) {
		menu -e -dai $theMenu;
		menuItem -label (getPluginResource("modelingToolkit", "kExtendEdge")) -p $theMenu -c "dR_setExtendEdge";
		menuItem -label (getPluginResource("modelingToolkit", "kExtendLoop")) -p $theMenu -c "dR_setExtendLoop";
		menuItem -label (getPluginResource("modelingToolkit", "kExtendBorder")) -p $theMenu -c "dR_setExtendBorder";
	}
	global proc dR_buildManipCoordSpaceMenu(string $theMenu) {
		menu -e -dai $theMenu;
		menuItem -label (getPluginResource("modelingToolkit", "kWorld")) -p $theMenu -c "dR_coordSpaceWorld; dR_updateCommandPanel();";
		menuItem -label (getPluginResource("modelingToolkit", "kObject")) -p $theMenu -c "dR_coordSpaceObject; dR_updateCommandPanel();";
		menuItem -label (getPluginResource("modelingToolkit", "kLocal")) -p $theMenu -c "dR_coordSpaceLocal; dR_updateCommandPanel();";
		menuItem -label (getPluginResource("modelingToolkit", "kCustom")) -p $theMenu -c "dR_coordSpaceCustom; dR_updateCommandPanel();";
	}
	global proc string dR_addModeBtn(string $modeBtn) {
		global string $gDRasterModeBtns[];
		$gDRasterModeBtns[size($gDRasterModeBtns)] = $modeBtn;
		return $modeBtn;
	}
	global proc int dR_isSelCtx() {
		string $currentCtx = `currentCtx`;
		return ($currentCtx == "selectSuperContext" || $currentCtx == "draggerContext" || $currentCtx == "dragAttrContext" || dR_isTransformCtx());
	}
	global proc int dR_isTransformCtx() {
		return dR_isMoveCtx() || dR_isRotateCtx() || dR_isScaleCtx();
	}
	global proc int dR_isMoveCtx() {
		string $currentCtx = `currentCtx`;
		return $currentCtx == "moveSuperContext" || $currentCtx == "manipMoveContext";
	}
	global proc int dR_isRotateCtx() {
		string $currentCtx = `currentCtx`;
		return $currentCtx == "RotateSuperContext" || $currentCtx == "manipRotateContext";
	}
	global proc int dR_isScaleCtx() {
		string $currentCtx = `currentCtx`;
		return $currentCtx == "scaleSuperContext" || $currentCtx == "manipScaleContext";
	}
	global proc int dR_isEditingPivot() {
		if (dR_isMoveCtx()) {
			return `manipMoveContext -q -editPivotMode Move`;
		} else if (dR_isRotateCtx()) {
			return `manipRotateContext -q -editPivotMode Rotate`;
		} else if (dR_isScaleCtx()) {
			return `manipScaleContext -q -editPivotMode Scale`;
		}
		return 0;
	}
	global proc dR_tglSafeFrame() {
		string $curPanel = `getPanel -wf`;
		if(`getPanel -typeOf $curPanel` == "modelPanel") {
			string $camera = `modelPanel -q -cam $curPanel`;
			if(!`attributeQuery -node $camera -ex nexSafeFrame`) {
				addAttr -longName nexSafeFrame -at bool $camera;
			}
			int $showSafeFrame = (!getAttr($camera + ".nexSafeFrame"));
			setAttr ($camera + ".nexSafeFrame") $showSafeFrame;
			camera -e -displayResolution $showSafeFrame $camera;
			if(`nexOpt -q setSafeFrameOverscan`) {
				if($showSafeFrame) {
					camera -e -overscan `nexOpt -q safeFrameOverscan` $camera;
				} else {
					camera -e -overscan 1.0 $camera;
				}
			}
		}
	}
	global proc dR_exitNex() {

		global string $gMTSuperContext;
		string $currentCtx = `currentCtx`;

		if( $gMTSuperContext == $currentCtx ) 
		{
			invokeLastAction;
			if( $gMTSuperContext == $currentCtx ) 
			{
				setToolTo selectSuperContext;
			}
		}
	}
	global proc dR_exitForSnap() {
		global string $gNexLastSnapManipType;
		global int $gNexLastMoveManipMode;
		global int $gNexLastMoveManipHandle;
		$gNexLastSnapManipType = "";
		string $curPanel = `getPanel -wf`;
		if( modelingTookitActive() && `getPanel -typeOf $curPanel` == "modelPanel" ) {
			string $manipType = `nexOpt -q manipType`;
			switch($manipType) {
				case "move":
					float $manipPos[] = `nexCtx -q -mp`;
					string $curUnit = `currentUnit -q -l`;
					$manipPos[0] = `convertUnit -fromUnit "cm" -toUnit $curUnit (" " + ((string) $manipPos[0]))`;
					$manipPos[1] = `convertUnit -fromUnit "cm" -toUnit $curUnit (" " + ((string) $manipPos[1]))`;
					$manipPos[2] = `convertUnit -fromUnit "cm" -toUnit $curUnit (" " + ((string) $manipPos[2]))`;
					$gNexLastSnapManipType = "move";
					$gNexLastMoveManipMode = `manipMoveContext -q -mode Move`;
					$gNexLastMoveManipHandle = `manipMoveContext -q -ah Move`;
					int $activeHandle = 3;
					int $gNexActiveHandle = `nexOpt -q activeMoveHandle`;
					if($gNexActiveHandle >= 1 && $gNexActiveHandle <= 3) {
						$activeHandle = $gNexActiveHandle - 1;
					}
					manipMoveContext -e -mode 2 Move;
					manipMoveContext -e -ah $activeHandle Move;
					setToolTo moveSuperContext;
					ctxEditMode;
					if(size(`ls -sl`)) {
						scmh -a $manipPos[0] $manipPos[1] $manipPos[2];
					}
					ctxEditMode;
					break;
			}
		}
	}
	global proc dR_setActiveHandle(int $newAxis) {
		string $manipType = `nexOpt -q manipType`;
		switch($manipType) {
			case "move":
				nexOpt -e activeMoveHandle $newAxis;
				break;
			case "rotate":
				nexOpt -e activeRotateHandle $newAxis;
				break;
			case "scale":
				nexOpt -e activeScaleHandle $newAxis;
				break;
		}
	}
	global proc int dR_getActiveHandle() {
		string $manipType = `nexOpt -q manipType`;
		switch($manipType) {
			case "move":
				return `nexOpt -q activeMoveHandle`;
			case "rotate":
				return `nexOpt -q activeRotateHandle`;
			case "scale":
				return `nexOpt -q activeScaleHandle`;
		}
		return false;
	}
	global proc int[] dR_getAxisStates(int $activeHandle) {
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		int $axisStates[3] = { 0, 0, 0 };
		if($activeHandle == $gNexHandleX) {
			$axisStates[0] = 1;
		} else if($activeHandle == $gNexHandleY) {
			$axisStates[1] = 1;
		} else if($activeHandle == $gNexHandleZ) {
			$axisStates[2] = 1;
		} else if($activeHandle == $gNexHandleXY) {
			$axisStates[0] = 1;
			$axisStates[1] = 1;
		} else if($activeHandle == $gNexHandleYZ) {
			$axisStates[1] = 1;
			$axisStates[2] = 1;
		} else if($activeHandle == $gNexHandleXZ) {
			$axisStates[0] = 1;
			$axisStates[2] = 1;
		} else if($activeHandle == $gNexHandleXYZ) {
			$axisStates[0] = 1;
			$axisStates[1] = 1;
			$axisStates[2] = 1;
		}
		return $axisStates;
	}
	global proc int dR_getHandleFromAxisStates(int $axis[], string $manipType, int $axisChange) {
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		if($axis[0] && !$axis[1] && !$axis[2]) {
			return $gNexHandleX;
		} else if($axis[1] && !$axis[0] && !$axis[2]) {
			return $gNexHandleY;
		} else if($axis[2] && !$axis[0] && !$axis[1]) {
			return $gNexHandleZ;
		} else if($axis[0] && $axis[1] && !$axis[2]) {
			if($manipType == "rotate") {
				if($axisChange == $gNexHandleX) {
					return $gNexHandleX;
				}
				return $gNexHandleY;
			} else {
				return $gNexHandleXY;
			}
		} else if($axis[1] && $axis[2] && !$axis[0]) {
			if($manipType == "rotate") {
				if($axisChange == $gNexHandleY) {
					return $gNexHandleY;
				}
				return $gNexHandleZ;
			} else {
				return $gNexHandleYZ;
			}
		} else if($axis[0] && $axis[2] && !$axis[1]) {
			if($manipType == "rotate") {
				if($axisChange == $gNexHandleX) {
					return $gNexHandleX;
				}
				return $gNexHandleZ;
			} else {
				return $gNexHandleXZ;
			}
		} else if($axis[0] && $axis[1] && $axis[2]) {
			return $gNexHandleXYZ;
		}
		return 0;
	}
	global proc dR_setActiveHandleRunCmd(int $handleNum) {
		switch($handleNum)
		{
		case 1:
			dR_activeHandleX;
			break;
		case 2:
			dR_activeHandleY;
			break;
		case 3:
			dR_activeHandleZ;
			break;
		case 4:
			dR_activeHandleXY;
			break;
		case 5:
			dR_activeHandleYZ;
			break;
		case 6:
			dR_activeHandleXZ;
			break;
		case 7:
			dR_activeHandleXYZ;
			break;
		}
	}
	global proc dR_setActiveAxis(int $axisChange) {
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		string $curManip = `nexOpt -q manipType`;
		if (dR_isCtrlHeld() && $curManip != "rotate") {
			int $activeHandle = `dR_getActiveHandle`;
			int $axisStates[] = dR_getAxisStates($activeHandle);
			if($axisChange == $gNexHandleX) {
				$axisStates[0] = !$axisStates[0];
			} else if($axisChange == $gNexHandleY) {
				$axisStates[1] = !$axisStates[1];
			} else if($axisChange == $gNexHandleZ) {
				$axisStates[2] = !$axisStates[2];
			}
			int $newHandle = `dR_getHandleFromAxisStates $axisStates $curManip $axisChange`;
			if($newHandle) {
				dR_setActiveHandleRunCmd($newHandle);
			}
		} else {
			dR_setActiveHandleRunCmd($axisChange);
		}
		dR_updateCommandPanel;
	}
	global proc int dR_isAxisActive(int $axis) {
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		int $activeHandle = `dR_getActiveHandle`;
		if($activeHandle == $gNexHandleXYZ) {
			return true;
		} else {
			if($axis == $gNexHandleX) {
				if($activeHandle == $gNexHandleX || $activeHandle == $gNexHandleXY || $activeHandle == $gNexHandleXZ) {
					return true;
				}
			} else if($axis == $gNexHandleY) {
				if($activeHandle == $gNexHandleY || $activeHandle == $gNexHandleXY || $activeHandle == $gNexHandleYZ) {
					return true;
				}
			} else if($axis == $gNexHandleZ) {
				if($activeHandle == $gNexHandleZ || $activeHandle == $gNexHandleXZ || $activeHandle == $gNexHandleYZ) {
					return true;
				}
			}
		}
		return false;
	}
	global proc dR_buildTransformModeMenu(string $menu) {
		if (dR_isMoveCtx()) {
			menu -e -dai $menu;
			menuItem -label (getPluginResource("modelingToolkit", "kObject")) -p $menu -c "manipMoveContext -e -mode 0 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kWorld")) -p $menu -c "manipMoveContext -e -mode 2 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kComponent")) -p $menu -c "manipMoveContext -e -mode 10 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kParent")) -p $menu -c "manipMoveContext -e -mode 1 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kNormal")) -p $menu -c "manipMoveContext -e -mode 3 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kAlongRotationAxis")) -p $menu -c "manipMoveContext -e -mode 4 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kAlongLiveObjectAxis")) -p $menu -c "manipMoveContext -e -mode 5 Move";
			menuItem -label (getPluginResource("modelingToolkit", "kCustom")) -p $menu -c "manipMoveContext -e -mode 6 Move";
		} else if (dR_isRotateCtx()) {
			menu -e -dai $menu;
			menuItem -label (getPluginResource("modelingToolkit", "kObject")) -p $menu -c "manipRotateContext -e -mode 0 Rotate";
			menuItem -label (getPluginResource("modelingToolkit", "kWorld")) -p $menu -c "manipRotateContext -e -mode 1 Rotate";
			menuItem -label (getPluginResource("modelingToolkit", "kComponent")) -p $menu -c "manipRotateContext -e -mode 10 Rotate";
			menuItem -label (getPluginResource("modelingToolkit", "kGimbal")) -p $menu -c "manipRotateContext -e -mode 2 Rotate";
			menuItem -label (getPluginResource("modelingToolkit", "kCustom")) -p $menu -c "manipRotateContext -e -mode 3 Rotate";
		} else if (dR_isScaleCtx()) {
			menu -e -dai $menu;
			menuItem -label (getPluginResource("modelingToolkit", "kObject")) -p $menu -c "manipScaleContext -e -mode 0 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kWorld")) -p $menu -c "manipScaleContext -e -mode 2 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kComponent")) -p $menu -c "manipScaleContext -e -mode 10 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kParent")) -p $menu -c "manipScaleContext -e -mode 1 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kNormal")) -p $menu -c "manipScaleContext -e -mode 3 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kAlongRotationAxis")) -p $menu -c "manipScaleContext -e -mode 4 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kAlongLiveObjectAxis")) -p $menu -c "manipScaleContext -e -mode 5 Scale";
			menuItem -label (getPluginResource("modelingToolkit", "kCustom")) -p $menu -c "manipScaleContext -e -mode 6 Scale";
		}
	}
	global proc dR_toggleTransformModeMenu(string $menu) {
		if (dR_isMoveCtx()) {
			manipMoveContext -e -mode `manipMoveContext -q -lastMode Move` Move;
		} else if (dR_isRotateCtx()) {
			manipRotateContext -e -mode `manipRotateContext -q -lastMode Rotate` Rotate;
		} else if (dR_isScaleCtx()) {
			manipScaleContext -e -mode `manipScaleContext -q -lastMode Scale` Scale;
		}
	}
	global proc string dR_getTransformOptionsLabel() {
		string $stringId = "kTransformOptions";
		if (dR_isMoveCtx()) {
			$stringId = "kMoveOptions";
		} else if (dR_isRotateCtx()) {
			$stringId = "kRotateOptions";
		} else if (dR_isScaleCtx()) {
			$stringId = "kScaleOptions";
		}
		return getPluginResource("modelingToolkit", $stringId);
	}
	global proc string dR_getTransformMode() {
		if (dR_isMoveCtx()) {
			int $mode = `manipMoveContext -q -mode Move`;
			switch ($mode) {
			case 2: return getPluginResource("modelingToolkit", "kWorld");
			case 0: return getPluginResource("modelingToolkit", "kObject");
			case 1: return getPluginResource("modelingToolkit", "kParent");
			case 3: return getPluginResource("modelingToolkit", "kNormal");
			case 4: return getPluginResource("modelingToolkit", "kAlongRotationAxisShort");
			case 5: return getPluginResource("modelingToolkit", "kAlongLiveObjectAxisShort");
			case 6: return getPluginResource("modelingToolkit", "kCustom");
			case 9: case 10: return getPluginResource("modelingToolkit", "kComponent");
			}
		} else if (dR_isRotateCtx()) {
			int $mode = `manipRotateContext -q -mode Rotate`;
			switch ($mode) {
			case 0: return getPluginResource("modelingToolkit", "kObject");
			case 1: return getPluginResource("modelingToolkit", "kWorld");
			case 2: return getPluginResource("modelingToolkit", "kGimbal");
			case 3: return getPluginResource("modelingToolkit", "kCustom");
			case 9: case 10: return getPluginResource("modelingToolkit", "kComponent");
			}
		} else if (dR_isScaleCtx()) {
			int $mode = `manipScaleContext -q -mode Scale`;
			switch ($mode) {
			case 2: return getPluginResource("modelingToolkit", "kWorld");
			case 0: return getPluginResource("modelingToolkit", "kObject");
			case 1: return getPluginResource("modelingToolkit", "kParent");
			case 3: return getPluginResource("modelingToolkit", "kNormal");
			case 4: return getPluginResource("modelingToolkit", "kAlongRotationAxisShort");
			case 5: return getPluginResource("modelingToolkit", "kAlongLiveObjectAxisShort");
			case 6: return getPluginResource("modelingToolkit", "kCustom");
			case 9: case 10: return getPluginResource("modelingToolkit", "kComponent");
			}
		}
		return "";
	}
	global proc dR_setActiveTransformAxis(int $axisChange) {
		if (dR_isTransformManipVisible()) {
			if (dR_isRotateCtx()) {
				manipRotateContext -e -cah $axisChange Rotate;
			} else if (dR_isCtrlHeld()) {
				int $xActive = dR_isTransformAxisActive(0);
				int $yActive = dR_isTransformAxisActive(1);
				int $zActive = dR_isTransformAxisActive(2);
				if ($axisChange == 0) $xActive = !$xActive;
				else if ($axisChange == 1) $yActive = !$yActive;
				else if ($axisChange == 2) $zActive = !$zActive;
				if ($xActive || $yActive || $zActive) {
					int $active;
					if ($xActive && $yActive && $zActive) $active = /*xyz*/3;
					else if ($xActive && $yActive) $active = /*xy*/4;
					else if ($yActive && $zActive) $active = /*yz*/5;
					else if ($xActive && $zActive) $active = /*xz*/6;
					else if ($xActive) $active = /*x*/0;
					else if ($yActive) $active = /*y*/1;
					else if ($zActive) $active = /*x*/2;
					if (dR_isMoveCtx()) {
						manipMoveContext -e -cah $active Move;
					} else if (dR_isScaleCtx()) {
						manipScaleContext -e -cah $active Scale;
					}
				}
			} else if (dR_isMoveCtx()) {
				manipMoveContext -e -cah $axisChange Move;
			} else if (dR_isScaleCtx()) {
				manipScaleContext -e -cah $axisChange Scale;
			}
			dR_updateCommandPanel;
		}
	}
	global proc int dR_isTransformAxisActive(int $axis) {
		if (dR_isRotateCtx()) {
			int $active = `manipRotateContext -q -cah Rotate`;
			if ($active == $axis || $active >= /*xyz*/3) return 1;
		} else {
			int $active = -1;
			if (dR_isMoveCtx()) {
				$active = `manipMoveContext -q -cah Move`;
			} else if (dR_isScaleCtx()) {
				$active = `manipScaleContext -q -cah Scale`;
			}
			if ($active == $axis || $active == /*xyz*/3) return 1;
			else if ($axis == /*x*/0 && ($active == /*xy*/4 || $active == /*xz*/6)) return 1;
			else if ($axis == /*y*/1 && ($active == /*xy*/4 || $active == /*yz*/5)) return 1;
			else if ($axis == /*z*/2 && ($active == /*yz*/5 || $active == /*xz*/6)) return 1;
		}
		return 0;
	}
	global proc dR_buildStepSnapMenu(string $menu) {
		menu -e -dai $menu;
		menuItem -label (getPluginResource("modelingToolkit", "kOff")) -p $menu -c "dR_setTransformStepSnapMode 0";
		menuItem -label (getPluginResource("modelingToolkit", "kRelative")) -p $menu -c "dR_setTransformStepSnapMode 1";

		int $allowAbsolute = 1;
		if (dR_isMoveCtx()) {
			int $manipMode = `manipMoveContext -q -mode Move`;
			if ($manipMode != /*world*/2) {
				// Absolute only supported in world mode
				$allowAbsolute = 0;
			}
		}
		if ($allowAbsolute) {
			menuItem -label (getPluginResource("modelingToolkit", "kAbsolute")) -p $menu -c "dR_setTransformStepSnapMode 2";
		}
	}
	global proc int dR_transformStepSnapMode() {
		int $enabled = 0;
		int $relative = 0;
		if (dR_isMoveCtx()) {
			$enabled  = `manipMoveContext -q -snap Move`;
			$relative = $enabled && `manipMoveContext -q -snapRelative Move`;
		} else if (dR_isRotateCtx()) {
			$enabled  = `manipRotateContext -q -snap Rotate`;
			$relative = $enabled && `manipRotateContext -q -snapRelative Rotate`;
		} else if (dR_isScaleCtx()) {
			$enabled  = `manipScaleContext -q -snap Scale`;
			$relative = $enabled && `manipScaleContext -q -snapRelative Scale`;
		}
		return !$enabled ? /*off*/0 : $relative ? /*relative*/1 : /*absolute*/2;
	}
	global proc dR_setTransformStepSnapMode(int $mode) {
		if (dR_isMoveCtx()) {
			global int $gPrevMoveStepSnapMode;
			if ($mode != 0) $gPrevMoveStepSnapMode = $mode;
			switch ($mode) {
			default: case 0: manipMoveContext -e -snap 0 Move; break;
			case 1: manipMoveContext -e -snap 1 -snapRelative 1 Move; break;
			case 2: manipMoveContext -e -snap 1 -snapRelative 0 Move; break;
			}
		} else if (dR_isRotateCtx()) {
			global int $gPrevRotateStepSnapMode;
			if ($mode != 0) $gPrevRotateStepSnapMode = $mode;
			switch ($mode) {
			default: case 0: manipRotateContext -e -snap 0 Rotate; break;
			case 1: manipRotateContext -e -snap 1 -snapRelative 1 Rotate; break;
			case 2: manipRotateContext -e -snap 1 -snapRelative 0 Rotate; break;
			}
		} else if (dR_isScaleCtx()) {
			global int $gPrevScaleStepSnapMode;
			if ($mode != 0) $gPrevScaleStepSnapMode = $mode;
			switch ($mode) {
			default: case 0: manipScaleContext -e -snap 0 Scale; break;
			case 1: manipScaleContext -e -snap 1 -snapRelative 1 Scale; break;
			case 2: manipScaleContext -e -snap 1 -snapRelative 0 Scale; break;
			}
		}
	}
	global proc dR_toggleTransformStepSnapMode() {
		int $mode = dR_transformStepSnapMode();
		if (dR_isMoveCtx()) {
			global int $gPrevMoveStepSnapMode;
			dR_setTransformStepSnapMode($mode == 0 ? $gPrevMoveStepSnapMode : 0);
		} else if (dR_isRotateCtx()) {
			global int $gPrevRotateStepSnapMode;
			dR_setTransformStepSnapMode($mode == 0 ? $gPrevRotateStepSnapMode : 0);
		} else if (dR_isScaleCtx()) {
			global int $gPrevScaleStepSnapMode;
			dR_setTransformStepSnapMode($mode == 0 ? $gPrevScaleStepSnapMode : 0);
		}
	}
	global proc float dR_transformStepSnapStep() {
		float $value = 0;
		if (dR_isMoveCtx()) {
			$value  = `manipMoveContext -q -snapValue Move`;
		} else if (dR_isRotateCtx()) {
			$value  = `manipRotateContext -q -snapValue Rotate`;
		} else if (dR_isScaleCtx()) {
			$value  = `manipScaleContext -q -snapValue Scale`;
		}
		return $value;
	}
	global proc dR_setTransformStepSnapStep(float $value) {
		if (dR_isMoveCtx()) {
			manipMoveContext -e -snapValue $value Move;
		} else if (dR_isRotateCtx()) {
			manipRotateContext -e -snapValue $value Rotate;
		} else if (dR_isScaleCtx()) {
			manipScaleContext -e -snapValue $value Scale;
		}
	}
	global proc int dR_isTransformManipVisible() {
		if (dR_isMoveCtx()) {
			return `manipMoveContext -q -vis Move`;
		} else if (dR_isRotateCtx()) {
			return `manipRotateContext -q -vis Rotate`;
		} else if (dR_isScaleCtx()) {
			return `manipScaleContext -q -vis Scale`;
		}
		return 0;
	}
	global proc float[] dR_getTransformValues() {
		float $values[] = {0, 0, 0};
		if (dR_isTransformManipVisible()) {
			if (dR_isMoveCtx()) {
				$values = `manipMoveContext -q -translate Move`;
			} else if (dR_isRotateCtx()) {
				$values = `manipRotateContext -q -rotate Rotate`;
			} else if (dR_isScaleCtx()) {
				$values = `manipScaleContext -q -scale Scale`;
			}
		}
		return $values;
	}
	global proc dR_setTransformValue(int $index, float $newValue) {
		if (dR_isTransformManipVisible()) {
			float $v[] = dR_getTransformValues();
			$v[$index] = $newValue;
			if (dR_isMoveCtx()) {
				manipMoveContext -e -translate $v[0] $v[1] $v[2] Move;
			} else if (dR_isRotateCtx()) {
				manipRotateContext -e -rotate $v[0] $v[1] $v[2] Rotate;
			} else if (dR_isScaleCtx()) {
				manipScaleContext -e -scale $v[0] $v[1] $v[2] Scale;
			}
			dR_updateCommandPanel;
		}
	}
	global proc dR_enterForSnap() {
		global string $gMTSuperContext;
		global string $gNexLastSnapManipType;
		global int $gNexLastMoveManipMode;
		global int $gNexLastMoveManipHandle;
		if($gNexLastSnapManipType != "") {
			// Restore the handles to their previous values
			manipMoveContext -e -m $gNexLastMoveManipMode Move;
			manipMoveContext -e -ah $gNexLastMoveManipHandle Move;
			setToolTo $gMTSuperContext;
			nexOpt -e manipType $gNexLastSnapManipType;
		}
		$gNexLastSnapManipType = "";
	}
	global proc dR_setQuadDrawMeshAlpha() {
		float $meshTransp = -1;
		int $useMeshTransp = `nexOpt -q useMeshAlpha`;
		if ( $useMeshTransp == 1 )
			$meshTransp = `nexOpt -q meshAlpha`;
		setAttr "hardwareRenderingGlobals.quadDrawOverrideTransparency" $meshTransp;
	}
    global proc dR_setQuadDrawMeshColorOverride() {
		float $meshColor[] = {-1.0, -1.0, -1.0};
		int $useMeshColorOverride = `nexOpt -q useMeshColorOverride`;
		if ( $useMeshColorOverride == 1 )
		{
			$meshColor = `nexOpt -q meshColorOverride`;
		}
		setAttr "hardwareRenderingGlobals.quadDrawOverrideColorR" $meshColor[0];
		setAttr "hardwareRenderingGlobals.quadDrawOverrideColorG" $meshColor[1];
		setAttr "hardwareRenderingGlobals.quadDrawOverrideColorB" $meshColor[2];
	}
	global proc dR_setQuadDrawSnapToBackfaces() {
		int $snapToBackfaces = `nexOpt -q snapToBackfaces`;
		setAttr "hardwareRenderingGlobals.quadDrawAlwaysOnTop" $snapToBackfaces;
	}
	global proc dR_updateToolSettings() {
		//NOTE: Check the current tool before updating the command panel
		if (dR_isSelCtx()) {
			dR_updateCommandPanel();
		}
	}
	global proc dR_updateCommandPanel() {
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		global string $gDRasterModeBtns[];
		int $i;
		string $controlParent;
		global string $gNexLastSelectionMode = "";
		for($i = 0; $i < size($gDRasterModeBtns); $i++) {
			string $arr[] = `stringToStringArray $gDRasterModeBtns[$i] "|"`;
			if (`size $arr` > 0) {
				string $controlLabel = $arr[(`size $arr` - 1)];
				switch($controlLabel) {
				case "overlayAppendMeshMultiCut":
				case "overlayAppendMeshQuadDraw": {
					int $wireOverlay = `nexOpt -q overlayAppendMesh`;
					checkBoxGrp -edit -value1 $wireOverlay $gDRasterModeBtns[$i];
					break;
				}
				case "snapToBackfacesMultiCut":
				case "snapToBackfacesQuadDraw": {
					int $snapToBackfaces = `nexOpt -q snapToBackfaces`;
					checkBoxGrp -edit -value1 $snapToBackfaces $gDRasterModeBtns[$i];
					break;
				}
				case "nexCutColorLineSlider": {
					float $rgb[] = `nexOpt -q hiliteColorCutLine`;
					colorSliderGrp -edit -rgbValue $rgb[0] $rgb[1] $rgb[2] nexCutColorLineSlider;
					break;
				}
				case "nexCutColorVertSlider": {
					float $rgb[] = `nexOpt -q hiliteColorCutVert`;
					colorSliderGrp -edit -rgbValue $rgb[0] $rgb[1] $rgb[2] nexCutColorVertSlider;
					break;
				}
				case "nexCutColorEdgeSlider": {
					float $rgb[] = `nexOpt -q hiliteColorCutEdge`;
					colorSliderGrp -edit -rgbValue $rgb[0] $rgb[1] $rgb[2] nexCutColorEdgeSlider;
					break;
				}
				case "nexCutColorFaceSlider": {
					float $rgb[] = `nexOpt -q hiliteColorCutFace`;
					colorSliderGrp -edit -rgbValue $rgb[0] $rgb[1] $rgb[2] nexCutColorFaceSlider;
					break;
				}
				case "nexOverlayMeshColorMultiCut":
				case "nexOverlayMeshColorQuadDraw": {
					float $rgbOverlay[] = `nexOpt -q appendMeshColor`;
					colorSliderGrp -edit -rgbValue $rgbOverlay[0] $rgbOverlay[1] $rgbOverlay[2] $gDRasterModeBtns[$i];
					break;
				}
				case "useMeshColorOverrideMultiCut":
				case "useMeshColorOverrideQuadDraw": {
					int $useColor = `nexOpt -q useMeshColorOverride`;
					checkBoxGrp -edit -value1 $useColor $gDRasterModeBtns[$i];
					break;
				}
				case "meshColorOverrideMultiCut":
				case "meshColorOverrideQuadDraw": {
					float $rgbColor[] = `nexOpt -q meshColorOverride`;
					colorSliderGrp -edit -rgbValue $rgbColor[0] $rgbColor[1] $rgbColor[2] $gDRasterModeBtns[$i];
					break;
				}
				case "nexweldBtn": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					// Only visible when in vertex or edge mode
					if(`currentCtx` == "polyMergeVertexContext") {
						MTcbButtonOn($controlParent, $controlLabel);
					} else {
						MTcbButtonOff($controlParent, $controlLabel);
					}
					break;
				}
				case "nexConnectSlide": {
					if(`nexOpt -q connectCurLmbMap` == "slide") {
						radioButtonGrp -e -sl (`nexOpt -q connectCurLmbMap` == "slide") nexConnectSlide;
					}
					if(`nexOpt -q connectCurLmbMap` == "segments") {
						radioButtonGrp -e -sl (`nexOpt -q connectCurLmbMap` == "segments") nexConnectSegments;
					}
					if(`nexOpt -q connectCurLmbMap` == "pinch") {
						radioButtonGrp -e -sl (`nexOpt -q connectCurLmbMap` == "pinch") nexConnectPinch;
					}
					break;
				}
				case "nexBridgeDivisions": {
					if(`nexOpt -q bridgeCurLmbMap` == "divisions") {
						radioButtonGrp -e -sl (`nexOpt -q bridgeCurLmbMap` == "divisions") nexBridgeDivisions;
					}
					if(`nexOpt -q bridgeCurLmbMap` == "taper") {
						radioButtonGrp -e -sl (`nexOpt -q bridgeCurLmbMap` == "taper") nexBridgeTaper;
					}
					if(`nexOpt -q bridgeCurLmbMap` == "twist") {
						radioButtonGrp -e -sl (`nexOpt -q bridgeCurLmbMap` == "twist") nexBridgeTwist;
					}
					if(`nexOpt -q bridgeCurLmbMap` == "offset") {
						radioButtonGrp -e -sl (`nexOpt -q bridgeCurLmbMap` == "offset") nexBridgeOffset;
					}
					break;
				}
				case "nexVertExtrudeDivisions": {
					if(`nexOpt -q extrudeVertexCurLmbMap` == "divisions") {
						radioButtonGrp -e -sl (`nexOpt -q extrudeVertexCurLmbMap` == "divisions") nexVertExtrudeDivisions;
					}
					if(`nexOpt -q extrudeVertexCurLmbMap` == "width") {
						radioButtonGrp -e -sl (`nexOpt -q extrudeVertexCurLmbMap` == "width") nexVertExtrudeWidth;
					}
					if(`nexOpt -q extrudeVertexCurLmbMap` == "length") {
						radioButtonGrp -e -sl (`nexOpt -q extrudeVertexCurLmbMap` == "length") nexVertExtrudeHeight;
					}
					break;
				}
				case "nexFaceExtrudeDivisions": {
					if(`nexOpt -q extrudeFaceCurLmbMap` == "divisions") {
						radioButtonGrp -e -sl (`nexOpt -q extrudeFaceCurLmbMap` == "divisions") nexFaceExtrudeDivisions;
					}
					if(`nexOpt -q extrudeFaceCurLmbMap` == "localz") {
						radioButtonGrp -e -sl (`nexOpt -q extrudeFaceCurLmbMap` == "localz") nexFaceExtrudeLocalZ;
					}
					if(`nexOpt -q extrudeFaceCurLmbMap` == "offset") {
						radioButtonGrp -e -sl (`nexOpt -q extrudeFaceCurLmbMap` == "offset") nexFaceExtrudeOffset;
					}
					break;
				}
				case "nexBevelDivisions": {
					if(`nexOpt -q polyBevelCurLmbMap` == "segments") {
						radioButtonGrp -e -sl (`nexOpt -q polyBevelCurLmbMap` == "segments") nexBevelDivisions;
					}
					if(`nexOpt -q polyBevelCurLmbMap` == "fraction") {
						radioButtonGrp -e -sl (`nexOpt -q polyBevelCurLmbMap` == "fraction") nexBevelOffset;
					}
					break;
				}

				case "nexTargWeldMergeTarget": {
					if(`targetWeldCtx -q -mergeToCenter polyMergeVertexContext` == 0) {
						radioButtonGrp -e -sl 1 nexTargWeldMergeTarget;
					}
					break;
				}

				case "nexTargWeldMergeCenter": {
					if(`targetWeldCtx -q -mergeToCenter polyMergeVertexContext` == 1) {
						radioButtonGrp -e -sl 1 nexTargWeldMergeCenter;
					}
					break;
				}

				case "nexcutBtn": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					// Only visible when in vertex or edge mode
					global string $gMultiCutContext;
					if(`currentCtx` == $gMultiCutContext) {
						MTcbButtonOn($controlParent, $controlLabel);
					} else {
						MTcbButtonOff($controlParent, $controlLabel);
					}
					break;
				}
				case "nexconnectBtn": {
					global string $gConnectContext;
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if(`currentCtx` == $gConnectContext) {
						MTcbButtonOn($controlParent, $controlLabel);
					} else {
						MTcbButtonOff($controlParent, $controlLabel);
					}
					break;
				}
				case "nexquaDrawBtn": {
					global string $gQDContext;
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if(`currentCtx` == $gQDContext) {
						MTcbButtonOn($controlParent, $controlLabel);
					} else {
						MTcbButtonOff($controlParent, $controlLabel);
					}
					break;
				}
				
				case "nexlockSelBtn": {
					string $manipType = `nexOpt -q manipType`;
					if($manipType != "move" && $manipType != "rotate" && $manipType != "scale") {
						button -e -en false -l (getPluginResource("modelingToolkit", "kLockSelected")) $gDRasterModeBtns[$i];
					} else {
						if(`nexCtx -q -hs`) {
							button -e -en true -l (getPluginResource("modelingToolkit", "kLockSelected")) $gDRasterModeBtns[$i];
						} else {
							button -e -en false -l (getPluginResource("modelingToolkit", "kLockSelected")) $gDRasterModeBtns[$i];
						}
					}
					break;
				}
				case "nexselLockedBtn": {
					string $axisLockSets[] = `ls "nexAxisLockSet_*"`;
					if(size($axisLockSets) == 1) {
						string $vertList[] = `sets -q $axisLockSets[0]`;
						$vertList = `ls -flatten $vertList`;
						string $axisConstraint = `substring $axisLockSets[0] 16 (size($axisLockSets[0]))`;
						button -e -en true -l (getPluginResource("modelingToolkit", "kSelectLocked") + " (" + size($vertList) + " - " + $axisConstraint + ")")  $gDRasterModeBtns[$i];
					} else {
						button -e -en false -l (getPluginResource("modelingToolkit", "kSelectLocked"))  $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexunlockAllBtn": {
					string $axisLockSets[] = `ls "nexAxisLockSet_*"`;
					if(size($axisLockSets)) {
						button -e -en true $gDRasterModeBtns[$i];
					} else {
						button -e -en false $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexPivotBtn": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if(modelingTookitActive() && `nexOpt -q manipType` == "pivot") {
						MTcbButtonOn($controlParent, $gDRasterModeBtns[$i]);
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
					}
					break;
				}
				case "manipCoordSpaceButton": {
					if(`nexOpt -q manipType` == "pivot") {
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					} else {
						iconTextButton -e -en 1 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "manipCoordSpaceText": {
					if(`nexOpt -q manipType` == "pivot") {
						textField -e -en 0 $gDRasterModeBtns[$i];
					} else {
						textField -e -en 1 $gDRasterModeBtns[$i];
					}
					string $menuLabel = interToUI(`nexOpt -q manipCoordSpace`);
					textField -e -tx (`modelingToolkit_melToUI $menuLabel $controlLabel`) $gDRasterModeBtns[$i];
					break;
				}
				case "nexXField":
				case "nexYField":
				case "nexZField": {
					string $manipType = `nexOpt -q manipType`;
					if($manipType == "pivot" || (`nexCtx -q -hs` && ($manipType == "move" || $manipType == "rotate" || $manipType == "scale"))) {
						floatField -e -en 1 $gDRasterModeBtns[$i];
						if($manipType == "pivot") {
							int $activePivotHandle = `nexOpt -q activePivotHandle`;
							if($activePivotHandle >= 8 && $activePivotHandle <= 10) {
								$manipType = "rotate";
							}
						}
						switch($manipType) {
							case "move":
							case "pivot": {
								float $pos[] = `nexCtx -q -mp`;
								if($controlLabel == "nexXField") {
									floatField -e -v $pos[0] $gDRasterModeBtns[$i];
								} else if($controlLabel == "nexYField") {
									floatField -e -v $pos[1] $gDRasterModeBtns[$i];
								} else if($controlLabel == "nexZField") {
									floatField -e -v $pos[2] $gDRasterModeBtns[$i];
								}
								break;
							}
							case "rotate": {
								float $orient[] = `nexCtx -q -mo`;
								if($controlLabel == "nexXField") {
									floatField -e -v $orient[0] $gDRasterModeBtns[$i];
								} else if($controlLabel == "nexYField") {
									floatField -e -v $orient[1] $gDRasterModeBtns[$i];
								} else if($controlLabel == "nexZField") {
									floatField -e -v $orient[2] $gDRasterModeBtns[$i];
								}
								break;
							}
							case "scale": {
								floatField -e -v 1.0 $gDRasterModeBtns[$i];
								break;
							}
						}
					} else {
						floatField -e -v 0 $gDRasterModeBtns[$i];
						floatField -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexHighlightBackfaces": {
					checkBox -e -v `selectPref -q -preSelectBackfacing` $gDRasterModeBtns[$i];
					break;
				}
				case "nexHighlightClosest": {
					checkBox -e -v `selectPref -q -preSelectClosest` $gDRasterModeBtns[$i];
					break;
				}
				case "nexPickMarqueeGrp": //Good
				case "nexRaycastGrp": //Good
				case "nexHybridRayGrp": //Good
				case "nexTweakMarqueeGrp": {
					if (dR_isTransformCtx()) {
						radioButtonGrp -e -en 1 nexTweakMarqueeGrp;
						if (`manipMoveContext -q -tweakMode Move`) {
							radioButtonGrp -e -sl 1 nexTweakMarqueeGrp;
							if(`nexOpt -q selectOption` != "tweakMarquee") {
								$gNexLastSelectionMode = `nexOpt -q selectOption`;
								nexOpt -e selectOption "tweakMarquee";
								dR_updateCommandPanel();
							}
						} else {
							if(`nexOpt -q selectOption` == "") {
								radioButtonGrp -e -sl 1 nexPickMarqueeGrp;
							} else if(`nexOpt -q selectOption` == "raycast") {
								radioButtonGrp -e -sl 1 nexRaycastGrp;
							} else if(`nexOpt -q selectOption` == "hybrid") {
								radioButtonGrp -e -sl 1 nexHybridRayGrp;
							} else {
								nexOpt -e selectOption $gNexLastSelectionMode;
								string $tempControlName = "nexPickMarqueeGrp";
								switch ($gNexLastSelectionMode) {
									case "": { $tempControlName = "nexPickMarqueeGrp"; break; }
									case "raycast" : { $tempControlName = "nexRaycastGrp"; break; }
									case "hybrid" : { $tempControlName = "nexHybridRayGrp"; break; }
									default: { break; }
								}
								radioButtonGrp -e -sl 1 $tempControlName;
								dR_updateCommandPanel(); // don't like to have to do it, but it is a unique case
							}
						}
					} else {
						radioButtonGrp -e -en 0 nexTweakMarqueeGrp;
						if(`nexOpt -q selectOption` == "") {
							radioButtonGrp -e -sl 1 nexPickMarqueeGrp;
						} else if(`nexOpt -q selectOption` == "raycast") {
							radioButtonGrp -e -sl 1 nexRaycastGrp;
						} else if(`nexOpt -q selectOption` == "hybrid") {
							radioButtonGrp -e -sl 1 nexHybridRayGrp;
						} else {
							nexOpt -e selectOption "";
							radioButtonGrp -e -sl 1 nexPickMarqueeGrp;
						}
					}
					break;
				}
				case "nexselConstField": {
					if(`nexOpt -q selectOption` == "" && `polySelectConstraint -q -ap`) {
						control -e -en true $gDRasterModeBtns[$i];
					} else {
						control -e -en false $gDRasterModeBtns[$i];
					}
					break;
				}
				case "selConstDropdown": {
					if(`nexOpt -q selectOption` != "") {
						optionMenu -e -en false $gDRasterModeBtns[$i];
					} else {
						optionMenu -e -en true $gDRasterModeBtns[$i];
					}

					dR_updateSelConstField;
				}
				case "nexSoftSelection": {
					checkBox -e -v `softSelect -q -sse` $gDRasterModeBtns[$i];
					break;
				}
				case "nexXYZAxis": {
					string $manipType = `nexOpt -q manipType`;
					if($manipType == "move" || $manipType == "rotate" || $manipType == "scale") {
						iconTextButton -e -en true $gDRasterModeBtns[$i];
					} else {
						iconTextButton -e -en false $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexConnectSlideField": {
					if(modelingTookitActive() && `nexOpt -q manipType` == "connect") {
						floatField -e -v `nexCtx -gmv connect slide` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexConnectSegmentsField": {
					if(modelingTookitActive() && `nexOpt -q manipType` == "connect") {
						intField -e -v `nexCtx -gmv connect segments` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexConnectPinchField": {
					if(modelingTookitActive() && `nexOpt -q manipType` == "connect") {
						floatField -e -v `nexCtx -gmv connect pinch` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexBridgeDivisionsField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "bridge") {
						intField -e -v `nexCtx -gmv bridge divisions` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexBridgeTaperField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "bridge") {
						floatField -e -v `nexCtx -gmv bridge taper` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexBridgeTwistField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "bridge") {
						floatField -e -v `nexCtx -gmv bridge twist` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexBridgeOffsetField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "bridge") {
						intField -e -v `nexCtx -gmv bridge offset` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexVertExtrudeDivisionsField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "extrudevertex") {
						intField -e -v `nexCtx -gmv extrudeVertex divisions` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexVertExtrudeWidthField": {
					if(modelingTookitActive() && (`nexCtx -q -sm` == "extrudevertex" || `nexCtx -q -sm` == "chamfervertex")) {
						floatField -e -v `nexCtx -gmv extrudeVertex width` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexVertExtrudeHeightField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "extrudevertex") {
						floatField -e -v `nexCtx -gmv extrudeVertex height` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexFaceExtrudeDivisionsField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "extrudeface") {
						intField -e -v `nexCtx -gmv extrudeface divisions` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexFaceExtrudeLocalZField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "extrudeface") {
						floatField -e -v `nexCtx -gmv extrudeface localz` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexFaceExtrudeOffsetField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "extrudeface") {
						floatField -e -v `nexCtx -gmv extrudeface offset` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexFaceExtrudeKeepFacesTogether": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "extrudeface") {
						checkBoxGrp -e -value1 `nexCtx -q -kft` nexFaceExtrudeKeepFacesTogether;
					}
					break;
				}
				case "nexBevelDivisionsField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "bevel") {
						intField -e -v `nexCtx -gmv bevel segments` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexBevelOffsetField": {
					if(modelingTookitActive() && `nexCtx -q -sm` == "bevel") {
						floatField -e -v `nexCtx -gmv bevel fraction` $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexXAxis": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					string $manipType = `nexOpt -q manipType`;
					if($manipType == "move" || $manipType == "rotate" || $manipType == "scale") {
						if(`dR_isAxisActive $gNexHandleX`) {
							iconTextButton -e -en 1 -bgc 1 0 0 $gDRasterModeBtns[$i];
						} else {
							iconTextButton -e -en 1 $gDRasterModeBtns[$i];
							MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						}
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexYAxis": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					string $manipType = `nexOpt -q manipType`;
					if($manipType == "move" || $manipType == "rotate" || $manipType == "scale") {
						if(`dR_isAxisActive $gNexHandleY`) {
							iconTextButton -e -en 1 -bgc 0 1 0 $gDRasterModeBtns[$i];
						} else {
							iconTextButton -e -en 1 $gDRasterModeBtns[$i];
							MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						}
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexZAxis": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					string $manipType = `nexOpt -q manipType`;
					if($manipType == "move" || $manipType == "rotate" || $manipType == "scale") {
						if(`dR_isAxisActive $gNexHandleZ`) {
							iconTextButton -e -en 1 -bgc 0 0 1 $gDRasterModeBtns[$i];
						} else {
							iconTextButton -e -en 1 $gDRasterModeBtns[$i];
							MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						}
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexSmoothingIntSlider": {
					intSliderGrp -e -v `nexOpt -q cutSmoothingAngle` $gDRasterModeBtns[$i];
					break;
				}
				case "nexSubdivisionsIntSlider": {
					intSliderGrp -e -v `nexOpt -q cutSubdivisions` $gDRasterModeBtns[$i];
					break;
				}
				case "nexEdgeFlowFloatField": {
					floatSliderGrp -e -v `nexOpt -q edgeFlowValue` $gDRasterModeBtns[$i];
					break;
				}
				case "edgeFlowCheckbox": {
					int $ef = `nexOpt -q useEdgeFlow`;
					int $live = `dR_liveSurfaceActive`;
					checkBoxGrp -e -en (!$live) -value1 $ef $gDRasterModeBtns[$i];
					floatSliderGrp -e -en (!$live && $ef) nexEdgeFlowFloatField;
					break;
				}
				case "nexDeleteFacesCheckbox": {
					checkBoxGrp -e -value1 `nexOpt -q useDeleteFaces` $gDRasterModeBtns[$i];
					break;
				}
				case "nexExtractFacesCheckbox": {
					int $ef = `nexOpt -q useExtractFaces`;
					int $live = `dR_liveSurfaceActive`;
					checkBoxGrp -e -en (!$live) -value1 $ef $gDRasterModeBtns[$i];
					floatFieldGrp -e -en (!$live && $ef) nexExtractFacesFloatGrp;
					break;
				}
				case "nexExtractFacesFloatGrp": {
					floatFieldGrp -e -value1 `nexOpt -q extractFacesX` -value2 `nexOpt -q extractFacesY` -value3 `nexOpt -q extractFacesZ` $gDRasterModeBtns[$i];
					break;
				}
				case "nexSliceIgnoreBackfacesCheckbox": {
					checkBoxGrp -e -value1 `nexOpt -q sliceIgnoreBackfaces` $gDRasterModeBtns[$i];
					break;
				}
				case "nexSoftSelectionFalloff":
				case "nexSoftSelectionDistanceType": {
					switch($controlLabel) {
						case "nexSoftSelectionFalloff": {
							floatField -e -v `softSelect -q -softSelectDistance` $gDRasterModeBtns[$i];
							break;
						}
						case "nexSoftSelectionDistanceType": {
							int $distType = (`softSelect -q -softSelectFalloff` + 1);
							optionMenu -e -sl $distType $gDRasterModeBtns[$i];
							break;
						}
					}
					if(`softSelect -q -sse`) {
						control -e -en true $gDRasterModeBtns[$i];
					} else {
						control -e -en false $gDRasterModeBtns[$i];
					}
					break;
				}
				case "nexSoftSelectionCurve": {
					gradientControlNoAttr -e -asString `softSelect -q -softSelectCurve` $gDRasterModeBtns[$i];
			    	break;
				}
				case "meshAlphaCheckboxMultiCut":
				case "meshAlphaCheckboxQuadDraw": {
					int $useAlpha = `nexOpt -q useMeshAlpha`;
					checkBoxGrp -e -value1 $useAlpha $gDRasterModeBtns[$i];
					floatSliderGrp -e -en $useAlpha meshAlphaFltFieldMultiCut;
					floatSliderGrp -e -en $useAlpha meshAlphaFltFieldQuadDraw;
					break;
				}

				case "meshAlphaFltFieldMultiCut":
				case "meshAlphaFltFieldQuadDraw": {
					floatSliderGrp -e -v `nexOpt -q meshAlpha` $gDRasterModeBtns[$i];
					break;
				}

				case "meshOffsetCheckboxMultiCut":
				case "meshOffsetCheckboxQuadDraw": {
					int $useOffset = `nexOpt -q useMeshOffset`;
					checkBoxGrp -e -value1 $useOffset $gDRasterModeBtns[$i];
					floatSliderGrp -e -en $useOffset meshOffsetFltFieldMultiCut;
					floatSliderGrp -e -en $useOffset meshOffsetFltFieldQuadDraw;
					break;
				}

				case "meshOffsetFltFieldMultiCut":
				case "meshOffsetFltFieldQuadDraw": {
					floatSliderGrp -e -v `nexOpt -q meshOffset` $gDRasterModeBtns[$i];
					break;
				}

				case "autoWeldCheckbox":
				{
					checkBoxGrp -e -value1 `nexOpt -q useAutoWeld` $gDRasterModeBtns[$i];
					break;
				}

				case "autoWeldIntField":
				{
					intSliderGrp -e -v `nexOpt -q autoWeldTolerance` $gDRasterModeBtns[$i];
					break;
				}
				case "stripSizeIntField":
				{
					intSliderGrp -e -v `nexOpt -q quaDrawStripSize` $gDRasterModeBtns[$i];
					break;
				}
				case "nexSnapPercent": {
					intSliderGrp -e -v `nexOpt -q cutSnapAngle` $gDRasterModeBtns[$i];
					break;
				}
				case "transformModeText": {
					textField -e -tx (`dR_getTransformMode`) $gDRasterModeBtns[$i];
					break;
				}
				case "transformPivotBtn": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if (dR_isEditingPivot()) {
						MTcbButtonOn($controlParent, $gDRasterModeBtns[$i]);
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
					}
					break;
				}
				case "transformXYZAxis": {
					if (dR_isTransformCtx()) {
						iconTextButton -e -en true $gDRasterModeBtns[$i];
					} else {
						iconTextButton -e -en false $gDRasterModeBtns[$i];
					}
					break;
				}
				case "transformXAxis": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if (dR_isTransformCtx()) {
						if(dR_isTransformAxisActive(0)) {
							iconTextButton -e -en 1 -bgc 0.980 0.275 0.275 $gDRasterModeBtns[$i];
						} else {
							iconTextButton -e -en 1 $gDRasterModeBtns[$i];
							MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						}
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "transformYAxis": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if (dR_isTransformCtx()) {
						if(dR_isTransformAxisActive(1)) {
							iconTextButton -e -en 1 -bgc 0.275 0.980 0.522 $gDRasterModeBtns[$i];
						} else {
							iconTextButton -e -en 1 $gDRasterModeBtns[$i];
							MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						}
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "transformZAxis": {
					$controlParent = `iconTextButton -q -p $gDRasterModeBtns[$i]`;
					if (dR_isTransformCtx()) {
						if(dR_isTransformAxisActive(2)) {
							iconTextButton -e -en 1 -bgc 0.184 0.404 0.988 $gDRasterModeBtns[$i];
						} else {
							iconTextButton -e -en 1 $gDRasterModeBtns[$i];
							MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						}
					} else {
						MTcbButtonOff($controlParent, $gDRasterModeBtns[$i]);
						iconTextButton -e -en 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "transformXField": {
					int $enable = dR_isTransformManipVisible();
					if ($enable) {
						float $p[] = dR_getTransformValues();
						floatField -e -en 1 -v ($p[0]) $gDRasterModeBtns[$i];
					} else {
						floatField -e -en 0 -v 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "transformYField": {
					int $enable = dR_isTransformManipVisible();
					if ($enable) {
						float $p[] = dR_getTransformValues();
						floatField -e -en 1 -v ($p[1]) $gDRasterModeBtns[$i];
					} else {
						floatField -e -en 0 -v 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "transformZField": {
					int $enable = dR_isTransformManipVisible();
					if ($enable) {
						float $p[] = dR_getTransformValues();
						floatField -e -en 1 -v ($p[2]) $gDRasterModeBtns[$i];
					} else {
						floatField -e -en 0 -v 0 $gDRasterModeBtns[$i];
					}
					break;
				}
				case "stepSnapText": {
					int $snapMode = dR_transformStepSnapMode();
					if ($snapMode == 2 && dR_isMoveCtx()) {
						int $manipMode = `manipMoveContext -q -mode Move`;
						if ($manipMode != /*world*/2) {
							// It has to be Discrete Relative
							dR_setTransformStepSnapMode 1;
							$snapMode = 1;
						}
					}

					string $label;
					switch ($snapMode) {
					default:
					case 0: $label = getPluginResource("modelingToolkit", "kOff"); break;
					case 1: $label = getPluginResource("modelingToolkit", "kRelative"); break;
					case 2: $label = getPluginResource("modelingToolkit", "kAbsolute"); break;
					}
					textField -e -tx $label $gDRasterModeBtns[$i];
					break;
				}
				case "stepSnapStep": {
					floatField -e -en (dR_transformStepSnapMode() != 0) -v (dR_transformStepSnapStep()) $gDRasterModeBtns[$i];
					break;
				}
			  }
			}
		}

		global int $gDrCompBtnCount;
		if ( 0 < $gDrCompBtnCount)
		{
			global string $gDrCompBtns[], $gDrCompBtns_Names[];
			int $isObjectMode = `selectMode -q -o`;
			string $curSelType = dR_getComponentSelType();
			if ($isObjectMode && $curSelType == "") $curSelType = "object";
			int $multi = ($curSelType == "multi");

			// Highlight individual buttons
			for ($i = 1; $i < $gDrCompBtnCount; $i++) {
				if ($multi && $i > 1 && $i < $gDrCompBtnCount-1) {
					$controlParent = `iconTextButton -q -p $gDrCompBtns[$i]`;
					iconTextButton -e -fla 1 $gDrCompBtns[$i];
					MTcbButtonOn($controlParent, $gDrCompBtns[$i]);
				} else if ($curSelType == $gDrCompBtns_Names[$i]) {
					// Highlight select button
					$controlParent = `iconTextButton -q -p $gDrCompBtns[$i]`;
					iconTextButton -e -fla 0 $gDrCompBtns[$i];
					MTcbButtonOn($controlParent, $gDrCompBtns[$i]);
				} else {
					// Unhighlight button
					iconTextButton -e -nbg 1 -fla 1 $gDrCompBtns[$i];
				}
			}

			if ($multi) {
				// Highlight multi group
				$controlParent = `iconTextButton -q -p $gDrCompBtns[0]`;
				iconTextButton -e -fla 1 $gDrCompBtns[0];
				MTcbButtonOn($controlParent, $gDrCompBtns[0]);

				global float $gActiveControlColor[];
				string $indivCompsParent = `iconTextButton -q -p $gDrCompBtns[2]`;
				formLayout -e -bgc $gActiveControlColor[0] $gActiveControlColor[1] $gActiveControlColor[2] $indivCompsParent;
			} else {
				// Unhighlight multi group
				iconTextButton -e -nbg 1 -fla 0 $gDrCompBtns[0];
				$controlParent = `iconTextButton -q -p $gDrCompBtns[0]`;
				MTcbButtonOff($controlParent, $gDrCompBtns[0]);

				string $indivCompsParent = `iconTextButton -q -p $gDrCompBtns[2]`;
				formLayout -e -nbg 1 $indivCompsParent;
				formLayout -e -nbg 0 $indivCompsParent;
			}

			dR_contextPanel;
			dR_updateCameraBasedSelectionField;
			dR_updateSlideField;
			dR_updateSelConstField;
			dR_updateRelaxAffectsField;
			dR_updateExtendField;
			//control -e -en ( ($allCount == 1 && $edgeCount == 1) || `dR_symmetryEnabled` ) $gNexSymBtn;
		}
	}
	global proc string[] dR_convertSelection(string $newSelectionMode) {
		string $convertedSel[];
		switch($newSelectionMode) {
			case "vertex":
				$convertedSel = `polyListComponentConversion -tv`;
				break;
			case "edge":
				$convertedSel = `polyListComponentConversion -te`;
				break;
			case "face":
				$convertedSel = `polyListComponentConversion -tf`;
				break;
			case "uv":
				$convertedSel = `polyListComponentConversion -tuv`;
				break;
		}
		return $convertedSel;
	}
	global proc int dR_isTexturePanelVisible() {
		string $visPanels[] = `getPanel -vis`;
		string $thisPanel;
		for($thisPanel in $visPanels) {
			if($thisPanel == "polyTexturePlacementPanel1") {
				return true;
			}
		}
		return false;
	}
	global proc dR_selTypeChanged(string $mask) {
		global string $gNexLastSelType;
		string $newSelType = "";
		string $selTypeCmd = "selectType -q ";
		if(`selectMode -q -o`) {
			$selTypeCmd += "-ocm ";
		}
		if($mask != "") {
			string $compTypes[] = { "vertex", "edge", "facet", "meshComponents", "polymeshUV" };
			if( stringArrayContains($mask, $compTypes) ) {
				$newSelType = $mask;
			}
		} else {
			int $i;
			string $compTypes[] = { "vertex", "edge", "facet", "meshComponents", "polymeshUV" };
			for($i = 0; $i < size($compTypes); $i++) {
				string $cmd = $selTypeCmd + "-" + $compTypes[$i];
				if(`eval $cmd`) {
					$newSelType = $compTypes[$i];
				}
			}
		}
		if($newSelType != "") {
			if($newSelType == "facet") {
				$newSelType = "face";
			} else if($newSelType == "polymeshUV") {
				$newSelType = "uv";
			}
		}
		global string $gMTSuperContext;
		if($gMTSuperContext == `currentCtx` && `selectMode -q -o` && size(`ls -hilite -hd 1`)==0) {
			dR_exitNex();
		}
		if(modelingTookitActive() && $newSelType != "meshComponents" && $newSelType != "vertex" && $newSelType != "edge" && `nexOpt -q manipType` == "weld") {
			nexOpt -e manipType "select";
		}
		/*nexCtx -e -mcm 0;*/
		/*nexOpt -e selType $newSelType;*/
		$gNexLastSelType = $newSelType;
		dR_updateCommandPanel();
	}
	global proc string dR_getSelType() {
		if(`selectMode -q -co`) {
			if(`selectType -q -vertex`) {
				return "vertex";
			} else if(`selectType -q -polymeshEdge`) {
				return "edge";
			} else if(`selectType -q -facet`) {
				return "face";
			}
		} else {
			if(`selectType -q -ocm -vertex`) {
				return "vertex";
			} else if(`selectType -q -ocm -polymeshEdge`) {
				return "edge";
			} else if(`selectType -q -ocm -facet`) {
				return "face";
			}
		}
		return "";
	}
	global proc dR_setSelType(string $newSelectionMode) {
		nexCtx -e -ssc true;
		switch($newSelectionMode) {
			case "vertex":
				selectType -allComponents false;
				selectType -ocm -allComponents false;
				selectMode -co; selectType -cv 1 -vertex 1 -subdivMeshPoint 1 -latticePoint 1 -particle 1;
				break;
			case "edge":
				selectType -allComponents false;
				selectType -ocm -allComponents false;
				selectMode -co; selectType -polymeshEdge 1 -subdivMeshEdge 1 -surfaceEdge 1;
				break;
			case "face":
				selectType -allComponents false;
				selectType -ocm -allComponents false;
				selectMode -co; selectType -surfaceFace 1 -facet 1 -subdivMeshFace 1;
				break;
			case "uv":
				selectType -allComponents false;
				selectType -ocm -allComponents false;
				selectMode -co; selectType -locatorUV 1 -polymeshUV 1 -subdivMeshUV 1;
				break;
			case "multi":
				selectType -allComponents false;
				selectType -ocm -allComponents false;
				selectMode -co; selectType -meshComponents 1;
				break;
		}
		nexCtx -e -ssc false;
	}
	global proc string dR_getComponentSelType() {
		int $isObjectMode = `selectMode -q -o`;
		string $ocm = ($isObjectMode ? "-ocm " : "");
		string $selQuery = "selectType -q " + $ocm;
		if (eval($selQuery + "-meshComponents")) {
			return "multi";
		} else if (eval($selQuery + "-vertex")) {
			return "vertex";
		} else if (eval($selQuery +"-polymeshEdge")) {
			return "edge";
		} else if (eval($selQuery + "-facet")) {
			return "face";
		} else if (eval($selQuery + "-polymeshUV")) {
			return "uv";
		}
		return "";
	}
	global proc int dR_toggleSelectionMode(string $newSelMode, int $convertSelection, int $allowToggle) {
		global string $gNexLastSelType;
		int $isObjectMode = `selectMode -q -o`;
		string $curSelMode = dR_getComponentSelType();
		if ($isObjectMode && $curSelMode == "") $curSelMode = "object";
		int $multi = ($curSelMode == "multi");

		if ($allowToggle && ($newSelMode == "object" && $newSelMode == $curSelMode))
			$newSelMode = "multi"; // Object toggles to multi

		HideManipulators;

		if (($newSelMode == "object" || $newSelMode == "") ||
			($allowToggle && 
			 (($multi && $newSelMode == "multi") ||
			  ($curSelMode == $newSelMode && (!$multi || $newSelMode == "multi")))))
		{
			if (`nexOpt -q useCompModeCustCmd`) {
				string $custCmd = `nexOpt -q compModeCustCmd`;
				eval($custCmd);
			} else {
				selectMode -o;
				selectType -ocm -allComponents false;
				selectType -allComponents false;
				selectType -meshComponents 0;
				string $hiliteList[] = `ls -hilite`;
				if (size($hiliteList) > 0) {
					hilite -replace {};
					if ($isObjectMode) {
						// Select hilited object(s) in object-component mode
						select -add $hiliteList;
					}
				}	
				dR_exitNex;
			}
			dR_updateCommandPanel;
			return false;
		} else {
			string $convertedSel[];
			if ($convertSelection) {
				$convertedSel = dR_convertSelection($newSelMode);
			} else {
				hilite;
			}
			dR_setSelType($newSelMode);
			if ($newSelMode == "multi") {
				if ($gNexLastSelType == "") {
					$gNexLastSelType = "edge";
				}
			} else {
				$gNexLastSelType = $newSelMode;
				if (size($convertedSel) > 0) {
					select -r $convertedSel;
				}
			}
			dR_updateCommandPanel;
			return true;
		}
	}
	global proc dR_selPrefChanged() {
		int $mayaRaycast = `selectPref -q -paintSelect`;
		int $mtkRaycast  = (`nexOpt -q selectOption` != "");
		if ($mayaRaycast && !$mtkRaycast) {
			nexOpt -e selectOption "raycast";
		} else if (!$mayaRaycast && $mtkRaycast) {
			nexOpt -e selectOption "";
		}
		dR_updateCommandPanel;
	}
	global proc int dR_validSymmetrySelection() {
		int $s = size(`ls -sl -fl`);
		if ( $s == 1 ) {
			if ( `nexCtx -cnt "edge"` == 1 ) {
				return true;
			}
		}
		else if ( $s == 4 ) {
			if ( `nexCtx -cnt "edge"` == 2 && `nexCtx -cnt "face"` == 2 ) {
				return true;
			}
		}
		return false;
	}
	global proc int dR_shouldAllowSymmetry() {
		if (`dR_symmetryEnabled`) {
			return true;
		}
		return `dR_validSymmetrySelection`;
	}
	global proc dR_updateCounter() {
		// Don't need to update if the Modeling Toolkit panel is not visible
		if(!`workspaceControl -q -vis NEXDockControl`) {
			return;
		}

		string $countDisplay = " ";
		int $selCount = size(`ls -sl`);
		global string $gNexComponentCountLabel;
		if ($selCount == 0) {
			// Nothing is selected OR
			text -e -label $countDisplay $gNexComponentCountLabel;
			return;
		}

		// Object selection count
		int $inComponentSelMode = `selectMode -q -component`;
		if (!$inComponentSelMode && size(`ls -hl`) == 0) {
			// In object mode but nothing is hilited (i.e. no components could possibly be selected)
			$selCount = size(`ls -sl -transforms -shapes`); // Just count dag objects
			if ($selCount == 1) {
				$countDisplay = `format -stringArg $selCount (getPluginResource("modelingToolkit", "kObjectSelected"))`;
			} else {
				$countDisplay = `format -stringArg $selCount (getPluginResource("modelingToolkit", "kObjectsSelected"))`;
			}
			text -e -label $countDisplay $gNexComponentCountLabel;
			return;
		}

		// Component selection count
		int $preserveCompSel = `selectPref -q -selectTypeChangeAffectsActive`;
		int $inMultiCompSelection = `selectType -q -meshComponents`;
		int $inVertexSelection = 0;
		int $inEdgeSelection = 0;
		int $inFaceSelection = 0;
		int $inUVSelection = 0;

		if($inComponentSelMode) {
			// Check current component mode selection type
			$inVertexSelection = `selectType -q -vertex`;
			$inEdgeSelection = `selectType -q -edge`;
			$inFaceSelection = `selectType -q -facet`;
			$inUVSelection = `selectType -q -polymeshUV`;
		} else {
			// Check current object component mode selection type
			$inVertexSelection = `selectType -q -ocm -vertex`;
			$inEdgeSelection = `selectType -q -ocm -edge`;
			$inFaceSelection = `selectType -q -ocm -facet`;
			$inUVSelection = `selectType -q -ocm -polymeshUV`;
		}

		// If we're in Multi-Component mode or the "Preserve Component Selection" pref is off
		// (i.e. multiple component types can be selected at the same time), we need to check
		// for selections of all component types
		int $numSelItems = 0;
		if (!$preserveCompSel || ($inComponentSelMode && $inMultiCompSelection)) {
			int $numSelVerts = `nexCtx -cnt "vertex"`;
			int $numSelEdges = `nexCtx -cnt "edge"`;
			int $numSelFaces = `nexCtx -cnt "face"`;

			// Check if more than one type is currently selected
			if (($numSelVerts > 0 && $numSelEdges > 0) ||
				($numSelVerts > 0 && $numSelFaces > 0) ||
				($numSelEdges > 0 && $numSelFaces > 0))
			{
				text -e -label (getPluginResource("modelingToolkit", "kMultiCompSelected")) $gNexComponentCountLabel;
				return;
			} else {	// only one type is currently selected
				// Setup to display type-specific count, as implemented below
				if($numSelVerts > 0) {
					$inVertexSelection = 1;
					$numSelItems = $numSelVerts;
				} else if($numSelEdges > 0) {
					$inEdgeSelection = 1;
					$numSelItems = $numSelEdges;
				} else if($numSelFaces > 0) {
					$inFaceSelection = 1;
					$numSelItems = $numSelFaces;
				}
			}
		}

		// Display selection count according to the current component selection type
		if($inVertexSelection) {
			if($numSelItems == 0) {
				$numSelItems = `nexCtx -cnt "vertex"`;
			}
			if($numSelItems > 0) {
				if($numSelItems == 1) {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kVertexSelected"))`;
				} else {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kVerticesSelected"))`;
				}
			}
		} else if($inEdgeSelection) {
			if($numSelItems == 0) {
				$numSelItems = `nexCtx -cnt "edge"`;
			}
			if($numSelItems > 0) {
				if($numSelItems == 1) {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kEdgeSelected"))`;
				} else {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kEdgesSelected"))`;
				}
			}
		} else if($inFaceSelection) {
			if($numSelItems == 0) {
				// Selection mask 34 = polygon faces, selection mask 38 = subdivision mesh faces
				$numSelItems = `nexCtx -cnt "face"`;
			}
			if($numSelItems > 0) {
				if($numSelItems == 1) {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kFaceSelected"))`;
				} else {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kFacesSelected"))`;
				}
			}
		} else if ($inUVSelection) {
			if($numSelItems == 0) {
				$numSelItems = `nexCtx -cnt "uv"`;
			}
			if($numSelItems > 0) {
				if($numSelItems == 1) {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kUVSelected"))`;
				} else {
					$countDisplay = `format -stringArg $numSelItems (getPluginResource("modelingToolkit", "kUVsSelected"))`;
				}
			}
		}
		text -e -label $countDisplay $gNexComponentCountLabel;
	}
	global proc int dR_isPanelVisible() {
		return `workspaceControl -q -vis NEXDockControl`;
	}
	global proc nexDockPanel(int $doDock) {
		global string $gNexRightPanel, $gNexFloatForm;
		nexOpt -s -e panelDock $doDock;
		
		global string $gDRBottomPane;
		if($gDRBottomPane != "" && catchQuiet(`objectTypeUI $gDRBottomPane`) == 0) {
			dRSaveShelves;
		}
	}
	global proc dR_ToggleCommandPanel() {
		toggleUIComponentVisibility("NEXDockControl");
	}
	global proc int DRUseModelingToolkitMM(string $parentName) {
		if(modelingTookitActive() && (`nexOpt -q useCustomMenuAndStatusLineItems` == 1)) {
			return dR_buildRightMM($parentName);
		}

		return false;
	}
	global proc DRBuildMenus() {
		global string $gNexPanelMenuCont;
		// 
		// Create the menus in the menubar
		//
		menu -label (getPluginResource("modelingToolkit", "kObject")) -to true -p $gNexPanelMenuCont;

			menuItem -label (getPluginResource("modelingToolkit", "kHide"))
				-annotation (getRunTimeCommandAnnotation("dR_objectHideTGL"))
				-command "dR_objectHideTGL";

			menuItem -label (getPluginResource("modelingToolkit", "kFreeze"))
				-annotation (getRunTimeCommandAnnotation("dR_objectTemplateTGL"))
				-command "dR_objectTemplateTGL";

			menuItem -label (getPluginResource("modelingToolkit", "kXRay"))
				-annotation (getRunTimeCommandAnnotation("dR_objectXrayTGL"))
				-command "dR_objectXrayTGL";

			menuItem -label (getPluginResource("modelingToolkit", "kBackfaceCull"))
				-annotation (getRunTimeCommandAnnotation("dR_objectBackfaceTGL"))
				-command "dR_objectBackfaceTGL";

			menuItem -label (getPluginResource("modelingToolkit", "kFaceTriangles"))
				-annotation (getRunTimeCommandAnnotation("dR_objectEdgesOnlyTGL"))
				-command "dR_objectEdgesOnlyTGL";

		menu -label (getPluginResource("modelingToolkit", "kHelp")) -p $gNexPanelMenuCont;

			menuItem -label (getPluginResource("modelingToolkit", "kHelpOnMT"))
				-command "dR_showHelp";
	}
	global proc DRRebuildHotboxMenus() {
		global string $gMainWindow;
		setParent $gMainWindow;
		buildHotboxMenus();
		hotBox -updateMenus; 
	}
	global proc dR_adjustColorSliderOpt(string $colorSlider, string $optName) {
		float $newColor[] = `colorSliderGrp -q -rgb $colorSlider`;
		nexOpt -e $optName $newColor[0] $newColor[1] $newColor[2] 1;
	}
	global proc dR_resetCutColorSliders() {
		global string $gCutColorLineSlider, $gCutColorVertSlider, $gCutColorEdgeSlider, $gCutColorFaceSlider;

		float $cutColorLine[] = `nexOpt -q hiliteColorCutLine`;

		colorSliderGrp -e -rgb $cutColorLine[0] $cutColorLine[1] $cutColorLine[2] -cc ("dR_adjustColorSliderOpt(\"" + $gCutColorLineSlider + "\", \"hiliteColorCutLine\"); refresh -f") -dc ("dR_adjustColorSliderOpt(\"" + $gCutColorLineSlider + "\", \"hiliteColorCutLine\"); refresh -f") $gCutColorLineSlider;

		float $cutColorVert[] = `nexOpt -q hiliteColorCutVert`;

		colorSliderGrp -e -rgb $cutColorVert[0] $cutColorVert[1] $cutColorVert[2] -cc ("dR_adjustColorSliderOpt(\"" + $gCutColorVertSlider + "\", \"hiliteColorCutVert\"); refresh -f") -dc ("dR_adjustColorSliderOpt(\"" + $gCutColorVertSlider + "\", \"hiliteColorCutVert\"); refresh -f") $gCutColorVertSlider;

		float $cutColorEdge[] = `nexOpt -q hiliteColorCutEdge`;

		colorSliderGrp -e -rgb $cutColorEdge[0] $cutColorEdge[1] $cutColorEdge[2] -cc ("dR_adjustColorSliderOpt(\"" + $gCutColorEdgeSlider + "\", \"hiliteColorCutEdge\"); refresh -f") -dc ("dR_adjustColorSliderOpt(\"" + $gCutColorEdgeSlider + "\", \"hiliteColorCutEdge\"); refresh -f") $gCutColorEdgeSlider;

		float $cutColorFace[] = `nexOpt -q hiliteColorCutFace`;

		colorSliderGrp -e -rgb $cutColorFace[0] $cutColorFace[1] $cutColorFace[2] -cc ("dR_adjustColorSliderOpt(\"" + $gCutColorFaceSlider + "\", \"hiliteColorCutFace\"); refresh -f") -dc ("dR_adjustColorSliderOpt(\"" + $gCutColorFaceSlider + "\", \"hiliteColorCutFace\"); refresh -f") $gCutColorFaceSlider;
	}
	global proc dR_noMeshDeformerWarning() {
		warning -n (getPluginResource("modelingToolkit", "kMTWarnNoMeshDeformer"));
	}
	global proc string[] nPolyBridgeFaces() {
		string $bridgeEdges[];
		string $objects[] = `ls -sl -o`;
		if (`size $objects` == 1) {
			string $selectedFaces[] = `filterExpand -sm 34 -ex 1`;
			ConvertSelectionToEdges;
			string $edges[] = `ls -sl`;
			select $selectedFaces;
			ConvertSelectionToContainedEdges;
			string $inEdges[] = `ls -sl`;
			select $edges;
			select -tgl $inEdges;
			string $edgeSet;
			$edgeSet = `sets -name $edgeSet`;
			delete $selectedFaces;
			select -r $edgeSet;
			$bridgeEdges = nPerformPolyBridgeEdge();
			select -r $edgeSet;
			string $outEdges[] = `ls -sl`;
			int $borderFound = 0;
			int $i = 0;
			while($i < `size $outEdges` && ! $borderFound) {
				select -r $outEdges[$i];
				string $faces[] = `polyInfo -ef`;
				string $buffer[];
				$borderFound = `tokenize $faces[0] $buffer` < 4;
				$i = $i + 1;
			}
			if ($borderFound) {
				warning -n (getPluginResource("modelingToolkit", "kMTWarnExtraFacesExist"));
			}
			select -r $outEdges;
			delete $edgeSet;
		} else {
			error -n (getPluginResource("modelingToolkit", "kMTWarnTooManyObjects"));
		}
		return $bridgeEdges;
	}
	global proc string[] nPerformPolyBridgeEdge() {
		int $numEdges = `nexCtx -cnt "edge"`;
		int $numFaces = `nexCtx -cnt "face"`;

		int $doHistory = `constructionHistory -q -toggle`;
		string $bridgeNodes[];
		if ($numEdges != 0 || $numFaces == 0) {
			int $doHistory = `constructionHistory -q -toggle`;
			string $cmd = "polyBridgeEdge -ch 1 -divisions 5 -twist 0 -taper 1 -curveType 0 -smoothingAngle 30";
			$bridgeNodes = `evalEcho $cmd`;
			for($bridgeNode in $bridgeNodes) {
				setAttr ($bridgeNode + ".dv") 0;
			}
		} else {
			string $cmd = "nPolyBridgeFaces";
			$bridgeNodes = `evalEcho $cmd`;
		}
		select -d;
		int $prevSuppressWarn = `scriptEditorInfo -q -sw`;
		scriptEditorInfo -e -sw true;
	 	for($i = 0; $i < size($bridgeNodes); $i++) {
			string $bridgeManipAttr = $bridgeNodes[$i] + ".manipMatrix";
			string $shNodes[] = `listConnections -shapes true -s true -d false $bridgeManipAttr`;
			if(size($shNodes) == 1) {
				string $sewEdgeCmd = "polySewEdge " + $shNodes[0];
				string $sewNodes[];
				string $edgeAttrib = $shNodes[0] + ".edge";
				int $prevEdgeCount = `getAttr -s $edgeAttrib`;
				catchQuiet( $sewNodes = eval($sewEdgeCmd) );
				int $newEdgeCount = `getAttr -s $edgeAttrib`;
				if($prevEdgeCount == $newEdgeCount) {
					delete $sewNodes;
				} else {
					nexCtx -e -lsn $sewNodes[0];
				}
			}
		}
		scriptEditorInfo -e -sw $prevSuppressWarn;
		select -d;
		return $bridgeNodes;
	}
	global proc dR_manipEntered() {
		hilite;
		$isUVMode = false;
		if(`selectMode -q -co`) {
			if(`selectType -q -polymeshUV`) {
				$isUVMode = true;
			}
		} else if(`selectType -q -ocm -polymeshUV`) {
			$isUVMode = true;
		}
		if( !$isUVMode && `dR_getComponentSelType` == "" ) {
			dR_setSelType("multi");
			if( `nexCtx -q -sm` == "cut" ) {
				// Multi-cut: clear selection if tool entered in object selection mode. (MAYA-84205)
				select -clear;
			}
		}
		if( `nexCtx -q -sm` == "quadraw" ) {
			// Component selections can interfere with Auto-weld and are visually distracting, so we clear them
			select -clear;
		}
		dR_updateCommandPanel;
	}
	global proc drBuildCustomMenus() {
		global string $gMainWindow;
		if(`nexOpt -q customViewMM`) {
			string $menuArray[] = `window -q -ma $gMainWindow`;
			for ($menu in $menuArray) {
				string $label = `menu -q -label $menu`;
				if($label == "Hotbox Center 3" || $label == "Hotbox Center 2" || $label == "Hotbox Center 1") {
					setParent -m $menu;
					
					// Only do our stuff if the standard items have already been set up
					if(`menu -q -numberOfItems $menu` > 0) {
						string $subMenuArray[] = `menu -q -ia $menu`;
						for ($subMenu in $subMenuArray) {
							string $mItemLabel = `menuItem -q -l $subMenu`;
							if ($mItemLabel == localizedPanelLabel("Perspective View")) {
								menuItem -e -c "dR_DoCmd(\"viewPersp\")" $subMenu;
							} else if($mItemLabel == localizedPanelLabel("Side View")) {
								menuItem -e -c "dR_DoCmd(\"viewRight\")" -label (localizedPanelLabel("Right View")) $subMenu;
							} else if($mItemLabel == localizedPanelLabel("Front View")) {
								menuItem -e -c "dR_DoCmd(\"viewFront\")" $subMenu;
							} else if($mItemLabel == localizedPanelLabel("Top View")) {
								menuItem -e -c "dR_DoCmd(\"viewTop\")" $subMenu;
							} else if($mItemLabel == localizedPanelLabel("Left View") || $mItemLabel == localizedPanelLabel("Back View") || $mItemLabel == localizedPanelLabel("Bottom View") || $mItemLabel == (getPluginResource("modelingToolkit", "kNewCamera"))) {
								deleteUI -menuItem $subMenu;
							}
						}
						
						menuItem
							-label (localizedPanelLabel("Left View"))
							-divider 0
							-subMenu 0
							-command "dR_DoCmd(\"viewLeft\")" 
							-altModifier 0
							-optionModifier 0
							-commandModifier 0
							-ctrlModifier 0
							-shiftModifier 0
							-optionBox 0
							-enable 1
							-data 0
							-radialPosition "NW"
							-enableCommandRepeat 1
							-echoCommand 0
							-italicized 0
							-boldFont 0
							drLeftViewMenuItem;
						menuItem
							-label (localizedPanelLabel("Back View"))
							-divider 0
							-subMenu 0
							-command "dR_DoCmd(\"viewBack\")" 
							-altModifier 0
							-optionModifier 0
							-commandModifier 0
							-ctrlModifier 0
							-shiftModifier 0
							-optionBox 0
							-enable 1
							-data 0
							-radialPosition "SW"
							-enableCommandRepeat 1
							-echoCommand 0
							-italicized 0
							-boldFont 0
							drBackViewMenuItem;
						menuItem
							-label (localizedPanelLabel("Bottom View"))
							-divider 0
							-subMenu 0
							-command "dR_DoCmd(\"viewBottom\")" 
							-altModifier 0
							-optionModifier 0
							-commandModifier 0
							-ctrlModifier 0
							-shiftModifier 0
							-optionBox 0
							-enable 1
							-data 0
							-radialPosition "SE"
							-enableCommandRepeat 1
							-echoCommand 0
							-italicized 0
							-boldFont 0
							drBottomViewMenuItem;
						menuItem
							-label (getPluginResource("modelingToolkit", "kNewCamera"))
							-divider 0
							-subMenu 0
							-command "dR_DoCmd(\"createCameraFromView\")" 
							-altModifier 0
							-optionModifier 0
							-commandModifier 0
							-ctrlModifier 0
							-shiftModifier 0
							-optionBox 0
							-enable 1
							-data 0
							-radialPosition "NE"
							-enableCommandRepeat 1
							-echoCommand 0
							-italicized 0
							-boldFont 0
							drCreateNewCameraFromView;
					}
				}
			}
		}
	}
	global proc dR_doMeshConnect() {
		int $numConnItems = `nexCtx -q -numConnItems`;
		if($numConnItems) {
			select -cl;
			string $connSets[];
			int $i;
			for($i = 0; $i < $numConnItems; $i++) {
				string $connItems[] = `nexCtx -connItemSel $i`;
				$connSets[$i] = `sets $connItems`;
			}
			// For each set, retrieve the command
			for($i = 0; $i < $numConnItems; $i++) {
				string $theseConnItems[] = `sets -q $connSets[$i]`;
				string $splitCmd = `nexCtx -gsc $theseConnItems`;
				evalEcho $splitCmd;
			}
			for($i = 0; $i < $numConnItems; $i++) {
				delete $connSets[$i];
			}
		}
	}
	global proc int dR_buildRightMM(string $parentName) {
		global int $gIsMarkingMenuOn;
		string $manipType = `nexCtx -q -sm`;
		if(modelingTookitActive() && `popupMenu -e -exists $parentName` && (`nexCtx -q -stickyIsDown` || (`dR_isCtrlHeld` && `dR_isShiftHeld`) )) {
			popupMenu -e -deleteAllItems $parentName;	
			if (`popupMenu -q -mm $parentName` != $gIsMarkingMenuOn) {
				popupMenu -e -mm $gIsMarkingMenuOn $parentName;
			}
			setParent -m $parentName;
			string $curSelType = `dR_getSelType`;
			/*int $hasMcm = `nexCtx -q -mcm`;*/
			int $hasMcm = `selectType -q -meshComponents`;
			switch($manipType) {
				case "quadraw": {
					radioMenuItemCollection;
					menuItem
						-ecr false
						-label (getPluginResource("modelingToolkit", "kMultiCutTool"))
						-command "dR_multiCutTool" 
						-image "multiCut_NEX32.png"
						-radialPosition "N";
					menuItem
						-label (getPluginResource("modelingToolkit", "kAutoWeld"))
						-ecr false
						-command ("dR_autoWeldTGL; dR_updateCommandPanel();")
						-cb (`nexOpt -q useAutoWeld`)
						-radialPosition "W";
 					menuItem
						-label (getPluginResource("modelingToolkit", "kClearDots"))
						-ecr false
						-command ("dR_quadDrawClearDots; dR_updateCommandPanel();")
						-radialPosition "E";
					menuItem
						-label (getPluginResource("modelingToolkit", "kQuadDrawSoftenHarden"))
						-ecr false
						-command "performQuadDrawSoftEdge 0"
						-radialPosition "NE";
					menuItem
						-label (getPluginResource("modelingToolkit", "kQuadDrawSoftenHardenOptions"))
						-ecr false
						-command "performQuadDrawSoftEdge 1" 
						-optionBox 1
						-radialPosition "NE";

					menuItem
						-label (getPluginResource("modelingToolkit", "kRelaxAffectsMenu"))
						-ecr false
						-sm true
						-radialPosition "NW";
						menuItem
							-label (getPluginResource("modelingToolkit", "kRelaxAffectsAll"))
							-ecr false
							-command ("dR_setRelaxAffectsAll; refresh -f;")
							-rb (`nexOpt -q relaxAffects` == 0)
							-radialPosition "N";
						menuItem
							-label (getPluginResource("modelingToolkit", "kRelaxAffectsAuto"))
							-ecr false
							-command ("dR_setRelaxAffectsAuto; refresh -f;")
							-rb (`nexOpt -q relaxAffects` == 3)
							-radialPosition "NW";
						menuItem
							-label (getPluginResource("modelingToolkit", "kRelaxAffectsInterior"))
							-ecr false
							-command ("dR_setRelaxAffectsInterior; refresh -f;")
							-rb (`nexOpt -q relaxAffects` == 1)
							-radialPosition "SW";
						menuItem
							-label (getPluginResource("modelingToolkit", "kRelaxAffectsBorders"))
							-ecr false
							-command ("dR_setRelaxAffectsBorders; refresh -f;")
							-rb (`nexOpt -q relaxAffects` == 2)
							-radialPosition "W";
						setParent -m ..;

					radioMenuItemCollection;
					menuItem
						-label (getPluginResource("modelingToolkit", "kExtendMenu"))
						-ecr false
						-sm true
						-radialPosition "SW";
						menuItem
							-label (getPluginResource("modelingToolkit", "kExtendBorder"))
							-ecr false
							-command ("dR_setExtendBorder; refresh -f;")
							-rb (`nexOpt -q extendType` == 2)
							-radialPosition "W";
						menuItem
							-label (getPluginResource("modelingToolkit", "kExtendEdge"))
							-ecr false
							-command ("dR_setExtendEdge; refresh -f;")
							-rb (`nexOpt -q extendType` == 0)
							-radialPosition "SW";
						menuItem
							-label (getPluginResource("modelingToolkit", "kExtendLoop"))
							-ecr false
							-command ("dR_setExtendLoop; refresh -f;")
							-rb (`nexOpt -q extendType` == 1)
							-radialPosition "S";
						setParent -m ..;

					menuItem -d 1; menuItem -d 1; menuItem -d 1;
					menuItem -label (getPluginResource("modelingToolkit", "kSnapToBackfaces")) -ecr false
						-command ("dR_snapToBackfacesTGL; dR_updateCommandPanel();") -cb (`nexOpt -q snapToBackfaces`);
					menuItem -d 1;
					menuItem -label (getPluginResource("modelingToolkit", "kResetSettings")) -ecr false -command ("nexCtx -resetManip; dR_updateCommandPanel;");

					return true;
				}
				case "bevel": {
					if(!`nexCtx -q -ctm`) {
						radioMenuItemCollection;
						menuItem
							-label (getPluginResource("modelingToolkit", "kSegments"))
							-ecr false
							-command ("nexOpt -e polyBevelCurLmbMap segments; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q polyBevelCurLmbMap` == "segments")
							-radialPosition "N";
						menuItem
							-label (getPluginResource("modelingToolkit", "kOffset"))
							-ecr false
							-command ("nexOpt -e polyBevelCurLmbMap offset; refresh -f; dR_updateCommandPanel")
							-rb (`nexOpt -q polyBevelCurLmbMap` == "fraction")
							-radialPosition "E";
						menuItem -d 1; menuItem -d 1; menuItem -d 1;
						menuItem -label (getPluginResource("modelingToolkit", "kResetSettings")) -ecr false -command ("mtk_initToolOptions(1, \"quadraw\"); nexCtx -resetManip; dR_updateCommandPanel;");
						return true;
					}
					break;
				}
				case "chamfervertex": {
					radioMenuItemCollection;
					menuItem
						-label (getPluginResource("modelingToolkit", "kWidth"))
						-ecr false
						-command ("nexOpt -e extrudeVertexCurLmbMap width; refresh -f; dR_updateCommandPanel;")
						-rb (`nexOpt -q extrudeVertexCurLmbMap` == "width")
						-radialPosition "N";
					menuItem -label (getPluginResource("modelingToolkit", "kResetSettings")) -ecr false -command ("nexCtx -resetManip; refresh -f; dR_updateCommandPanel;");
					return true;
				}
				case "extrudevertex":
				case "extrudeface": {
					if($curSelType == "vertex" && !$hasMcm) {
						radioMenuItemCollection;
						menuItem
							-label (getPluginResource("modelingToolkit", "kDivisions"))
							-ecr false
							-command ("nexOpt -e extrudeVertexCurLmbMap divisions; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q extrudeVertexCurLmbMap` == "divisions")
							-radialPosition "N";
						menuItem
							-label (getPluginResource("modelingToolkit", "kWidth"))
							-ecr false
							-command ("nexOpt -e extrudeVertexCurLmbMap width; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q extrudeVertexCurLmbMap` == "width")
							-radialPosition "E";
						menuItem
							-label (getPluginResource("modelingToolkit", "kLength"))
							-ecr false
							-command ("nexOpt -e extrudeVertexCurLmbMap length; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q extrudeVertexCurLmbMap` == "length")
							-radialPosition "W";
						menuItem
							-label (getPluginResource("modelingToolkit", "kLengthWidth")) 
							-ecr false
							-command ("nexOpt -e extrudeVertexCurLmbMap widthlength; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q extrudeVertexCurLmbMap` == "widthlength")
							-radialPosition "S";
						menuItem -d 1; menuItem -d 1; menuItem -d 1;
						menuItem -label (getPluginResource("modelingToolkit", "kResetSettings")) -ecr false -command ("nexCtx -resetManip; dR_updateCommandPanel;");
						return true;
					} else {
						radioMenuItemCollection;
						menuItem
							-label (getPluginResource("modelingToolkit", "kLocalZ"))
							-command ("nexOpt -e extrudeFaceCurLmbMap localz; refresh -f; dR_updateCommandPanel;")
							-ecr false
							-rb (`nexOpt -q extrudeFaceCurLmbMap` == "localz")
							-radialPosition "W";
						if(!`nexCtx -q -ctm`) {
							menuItem
								-label (getPluginResource("modelingToolkit", "kDivisions")) 
								-command ("nexOpt -e extrudeFaceCurLmbMap divisions; refresh -f; dR_updateCommandPanel;")
								-ecr false
								-rb (`nexOpt -q extrudeFaceCurLmbMap` == "divisions")
								-radialPosition "N";
						}
						string $offsetCmd;
						if($hasMcm) {
							$offsetCmd = "nexOpt -e polyExtrudeCurLmbMap offset; nexOpt -e polyBevelCurLmbMap offset; refresh -f; dR_updateCommandPanel;";
						} else {
							$offsetCmd = "nexOpt -e extrudeFaceCurLmbMap offset; refresh -f; dR_updateCommandPanel;";
						}
						menuItem
							-label (getPluginResource("modelingToolkit", "kOffset")) 
							-command ("nexOpt -e extrudeFaceCurLmbMap offset; refresh -f; dR_updateCommandPanel;")
							-ecr false
							-rb (`nexOpt -q extrudeFaceCurLmbMap` == "offset")
							-radialPosition "E";
						menuItem
							-label (getPluginResource("modelingToolkit", "kKeepFacesTogether")) 
							-ecr false
							-command ("nexCtx -e -kft (!`nexCtx -q -kft`); refresh -f")
							-cb (`nexCtx -q -kft`)
							-radialPosition "S";
						menuItem -d 1; menuItem -d 1; menuItem -d 1;
						menuItem -label (getPluginResource("modelingToolkit", "kResetSettings")) -ecr false -command ("nexCtx -resetManip; dR_updateCommandPanel;");
						return true;
					}
				}
				case "bridge": {
					radioMenuItemCollection;
					menuItem
						-label (getPluginResource("modelingToolkit", "kTwist"))
						-ecr false
						-command ("nexOpt -e bridgeCurLmbMap twist; refresh -f; dR_updateCommandPanel;")
						-rb (`nexOpt -q bridgeCurLmbMap` == "twist")
						-radialPosition "NW";
					menuItem
						-label (getPluginResource("modelingToolkit", "kTaper")) 
						-ecr false
						-command ("nexOpt -e bridgeCurLmbMap taper; refresh -f; dR_updateCommandPanel;")
						-rb (`nexOpt -q bridgeCurLmbMap` == "taper")
						-radialPosition "W";
					menuItem
						-label (getPluginResource("modelingToolkit", "kOffset"))
						-ecr false
						-command ("nexOpt -e bridgeCurLmbMap offset; refresh -f; dR_updateCommandPanel;")
						-rb (`nexOpt -q bridgeCurLmbMap` == "offset")
						-radialPosition "E";
					menuItem
						-label (getPluginResource("modelingToolkit", "kDivisions"))
						-command ("nexOpt -e bridgeCurLmbMap divisions; refresh -f; dR_updateCommandPanel;")
						-rb (`nexOpt -q bridgeCurLmbMap` == "divisions")
						-radialPosition "N";
					menuItem -d 1; menuItem -d 1; menuItem -d 1;
					menuItem
						-ecr false
						-label (getPluginResource("modelingToolkit", "kResetSettings"))
						-command ("nexCtx -resetManip; dR_updateCommandPanel;");
					menuItem
						-ecr false
						-label (getPluginResource("modelingToolkit", "kCurveTypes") + "...")
						-subMenu 1
						-radialPosition "S"
						-allowOptionBoxes 1;
						radioMenuItemCollection;
						
						int $blendType = (`nexCtx -q -bridgeCurveType`);
						menuItem
							-ecr false
							-label (getPluginResource("modelingToolkit", "kBlend"))
							-command ("nexCtx -e -bridgeCurveType 1; refresh -f; dR_updateCommandPanel;")
							-rb $blendType
							-radialPosition "W";
						menuItem
							-ecr false
							-label (getPluginResource("modelingToolkit", "kLinear")) 
							-command ("nexCtx -e -bridgeCurveType 0; refresh -f; dR_updateCommandPanel;")
							-rb (!$blendType)
							-radialPosition "S";
					return true;
				}
				case "connect": {
					if(!`nexCtx -q -ctm`) {
						radioMenuItemCollection;
						menuItem
							-ecr false
							-label (getPluginResource("modelingToolkit", "kSlide"))
							-command ("nexOpt -e connectCurLmbMap slide; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q connectCurLmbMap` == "slide")
							-radialPosition "E";
						menuItem
							-ecr false
							-label (getPluginResource("modelingToolkit", "kPinch")) 
							-command ("nexOpt -e connectCurLmbMap pinch; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q connectCurLmbMap` == "pinch")
							-radialPosition "W";
						menuItem
							-ecr false
							-label (getPluginResource("modelingToolkit", "kSegments")) 
							-command ("nexOpt -e connectCurLmbMap segments; refresh -f; dR_updateCommandPanel;")
							-rb (`nexOpt -q connectCurLmbMap` == "segments")
							-radialPosition "N";
						menuItem -d 1; menuItem -d 1; menuItem -d 1;
						menuItem
							-ecr false
							-label (getPluginResource("modelingToolkit", "kResetSettings")) 
							-command ("mtk_initToolOptions(1, \"connect\"); nexCtx -resetManip; dR_updateCommandPanel;");
						return true;
					}
				}
				case "cut": {
					if(`dR_isCtrlHeld`==0 && `dR_isShiftHeld`==0) {
						return false;
					}
					radioMenuItemCollection;
					string $liveList[] = `ls -live`;
					int $live = (size($liveList) > 0);
					menuItem
						-ecr false
						-label (getPluginResource("modelingToolkit", "kQuadDrawTool"))
						-command "dR_quadDrawTool" 
						-image "quadDraw_NEX32.png"
						-radialPosition "N";
					menuItem
						-label (getPluginResource("modelingToolkit", "kEdgeFlow"))
						-ecr false
						-command ("nexOpt -e useEdgeFlow (!`nexOpt -q useEdgeFlow`); floatSliderGrp -e -en `nexOpt -q useEdgeFlow` nexEdgeFlowFloatField; refresh -f; dR_updateCommandPanel;")
						-cb (`nexOpt -q useEdgeFlow`)
						-en (!$live)
						-radialPosition "E";
					menuItem
						-label (getPluginResource("modelingToolkit", "kSliceLabel"))
						-ecr false
						-sm true
						-radialPosition "W";
					menuItem
						-label (getPluginResource("modelingToolkit", "kDeleteFacesChk"))
						-ecr false
						-command ("dR_setSliceMode useDeleteFaces (!`nexOpt -q useDeleteFaces`); dR_updateCommandPanel;")
						-cb (`nexOpt -q useDeleteFaces`)
						-radialPosition "SW";
					menuItem
						-label (getPluginResource("modelingToolkit", "kExtractFacesChk"))
						-ecr false
						-command ("dR_setSliceMode useExtractFaces (!`nexOpt -q useExtractFaces`); floatFieldGrp -e -en `nexOpt -q useExtractFaces` nexExtractFacesFloatGrp; dR_updateCommandPanel;")
						-cb (`nexOpt -q useExtractFaces`)
						-radialPosition "S";
					menuItem
						-label (getPluginResource("modelingToolkit", "kSliceIgnoreBackfacesChk"))
						-ecr false
						-command ("dR_setSliceMode sliceIgnoreBackfaces (!`nexOpt -q sliceIgnoreBackfaces`); dR_updateCommandPanel;")
						-cb (`nexOpt -q sliceIgnoreBackfaces`)
						-radialPosition "SE";
					menuItem
						-label (getPluginResource("modelingToolkit", "kYZ"))
						-ecr false
						-command ("dr_polyCut(0);")
						
						-radialPosition "W";
					menuItem
						-label (getPluginResource("modelingToolkit", "kZX"))
						-ecr false
						-command ("dr_polyCut(1);")
						
						-radialPosition "NW";
					menuItem
						-label (getPluginResource("modelingToolkit", "kXY"))
						-ecr false
						-command ("dr_polyCut(2);")
						
						-radialPosition "N";
					setParent -m ..;
					menuItem -d 1; menuItem -d 1; menuItem -d 1;
					menuItem -label (getPluginResource("modelingToolkit", "kResetSettings")) -ecr false -command ("mtk_initToolOptions(1, \"cut\"); nexCtx -resetManip; dR_updateCommandPanel;");
					return true;
				}
			}
		}
		return false;
	}
	global proc dR_contextPanel() {
		global string $gLocksFrame, $gTransformFrame, $gDrTransformFrame, $gDrTFormLayout, $gDrOptionPanel, $gDrQuaDrawPanel, $gDrConnectFormLayout, $gDrBridgeFormLayout, $gDrVertChamferFormLayout, $gDrVertExtrudeFormLayout, $gDrFaceExtrudeFormLayout, $gDrBevelFormLayout, $gDrCutFormLayout, $gDrTargetWeldFormLayout;
		string $manipType = `nexCtx -q -sm`;
		if(`currentCtx` == "polyMergeVertexContext") {
			$manipType = "weld";
		} else if (dR_isTransformCtx()) {
			$manipType = "transform";
		}
		switch($manipType) {
			case "move":
			case "rotate":
			case "scale":
			case "pivot":
				formLayout -edit
					-attachForm	$gDrTFormLayout "top"	0
					-attachForm	$gDrTFormLayout "left"	0
					-attachForm	$gDrTFormLayout "right"	0
					$gDrOptionPanel;
				layout -e -m 1 $gDrTFormLayout;
				layout -e -m 1 $gLocksFrame;
				layout -e -m 1 $gDrTransformFrame;
				layout -e -m 0 $gTransformFrame;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "transform":
				formLayout -edit
					-attachForm	$gDrTFormLayout "top"	0
					-attachForm	$gDrTFormLayout "left"	0
					-attachForm	$gDrTFormLayout "right"	0
					$gDrOptionPanel;
				frameLayout -edit -l `dR_getTransformOptionsLabel` $gTransformFrame;
				layout -e -m 1 $gDrTFormLayout;
				layout -e -m 1 $gTransformFrame;
				layout -e -m 0 $gDrTransformFrame;
				layout -e -m 0 $gLocksFrame;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "quadraw":
				formLayout -edit
					-attachControl	$gDrTFormLayout "top"	6 $gDrQuaDrawPanel
					-attachForm	$gDrTFormLayout "left"	0
					-attachForm	$gDrTFormLayout "right"	0
					$gDrOptionPanel;

				layout -e -m 1 $gDrQuaDrawPanel;
				layout -e -m 1 $gDrTFormLayout;
				layout -e -m 0 $gLocksFrame;
				layout -e -m 0 $gTransformFrame;
				layout -e -m 0 $gDrTransformFrame;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "connect":
				layout -e -m 1 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "bridge":
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 1 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "chamfervertex":
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				layout -e -m 1 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				break;
			case "extrudevertex":
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 1 $gDrVertExtrudeFormLayout;
				break;
			case "extrudeface":
				layout -e -m 1 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "bevel":
				layout -e -m 1 $gDrBevelFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			case "weld":
				layout -e -m 1 $gDrTargetWeldFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				break;
			case "cut":
				layout -e -m 1 $gDrCutFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
			default:
				layout -e -m 0 $gDrTFormLayout;
				layout -e -m 0 $gDrQuaDrawPanel;
				layout -e -m 0 $gDrConnectFormLayout;
				layout -e -m 0 $gDrBridgeFormLayout;
				layout -e -m 0 $gDrVertExtrudeFormLayout;
				layout -e -m 0 $gDrVertChamferFormLayout;
				layout -e -m 0 $gDrFaceExtrudeFormLayout;
				layout -e -m 0 $gDrBevelFormLayout;
				layout -e -m 0 $gDrCutFormLayout;
				layout -e -m 0 $gDrTargetWeldFormLayout;
				break;
		}
	}
	global proc dR_buildTransformMM(string $useMode) {
		if (`popupMenu -exists tempMM`) {
			deleteUI tempMM;
		}
		popupMenu -markingMenu true 
			-aob true
			-button 1 
			-parent viewPanes  
			tempMM;
		if($useMode == "select") {
			selectToolOptionsPopup();
		} else {
			radioMenuItemCollection;
			menuItem
				-label (getPluginResource("modelingToolkit", "kLocal")) 
				-command ("if(`nexOpt -q manipType` != \"" + $useMode + "\") { nexOpt -e manipType " + $useMode + "; } nexOpt -e manipCoordSpace local; dR_updateCommandPanel(); dR_buildTransformMM(\"" + $useMode + "\")") 
				-rb (`nexOpt -q manipCoordSpace` == "local" &&  `nexOpt -q manipType` != "pivot")
				-radialPosition "NE";
			menuItem
				-label (getPluginResource("modelingToolkit", "kWorld")) 
				-command ("if(`nexOpt -q manipType` != \"" + $useMode + "\") { nexOpt -e manipType " + $useMode + "; } nexOpt -e manipCoordSpace world; dR_updateCommandPanel(); dR_buildTransformMM(\"" + $useMode + "\")")
				-rb (`nexOpt -q manipCoordSpace` == "world" && `nexOpt -q manipType` != "pivot")
				-radialPosition "W";
			menuItem
				-label (getPluginResource("modelingToolkit", "kObject"))
				-command ("if(`nexOpt -q manipType` != \"" + $useMode + "\") { nexOpt -e manipType " + $useMode + "; } nexOpt -e manipCoordSpace object; dR_updateCommandPanel(); dR_buildTransformMM(\"" + $useMode + "\")")
				-rb (`nexOpt -q manipCoordSpace` == "object" && `nexOpt -q manipType` != "pivot")
				-radialPosition "NW";
			menuItem
				-label (getPluginResource("modelingToolkit", "kKeepSpacing"))
				-command ("int $val = `manipMoveContext -query -snapComponentsRelative Move`; $val = !$val; manipMoveContext -edit -snapComponentsRelative $val Move")
				-checkBox `manipMoveContext -query -snapComponentsRelative Move`
				-radialPosition "SE" 
				-annotation (getPluginResource("modelingToolkit", "kKeepSpacing") + ": " + getPluginResource("modelingToolkit", "kKeepSpacingAnn"));
			menuItem
				-label (getPluginResource("modelingToolkit", "kMTOptions") + "...")
				-subMenu 1
				-radialPosition "E" 
				-allowOptionBoxes 1;
				menuItem
					-label (getPluginResource("modelingToolkit", "kMTPanel"))
					-command ("dR_mtkPanelTGL; dR_buildTransformMM(\"" + $useMode + "\")")
					-cb `dR_isPanelVisible`
					-radialPosition "E";
				menuItem
					-label (getPluginResource("modelingToolkit", "kHighlightBackfaces")) 
					-command ("selectPref -preSelectBackfacing (!`selectPref -q -preSelectBackfacing`); dR_updateCommandPanel(); dR_buildTransformMM(\"" + $useMode + "\")")
					-cb `selectPref -q -preSelectBackfacing`
					-radialPosition "S";
			setParent -m ..;
			menuItem
				-label (getPluginResource("modelingToolkit", "kAlignAlong") + "...")
				-subMenu 1
				-radialPosition "SW" 
				-allowOptionBoxes 1;
				menuItem
					-label (getPluginResource("modelingToolkit", "kResetPivotPosition"))
					-command "nexCtx -e -rc \"position\"" 
					-radialPosition "NE";
				menuItem
					-label (getPluginResource("modelingToolkit", "kResetPivotPositionAndOrientation")) 
					-command "nexCtx -e -rc \"all\"" 
					-radialPosition "E";
				menuItem
					-label (getPluginResource("modelingToolkit", "kResetPivotOrientation")) 
					-command "nexCtx -e -rc \"orientation\"" 
					-radialPosition "SE";
				menuItem
					-label (getPluginResource("modelingToolkit", "kAdjustPivotTool"))
					-command ("nexOpt -e manipType \"pivot\"; dR_updateCommandPanel(); dR_buildTransformMM(\"" + $useMode + "\")")
					-radialPosition "SW";
				menuItem
					-label (getPluginResource("modelingToolkit", "kCustomCoordinateSpace"))
					-command ("if(`nexOpt -q manipType` != \"" + $useMode + "\") { nexOpt -e manipType " + $useMode + "; } nexOpt -e manipCoordSpace custom; dR_updateCommandPanel(); dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`nexOpt -q manipCoordSpace` == "custom" || `nexOpt -q manipType` == "pivot")
					-radialPosition "W";
			setParent -m ..;
			global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
			menuItem
				-label (getPluginResource("modelingToolkit", "kActiveAxis") + "...")
				-subMenu 1
				-radialPosition "S" 
				-allowOptionBoxes 1;
				radioMenuItemCollection;
				menuItem
					-label (getPluginResource("modelingToolkit", "kY"))
					-c ("dR_setActiveAxis " + $gNexHandleY + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleY)
					-radialPosition "N";
				menuItem
					-label (getPluginResource("modelingToolkit", "kYZ")) 
					-c ("dR_setActiveAxis " + $gNexHandleYZ + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleYZ)
					-radialPosition "NE";
				menuItem
					-label (getPluginResource("modelingToolkit", "kZ")) 
					-c ("dR_setActiveAxis " + $gNexHandleZ + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleZ)
					-radialPosition "E";
				menuItem
					-label (getPluginResource("modelingToolkit", "kXZ")) 
					-c ("dR_setActiveAxis " + $gNexHandleXZ + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleXZ)
					-radialPosition "SE";
				menuItem
					-label (getPluginResource("modelingToolkit", "kXYZ"))
					-c ("dR_setActiveAxis " + $gNexHandleXYZ + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleXYZ)
					-radialPosition "S";
				menuItem
					-label (getPluginResource("modelingToolkit", "kX"))
					-c ("dR_setActiveAxis " + $gNexHandleX + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleX)
					-radialPosition "W";
				menuItem
					-label (getPluginResource("modelingToolkit", "kXY"))
					-c ("dR_setActiveAxis " + $gNexHandleXY + "; dR_buildTransformMM(\"" + $useMode + "\")")
					-rb (`dR_getActiveHandle` == $gNexHandleXY)
					-radialPosition "NW";
				setParent -m ..;
			menuItem -d 1; menuItem -d 1; menuItem -d 1;
				menuItem
					-label (getPluginResource("modelingToolkit", "kSymmetrize")) 
					-en (`dR_symmetryEnabled`)
					-c ("dR_symmetrize");
				menuItem
					-label (getPluginResource("modelingToolkit", "kSymmetry"))
					-c ("dR_symmetryTGL; dR_buildTransformMM(\"" + $useMode + "\"); ")
					-en (`dR_shouldAllowSymmetry`)
					-cb (`dR_symmetryEnabled`);
				menuItem -d 1;
				$transConstMenu = `menuItem -label (getPluginResource("modelingToolkit", "kTransformConstraints")) -sm true`;
				dR_buildSlideMenu $transConstMenu;
				setParent -m ..;
		}
	}
	global proc dR_releaseAllStickies() {
		SelectMaskToolMarkingMenuPopDown;
		TranslateToolWithSnapMarkingMenuPopDown;
		RotateToolWithSnapMarkingMenuPopDown;
		ScaleToolWithSnapMarkingMenuPopDown;
	}
	proc reassignCmd(string $nameCommand, string $cbCmd) {
		int $cmdIdx, $count = `assignCommand -query -numElements`;
		for ($cmdIdx = 1; $cmdIdx <= $count; $cmdIdx++) {
			$thisCmdName = `assignCommand -q -name $cmdIdx`;
			if($thisCmdName == $nameCommand) {
				string $curCmd = `assignCommand -q -c $cmdIdx`;
				if(!gmatch($curCmd, $cbCmd)) {
					assignCommand -e -i $cmdIdx -c $cbCmd;
				}
			}
		}
	}
	global proc dR_matchManipSize() {
		float $manipSize[] = `manipOptions -q -s`;
		nexOpt -e manipSize ($manipSize[0] * 40);
	}
	global proc dR_snapOptionCB() {
		if(`nexOpt -q useSnapKeys`) {
			reassignCmd("NameComSnap_to_Curve_modifierON", "dR_curveSnapPress");
			reassignCmd("NameComSnap_to_Curve_modifierOFF", "dR_curveSnapRelease");
			reassignCmd("NameComSnap_to_Grid_modifierON", "dR_gridSnapPress");
			reassignCmd("NameComSnap_to_Grid_modifierOFF", "dR_gridSnapRelease");
			reassignCmd("NameComSnap_to_Point_modifierON", "dR_pointSnapPress");
			reassignCmd("NameComSnap_to_Point_modifierOFF", "dR_pointSnapRelease");
		} else {
			reassignCmd("NameComSnap_to_Curve_modifierON", "SnapToCurvePress");
			reassignCmd("NameComSnap_to_Curve_modifierOFF", "SnapToCurveRelease");
			reassignCmd("NameComSnap_to_Grid_modifierON", "SnapToGridPress");
			reassignCmd("NameComSnap_to_Grid_modifierOFF", "SnapToGridRelease");
			reassignCmd("NameComSnap_to_Point_modifierON", "SnapToPointPress");
			reassignCmd("NameComSnap_to_Point_modifierOFF", "SnapToPointRelease");
		}
	}
	global proc dR_manipSizeOptionCB() {
		if(`nexOpt -q useManipSizeKeys`) {
			reassignCmd("NameComIncrease_Manipulator_Size", "dR_increaseManipSize");
			reassignCmd("NameComDecrease_Manipulator_Size", "dR_decreaseManipSize");
		} else {
			reassignCmd("NameComIncrease_Manipulator_Size", "IncreaseManipulatorSize");
			reassignCmd("NameComDecrease_Manipulator_Size", "DecreaseManipulatorSize");
		}
	}
	global proc dR_selTransformKeysCB() {
		if(`nexOpt -q useSelTransformKeys`) {
			reassignCmd("SelectToolOptionsNameCommand", "dR_selectPress");
			reassignCmd("SelectToolOptionsNameCommand_release", "dR_selectRelease");
			reassignCmd("NameComSelectTool_MaskMMenu", "dR_selectPress");
			reassignCmd("NameComSelectTool_MaskMMenu_release", "dR_selectRelease");
			reassignCmd("TranslateToolWithSnapMarkingMenuNameCommand", "dR_movePress");
			reassignCmd("TranslateToolWithSnapMarkingMenuPopDownNameCommand", "dR_moveRelease");
			reassignCmd("RotateToolWithSnapMarkingMenuNameCommand", "dR_rotatePress");
			reassignCmd("RotateToolWithSnapMarkingMenuPopDownNameCommand", "dR_rotateRelease");
			reassignCmd("ScaleToolWithSnapMarkingMenuNameCommand", "dR_scalePress");
			reassignCmd("ScaleToolWithSnapMarkingMenuPopDownNameCommand", "dR_scaleRelease");
			reassignCmd("STRSTweakModeOnNameCommand", "dR_tweakPress");
			reassignCmd("STRSTweakModeOffNameCommand", "dR_tweakRelease");
		} else {
			reassignCmd("SelectToolOptionsNameCommand", "SelectToolOptionsMarkingMenu");
			reassignCmd("SelectToolOptionsNameCommand_release", "SelectToolOptionsMarkingMenuPopDown");
			reassignCmd("NameComSelectTool_MaskMMenu", "SelectMaskToolMarkingMenu");
			reassignCmd("NameComSelectTool_MaskMMenu_release", "SelectMaskToolMarkingMenuPopDown");
			reassignCmd("TranslateToolWithSnapMarkingMenuNameCommand", "TranslateToolWithSnapMarkingMenu");
			reassignCmd("TranslateToolWithSnapMarkingMenuPopDownNameCommand", "TranslateToolWithSnapMarkingMenuPopDown");
			reassignCmd("RotateToolWithSnapMarkingMenuNameCommand", "RotateToolWithSnapMarkingMenu");
			reassignCmd("RotateToolWithSnapMarkingMenuPopDownNameCommand", "RotateToolWithSnapMarkingMenuPopDown");
			reassignCmd("ScaleToolWithSnapMarkingMenuNameCommand", "ScaleToolWithSnapMarkingMenu");
			reassignCmd("ScaleToolWithSnapMarkingMenuPopDownNameCommand", "ScaleToolWithSnapMarkingMenuPopDown");
			reassignCmd("STRSTweakModeOnNameCommand", "STRSTweakModeOn");
			reassignCmd("STRSTweakModeOffNameCommand", "STRSTweakModeOff");
		}
	}
	global proc dR_adjustPivotToggle() {
		string $curPanel = `getPanel -wf`;
		if( modelingTookitActive() && `getPanel -typeOf $curPanel` == "modelPanel") {
			nexOpt -e manipType pivot;
			dR_updateCommandPanel;
		} else {
			EnterEditMode;
		}
	}
	global proc dR_adjustPivotPress() {
		string $curPanel = `getPanel -wf`;
		if( modelingTookitActive() && `getPanel -typeOf $curPanel` == "modelPanel") {
			nexOpt -e manipType pivot;
			dR_updateCommandPanel;
		} else {
			EnterEditModePress;
		}
	}
	global proc dR_adjustPivotRelease() {
		string $curPanel = `getPanel -wf`;
		if( modelingTookitActive() && `getPanel -typeOf $curPanel` == "modelPanel") {
			nexOpt -e manipType pivot;
			dR_updateCommandPanel;
		} else {
			EnterEditModeRelease;
		}
	}
	global proc dR_toolEditKeysCB() {
		if(`nexOpt -q useToolEditKeys`) {
			reassignCmd("NameComEnter_Tool_Edit_Mode", "dR_customPivotTool");
			reassignCmd("NameComEnter_Tool_Edit_Mode_Press", "dR_customPivotToolPress");
			reassignCmd("NameComEnter_Tool_Edit_Mode_Release", "dR_customPivotToolRelease");
		} else {
			reassignCmd("NameComEnter_Tool_Edit_Mode", "EnterEditMode");
			reassignCmd("NameComEnter_Tool_Edit_ModePress", "EnterEditModePress");
			reassignCmd("NameComEnter_Tool_Edit_ModeRelease", "EnterEditModeRelease");
		}
	}
	global proc dR_brushResizeKeysCB() {
		if(`nexOpt -q useBrushResizeKeys`) {
			reassignCmd("artisanModifyUpperRadius_press", "dR_softSelStickyPress");
			reassignCmd("artisanModifyUpperRadius_release", "dR_softSelStickyRelease");
		} else {
			reassignCmd("artisanModifyUpperRadius_press", "ModifyUpperRadiusPress");
			reassignCmd("artisanModifyUpperRadius_release", "ModifyUpperRadiusRelease");
		}
	}
	global proc dR_reloadTexture(string $ftn) {
		if(`objExists $ftn` && `getAttr -se $ftn`) {
			int $undoState = `undoInfo -q -st`;
			undoInfo -swf 0;
			string $currFile = `getAttr $ftn`;
			setAttr $ftn -type "string" $currFile;
			undoInfo -swf $undoState;
		}
	}
	global proc dRShelfSizeChanged(string $parent)
	{
		int $paneSize[];
		$paneSize = `paneLayout -query -ps $parent`;
		optionVar -iv mtkShelfHeight $paneSize[3];
	}
	global proc dRSaveShelves() {
		global string $gDRBottomPane;
		string $shelvesName =  (`internalVar -userPrefDir` + "MTKShelf");
		saveShelf $gDRBottomPane $shelvesName;
	}
	global proc dRRestoreShelves() {
		global string $gDRBottomPane;
		string $shelvesName =  (`internalVar -userPrefDir` + "MTKShelf");
		string $shelvesFile = $shelvesName + ".mel";
		if(`filetest -r $shelvesFile`) {
			string $cmd = "source \"" + $shelvesName + "\"";
			eval ($cmd);
			setParent $gDRBottomPane;
			MTKShelf;
		}
	}
	global proc dRSetSoftSelFalloffType(int $type) {
		switch ($type) {
		case 0: dR_softSelDistanceTypeVolume; break;
		case 1: dR_softSelDistanceTypeSurface; break;
		case 2: dR_softSelDistanceTypeGlobal; break;
		case 3: dR_softSelDistanceTypeObject; break;
		}
	}
	proc string buildSoftSelectPanel() {
		global float $gMTKFrameHeadColor[];
		string $prev = `setParent -q`;
		string $softSel = `frameLayout -cll 1 -cl 1 
			-l (getPluginResource("modelingToolkit", "kSoftSelection")) -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2] `;
			string $frmLayout = `formLayout -nd 4`;
				string $softSelLabel = `text -l (getPluginResource("modelingToolkit", "kSoftSelect") + ":") -ann (getPluginResource("modelingToolkit", "kEnableDisableSoftSelect"))`;
				string $softSelChk = dR_addModeBtn(`checkBox -l "" -ann (getPluginResource("modelingToolkit", "kEnableDisableSoftSelect")) -cc "dR_softSelToolTGL; dR_updateCommandPanel();" nexSoftSelection`);
				global string $gDrSoftSelDistType;
				$gDrSoftSelDistType = dR_addModeBtn(`optionMenu -ann (getPluginResource("modelingToolkit", "kSetSoftSelFalloffMode")) nexSoftSelectionDistanceType`);
				optionMenu -e -cc ("dRSetSoftSelFalloffType(`optionMenu -q -sl " + $gDrSoftSelDistType + "` - 1)") $gDrSoftSelDistType;
					menuItem -label (getPluginResource("modelingToolkit", "kVolume"));
					menuItem -label (getPluginResource("modelingToolkit", "kSurface"));
					menuItem -label (getPluginResource("modelingToolkit", "kGlobal"));
					menuItem -label (getPluginResource("modelingToolkit", "kObject"));
				string $falloffFld = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kSetSoftSelFalloffRadius"))
			    	-dc "softSelect -e -softSelectDistance #1" -cc "softSelect -e -softSelectDistance #1; dR_updateHUD;" -step 0.01 -min 0 -max 100000 -pre 2 -v 1 -height 26 nexSoftSelectionFalloff`);
				string $falloffCurve = `softSelect -q -softSelectCurve`;
				string $falloffRamp = dR_addModeBtn(`gradientControlNoAttr -ann (getPluginResource("modelingToolkit", "kSoftSelCurve")) -h 90 -w 154 -asString $falloffCurve -changeCommand "softSelect -e -softSelectCurve \"#1\"" -ov "" nexSoftSelectionCurve`);
				string $resetGraphBtn = dR_addModeBtn(`button -ann (getPluginResource("modelingToolkit", "kResetCurve")) -l (getPluginResource("modelingToolkit", "kResetCurve")) -c "softSelect -e -softSelectCurve \"1,0,2,0,1,2\"; gradientControlNoAttr -e -asString \"1,0,2,0,1,2\" nexSoftSelectionCurve" -rs false -h 18 nexResetSoftSelectionCurve`);
				formLayout -e
					-attachForm		$softSelLabel		"top"		6
					-attachForm		$softSelLabel		"left"		14
					-attachControl	$softSelLabel		"bottom"	4		$gDrSoftSelDistType
					-attachNone		$softSelLabel		"right"
					-attachForm		$softSelChk			"top"		6
					-attachControl	$softSelChk			"left"		6		$softSelLabel
					-attachControl	$softSelChk			"bottom"	4		$gDrSoftSelDistType
					-attachNone		$softSelChk			"right"
					-attachNone		$gDrSoftSelDistType	"top"
					-attachForm		$gDrSoftSelDistType	"left"		14
					-attachControl	$gDrSoftSelDistType	"bottom"	6		$falloffRamp
					-attachControl	$gDrSoftSelDistType	"right"		4		$falloffFld
					-attachNone		$falloffFld			"top"
					-attachPosition	$falloffFld			"left"		40		2
					-attachControl	$falloffFld			"bottom"	4		$falloffRamp
					-attachForm		$falloffFld			"right"		12
					-attachNone		$falloffRamp		"top"
					-attachForm		$falloffRamp		"left"		6
					-attachControl	$falloffRamp		"bottom"	4		$resetGraphBtn
					-attachForm		$falloffRamp		"right"		6
					-attachNone		$resetGraphBtn		"top"
					-attachForm		$resetGraphBtn		"left"		4
					-attachForm		$resetGraphBtn		"bottom"	4
					-attachForm		$resetGraphBtn		"right"		4
					$frmLayout;
				//if (`about -linux`) {
					// Force a redraw on Linux 
					//evalDeferred( "gradientControlNoAttr -e -vis off nexSSGradient; gradientControlNoAttr -e -vis on nexSSGradient; ");
				//}
		setParent $prev;
		return $softSel;
	}
	global proc dR_transformFloat(string $axis, float $newVal) {
		string $manipType = `nexOpt -q manipType`;
		if($manipType == "pivot") {
			int $activePivotHandle = `nexOpt -q activePivotHandle`;
			if($activePivotHandle >= 8 && $activePivotHandle <= 10) {
				$manipType = "rotate";
			}
		}
		switch($manipType) {
			case "move":
			case "pivot":
				if($axis == "x") {
					nexCtx -e -mpx $newVal;
				} else if($axis == "y") {
					nexCtx -e -mpy $newVal;
				} else if($axis == "z") {
					nexCtx -e -mpz $newVal;
				}
				break;
			case "rotate":
				if($axis == "x") {
					nexCtx -e -mox $newVal;
				} else if($axis == "y") {
					nexCtx -e -moy $newVal;
				} else if($axis == "z") {
					nexCtx -e -moz $newVal;
				}
				break;
			case "scale":
				if($axis == "x") {
					nexCtx -e -msx $newVal;
				} else if($axis == "y") {
					nexCtx -e -msy $newVal;
				} else if($axis == "z") {
					nexCtx -e -msz $newVal;
				}
				break;
		}
	}
	global proc nexBuildDockMenu(string $dockMenu) {
		popupMenu -e -dai $dockMenu;
		radioMenuItemCollection -p $dockMenu;
		int $isDocked = `nexOpt -q panelDock`;
		menuItem -rb ($isDocked == 1) -c "nexDockPanel(1)" -label (getPluginResource("modelingToolkit", "kDockRight")) -p $dockMenu;
		menuItem -rb ($isDocked == 0) -c "nexDockPanel(0)" -label (getPluginResource("modelingToolkit", "kFloat")) -p $dockMenu;
	}
	global proc string dR_getSelCurve() {
		string $origSel[] = `ls -selection -objectsOnly`;
		string $curveNode = "";
		for ($node in $origSel) {
			if (size(`ls ($node+".editPoints")`) > 0) {
				$curveNode = $node;
				break;
			}
		}
		return $curveNode;
	}
	global proc dR_ctxHelp() {
		string $manipType = `nexOpt -q manipType`;
		string $helpID = "ModelingToolkit_" + $manipType;
		showHelp $helpID;
	}
	global proc dR_performBridge() {
		if( `nexCtx -q -gfb` ) {
			dR_bridgeTool;
		} else {
			error -n (getPluginResource("modelingToolkit", "kBridgeError"));
		}
	}
	global proc dR_doToggleSymmetry() {
		if (`dR_symmetryEnabled`) {
			symmetricModelling -topoSymmetry 0;
		} else {
			symmetricModelling -topoSymmetry 1;
		}
		dR_updateCommandPanel();
	}
	global proc dR_enableTweakMarquee() {
		nexOpt -e selectOption "tweakMarquee";
		nexOpt -e -s useClickDrag 1;
		global string $gNexLastSelectionMode;
		$gNexLastSelectionMode = "";
		if (dR_isTransformCtx()) {
			STRSTweakModeOn;
		}
	}
	global proc dR_disableTweakMarquee() {
		nexOpt -e -s useClickDrag 0;
		if (dR_isTransformCtx()) {
			STRSTweakModeOff;
		}
	}
	global proc dr_polyCut(int $idx) {
		string $xyzArray[] = {"X", "Y", "Z"}; 
		string $hiliteObjs[] = `ls -hilite`;
		int $nHilites = size($hiliteObjs);
		if($nHilites > 0) {
			select -cl;
			for ($i = 0; $i < $nHilites; $i++) {
				string $result[];
				if (`nexOpt -q useExtractFaces` == 1) {
					$result = evalEcho("polyCut -ws 1 -cd " + $xyzArray[$idx] + " -ch 1 -df " + `nexOpt -q useDeleteFaces` + " -ef " + `nexOpt -q useExtractFaces` + " -eo " + `nexOpt -q extractFacesX` + " " + `nexOpt -q extractFacesY` + " " + `nexOpt -q extractFacesZ` + " " + $hiliteObjs[$i]);
				} else {
					$result = evalEcho("polyCut -ws 1 -cd " + $xyzArray[$idx] + " -ch 1 -df " + `nexOpt -q useDeleteFaces` + " " + $hiliteObjs[$i]);
				}
				if(size($result)>0) {
					select -add $result[0];
				}
			}
			global string $gPolyLastTool;
			$gPolyLastTool="";
			ShowManipulators;
		}
	}
	global proc string nexBuildLiveSurfaceFrame(string $parent, string $suffix) {
		global float $gMTKFrameHeadColor[];

		string $liveFrame = `frameLayout -p $parent -l (getPluginResource("modelingToolkit", "kLiveSurfaceOptions")) 
			-mw 0 -mh 4 -cll true -cl 1 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;

			string $liveFormLayout = `formLayout -p $liveFrame`;

				string $overlayAppendMeshChk = dR_addModeBtn(`checkBoxGrp -ncb 1
					-l "" -height 24 -width 122 -cw2 1 60
					-l1 (getPluginResource("modelingToolkit", "kOverlayAppendMesh"))
					-cc "dR_overlayAppendMeshTGL"
					("overlayAppendMesh" + $suffix)`);
				checkBoxGrp -e -value1 `nexOpt -q overlayAppendMesh` $overlayAppendMeshChk;

				string $appendMeshColor = dR_addModeBtn(`colorSliderGrp
					-label "" -rgb 0 0 1 -width 32 -cw3 1 32 1
					("nexOverlayMeshColor" + $suffix)`);
				float $apColor[] = `nexOpt -q appendMeshColor`;
				colorSliderGrp -e -rgb $apColor[0] $apColor[1] $apColor[2]
					-cc ("dR_adjustColorSliderOpt(\"" + $appendMeshColor + "\", \"appendMeshColor\"); refresh -f")
					-dc ("dR_adjustColorSliderOpt(\"" + $appendMeshColor + "\", \"appendMeshColor\"); refresh -f")
					$appendMeshColor;

				string $snapToBackfacesChk = dR_addModeBtn(`checkBoxGrp -ncb 1
					-l "" -height 22 -width 75 -cw2 1 60
					-l1 (getPluginResource("modelingToolkit", "kSnapToBackfaces"))
					-cc "dR_snapToBackfacesTGL"
					("snapToBackfaces" + $suffix)`);
				checkBoxGrp -e -value1 `nexOpt -q snapToBackfaces` $snapToBackfacesChk;

				string $useMeshColorOverride = dR_addModeBtn(`checkBoxGrp -ncb 1
					-l "" -height 24 -width 90 -cw2 1 60
					-l1 (getPluginResource("modelingToolkit", "kMeshColorOverride"))
					-cc "dR_meshColorOverrideTGL"
					("useMeshColorOverride" + $suffix)`);
				checkBoxGrp -e -value1 `nexOpt -q useMeshColorOverride` $useMeshColorOverride;

				string $meshColorOverride = dR_addModeBtn(`colorSliderGrp
					-label "" -rgb 0 0 0 -width 32 -cw3 1 32 1
					("meshColorOverride" + $suffix)`);
				float $meshColor[] = `nexOpt -q meshColorOverride`;
				colorSliderGrp -e -rgb $meshColor[0] $meshColor[1] $meshColor[2]
					-cc ("dR_adjustColorSliderOpt(\"" + $meshColorOverride + "\", \"meshColorOverride\"); refresh -f")
					-dc ("dR_adjustColorSliderOpt(\"" + $meshColorOverride + "\", \"meshColorOverride\"); refresh -f")
					$meshColorOverride;

				int $useMeshAlpha = `nexOpt -q useMeshAlpha`;
				string $meshTranspChk = dR_addModeBtn(`checkBoxGrp -ncb 1
					-l "" -height 24 -width 90 -cw2 1 60 -value1 $useMeshAlpha
					-l1 (getPluginResource("modelingToolkit", "kMeshAlpha"))
					-ann (getPluginResource("modelingToolkit", "kMeshAlphaAnn"))
					-cc "dR_meshAlphaTGL"
					("meshAlphaCheckbox" + $suffix)`);

				float $meshAlpha = `nexOpt -q meshAlpha`;
				string $meshAlphaFltField = dR_addModeBtn(`floatSliderGrp -min 0.0 -max 1.0 -fieldMinValue 0 -fieldMaxValue 1.0 -field true
					-ann (getPluginResource("modelingToolkit", "kMeshAlphaAnn")) -cw2 34 1 -pre 2
					-v $meshAlpha -en $useMeshAlpha
				    -cc "nexOpt -e meshAlpha #1"
					-dc "nexOpt -e meshAlpha #1"
				    ("meshAlphaFltField" + $suffix)`);

				int $useMeshOffset = `nexOpt -q useMeshOffset`;
				string $meshOffsetChk = dR_addModeBtn(`checkBoxGrp -ncb 1
					-l "" -height 24 -width 105 -cw2 1 60 -value1 $useMeshOffset
					-l1 (getPluginResource("modelingToolkit", "kMeshOffset"))
					-ann (getPluginResource("modelingToolkit", "kMeshOffsetAnn"))
					-cc "dR_meshOffsetTGL"
					("meshOffsetCheckbox" + $suffix)`);

				float $meshOffset = `nexOpt -q meshOffset`;
				string $meshOffsetFltField = dR_addModeBtn(`floatSliderGrp
					-min 0 -max 0.1 -fieldMinValue -100 -fieldMaxValue 100 -step 0.01 -pre 3 -field true -cw2 41 1
					-v $meshOffset -en $useMeshOffset
					-ann (getPluginResource("modelingToolkit", "kMeshOffsetAnn"))
				    -cc "nexOpt -e meshOffset #1"
					-dc "nexOpt -e meshOffset #1"
				    ("meshOffsetFltField" + $suffix)`);
	
		formLayout -edit
			-attachForm $overlayAppendMeshChk "top" 2
			-attachForm $overlayAppendMeshChk "left" 4
			-attachNone $overlayAppendMeshChk "right"
			-attachForm $appendMeshColor "top" 6
			-attachControl $appendMeshColor "left" 4  $overlayAppendMeshChk
			-attachNone $appendMeshColor "right"
				
			-attachControl $useMeshColorOverride "top" 2 $overlayAppendMeshChk
			-attachForm $useMeshColorOverride "left" 4
			-attachNone $useMeshColorOverride "right"
			-attachControl $meshColorOverride "top" 6 $overlayAppendMeshChk
			-attachControl $meshColorOverride "left" 4  $useMeshColorOverride
			-attachNone $meshColorOverride "right"
				
			-attachControl $meshTranspChk "top" 2 $useMeshColorOverride
			-attachForm $meshTranspChk "left" 4
			-attachNone $meshTranspChk "right"
				
			-attachControl $meshAlphaFltField "top" 2 $useMeshColorOverride
			-attachControl $meshAlphaFltField "left" 4 $meshTranspChk
			-attachForm $meshAlphaFltField "right" 4
				
			-attachControl $meshOffsetChk "top" 2 $meshTranspChk
			-attachForm $meshOffsetChk "left" 4
			-attachNone $meshOffsetChk "right"
				
			-attachControl $meshOffsetFltField "top" 2 $meshTranspChk
			-attachControl $meshOffsetFltField "left" 4 $meshOffsetChk
			-attachForm $meshOffsetFltField "right" 4

			-attachControl $snapToBackfacesChk "top" 2 $meshOffsetChk
			-attachForm $snapToBackfacesChk "left" 4
			-attachForm $snapToBackfacesChk "right" 4

			$liveFormLayout;

		return $liveFrame;
	}

	// Allow shift-clicking a button to run its command.
	global proc mtkBtnCmd( string $cmd ) {  
		if(`getModifiers`%2) { 
			$cmd += "Options";
		} 
		eval( $cmd );
	}

	global proc mtkBtnCmd2( string $cmd, string $optCmd ) {  
		if(`getModifiers`%2) { 
			$cmd = $optCmd;
		} 
		eval( $cmd );
	}	

	global proc nexBuildPanel(string $parentForm) {
		// we use ModelingToolkitTemplate to give a flat UI consistencey.
		setUITemplate -pushTemplate ModelingToolkitTemplate;
		string $menu, $menu2;
		global string $gDrpanel;
		global string $gNexRefreshCmd;
		global string $gDRasterModeBtns[];
		global string $gAttributeEditorForm;
		global string $gMainPane;
		global string $gDrPanes;
		global string $gDRTopPane;
		global string $gDRBottomPane;
		global int $gDrCompBtnCount;
		global string $gDrCompBtns_Cmds[], $gDrCompBtns_Ann[], $gDrCompBtns_Images[], $gDrCompBtns_Names[], $gDrCompBtns[];
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		global float $gMTKFrameHeadColor[];
		
		$gDRasterModeBtns = { };

		$gDrCompBtnCount = 6;
		$gDrCompBtns_Names = { "multi", "object", "vertex", "edge", "face", "uv" };

		$gDrCompBtns_Images = {
			"",
			(dR_xpmToPng("object_NEX.xpm")),
			(dR_xpmToPng("vertex_NEX.xpm")),
			(dR_xpmToPng("edges_NEX.xpm")),
			(dR_xpmToPng("faces_NEX.xpm")),
			(dR_xpmToPng("vertex_UV_NEX.xpm"))
		};
		$gDrCompBtns_Ann = {
			(getPluginResource("modelingToolkit", "kMultiComponentAnn")),
			(getPluginResource("modelingToolkit", "kObjectSelectionAnn")),
			(getPluginResource("modelingToolkit", "kVertexComponentAnn")),
			(getPluginResource("modelingToolkit", "kEdgeComponentAnn")),
			(getPluginResource("modelingToolkit", "kFaceComponentAnn")),
			(getPluginResource("modelingToolkit", "kUVSelectionAnn"))
		};
		$gDrCompBtns_Cmds = {
			"dR_modeMulti",
			"dR_modeObject",
			"if( `dR_isCtrlHeld` && `dR_isShiftHeld`){ ConvertSelectionToVertexPerimeter; } else if (`dR_isCtrlHeld`) { dR_convertSelectionToVertex; } else { dR_modeVert; }",
			"if( `dR_isCtrlHeld` && `dR_isShiftHeld`){ ConvertSelectionToEdgePerimeter; } else if (`dR_isCtrlHeld`) { dR_convertSelectionToEdge; } else { dR_modeEdge; }",
			"if( `dR_isCtrlHeld` && `dR_isShiftHeld`){ ConvertSelectionToFacePerimeter; } else if (`dR_isCtrlHeld`) { dR_convertSelectionToFace; } else { dR_modePoly; }",
			"if( `dR_isCtrlHeld` && `dR_isShiftHeld`){ ConvertSelectionToUVPerimeter; } else if (`dR_isCtrlHeld`) { dR_convertSelectionToUV; } else { dR_modeUV; }"
		};

		string $lmb = getPluginResource("modelingToolkit", "kLMB");
		string $mmb = getPluginResource("modelingToolkit", "kMMB");
		string $rmb = getPluginResource("modelingToolkit", "kRMB");
		string $shift = getPluginResource("modelingToolkit", "kShift");
		string $ctrl = getPluginResource("modelingToolkit", "kCtrl");
		string $tab = getPluginResource("modelingToolkit", "kTab");

		// because the power button is added before the rest of the panel
		global string $gNexPowerButton;
		dR_addModeBtn($gNexPowerButton);
		$gDRTopPane = `formLayout -p $parentForm`;
		formLayout -e
			-attachForm		$gDRTopPane		"top"		0
			-attachForm		$gDRTopPane		"left"		0
			-attachForm		$gDRTopPane		"bottom"	0
			-attachForm		$gDRTopPane		"right"		0
			$parentForm;
		global string $gNexComponentCountLabel;
		int $btnIndex;
		global string $gDRTopPaneComponentsFrame;
		$gDRTopPaneComponentsFrame = `frameLayout -bv 0 -cll 0 -lv 0 -mw 8 -mh 4`;
			string $gDRTopPaneComponentsOutlineFrame = `frameLayout -bv 0 -cll 0 -lv 0`;
				string $gDRTopPaneComponentsAlignForm = `formLayout -nd 5`;
					// Multi-Component selection button
					$gDrCompBtns[0] = `iconTextButton
										-st "textOnly"
										-l (getPluginResource("modelingToolkit", "kMultiComponent"))
										-ann $gDrCompBtns_Ann[0]
										-h 26 -flat 0
										-c $gDrCompBtns_Cmds[0]`;

					// Object selection button
					$gDrCompBtns[1] = `iconTextButton
										-st "iconOnly"
										-i $gDrCompBtns_Images[1]
										-ann $gDrCompBtns_Ann[1]
										-w 36 -h 36	-mw 2 -mh 2
										-c $gDrCompBtns_Cmds[1]`;

					// vertex/edge/face selection buttons
					string $gDRTopPaneComponentsBtnForm = `formLayout -nd 3`;
						for ($btnIndex = 2; $btnIndex < $gDrCompBtnCount-1; $btnIndex++) {
							$gDrCompBtns[$btnIndex] = `iconTextButton
													-st "iconOnly"
													-i $gDrCompBtns_Images[$btnIndex]
													-ann $gDrCompBtns_Ann[$btnIndex]
													-w 36 -h 36 -mw 2 -mh 2
													-c $gDrCompBtns_Cmds[$btnIndex]`;
						}
						setParent ..; // $gDRTopPaneComponentsAlignForm

					// UV selection button
					$gDrCompBtns[$gDrCompBtnCount-1] = `iconTextButton
										-st "iconOnly"
										-i $gDrCompBtns_Images[$gDrCompBtnCount-1]
										-ann $gDrCompBtns_Ann[$gDrCompBtnCount-1]
										-w 36 -h 36 -mw 2 -mh 2
										-c $gDrCompBtns_Cmds[$gDrCompBtnCount-1]`;

					// add right-click to clear selection functionality to the above buttons.
					for ($btnIndex = 1; $btnIndex < $gDrCompBtnCount; $btnIndex++) {
						popupMenu -button 3
							-parent $gDrCompBtns[$btnIndex]
							-postMenuCommand( "select -clear" );
					}

					string $gDRTopPaneComponentsCountForm = `formLayout -h 25`;
						$gNexComponentCountLabel = `text -l " " -al "center"`;
						scriptJob -p $gNexComponentCountLabel -e "SelectionChanged" "dR_updateCounter";
						scriptJob -p $gNexComponentCountLabel -e "SceneOpened" "dR_updateCounter";
						workspaceControl -e -visibleChangeCommand "dR_updateCounter; MTsetToggleMenuItem" NEXDockControl;
						setParent ..; // $gDRTopPaneComponentsAlignForm
					formLayout -e
						-attachForm        $gDrCompBtns[2]				"top"    4
						-attachPosition    $gDrCompBtns[2]				"left"   0    0
						-attachForm		   $gDrCompBtns[2]				"bottom" 2
						-attachPosition    $gDrCompBtns[2]				"right"  0    1
						-attachForm        $gDrCompBtns[3]				"top"    4
						-attachPosition    $gDrCompBtns[3]				"left"   0    1
						-attachForm        $gDrCompBtns[3]				"bottom" 2
						-attachPosition    $gDrCompBtns[3]				"right"  0    2
						-attachForm        $gDrCompBtns[4]				"top"    4
						-attachPosition    $gDrCompBtns[4]				"left"   0    2
						-attachForm        $gDrCompBtns[4]				"bottom" 2
						-attachPosition    $gDrCompBtns[4]				"right"  0    3
						$gDRTopPaneComponentsBtnForm;
					formLayout -e
						-attachForm        $gNexComponentCountLabel		"top"	 0
						-attachForm        $gNexComponentCountLabel		"left"   0
						-attachForm        $gNexComponentCountLabel		"bottom" 0
						-attachForm        $gNexComponentCountLabel		"right"  0
						$gDRTopPaneComponentsCountForm;
					setParent ..; // $gDRTopPaneComponentsOutlineFrame
				formLayout -e
					-attachForm			$gDrCompBtns[0]					"top"		0
					-attachPosition		$gDrCompBtns[0]					"left"		0	1
					-attachNone			$gDrCompBtns[0]					"bottom"
					-attachPosition		$gDrCompBtns[0]					"right"		0	4

					-attachControl		$gDrCompBtns[1]					"top"		4 		$gDrCompBtns[0]
					-attachPosition		$gDrCompBtns[1]					"left"		0	0
					-attachNone			$gDrCompBtns[1]					"bottom"
					-attachPosition		$gDrCompBtns[1]					"right"		0	1

					-attachControl		$gDRTopPaneComponentsBtnForm	"top"		0		$gDrCompBtns[0]
					-attachPosition		$gDRTopPaneComponentsBtnForm	"left"		0	1
					-attachNone			$gDRTopPaneComponentsBtnForm	"bottom"
					-attachPosition		$gDRTopPaneComponentsBtnForm	"right"		0	4

					-attachControl		$gDrCompBtns[5]					"top"		4 		$gDrCompBtns[0]
					-attachPosition		$gDrCompBtns[5]					"left"		0	4
					-attachNone			$gDrCompBtns[5]					"bottom"
					-attachPosition		$gDrCompBtns[5]					"right"		0	5

					-attachControl		$gDRTopPaneComponentsCountForm	"top"		0		$gDRTopPaneComponentsBtnForm
					-attachForm			$gDRTopPaneComponentsCountForm	"left"		0
					-attachNone			$gDRTopPaneComponentsCountForm	"bottom"
					-attachForm			$gDRTopPaneComponentsCountForm	"right"		0
					$gDRTopPaneComponentsAlignForm;
				setParent ..; // $gDRTopPaneComponentsFrame

		{
			setParent $gDRTopPane;
			$gDrpanel = `frameLayout -lv false -bv false -mh 2`;
				string $frmLayout = `formLayout`;
					string $buttonSet = `formLayout -nd 7`;
						string $checkBoxes = `columnLayout`;
							string $selectionRBs = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 100
									-l1 (getPluginResource("modelingToolkit", "kPickMarquee"))
									-ann (getPluginResource("modelingToolkit", "kPickMarqueeAnn"))
									-on1 ("dR_selectModeMarquee")
									nexPickMarqueeGrp`);
								dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 100
									-l1 (getPluginResource("modelingToolkit", "kRaycast"))
									-ann (getPluginResource("modelingToolkit", "kRaycastAnn"))
									-on1 ("dR_selectModeRaycast")
									-shareCollection $selectionRBs
									nexRaycastGrp`);
								dR_addModeBtn(`radioButtonGrp -nrb 1
									-l ""
									-cw2 1 100
									-l1 (getPluginResource("modelingToolkit", "kTweakMarquee"))
									-ann (getPluginResource("modelingToolkit", "kTweakMarqueeAnn"))
									-on1 ("dR_selectModeTweakMarquee")
									-of1 ("dR_selectModeDisableTweakMarquee")
									-shareCollection $selectionRBs
									nexTweakMarqueeGrp`);
							setParent $buttonSet;
						string $highlightBackfaces = dR_addModeBtn(`checkBox
									-ann (getPluginResource("modelingToolkit", "kHighlightBackfacesAnn"))
									-l (getPluginResource("modelingToolkit", "kHighlightBackfaces"))
									-al "left"
									-cc "selectPref -preSelectBackfacing #1; dR_updateCommandPanel();"
									nexHighlightBackfaces`);
						string $highlightClosest = dR_addModeBtn(`checkBox
									-ann (getPluginResource("modelingToolkit", "kHighlightClosestAnn"))
									-l (getPluginResource("modelingToolkit", "kHighlightClosest"))
									-al "left"
									-cc "selectPref -preSelectClosest #1; dR_updateCommandPanel();"
									nexHighlightClosest`);

						string $camSelFormLayout = `formLayout`;
							string $gNexCamSelLabel = `text -align left
				 				-h 25
					 			-l (getPluginResource("modelingToolkit", "kCameraBasedSelection"))
					 			-ann (getPluginResource("modelingToolkit", "kCameraBasedSelectionAnn"))
								nexCamSelLabel`;

				 			string $gNexCamSelButton = `iconTextButton
				 				-dcc "dR_toggleCameraBasedSelection"
				 				-w 17 -h 26
				 				-image ("popupMenuIcon.png") 
				 				-p $camSelFormLayout nexCamSelButton`;

				 			global string $gNexCamSelText;
							$gNexCamSelText = `textField -ed false -h 25 -p $camSelFormLayout
				 				nexCamSelTextField`;
				 			$menu = `popupMenu -b 1 -p $gNexCamSelButton`;
				 				menu -e -pmc ("dR_buildCameraBasedSelectionMenu " + $menu) $menu;
				 			$menu2 = `popupMenu -b 2 -p $gNexCamSelButton`;
				 				menu -e -pmc "dR_toggleCameraBasedSelection" $menu2;

					 		// Layout the above form
					 		formLayout -e
					 			-attachForm 	$gNexCamSelLabel 	left	0
					 			-attachNone 	$gNexCamSelLabel 	right
					 			-attachForm 	$gNexCamSelLabel 	bottom	0
					 			-attachNone 	$gNexCamSelLabel 	top
					 			-attachControl	$gNexCamSelButton	left	2	$gNexCamSelLabel
					 			-attachNone 	$gNexCamSelButton	right
					 			-attachForm 	$gNexCamSelButton	bottom	0
					 			-attachNone 	$gNexCamSelButton	top
					 			-attachControl	$gNexCamSelText		left	0	$gNexCamSelButton
					 			-attachForm		$gNexCamSelText		bottom	0
					 			-attachForm		$gNexCamSelText		right	0
					 			-attachNone		$gNexCamSelText		top
					 			$camSelFormLayout;
						setParent $buttonSet;

						string $softSelFrame = buildSoftSelectPanel();

						string $symFormLayout = `formLayout`;
							string $gNexSymLabel = `text -align left
				 				-h 25
					 			-l (getPluginResource("modelingToolkit", "kSymmetry"))
				 				-ann (getPluginResource("modelingToolkit", "kSymmetryAnn"))
								nexSymLabel`;

				 			string $gNexSymButton = `iconTextButton
				 				-dcc "dR_toggleSym"
				 				-w 17 -h 26
				 				-ann (getPluginResource("modelingToolkit", "kSymmetryAnn"))
				 				-image ("popupMenuIcon.png") 
				 				-p $symFormLayout nexSymButton`;

				 			global string $gNexSymText;
							$gNexSymText = `textField -ed false -h 25 -p $symFormLayout
				 				-ann (getPluginResource("modelingToolkit", "kSymmetryAnn"))
				 				nexSymTextField`;
							global float $gDefaultFieldBgColor[];
							$gDefaultFieldBgColor = `textField -q -backgroundColor $gNexSymText`;
				 			$menu = `popupMenu -b 1 -p $gNexSymButton`;
				 				menu -e -pmc ("dR_buildSymMenu " + $menu) $menu;
				 			$menu2 = `popupMenu -b 2 -p $gNexSymButton`;
				 				menu -e -pmc "dR_toggleSym" $menu2;
							dR_setSymMesh; // To update label

					 		// Layout the above form
					 		formLayout -e
					 			-attachForm 	$gNexSymLabel 	left	0
					 			-attachNone 	$gNexSymLabel 	right
					 			-attachForm 	$gNexSymLabel 	bottom	0
					 			-attachNone 	$gNexSymLabel 	top
					 			-attachControl	$gNexSymButton	left	2	$gNexSymLabel
					 			-attachNone 	$gNexSymButton	right
					 			-attachForm 	$gNexSymButton	bottom	0
					 			-attachNone 	$gNexSymButton	top
					 			-attachControl	$gNexSymText		left	0	$gNexSymButton
					 			-attachForm		$gNexSymText		bottom	0
					 			-attachForm		$gNexSymText		right	0
					 			-attachNone		$gNexSymText		top
					 			$symFormLayout;				
						setParent $buttonSet;

						string $gNexSlideFormLayout = `formLayout`;
							string $gNexSlideLabel = `text -align left -h 25
					 			-l (getPluginResource("modelingToolkit", "kTransformConstraints"))
								-ann (getPluginResource("modelingToolkit", "kTransformConstraintAnn"))
								nextranConstLabel`;

				 			global string $gNexSlideButton;
				 			$gNexSlideButton = `iconTextButton
				 				-dcc "dR_toggleSlide"
				 				-w 17 -h 26
								-ann (getPluginResource("modelingToolkit", "kSetTransformContraintType"))
				 				-image ("popupMenuIcon.png") 
				 				-p $gNexSlideFormLayout nextranConstPopupButton`;

				 			global string $gNexSlideText;
							$gNexSlideText = `textField -ed false -h 25 -p $gNexSlideFormLayout
								-ann (getPluginResource("modelingToolkit", "kTransformConstraintAnn"))
				 				nextranConstTextField`;
							scriptJob -p $gNexSlideText -e "LiveListChanged" "dR_updateSlideField";
				 			$menu = `popupMenu -b 1 -p $gNexSlideButton`;
				 				menu -e -pmc ("dR_buildSlideMenu " + $menu) $menu;
				 			$menu2 = `popupMenu -b 2 -p $gNexSlideButton`;
				 				menu -e -pmc "dR_toggleSlide" $menu2;

					 		// Layout the above form
					 		formLayout -e
					 			-attachForm 	$gNexSlideLabel 	left	0
					 			-attachNone 	$gNexSlideLabel 	right
					 			-attachForm 	$gNexSlideLabel 	bottom	0
					 			-attachNone 	$gNexSlideLabel 	top
					 			-attachControl	$gNexSlideButton	left	2	$gNexSlideLabel
					 			-attachNone 	$gNexSlideButton	right
					 			-attachForm 	$gNexSlideButton	bottom	0
					 			-attachNone 	$gNexSlideButton	top
					 			-attachControl	$gNexSlideText	left	0	$gNexSlideButton
					 			-attachForm		$gNexSlideText	bottom	0
					 			-attachForm		$gNexSlideText	right	0
					 			-attachNone		$gNexSlideText	top
					 			$gNexSlideFormLayout;				
						setParent $buttonSet;

						string $selCnsFormLayout = `formLayout`;
							string $gNexSelCnsLabel = `text -align left
				 				-h 25
					 			-l (getPluginResource("modelingToolkit", "kSelectionConstraints"))
								-ann (getPluginResource("modelingToolkit", "kSetSelectionConstraintType"))
								nexselConstLabel`;

				 			string $gNexSelCnsButton = `iconTextButton
				 				-dcc ""
				 				-w 17 -h 26
								-ann (getPluginResource("modelingToolkit", "kSetSelectionConstraintType"))
				 				-image ("popupMenuIcon.png") 
				 				-p $selCnsFormLayout nexselConstPopupButton`;

							global string $gNexPickSelConstText;
							$gNexPickSelConstText = `textField -ed false -w 85 -h 25 -ebg 0 -p $selCnsFormLayout
								-tx (getPluginResource("modelingToolkit", "kOff"))
								-ann (getPluginResource("modelingToolkit", "kSetSelectionConstraintType"))
								nexselConstTextField`;
							scriptJob -p $gNexPickSelConstText -e "selectionConstraintsChanged" "dR_updateSelConstField";
				 			string $menu = `popupMenu -b 1 -p $gNexSelCnsButton`;
				 				menu -e -pmc ("dR_buildSelConstMenu " + $menu) $menu;
				 			string $menu2 = `popupMenu -b 2 -p $gNexSelCnsButton`;
				 				menu -e -pmc "dR_toggleSelConst" $menu2;

							float $angleVal = `polySelectConstraint -q -at`;
							global string $gSelConstField;
							$gSelConstField = dR_addModeBtn(`floatField
								-pre 0 -min 0 -max 180
								-w 25 -h 26 -step 1
								-p $selCnsFormLayout
								-cc "dR_setSelConstAngle #1"
								-v $angleVal
								-ann (getPluginResource("modelingToolkit", "kSetSelectionConstraintType")) 
								nexselConstField`);
							scriptJob -p $gSelConstField -event "selectionConstraintsChanged" "dR_updateSelConstAngle";

					 		// Layout the above form
					 		formLayout -e
					 			-attachForm 	$gNexSelCnsLabel 		left	0
					 			-attachNone 	$gNexSelCnsLabel 		right
					 			-attachForm 	$gNexSelCnsLabel 		bottom	0
					 			-attachNone 	$gNexSelCnsLabel 		top
					 			-attachControl	$gNexSelCnsButton		left	2	$gNexSelCnsLabel
					 			-attachNone 	$gNexSelCnsButton		right
					 			-attachForm 	$gNexSelCnsButton		bottom	0
					 			-attachNone 	$gNexSelCnsButton		top
					 			-attachControl	$gNexPickSelConstText	left	0	$gNexSelCnsButton
					 			-attachForm		$gNexPickSelConstText	bottom	0
					 			-attachNone		$gNexPickSelConstText	right
					 			-attachNone		$gNexPickSelConstText	top
					 			-attachControl	$gSelConstField			left	0	$gNexPickSelConstText
					 			-attachForm		$gSelConstField			bottom	0
					 			-attachForm		$gSelConstField			right	0
					 			-attachNone		$gSelConstField			top
					 			$selCnsFormLayout;					
						setParent $buttonSet;

					formLayout -e
						-attachForm		$checkBoxes				"top"		0
						-attachForm		$checkBoxes				"left"		0
						-attachNone		$checkBoxes				"bottom"
						-attachForm		$checkBoxes				"right"		0
						-attachControl	$highlightBackfaces		"top"		2		$checkBoxes
						-attachForm		$highlightBackfaces		"left"		10
						-attachNone		$highlightBackfaces		"bottom"
						-attachNone		$highlightBackfaces		"right"
						-attachControl	$highlightClosest		"top"		2		$highlightBackfaces
						-attachForm		$highlightClosest		"left"		10
						-attachNone		$highlightClosest		"bottom"
						-attachNone		$highlightClosest		"right"
						-attachControl	$camSelFormLayout		"top"		8		$highlightClosest
						-attachForm		$camSelFormLayout		"left"		6
						-attachNone		$camSelFormLayout		"bottom"
						-attachForm		$camSelFormLayout		"right"		0
						-attachControl	$symFormLayout			"top"		2		$camSelFormLayout
						-attachForm		$symFormLayout			"left"		6
						-attachNone		$symFormLayout			"bottom"
						-attachForm		$symFormLayout			"right"		0
						-attachControl	$selCnsFormLayout		"top"		2		$symFormLayout
						-attachForm		$selCnsFormLayout		"left"		6
						-attachNone		$selCnsFormLayout		"bottom"
						-attachForm		$selCnsFormLayout		"right"		0
						-attachControl	$gNexSlideFormLayout		"top"		2		$selCnsFormLayout
						-attachForm		$gNexSlideFormLayout		"left"		6
						-attachNone		$gNexSlideFormLayout		"bottom"
						-attachForm		$gNexSlideFormLayout		"right"		0
						-attachControl	$softSelFrame			"top"		8		$gNexSlideFormLayout
						-attachForm		$softSelFrame			"left"		6
						-attachForm		$softSelFrame			"bottom"	0
						-attachForm		$softSelFrame			"right"		0	
						$buttonSet;

				string $extraOpts = (uiRes("m_drInit.kExtraOpts"));

				string $meshEditFrame = `frameLayout -p $frmLayout -l (getPluginResource("modelingToolkit", "kMeshEditing")) 
					-mw 0 -mh 0 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
					string $meshEditLayout = `formLayout -p $meshEditFrame -numberOfDivisions 2`;
						string $combineBtn = `iconTextButton
								-st "iconAndTextHorizontal"
								-i (dR_xpmToPng("polyUnite24.xpm"))
								-l (getPluginResource("modelingToolkit", "kCombine"))
								-ann (getPluginResource("modelingToolkit", "kCombineAnn") + "\n" + $extraOpts)
								-flat 0
								-c ("mtkBtnCmd( \"CombinePolygons\" )")
								-rpt 1
								-height 26 -p $meshEditLayout nexcombineBtn`;
						string $separateBtn = `iconTextButton
						 		-st "iconAndTextHorizontal"
						 		-i (dR_xpmToPng("polySeparate24.xpm"))
						 		-l (getPluginResource("modelingToolkit", "kSeparate"))
						 		-ann (getPluginResource("modelingToolkit", "kSeparateAnn"))
						 		-flat 0
						 		-c "SeparatePolygon"
						 		-rpt 1
						 		-height 26 -p $meshEditLayout nexseparateBtn`;
						string $smoothBtn = `iconTextButton
								-st "iconAndTextHorizontal"
								-i (dR_xpmToPng("polySmooth24.xpm"))
								-l (getPluginResource("modelingToolkit", "kSmooth"))
								-ann (getPluginResource("modelingToolkit", "kSmoothAnn") + "\n" + $extraOpts)
								-flat 0
								-c ("mtkBtnCmd( \"SmoothPolygon\" )")
								-rpt 1
								-height 26 -p $meshEditLayout nexsmoothBtn`;
						string $booleanBtn = `iconTextButton
								-st "iconAndTextHorizontal"
								-i (dR_xpmToPng("polyBooleansUnion24.xpm"))
								-l (getPluginResource("modelingToolkit", "kBoolean"))
								-ann (getPluginResource("modelingToolkit", "kBooleanAnn") + "\n" + $extraOpts)
								-flat 0
								-c ("mtkBtnCmd( \"PolygonBooleanUnion\" )")
								-rpt 1
								-height 26 -p $meshEditLayout nexbooleanBtn`;

				string $updateIndex;
				// will reset the text colour to white as opposed to grey
				for ($updateIndex in { $combineBtn, $separateBtn, $smoothBtn, $booleanBtn }) {
					MTcbButtonOn($meshEditLayout, $updateIndex);
					MTcbButtonOff($meshEditLayout, $updateIndex);
					iconTextButton -e -mw 4 $updateIndex;
				}

				formLayout -edit
					-attachForm		$combineBtn		"top"		2
					-attachForm		$combineBtn		"left"		0
					-attachControl	$combineBtn		"bottom"	2	$smoothBtn
					-attachPosition	$combineBtn		"right"		1	1
					-attachForm		$separateBtn	"top"		2
					-attachPosition	$separateBtn	"left"		1	1
					-attachControl	$separateBtn	"bottom"	2	$booleanBtn
					-attachForm		$separateBtn	"right"		0
					-attachNone		$smoothBtn		"top"
					-attachForm		$smoothBtn		"left"		0
					-attachForm		$smoothBtn		"bottom"	4
					-attachPosition $smoothBtn		"right"		1	1
					-attachNone		$booleanBtn		"top"
					-attachPosition	$booleanBtn		"left"		1	1
					-attachForm		$booleanBtn		"bottom"	4
					-attachForm		$booleanBtn		"right"		0
					$meshEditLayout;

				string $meshCompFrame = `frameLayout -p $frmLayout -l (getPluginResource("modelingToolkit", "kMeshComponents")) 
					-mw 0 -mh 0 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
					string $meshCompLayout = `formLayout -p $meshCompFrame -numberOfDivisions 2`;
						string $extrudeBtn = `iconTextButton
								-st "iconAndTextHorizontal"
								-i (dR_xpmToPng("polyExtrudeFacet24.xpm"))
								-l (getPluginResource("modelingToolkit", "kExtrude"))
								-ann (getPluginResource("modelingToolkit", "kExtrudeAnn") + "\n" + $extraOpts)
								-flat 0
								-c ("mtkBtnCmd( \"PolyExtrude\" )")
								-rpt 1
								-height 26 -p $meshCompLayout nexextrudeBtn`;
						string $bevelBtn = `iconTextButton
						 		-st "iconAndTextHorizontal"
						 		-i (dR_xpmToPng("polyBevel24.xpm"))
						 		-l (getPluginResource("modelingToolkit", "kBevel"))
						 		-ann (getPluginResource("modelingToolkit", "kBevelAnn") + "\n" + $extraOpts)
						 		-flat 0
								-c ("mtkBtnCmd( \"BevelPolygon\" )")
						 		-rpt 1
						 		-height 26 -p $meshCompLayout nexbevelBtn`;
						string $bridgeBtn = `iconTextButton
								-st "iconAndTextHorizontal"
								-i (dR_xpmToPng("polyBridge24.xpm"))
								-l (getPluginResource("modelingToolkit", "kBridge"))
								-ann (getPluginResource("modelingToolkit", "kBridgeAnn") + "\n" + $extraOpts)
								-flat 0
								-c ("mtkBtnCmd2( \"performBridgeOrFill\", \"BridgeEdgeOptions\" )")
								-rpt 1
								-height 26 -p $meshCompLayout nexbridgeBtn`;
						string $addDivBtn = `iconTextButton
								-st "iconAndTextHorizontal"
								-i (dR_xpmToPng("addDivision24.xpm"))
								-l (getPluginResource("modelingToolkit", "kAddDivisions"))
								-ann (getPluginResource("modelingToolkit", "kAddDivisionsAnn") + "\n" + $extraOpts)
								-flat 0
								-c ("mtkBtnCmd( \"SubdividePolygon\" )")
								-rpt 1
								-height 26 -p $meshCompLayout nexaddDivBtn`;

				// will reset the text colour to white as opposed to grey
				for ($updateIndex in { $extrudeBtn, $bevelBtn, $bridgeBtn, $addDivBtn }) {
					MTcbButtonOn($meshCompLayout, $updateIndex);
					MTcbButtonOff($meshCompLayout, $updateIndex);
					iconTextButton -e -mw 4 $updateIndex;
				}

				formLayout -edit
					-attachForm		$extrudeBtn	"top"		2
					-attachForm		$extrudeBtn	"left"		0
					-attachControl	$extrudeBtn	"bottom"	2	$bridgeBtn
					-attachPosition	$extrudeBtn	"right"		1	1
					-attachForm		$bevelBtn	"top"		2
					-attachPosition	$bevelBtn	"left"		1	1
					-attachControl	$bevelBtn	"bottom"	2	$addDivBtn
					-attachForm		$bevelBtn	"right"		0
					-attachNone		$bridgeBtn	"top"
					-attachForm		$bridgeBtn	"left"		0
					-attachForm		$bridgeBtn	"bottom"	4
					-attachPosition $bridgeBtn	"right"		1	1
					-attachNone		$addDivBtn	"top"
					-attachPosition	$addDivBtn	"left"		1	1
					-attachForm		$addDivBtn	"bottom"	4
					-attachForm		$addDivBtn	"right"		0
					$meshCompLayout;

			string $meshToolsFrame = `frameLayout -p $frmLayout -l (getPluginResource("modelingToolkit", "kMeshTools")) 
				-mw 0 -mh 0 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
				string $meshToolsLayout = `formLayout -p $meshToolsFrame -numberOfDivisions 2`;
					string $cutBtn = dR_addModeBtn(`iconTextButton
							-st "iconAndTextHorizontal"
							-i (dR_xpmToPng("multiCut24_NEX.xpm"))
							-l (getPluginResource("modelingToolkit", "kMultiCut"))
							-ann (getPluginResource("modelingToolkit", "kMultiCutAnn"))
							-flat 0
							-c "dR_multiCutTool"
							-rpt 0
							-height 26 -p $meshToolsLayout nexcutBtn`);
					string $weldBtn = dR_addModeBtn(`iconTextButton
							-st "iconAndTextHorizontal"
							-i (dR_xpmToPng("weld24_NEX.xpm"))
							-l (getPluginResource("modelingToolkit", "kTargetWeld"))
							-ann (getPluginResource("modelingToolkit", "kTargetWeldAnn"))
							-flat 0
							-c "dR_targetWeldTool"
							-height 26 -p $meshToolsLayout nexweldBtn`);
					string $connectBtn = dR_addModeBtn(`iconTextButton
							-st "iconAndTextHorizontal"
							-i (dR_xpmToPng("connect24_NEX.xpm"))
							-l (getPluginResource("modelingToolkit", "kConnect"))
							-ann (getPluginResource("modelingToolkit", "kConnectAnn"))
							-flat 0
							-c "dR_connectTool"
							-rpt 0
							-height 26 -p $meshToolsLayout nexconnectBtn`);
					string $quaDrawBtn = dR_addModeBtn(`iconTextButton
							-st "iconAndTextHorizontal"
							-i (dR_xpmToPng("quadDraw24_NEX.xpm"))
							-l (getPluginResource("modelingToolkit", "kQuadDraw"))
							-ann (getPluginResource("modelingToolkit", "kQuadDrawAnn"))
							-flat 0
							-c "dR_quadDrawTool"
							-height 26 -p $meshToolsLayout nexquaDrawBtn`);

			// will reset the text colour to white as opposed to grey
			for ($updateIndex in { $cutBtn, $weldBtn, $connectBtn, $quaDrawBtn }) {
				MTcbButtonOn($meshToolsLayout, $updateIndex);
				MTcbButtonOff($meshToolsLayout, $updateIndex);
				iconTextButton -e -mw 4 $updateIndex;
			}
			formLayout -edit
				-attachForm		$cutBtn		"top"		2
				-attachForm		$cutBtn		"left"		0
				-attachControl	$cutBtn		"bottom"	2	$connectBtn
				-attachPosition	$cutBtn		"right"		1	1
				-attachForm		$weldBtn	"top"		2
				-attachPosition	$weldBtn	"left"		1	1
				-attachControl	$weldBtn	"bottom"	2	$quaDrawBtn
				-attachForm		$weldBtn	"right"		0
				-attachNone		$connectBtn	"top"
				-attachForm		$connectBtn	"left"		0
				-attachForm		$connectBtn	"bottom"	4
				-attachPosition $connectBtn	"right"		1	1
				-attachNone		$quaDrawBtn	"top"
				-attachPosition	$quaDrawBtn	"left"		1	1
				-attachForm		$quaDrawBtn	"bottom"	4
				-attachForm		$quaDrawBtn	"right"		0
				$meshToolsLayout;

			formLayout -edit
				-attachForm  	$buttonSet 				"top" 		0
				-attachForm  	$buttonSet 				"left" 		0
				-attachForm  	$buttonSet 				"right"		0
				-attachControl  $meshEditFrame  		"top" 		8 $buttonSet
				-attachForm  	$meshEditFrame  		"left"		0
				-attachForm  	$meshEditFrame  		"right"		0
				-attachControl  $meshCompFrame  		"top" 		4 $meshEditFrame
				-attachForm  	$meshCompFrame  		"left"		0
				-attachForm  	$meshCompFrame  		"right"		0
				-attachControl  $meshToolsFrame 		"top" 		4 $meshCompFrame
				-attachForm  	$meshToolsFrame 		"left"		0
				-attachForm  	$meshToolsFrame 		"right"		0
				$frmLayout;

			global string $gDrOptionPanel, $gDrTFormLayout, $gLocksFrame, $gTransformFrame, $gDrTransformFrame, $gDrQuaDrawPanel, $gDrConnectFormLayout, $gDrBridgeFormLayout, $gDrVertExtrudeFormLayout, $gDrVertChamferFormLayout, $gDrFaceExtrudeFormLayout, $gDrBevelFormLayout, $gDrCutFormLayout, $gDrTargetWeldFormLayout;
			$gDrOptionPanel = `formLayout -p $gDRTopPane`;
				{
					$gDrConnectFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $connectFrame = `frameLayout -p $gDrConnectFormLayout -l (getPluginResource("modelingToolkit", "kConnectOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $connectFormLayout = `formLayout -p $connectFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
								global string $gDrSlideRB, $gDrSegRadio, $gDrPinchRadio, $gDrSlideField, $gDrConnSegField, $gDrConnPinchField;
								$gDrSlideRB = dR_addModeBtn(`radioButtonGrp
									-nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kSlide"))
									-on1 ("nexOpt -e connectCurLmbMap slide; refresh -f;")
									nexConnectSlide`);
								$gDrSlideField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kSlide")) -cc "nexCtx -e -mv connect slide #1" -step 0.01 -pre 2 -v 0.5 -min 0.01 -max 0.99 -height 22 -width 43 nexConnectSlideField`);
								$gDrSegRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kSegments"))
									-on1 ("nexOpt -e connectCurLmbMap segments; refresh -f;")
									-shareCollection $gDrSlideRB
									nexConnectSegments`);
								$gDrConnSegField = dR_addModeBtn(`intField -ann (getPluginResource("modelingToolkit", "kSegments")) -cc "nexCtx -e -mv connect segments #1" -step 1 -v 1 -min 1 -max 50 -height 22 -width 43 nexConnectSegmentsField`);
								$gDrPinchRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kPinch"))
									-on1 ("nexOpt -e connectCurLmbMap pinch; refresh -f;")
									-shareCollection $gDrSlideRB
									nexConnectPinch`);
								$gDrConnPinchField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kPinch")) -cc "nexCtx -e -mv connect pinch #1" -step 0.01 -pre 2 -v 1 -min -0.99 -max 10.0 -height 22 -width 43 nexConnectPinchField`);
								string $shortcutFrame = `frameLayout -p $connectFormLayout -l (getPluginResource("modelingToolkit", "kShortcuts")) 
									-mw 0 -mh 4 -cll true -cl 1 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;

								rowColumnLayout -numberOfColumns 2 -cw 1 110 -cw 2 110;

									text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kConnectShortcut0")) -ww true;

									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($shift + "+" + $lmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kConnectShortcut1")) -ww true;

									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $lmb + ":") -height 50;
									text -align "left" -label (getPluginResource("modelingToolkit", "kConnectShortcut2")) -ww true;
									
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($mmb + ":") -height 50;
									text -align "left" -label (getPluginResource("modelingToolkit", "kConnectShortcut3")) -ww true;
									
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $rmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kConnectShortcut4")) -ww true;
								setParent ..;

								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "mtk_initToolOptions(1, \"connect\"); nexCtx -resetManip; dR_updateCommandPanel;" -p $connectFormLayout`;
								formLayout -e 
									-attachForm $helpBtn "right" 2

									-attachForm $gDrSlideRB "left" 0
									-attachForm $gDrSlideRB "top" 2

									-attachControl $gDrSlideField "left" 30 $gDrSlideRB
									-attachForm $gDrSlideField "top" 0

									-attachForm $gDrSegRadio "left" 0
									-attachControl $gDrSegRadio "top" 2 $gDrSlideRB

									-attachOppositeControl $gDrConnSegField "left" 0 $gDrSlideField
									-attachControl $gDrConnSegField "top" 0 $gDrSlideField

									-attachForm $gDrPinchRadio "left" 0
									-attachControl $gDrPinchRadio "top" 2 $gDrSegRadio

									-attachOppositeControl $gDrConnPinchField "left" 0 $gDrConnSegField
									-attachControl $gDrConnPinchField "top" 0 $gDrConnSegField

									-attachControl $resetButton "top" 8 $gDrConnPinchField
									-attachForm $resetButton "left" 2
									-attachForm $resetButton "right" 2

									-attachControl $shortcutFrame "top" 4 $resetButton
									-attachForm $shortcutFrame "left" 2
									-attachForm $shortcutFrame "right" 2

									$connectFormLayout;
						formLayout -edit
							-attachForm	$connectFrame "top"	0
							-attachForm	$connectFrame "left"	0
							-attachForm	$connectFrame "right"	0
							$gDrConnectFormLayout;
				}
				{
					$gDrBridgeFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $bridgeFrame = `frameLayout -p $gDrBridgeFormLayout -l (getPluginResource("modelingToolkit", "kBridgeOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $bridgeFormLayout = `formLayout -p $bridgeFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
								$divisionsRB = dR_addModeBtn(`radioButtonGrp
									-nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kDivisions"))
									-on1 ("nexOpt -e bridgeCurLmbMap divisions; refresh -f;")
									nexBridgeDivisions`);
								$divisionsField = dR_addModeBtn(`intField -ann (getPluginResource("modelingToolkit", "kDivisions")) -cc "nexCtx -e -mv bridge divisions #1" -step 1 -v 1 -min 0 -max 25 -height 22 -width 43 nexBridgeDivisionsField`);
								$taperRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kTaper"))
									-on1 ("nexOpt -e bridgeCurLmbMap taper; refresh -f;")
									-shareCollection $divisionsRB
									nexBridgeTaper`);
								$taperField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kTaper")) -cc "nexCtx -e -mv bridge taper #1" -step 0.01 -pre 2 -v 1 -min 0 -max 15 -height 22 -width 43 nexBridgeTaperField`);
								$twistRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kTwist"))
									-on1 ("nexOpt -e bridgeCurLmbMap twist; refresh -f;")
									-shareCollection $divisionsRB
									nexBridgeTwist`);
								$twistField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kTwist")) -cc "nexCtx -e -mv bridge twist #1" -step 0.01 -pre 2 -v 1 -min -180 -max 180 -height 22 -width 43 nexBridgeTwistField`);
								$offsetRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kOffset"))
									-on1 ("nexOpt -e bridgeCurLmbMap offset; refresh -f;")
									-shareCollection $divisionsRB
									nexBridgeOffset`);
								$offsetField = dR_addModeBtn(`intField -ann (getPluginResource("modelingToolkit", "kOffset")) -cc "nexCtx -e -mv bridge offset #1" -step 1 -v 1 -min 0 -max 10 -height 22 -width 43 nexBridgeOffsetField`);
								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "nexCtx -resetManip; dR_updateCommandPanel;"`;
							formLayout -e 
								-attachForm $helpBtn "right" 2
								-attachForm $divisionsRB "left" 0
								-attachForm $divisionsRB "top" 2
								-attachControl $divisionsField "left" 10 $divisionsRB
								-attachForm $divisionsField "top" 0
								-attachForm $taperRadio "left" 0
								-attachControl $taperRadio "top" 2 $divisionsRB
								-attachOppositeControl $taperField "left" 0 $divisionsField
								-attachControl $taperField "top" 0 $divisionsField
								-attachForm $twistRadio "left" 0
								-attachControl $twistRadio "top" 2 $taperRadio
								-attachOppositeControl $twistField "left" 0 $taperField
								-attachControl $twistField "top" 0 $taperField
								-attachForm $offsetRadio "left" 0
								-attachControl $offsetRadio "top" 2 $twistRadio
								-attachOppositeControl $offsetField "left" 0 $twistField
								-attachControl $offsetField "top" 0 $twistField
								-attachControl $resetButton "top" 8 $offsetField
								-attachForm $resetButton "left" 40
								$bridgeFormLayout;
							formLayout -edit
								-attachForm	$bridgeFrame "top"	0
								-attachForm	$bridgeFrame "left"	0
								-attachForm	$bridgeFrame "right"	0
								$gDrBridgeFormLayout;
				}
				{
					$gDrVertExtrudeFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $vertExtrudeFrame = `frameLayout -p $gDrVertExtrudeFormLayout -l (getPluginResource("modelingToolkit", "kVertexExtrudeOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $vertExtrudeFormLayout = `formLayout -p $vertExtrudeFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
								$divisionsRB = dR_addModeBtn(`radioButtonGrp
									-nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kDivisions"))
									-on1 ("nexOpt -e extrudeVertexCurLmbMap divisions; refresh -f;")
									nexVertExtrudeDivisions`);
								$divisionsField = dR_addModeBtn(`intField -ann (getPluginResource("modelingToolkit", "kDivisions")) -cc "nexCtx -e -mv vertExtrude divisions #1" -step 1 -v 1 -min 0 -max 10 -height 22 -width 43 nexVertExtrudeDivisionsField`);
								$widthRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kWidth"))
									-on1 ("nexOpt -e extrudeVertexCurLmbMap width; refresh -f;")
									-shareCollection $divisionsRB
									nexVertExtrudeWidth`);
								$widthField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kWidth")) -cc "nexCtx -e -mv vertExtrude width #1" -step 0.01 -pre 2 -v 1 -min 0 -max 15 -height 22 -width 43 nexVertExtrudeWidthField`);
								$heightRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kHeight"))
									-on1 ("nexOpt -e extrudeVertexCurLmbMap length; refresh -f;")
									-shareCollection $divisionsRB
									nexVertExtrudeHeight`);
								$heightField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kHeight")) -cc "nexCtx -e -mv vertExtrude height #1" -step 0.01 -pre 2 -v 1 -min 0 -max 15 -height 22 -width 43 nexVertExtrudeHeightField`);
								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "nexCtx -resetManip; dR_updateCommandPanel;"`;
								formLayout -e 
									-attachForm $helpBtn "right" 2
									-attachForm $divisionsRB "left" 0
									-attachForm $divisionsRB "top" 2
									-attachControl $divisionsField "left" 10 $divisionsRB
									-attachForm $divisionsField "top" 0
									-attachForm $widthRadio "left" 0
									-attachControl $widthRadio "top" 2 $divisionsRB
									-attachOppositeControl $widthField "left" 0 $divisionsField
									-attachControl $widthField "top" 0 $divisionsField
									-attachForm $heightRadio "left" 0
									-attachControl $heightRadio "top" 2 $widthRadio
									-attachOppositeControl $heightField "left" 0 $widthField
									-attachControl $heightField "top" 0 $widthField
									-attachControl $resetButton "top" 8 $heightField
									-attachForm $resetButton "left" 40
									$vertExtrudeFormLayout;
							formLayout -edit
								-attachForm	$vertExtrudeFrame "top"	0
								-attachForm	$vertExtrudeFrame "left"	0
								-attachForm	$vertExtrudeFrame "right"	0
								$gDrVertExtrudeFormLayout;
				}
				{
					$gDrVertChamferFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $vertChamferFrame = `frameLayout -p $gDrVertChamferFormLayout -l (getPluginResource("modelingToolkit", "kVertexChamferOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $vertChamferFormLayout = `formLayout -p $vertChamferFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
								$widthRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-sl 1
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kWidth"))
									-on1 ("nexOpt -e extrudeVertexCurLmbMap width; refresh -f;")
									nexVertExtrudeWidth`);
								$widthField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kWidth")) -cc "nexCtx -e -mv vertExtrude width #1" -step 0.01 -pre 2 -v 1 -min 0 -max 15 -height 22 -width 43 nexVertExtrudeWidthField`);
								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "nexCtx -resetManip; dR_updateCommandPanel;"`;
								formLayout -e 
									-attachForm $helpBtn "right" 2
									-attachForm $widthRadio "left" 0
									-attachForm $widthRadio "top" 2
									-attachControl $widthField "left" 10 $widthRadio
									-attachForm $widthField "top" 0
									-attachControl $resetButton "top" 8 $widthField
									-attachForm $resetButton "left" 40
									$vertChamferFormLayout;
							formLayout -edit
								-attachForm	$vertChamferFrame "top"	0
								-attachForm	$vertChamferFrame "left"	0
								-attachForm	$vertChamferFrame "right"	0
								$gDrVertChamferFormLayout;
				}
				{
					$gDrFaceExtrudeFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $faceExtrudeFrame = `frameLayout -p $gDrFaceExtrudeFormLayout -l (getPluginResource("modelingToolkit", "kFaceExtrudeOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $faceExtrudeFormLayout = `formLayout -p $faceExtrudeFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
								$divisionsRB = dR_addModeBtn(`radioButtonGrp
									-nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kDivisions"))
									-on1 ("nexOpt -e extrudeFaceCurLmbMap divisions; refresh -f;")
									nexFaceExtrudeDivisions`);
								$divisionsField = dR_addModeBtn(`intField -ann (getPluginResource("modelingToolkit", "kDivisions")) -cc "nexCtx -e -mv faceextrude divisions #1" -step 1 -v 1 -min 0 -max 50 -height 22 -width 43 nexFaceExtrudeDivisionsField`);
								$localzRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kLocalZ"))
									-on1 ("nexOpt -e extrudeFaceCurLmbMap localz; refresh -f;")
									-shareCollection $divisionsRB
									nexFaceExtrudeLocalZ`);
								$localzField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kLocalZ")) -cc "nexCtx -e -mv faceextrude localz #1" -step 0.01 -pre 2 -v 1 -height 22 -width 43 nexFaceExtrudeLocalZField`);
								$offsetRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kOffset"))
									-on1 ("nexOpt -e extrudeFaceCurLmbMap offset; refresh -f;")
									-shareCollection $divisionsRB
									nexFaceExtrudeOffset`);
								$offsetField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kOffset")) -cc "nexCtx -e -mv faceextrude offset #1" -step 0.01 -pre 2 -v 1 -height 22 -width 43 nexFaceExtrudeOffsetField`);
								string $keepFacesTogether = dR_addModeBtn(`checkBoxGrp -ncb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kKeepFacesTogether"))
									-cc ("nexCtx -e -kft #1; refresh -f")
									nexFaceExtrudeKeepFacesTogether`);
								checkBoxGrp -e
									-value1 `nexCtx -q -kft`
									nexFaceExtrudeKeepFacesTogether;
								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "nexCtx -resetManip; dR_updateCommandPanel;"`;
								formLayout -e 
									-attachForm $helpBtn "right" 2
									-attachForm $divisionsRB "left" 0
									-attachForm $divisionsRB "top" 2
									-attachControl $divisionsField "left" 10 $divisionsRB
									-attachForm $divisionsField "top" 0
									-attachForm $localzRadio "left" 0
									-attachControl $localzRadio "top" 2 $divisionsRB
									-attachOppositeControl $localzField "left" 0 $divisionsField
									-attachControl $localzField "top" 0 $divisionsField
									-attachForm $offsetRadio "left" 0
									-attachControl $offsetRadio "top" 2 $localzRadio
									-attachOppositeControl $offsetField "left" 0 $localzField
									-attachControl $offsetField "top" 0 $localzField
									-attachForm $keepFacesTogether "left" 0 
									-attachControl $keepFacesTogether "top" 0 $offsetField
									-attachControl $resetButton "top" 8 $keepFacesTogether
									-attachForm $resetButton "left" 40
									$faceExtrudeFormLayout;
							formLayout -edit
								-attachForm	$faceExtrudeFrame "top"	0
								-attachForm	$faceExtrudeFrame "left"	0
								-attachForm	$faceExtrudeFrame "right"	0
								$gDrFaceExtrudeFormLayout;
				}
				{
					$gDrBevelFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $bevelFrame = `frameLayout -p $gDrBevelFormLayout -l (getPluginResource("modelingToolkit", "kBevelOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $bevelFormLayout = `formLayout -p $bevelFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
								$divisionsRB = dR_addModeBtn(`radioButtonGrp
									-nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kSegments"))
									-on1 ("nexOpt -e polyBevelCurLmbMap segments; refresh -f;")
									nexBevelDivisions`);
								$divisionsField = dR_addModeBtn(`intField -ann (getPluginResource("modelingToolkit", "kSegments")) -cc "nexCtx -e -mv bevel segments #1" -step 1 -v 1 -min 1 -max 100 -height 22 -width 43 nexBevelDivisionsField`);
								$offsetRadio = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kOffsetFractional"))
									-on1 ("nexOpt -e polyBevelCurLmbMap offset; refresh -f;")
									-shareCollection $divisionsRB
									nexBevelOffset`);
								$offsetField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kOffsetFractional")) -cc "nexCtx -e -mv bevel fraction #1" -step 0.01 -pre 2 -v 1 -height 22 -width 43 nexBevelOffsetField`);
								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "nexCtx -resetManip; dR_updateCommandPanel;"`;
								formLayout -e 
									-attachForm $helpBtn "right" 2
									-attachForm $divisionsRB "left" 0
									-attachForm $divisionsRB "top" 2
									-attachControl $divisionsField "left" 40 $divisionsRB
									-attachForm $divisionsField "top" 0
									-attachForm $offsetRadio "left" 0
									-attachControl $offsetRadio "top" 2 $divisionsRB
									-attachOppositeControl $offsetField "left" 0 $divisionsField
									-attachControl $offsetField "top" 0 $divisionsField
									-attachControl $resetButton "top" 8 $offsetField
									-attachForm $resetButton "left" 40
									$bevelFormLayout;
							formLayout -edit
								-attachForm	$bevelFrame "top"	0
								-attachForm	$bevelFrame "left"	0
								-attachForm	$bevelFrame "right"	0
								$gDrBevelFormLayout;
				}
				{
					$gDrCutFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $generalCutFrame = `frameLayout -p $gDrCutFormLayout -l (getPluginResource("modelingToolkit", "kMultiCutOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $generalCutFormLayout = `formLayout -p $generalCutFrame`;
								$helpBtn = `button -l "?" -c "dR_ctxHelp" -width 16 -p $generalCutFormLayout`;
								$snapLabel = dR_addModeBtn(`text -label (getPluginResource("modelingToolkit", "kSnapStepLabel")) -width 65 -p $generalCutFormLayout`);
								$snapAngle = `nexOpt -q cutSnapAngle`;
								
								$snapField = dR_addModeBtn(`intSliderGrp
									-min 1 -max 90 -fieldMinValue 1 -fieldMaxValue 90 -step 1 -field true
									-ann (getPluginResource("modelingToolkit", "kSnapPercent"))
								    -cw2 30 76 -v $snapAngle
									-cc "nexOpt -e cutSnapAngle #1" -dc "nexOpt -e cutSnapAngle #1"
									nexSnapPercent`);

								string $cutFrame = `frameLayout -p $generalCutFormLayout -l (getPluginResource("modelingToolkit", "kCutOptions")) 
									-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
									string $cutFormLayout = `formLayout -p $cutFrame`;
										string $smoothingLabel = dR_addModeBtn(`text -label (getPluginResource("modelingToolkit", "kSmoothingAngle")) -p $cutFormLayout`);
										$smoothingAngle = `nexOpt -q cutSmoothingAngle`;
										string $smoothingIntSlider = dR_addModeBtn(`intSliderGrp
											-min 0 -max 180 -fieldMinValue 0 -fieldMaxValue 180 -step 1 -field true
											-ann (getPluginResource("modelingToolkit", "kSmoothingAngle"))
											-cw2 41 1 -v $smoothingAngle
											-cc "nexOpt -e cutSmoothingAngle #1" -dc "nexOpt -e cutSmoothingAngle #1"
											-p $cutFormLayout
											nexSmoothingIntSlider`);

										int $useEdgeFlow = `nexOpt -q useEdgeFlow`;
										int $live = `dR_liveSurfaceActive`;
										string $edgeFlowChk = dR_addModeBtn(`checkBoxGrp
											-ncb 1 -l "" -height 24 -width 75 -cw2 1 60
											-l1 (getPluginResource("modelingToolkit", "kEdgeFlow"))
											-ann (getPluginResource("modelingToolkit", "kEdgeFlowAnn"))
											-cc "nexOpt -e useEdgeFlow #1; floatSliderGrp -e -en #1 nexEdgeFlowFloatField;"
											-p $cutFormLayout
											edgeFlowCheckbox`);
										checkBoxGrp -e -en (!$live) -value1 $useEdgeFlow $edgeFlowChk;

										float $edgeFlowValue = `nexOpt -q edgeFlowValue`;
										string $edgeFlowFloatSlider = dR_addModeBtn(`floatSliderGrp
											-min 0 -max 1 -fieldMinValue -100000000000000 -fieldMaxValue 100000000000000 -step 0.01 -field true
											-ann (getPluginResource("modelingToolkit", "kEdgeFlowAnn"))
											-cw2 41 1 -v $edgeFlowValue
											-cc "nexOpt -e edgeFlowValue #1" -dc "nexOpt -e edgeFlowValue #1"
											-p $cutFormLayout
											nexEdgeFlowFloatField`);
										floatSliderGrp -e -en (!$live && $useEdgeFlow) $edgeFlowFloatSlider;

										string $subdivisionsLabel = dR_addModeBtn(`text -label (getPluginResource("modelingToolkit", "kSubdivisions")) -p $cutFormLayout`);
										$subdivisions = `nexOpt -q cutSubdivisions`;
										string $subdivisionsIntSlider = dR_addModeBtn(`intSliderGrp
											-min 1 -max 10 -fieldMinValue 1 -fieldMaxValue 1000000000 -step 1 -field true
											-ann (getPluginResource("modelingToolkit", "kSubdivisions"))
											-cw2 41 1 -v $subdivisions
											-cc "nexOpt -e cutSubdivisions #1; refresh" -dc "nexOpt -e cutSubdivisions #1; refresh"
											-p $cutFormLayout
											nexSubdivisionsIntSlider`);

									formLayout -edit
										-attachForm $smoothingLabel "left" 6
										-attachForm $smoothingLabel "top" 6
										-attachControl $smoothingIntSlider "left" 5 $smoothingLabel
										-attachForm $smoothingIntSlider "top" 2
										-attachForm $smoothingIntSlider "right" 4
										
										-attachControl $edgeFlowChk "top" 2 $smoothingLabel
										-attachForm $edgeFlowChk "left" 4

										-attachControl $edgeFlowFloatSlider "top" 5 $smoothingLabel
										-attachControl $edgeFlowFloatSlider "left" 12 $edgeFlowChk
										-attachForm $edgeFlowFloatSlider "right" 4

										-attachForm $subdivisionsLabel "left" 6
										-attachControl $subdivisionsLabel "top" 6 $edgeFlowFloatSlider
										-attachControl $subdivisionsIntSlider "left" 5 $subdivisionsLabel
										-attachControl $subdivisionsIntSlider "top" 2 $edgeFlowFloatSlider
										-attachForm $subdivisionsIntSlider "right" 4

										$cutFormLayout;

								string $sliceFrame = `frameLayout -p $generalCutFormLayout -l (getPluginResource("modelingToolkit", "kSliceOptions")) 
									-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
									string $sliceFormLayout = `formLayout -p $sliceFrame`;

										string $sliceLabel = `text -label (getPluginResource("modelingToolkit", "kSliceAlongPlaneLabel")) -p $sliceFormLayout`;

										$YZButton = `button -label (getPluginResource("modelingToolkit", "kYZ")) -width 60 -c "dr_polyCut(0);"`;
										$ZXButton = `button -label (getPluginResource("modelingToolkit", "kZX")) -width 60 -c "dr_polyCut(1);"`;
										$XYButton = `button -label (getPluginResource("modelingToolkit", "kXY")) -width 60 -c "dr_polyCut(2);"`;

										string $sliceIgnoreBackfacesChk = dR_addModeBtn(`checkBoxGrp
											-ncb 1 -l "" -height 22 -width 75 -cw2 1 60
											-l1 (getPluginResource("modelingToolkit", "kSliceIgnoreBackfacesChk"))
											-cc "dR_setSliceMode sliceIgnoreBackfaces #1; dR_updateCommandPanel;"
											-p $sliceFormLayout
											nexSliceIgnoreBackfacesCheckbox`);
										checkBoxGrp -e -value1 `nexOpt -q sliceIgnoreBackfaces` $sliceIgnoreBackfacesChk;

										string $deleteFacesChk = dR_addModeBtn(`checkBoxGrp
											-ncb 1 -l "" -height 22 -width 75 -cw2 1 60
											-l1 (getPluginResource("modelingToolkit", "kDeleteFacesChk"))
											-cc "dR_setSliceMode useDeleteFaces #1; dR_updateCommandPanel;"
											-p $sliceFormLayout
											nexDeleteFacesCheckbox`);
										checkBoxGrp -e -value1 `nexOpt -q useDeleteFaces` $deleteFacesChk;

										int $useExtractFaces = `nexOpt -q useExtractFaces`;
										string $extractFacesChk = dR_addModeBtn(`checkBoxGrp
											-ncb 1 -l "" -height 22 -width 75 -cw2 1 60
											-l1 (getPluginResource("modelingToolkit", "kExtractFacesChk"))
											-cc "dR_setSliceMode useExtractFaces #1; floatFieldGrp -e -en #1 nexExtractFacesFloatGrp; dR_updateCommandPanel;"
											-p $sliceFormLayout
											nexExtractFacesCheckbox`);
										checkBoxGrp -e -en (!$live) -value1 $useExtractFaces $extractFacesChk;

										float $extractFacesX = `nexOpt -q extractFacesX`;
										float $extractFacesY = `nexOpt -q extractFacesY`;
										float $extractFacesZ = `nexOpt -q extractFacesZ`;
										$extractFacesFloatGrp = dR_addModeBtn(`floatFieldGrp
											-label "" -numberOfFields 3 -cw4 1 60 60 60
											-value1 $extractFacesX -value2 $extractFacesY -value3 $extractFacesZ
											-cc "nexOpt -e extractFacesX #1; nexOpt -e extractFacesY #2; nexOpt -e extractFacesZ #3"
											-p $sliceFormLayout 
											nexExtractFacesFloatGrp`);
										floatFieldGrp -e -en (!$live && $useExtractFaces) $extractFacesFloatGrp;

									formLayout -edit
										-attachForm $sliceIgnoreBackfacesChk "top" 4
										-attachForm $sliceIgnoreBackfacesChk "left" 4
										-attachForm $sliceIgnoreBackfacesChk "right" 4

										-attachControl $deleteFacesChk "top" 2 $sliceIgnoreBackfacesChk
										-attachForm $deleteFacesChk "left" 4
										-attachForm $deleteFacesChk "right" 4

										-attachControl $extractFacesChk "top" 2 $deleteFacesChk
										-attachForm $extractFacesChk "left" 4
										-attachForm $extractFacesChk "right" 4

										-attachControl $extractFacesFloatGrp "top" 0 $extractFacesChk
										-attachForm $extractFacesFloatGrp "left" 4

										-attachForm $sliceLabel "left" 6
										-attachControl $sliceLabel "top" 6 $extractFacesFloatGrp
										
										-attachControl $YZButton "top" 2 $sliceLabel
										-attachForm $YZButton "left" 4
										-attachControl $ZXButton "top" 2 $sliceLabel
										-attachControl $ZXButton "left" 6 $YZButton
										-attachControl $XYButton "top" 2 $sliceLabel
										-attachControl $XYButton "left" 6 $ZXButton

										$sliceFormLayout;

								string $colorFrame = `frameLayout -p $generalCutFormLayout -l (getPluginResource("modelingToolkit", "kColorOptions")) 
									-mw 0 -mh 4 -cll true -cl 1 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
									string $colorFormLayout = `formLayout -p $colorFrame`;
										global string $gCutColorLineSlider, $gCutColorVertSlider, $gCutColorEdgeSlider, $gCutColorFaceSlider;

										int $cw1 = 75, $cw2 = 28;
										$gCutColorLineSlider = dR_addModeBtn(`colorSliderGrp
											-label (getPluginResource("modelingToolkit", "kCutClrLineLabel"))
											-rgb 0 0 1 -cw3 $cw1 $cw2 0 nexCutColorLineSlider`);

										$gCutColorVertSlider = dR_addModeBtn(`colorSliderGrp
											-label (getPluginResource("modelingToolkit", "kCutClrVertLabel"))
											-rgb 0 0 1 -cw3 $cw1 $cw2 0 nexCutColorVertSlider`);

										$gCutColorEdgeSlider = dR_addModeBtn(`colorSliderGrp
											-label (getPluginResource("modelingToolkit", "kCutClrEdgeLabel"))
											-rgb 0 0 1 -cw3 $cw1 $cw2 0 nexCutColorEdgeSlider`);

										$gCutColorFaceSlider = dR_addModeBtn(`colorSliderGrp
											-label (getPluginResource("modelingToolkit", "kCutClrFaceLabel"))
											-rgb 0 0 1 -cw3 $cw1 $cw2 0 nexCutColorFaceSlider`);

										dR_resetCutColorSliders();

									formLayout -edit
										-attachForm $gCutColorLineSlider "top" 2
										-attachForm $gCutColorLineSlider "left" 1
										-attachNone $gCutColorLineSlider "bottom"
										-attachNone $gCutColorLineSlider "right"

										-attachForm $gCutColorVertSlider "top" 2
										-attachControl $gCutColorVertSlider "left" 1 $gCutColorLineSlider
										-attachNone $gCutColorVertSlider "bottom"
										-attachNone $gCutColorVertSlider "right"

										-attachControl $gCutColorEdgeSlider "top" 2 $gCutColorLineSlider
										-attachForm $gCutColorEdgeSlider "left" 1
										-attachNone $gCutColorEdgeSlider "bottom"
										-attachNone $gCutColorEdgeSlider "right"

										-attachControl $gCutColorFaceSlider "top" 2 $gCutColorVertSlider
										-attachControl $gCutColorFaceSlider "left" 1 $gCutColorEdgeSlider
										-attachNone $gCutColorFaceSlider "bottom"
										-attachNone $gCutColorFaceSlider "right"
									$colorFormLayout;

									string $liveFrame = nexBuildLiveSurfaceFrame($generalCutFormLayout, "MultiCut");

								string $shortcutFrame = `frameLayout -p $generalCutFormLayout -l (getPluginResource("modelingToolkit", "kShortcuts")) 
									-mw 0 -mh 4 -cll true -cl 1  -width 200 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;

									rowColumnLayout -numberOfColumns 2 -cw 1 115 -cw 2 105;

										text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + ":") -height 30;
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut0")) -ww true;
										separator;separator;
								
										text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $lmb + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut1")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $mmb + ":")  -height 30;
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut2")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut3")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($mmb + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut4")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($mmb + ":") -height 30;
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut5")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label (getPluginResource("modelingToolkit", "kBackOrDelete") + ":")  -height 30;
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut6")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($shift + "+" + $lmb + ":") -height 50;
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut7")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($shift + "+" + $lmb + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut8")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $lmb + ":") -height 50;
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut9")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label (getPluginResource("modelingToolkit", "kSnapToGrid") + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcutSnapToGrid")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label (getPluginResource("modelingToolkit", "kSnapToPoints") + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcutSnapToPoints")) -ww true;
										separator;separator;

										text -align "left" -font smallBoldLabelFont -ww true -label (getPluginResource("modelingToolkit", "kEnter") + ":");
										text -align "left" -label (getPluginResource("modelingToolkit", "kMultiCutShortcut10")) -ww true;
									
									setParent ..;

								$resetButton = `button
									-label (getPluginResource("modelingToolkit", "kResetSettings"))
									-c ("mtk_initToolOptions(1, \"cut\"); nexCtx -resetManip; dR_updateCommandPanel; " +
										"floatFieldGrp -e -en 0 nexExtractFacesFloatGrp; floatSliderGrp -e -en 0 nexEdgeFlowFloatField; " +
										"dR_resetCutColorSliders")
									-p $generalCutFormLayout`;

								formLayout -edit
									-attachForm $snapLabel "left" 6
									-attachForm $snapLabel "top" 8
									-attachControl $snapField "left" 6 $snapLabel
									-attachForm $snapField "top" 4

									-attachForm $helpBtn "top" 2
									-attachForm $helpBtn "right" 4

									-attachControl $cutFrame "top" 8 $snapField
									-attachForm $cutFrame "left" 4
									-attachForm $cutFrame "right" 4
									
									-attachControl $sliceFrame "top" 8 $cutFrame
									-attachForm $sliceFrame "left" 4
									-attachForm $sliceFrame "right" 4

									-attachControl $colorFrame "top" 8 $sliceFrame
									-attachForm $colorFrame "left" 4
									-attachForm $colorFrame "right" 4

									-attachControl $liveFrame "top" 8 $colorFrame
									-attachForm $liveFrame "left" 4
									-attachForm $liveFrame "right" 4

									-attachControl $resetButton "top" 8 $liveFrame
									-attachForm $resetButton "left" 2
									-attachForm $resetButton "right" 2
									
									-attachControl $shortcutFrame "top" 8 $resetButton
									-attachForm $shortcutFrame "left" 2
									-attachForm $shortcutFrame "right" 2

									$generalCutFormLayout;
							formLayout -edit
								-attachForm	$generalCutFrame "top"	0
								-attachForm	$generalCutFrame "left"	0
								-attachForm	$generalCutFrame "right"	0
								$gDrCutFormLayout;
				}
				{
					$gDrTargetWeldFormLayout = `formLayout -m 0 -p $gDrOptionPanel`;
						string $targetWeldFrame = `frameLayout -p $gDrTargetWeldFormLayout -l (getPluginResource("modelingToolkit", "kTargetWeldOptions")) 
							-mw 0 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
							string $targetFormLayout = `formLayout -p $targetWeldFrame`;
								$helpBtn = `button -l "?" -c "showHelp \"ModelingToolkit_weld\""`;
							formLayout -edit
								-attachForm	$targetWeldFrame "top"		0
								-attachForm	$targetWeldFrame "left"		0
								-attachForm	$targetWeldFrame "right"	0
								$gDrTargetWeldFormLayout;

								string $mergeToLabel = dR_addModeBtn(`text -label (getPluginResource("modelingToolkit", "kMergeTo"))`);

								string $mergeToRB = dR_addModeBtn(`radioButtonGrp
									-nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kMergeToTarget"))
									-on1 ("targetWeldCtx -e -mergeToCenter 0 polyMergeVertexContext; refresh -f;")
									nexTargWeldMergeTarget`);

								string $centerRB = dR_addModeBtn(`radioButtonGrp -nrb 1
									-l "" 
									-cw2 1 60
									-l1 (getPluginResource("modelingToolkit", "kMergeToCenter"))
									-on1 ("targetWeldCtx -e -mergeToCenter 1 polyMergeVertexContext; refresh -f;")
									-shareCollection $mergeToRB
									nexTargWeldMergeCenter`);

								string $shortcutFrame = `frameLayout -p $targetFormLayout -l (getPluginResource("modelingToolkit", "kShortcuts")) 
									-mw 0 -mh 4 -cll true -cl 1 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;

								rowColumnLayout -numberOfColumns 2 -cw 1 85 -cw 2 135;
									text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kTargetWeldShortcut0")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kTargetWeldShortcut1")) -ww true;
								setParent ..;

								$resetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c "resetTool polyMergeVertexContext; dR_updateCommandPanel;" -p $targetFormLayout`;

								formLayout -e 
									-attachForm $helpBtn "right" 2

									-attachForm $mergeToLabel "top" 4
									-attachForm $mergeToLabel "left" 10

									-attachControl $mergeToRB "left" 6 $mergeToLabel
									-attachForm $mergeToRB "top" 2

									-attachControl $centerRB "top" 2 $mergeToRB
									-attachControl $centerRB "left" 6 $mergeToLabel

									-attachControl $resetButton "top" 4 $centerRB
									-attachForm $resetButton "left" 2
									-attachForm $resetButton "right" 2

									-attachControl $shortcutFrame "top" 4 $resetButton
									-attachForm $shortcutFrame "left" 2
									-attachForm $shortcutFrame "right" 2

									$targetFormLayout;
				}

				$gDrTFormLayout = `formLayout -m 1 -p $gDrOptionPanel`;
					$gTransformFrame = `frameLayout -l (getPluginResource("modelingToolkit", "kMoveOptions")) 
					-mw 0 -mh 0 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
						string $transFormLayout = `formLayout -nd 100 -h 104`;
							string $transformModeButton = `iconTextButton
										-w 17 -h 26
										-ann (getPluginResource("modelingToolkit", "kSetTransformCoordSpace"))
										-image ("popupMenuIcon.png")
										transformModeButton`;
							string $transformModeText = dR_addModeBtn(`textField
										-ed 0
										-h 26
										-ebg 0
										-ann (getPluginResource("modelingToolkit", "kSetTransformCoordSpace"))
										transformModeText`);
							string $transformModeMenu = `popupMenu -b 1 -p $transformModeButton`;
							menu -e -pmc ("dR_buildTransformModeMenu " + $transformModeMenu) $transformModeMenu;
							string $transformModeMenuMMB = `popupMenu -b 2 -p $transformModeButton`;
							menu -e -pmc ("dR_toggleTransformModeMenu " + $transformModeMenu) $transformModeMenuMMB;
							string $xyzAxis	= dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-c ("dR_setActiveTransformAxis 3")
									-ann (getPluginResource("modelingToolkit", "kXYZAxis"))
									-w 15
									-fla 0
									transformXYZAxis`);
							string $xAxis = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-fn "boldLabelFont"
									-c ("dR_setActiveTransformAxis 0")
									-l (getPluginResource("modelingToolkit", "kX") + ":")
									-ann (getPluginResource("modelingToolkit", "kXAxis"))
									-fla 0
									-h 22
									transformXAxis`);
							string $yAxis = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-fn "boldLabelFont"
									-c ("dR_setActiveTransformAxis 1")
									-l (getPluginResource("modelingToolkit", "kY") + ":")
									-ann (getPluginResource("modelingToolkit", "kYAxis"))
									-fla 0
									-h 22
									transformYAxis`);
							string $zAxis = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-fn "boldLabelFont"
									-c ("dR_setActiveTransformAxis 2")
									-l (getPluginResource("modelingToolkit", "kZ") + ":")
									-ann (getPluginResource("modelingToolkit", "kZAxis"))
									-fla 0
									-h 22
									transformZAxis`);
							string $xField = dR_addModeBtn(`floatField
									-ann (getPluginResource("modelingToolkit", "kXAxis"))
									-dc "" -cc "dR_setTransformValue 0 #1"
									-step 0.01 -pre 2 -height 22 -p $transFormLayout
									transformXField`);
							string $yField = dR_addModeBtn(`floatField
									-ann (getPluginResource("modelingToolkit", "kYAxis"))
									-dc "" -cc "dR_setTransformValue 1 #1"
									-step 0.01 -pre 2 -height 22 -p $transFormLayout
									transformYField`);
							string $zField = dR_addModeBtn(`floatField
									-ann (getPluginResource("modelingToolkit", "kZAxis"))
									-dc "" -cc "dR_setTransformValue 2 #1"
									-step 0.01 -pre 2 -height 22 -p $transFormLayout 
									transformZField`);
							string $pivotBtn = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-c "dR_customPivotTool; dR_updateCommandPanel();"
									-l (getPluginResource("modelingToolkit", "kAdjustPivot"))
									-ann (getPluginResource("modelingToolkit", "kAdjustPivotAnn"))
									-fla 0
									transformPivotBtn`);

							string $xyzInd;
							for ($xyzInd in { $xAxis, $yAxis, $zAxis }) { iconTextButton -e -mw 4 $xyzInd; }

							string $stepSnapLabel = dR_addModeBtn(`text -label (getPluginResource("modelingToolkit", "kStepSnap")) -ann (getPluginResource("modelingToolkit", "kStepSnapAnn"))`);
							string $stepSnapButton = dR_addModeBtn(`iconTextButton -w 17 -h 26 -image ("popupMenuIcon.png") -ann (getPluginResource("modelingToolkit", "kStepSnapAnn"))`);
						  	string $stepSnapText = dR_addModeBtn(`textField -ed false -height 26 -ebg false -ann (getPluginResource("modelingToolkit", "kStepSnapAnn")) stepSnapText`);
							string $stepSnapMenu = `popupMenu -b 1 -p $stepSnapButton`;
							menu -e -pmc ("dR_buildStepSnapMenu " + $stepSnapMenu) $stepSnapMenu;
							string $stepSnapToggle = `popupMenu -b 2 -p $stepSnapButton`;
							menu -e -pmc "dR_toggleTransformStepSnapMode" $stepSnapToggle;
							string $stepSnapStep = dR_addModeBtn(`floatField -dc "" -cc "dR_setTransformStepSnapStep #1" -step 0.01 -pre 2 -height 22 -p $transFormLayout stepSnapStep`);

							formLayout -e
								-attachNone		$transformModeButton			"top"
								-attachForm		$transformModeButton			"left"		4
								-attachControl	$transformModeButton			"bottom"   15		$pivotBtn
								-attachNone		$transformModeButton			"right"
								-attachNone		$transformModeText				"top"
								-attachControl	$transformModeText				"left"		4		$transformModeButton
								-attachControl	$transformModeText				"bottom"   15		$pivotBtn
								-attachPosition	$transformModeText				"right"		8		55
								-attachPosition	$pivotBtn						"top"		9		41
								-attachForm		$pivotBtn						"left"		4
								-attachNone		$pivotBtn						"bottom"
								-attachPosition	$pivotBtn						"right"		8		55
								-attachForm		$xyzAxis						"top"		4
								-attachPosition	$xyzAxis						"left"		0		55
								-attachForm     $xyzAxis						"bottom"   30
								-attachNone		$xyzAxis						"right"
								-attachForm		$xAxis							"top"		4
								-attachControl	$xAxis							"left"		2		$xyzAxis
								-attachControl	$xAxis							"bottom"	2		$yAxis
								-attachNone		$xAxis							"right"
								-attachPosition	$yAxis							"top"		0		27
								-attachControl	$yAxis							"left"		2		$xyzAxis
								-attachControl	$yAxis							"bottom"	2		$zAxis
								-attachNone		$yAxis							"right"
								-attachPosition	$zAxis							"top"		0		50
								-attachControl	$zAxis							"left"		2		$xyzAxis
								-attachNone		$zAxis							"bottom"
								-attachNone		$zAxis							"right"
								-attachForm		$xField							"top"		4
								-attachControl	$xField							"left"		2		$xAxis
								-attachControl	$xField							"bottom"	2		$yField
								-attachForm		$xField							"right"		4
								-attachPosition	$yField							"top"		0		27
								-attachControl	$yField							"left"		2		$yAxis
								-attachControl	$yField							"bottom"	2		$zField
								-attachForm		$yField							"right"		4
								-attachPosition	$zField							"top"		0		50
								-attachControl	$zField							"left"		2		$zAxis
								-attachNone		$zField							"bottom"
								-attachForm		$zField							"right"		4

								-attachControl 	$stepSnapLabel 					"top"	   14 		$zAxis
								-attachForm		$stepSnapLabel					"left"		4
								-attachNone 	$stepSnapLabel				 	"right"
								-attachNone 	$stepSnapLabel					"bottom"
								-attachControl  $stepSnapButton					"top"		8	 	$zAxis
								-attachControl  $stepSnapButton					"left"		2		$stepSnapLabel
								-attachNone		$stepSnapButton					"right"
								-attachNone		$stepSnapButton					"bottom"
								-attachControl  $stepSnapText					"top"		8		$zAxis
								-attachControl  $stepSnapText					"left"		0		$stepSnapButton
								-attachNone     $stepSnapText					"bottom"
								-attachControl	$stepSnapText					"right"		2		$stepSnapStep
								-attachControl  $stepSnapStep					"top"		8		$zAxis
								-attachControl  $stepSnapStep					"left"		2		$zAxis
								-attachNone     $stepSnapStep					"bottom"
								-attachForm     $stepSnapStep					"right"		4

								$transFormLayout;
							setParent $gDrTFormLayout;
							
					$gDrTransformFrame = `frameLayout -l (getPluginResource("modelingToolkit", "kTransformOptions")) 
					-mw 0 -mh 0 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
						string $drTransFormLayout = `formLayout -nd 100 -h 78`;
							string $gNexManipCoordSpaceButton = dR_addModeBtn(`iconTextButton
										-w 17 -h 26
										-ann (getPluginResource("modelingToolkit", "kSetTransformCoordSpace"))
										-image ("popupMenuIcon.png")
										manipCoordSpaceButton`);
							string $gNexManipCoordSpace = dR_addModeBtn(`textField
										-ed 0
										-h 26
										-ebg 0
										-tx (getPluginResource("modelingToolkit", "kWorld"))
										-ann (getPluginResource("modelingToolkit", "kSetTransformCoordSpace"))
										manipCoordSpaceText`);
							string $manipCoordSpaceMenu = `popupMenu -b 1 -p $gNexManipCoordSpaceButton`;
							menu -e -pmo 1 -pmc ("dR_buildManipCoordSpaceMenu " + $manipCoordSpaceMenu) $manipCoordSpaceMenu;
							$xyzAxis	= dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-c ("dR_setActiveAxis " + $gNexHandleXYZ)
									-ann (getPluginResource("modelingToolkit", "kXYZAxis"))
									-w 15
									-fla 0
									nexXYZAxis`);
							$xAxis = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-fn "boldLabelFont"
									-c ("dR_setActiveAxis " + $gNexHandleX)
									-l (getPluginResource("modelingToolkit", "kX") + ":")
									-ann (getPluginResource("modelingToolkit", "kXAxis"))
									-fla 0
									-h 22
									nexXAxis`);
							$yAxis = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-fn "boldLabelFont"
									-c ("dR_setActiveAxis " + $gNexHandleY)
									-l (getPluginResource("modelingToolkit", "kY") + ":")
									-ann (getPluginResource("modelingToolkit", "kYAxis"))
									-fla 0
									-h 22
									nexYAxis`);
							$zAxis = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-fn "boldLabelFont"
									-c ("dR_setActiveAxis " + $gNexHandleZ)
									-l (getPluginResource("modelingToolkit", "kZ") + ":")
									-ann (getPluginResource("modelingToolkit", "kZAxis"))
									-fla 0
									-h 22
									nexZAxis`);
							$xField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kXAxis")) -dc "" -cc "dR_transformFloat x #1" -step 0.01 -pre 2 -v 1 -height 22 -p $drTransFormLayout nexXField`);
							$yField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kYAxis")) -dc "" -cc "dR_transformFloat y #1" -step 0.01 -pre 2 -v 1 -height 22 -p $drTransFormLayout nexYField`);
							$zField = dR_addModeBtn(`floatField -ann (getPluginResource("modelingToolkit", "kZAxis")) -dc "" -cc "dR_transformFloat z #1" -step 0.01 -pre 2 -v 1 -height 22 -p $drTransFormLayout nexZField`);
							$pivotBtn = dR_addModeBtn(`iconTextButton
									-st "textOnly"
									-c "dR_customPivotTool; dR_updateCommandPanel();"
									-l (getPluginResource("modelingToolkit", "kAdjustPivot"))
									-ann (getPluginResource("modelingToolkit", "kAdjustPivotAnn"))
									-fla 0
									nexPivotBtn`);
							for ($xyzInd in { $xAxis, $yAxis, $zAxis }) { iconTextButton -e -mw 4 $xyzInd; }
							formLayout -e
								-attachNone		$gNexManipCoordSpaceButton		"top"
								-attachForm		$gNexManipCoordSpaceButton		"left"		4
								-attachControl	$gNexManipCoordSpaceButton		"bottom"	6		$pivotBtn
								-attachNone		$gNexManipCoordSpaceButton		"right"
								-attachNone		$gNexManipCoordSpace				"top"
								-attachControl	$gNexManipCoordSpace				"left"		4		$gNexManipCoordSpaceButton
								-attachControl	$gNexManipCoordSpace				"bottom"	8		$pivotBtn
								-attachPosition	$gNexManipCoordSpace				"right"		8		50
								-attachPosition	$pivotBtn						"top"		0		55
								-attachForm		$pivotBtn						"left"		4
								-attachNone		$pivotBtn						"bottom"
								-attachPosition	$pivotBtn						"right"		8		50
								-attachForm		$xyzAxis						"top"		4
								-attachPosition	$xyzAxis						"left"		0		50
								-attachForm		$xyzAxis						"bottom"	4
								-attachNone		$xyzAxis						"right"
								-attachForm		$xAxis							"top"		4
								-attachControl	$xAxis							"left"		2		$xyzAxis
								-attachControl	$xAxis							"bottom"	2		$yAxis
								-attachNone		$xAxis							"right"
								-attachPosition	$yAxis							"top"		0		36
								-attachControl	$yAxis							"left"		2		$xyzAxis
								-attachControl	$yAxis							"bottom"	2		$zAxis
								-attachNone		$yAxis							"right"
								-attachPosition	$zAxis							"top"		0		67
								-attachControl	$zAxis							"left"		2		$xyzAxis
								-attachForm		$zAxis							"bottom"	4
								-attachNone		$zAxis							"right"
								-attachForm		$xField							"top"		4
								-attachControl	$xField							"left"		2		$xAxis
								-attachControl	$xField							"bottom"	2		$yField
								-attachForm		$xField							"right"		4
								-attachPosition	$yField							"top"		0		36
								-attachControl	$yField							"left"		2		$yAxis
								-attachControl	$yField							"bottom"	2		$zField
								-attachForm		$yField							"right"		4
								-attachPosition	$zField							"top"		0		67
								-attachControl	$zField							"left"		2		$zAxis
								-attachForm		$zField							"bottom"	4
								-attachForm		$zField							"right"		4
								$drTransFormLayout;
							setParent $gDrTFormLayout;
							
							$gLocksFrame = `frameLayout -l (getPluginResource("modelingToolkit", "kVertexLocking")) 
								-mw 6 -mh 4 -cll true -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
								string $locksFormLayout = `formLayout`;
									string $lockSelBtn = dR_addModeBtn(`button -ann (getPluginResource("modelingToolkit", "kLockSelectedAnn")) -l (getPluginResource("modelingToolkit", "kLockSelected")) -c "dR_vertLockSelected; dR_updateCommandPanel();" -rs false -height 18 nexlockSelBtn`);
									string $selLockedBtn = dR_addModeBtn(`button -ann (getPluginResource("modelingToolkit", "kSelectLockedAnn")) -l (getPluginResource("modelingToolkit", "kSelectLocked")) -c "dR_vertSelectLocked; dR_updateCommandPanel();" -rs false -height 18 nexselLockedBtn`);
									string $unlockAllBtn = dR_addModeBtn(`button -ann (getPluginResource("modelingToolkit", "kUnlockAllAnn")) -l (getPluginResource("modelingToolkit", "kUnlockAll")) -c "dR_vertUnlockAll; dR_updateCommandPanel();" -rs false -height 18 nexunlockAllBtn`);
								frameLayout -e -cl true $gLocksFrame;
							formLayout -e 
								-attachForm $lockSelBtn "left" 0
								-attachForm $lockSelBtn "top" 2
								-attachForm $lockSelBtn "right" 0
								-attachForm $selLockedBtn "left" 0
								-attachForm $selLockedBtn "right" 0
								-attachControl $selLockedBtn "top" 4 $lockSelBtn
								-attachForm $unlockAllBtn "left" 0
								-attachForm $unlockAllBtn "right" 0
								-attachControl $unlockAllBtn "top" 4 $selLockedBtn
								$locksFormLayout;
							formLayout -e
								-attachForm			$gTransformFrame		"top"		0
								-attachForm			$gTransformFrame		"left"		0
								-attachControl		$gTransformFrame		"bottom"	0		$gDrTransformFrame
								-attachForm			$gTransformFrame		"right"		0
								-attachNone			$gDrTransformFrame	"top"
								-attachForm			$gDrTransformFrame	"left"		0
								-attachControl		$gDrTransformFrame	"bottom"	0		$gLocksFrame
								-attachForm			$gDrTransformFrame	"right"		0
								-attachNone			$gLocksFrame			"top"
								-attachForm			$gLocksFrame			"left"		0
								-attachForm			$gLocksFrame			"bottom"	0
								-attachForm			$gLocksFrame			"right"		0
								$gDrTFormLayout;
				
				$gDrQuaDrawPanel = `formLayout -m 0 -p $gDrOptionPanel`;
					string $quaDrawFrame = `frameLayout -lv true -l (getPluginResource("modelingToolkit", "kQuadDrawOptions")) -cll true 
						-mh 2 -mw 0 -p $gDrQuaDrawPanel -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
						string $quaDrawForm = `formLayout -p $quaDrawFrame`;
							string $autoWeldChk = dR_addModeBtn(`checkBoxGrp -ncb 1
								-l "" -height 24 -width 78 -cw2 1 60
								-l1 (getPluginResource("modelingToolkit", "kAutoWeld"))
								-ann (getPluginResource("modelingToolkit", "kAutoWeldAnn"))
								-cc "dR_autoWeldTGL"
								autoWeldCheckbox`);
							checkBoxGrp -e -value1 `nexOpt -q useAutoWeld` $autoWeldChk;

							int $autoWeldTol = `nexOpt -q autoWeldTolerance`;
							string $autoWeldIntField = dR_addModeBtn(`intSliderGrp -min 0 -max 40 -fieldMinValue 0 -fieldMaxValue 40 -step 1 -field true
								-ann (getPluginResource("modelingToolkit", "kAutoWeldToleranceAnn")) -cw2 28 1 -v $autoWeldTol
								-cc "nexOpt -e autoWeldTolerance #1"
								-dc "nexOpt -e autoWeldTolerance #1"
								autoWeldIntField`);

							int $stripSize = `nexOpt -q quaDrawStripSize`;
							string $stripSizeIntField = dR_addModeBtn(`intSliderGrp -min 4 -max 200 -fieldMinValue 4 -fieldMaxValue 40 -step 1 -field true
								-ann (getPluginResource("modelingToolkit", "kQuadStripSizeAnn")) -cw2 28 1 -v $stripSize
								-cc "nexOpt -e quaDrawStripSize #1"
								-dc "nexOpt -e quaDrawStripSize #1"
								stripSizeIntField`);

							string $stripSizeLabel = `text -p $quaDrawForm -label (getPluginResource("modelingToolkit", "kStripSizeLabel"))
								-ann (getPluginResource("modelingToolkit", "kQuadStripSizeAnn"))`;

							$helpBtn = `button -l "?" -c "dR_ctxHelp"`;
							//string $shrinkWrapBtn = dR_addModeBtn(`button -ann "Shrink Wrap" -l "Shrink Wrap" -en false -c "nexCtx -qsr;" -rs false -height 18 -p $quaDrawForm`);
							string $relaxAffectsLabel = `text -p $quaDrawForm -label (getPluginResource("modelingToolkit", "kRelaxAffectsLabel"))`;
							string $gNexPickRelaxAffects = `iconTextButton
								-p $quaDrawForm
								-w 17 -h 26
								-ann (getPluginResource("modelingToolkit", "kRelaxAffectsAnn"))
								-image ("popupMenuIcon.png")`;
							global string $gNexPickRelaxAffectsText;
							$gNexPickRelaxAffectsText = `textField 
								-p $quaDrawForm
								-ed false 
								-height 26
								-ebg false
								-tx (getPluginResource("modelingToolkit", "kOff"))
								-ann (getPluginResource("modelingToolkit", "kRelaxAffectsAnn"))`;
							string $relaxAffectsMenu = `popupMenu -b 1 -p $gNexPickRelaxAffects`;
								menu -e -pmc ("dR_buildRelaxAffectsMenu " + $relaxAffectsMenu) $relaxAffectsMenu;

							string $extendLabel = `text -p $quaDrawForm -label (getPluginResource("modelingToolkit", "kExtendLabel"))`;
							string $gNexPickExtend = `iconTextButton
								-p $quaDrawForm
								-w 17 -h 26
								-ann (getPluginResource("modelingToolkit", "kExtendAnn"))
								-image ("popupMenuIcon.png")`;
							global string $gNexPickExtendText;
							$gNexPickExtendText = `textField 
								-p $quaDrawForm
								-ed false 
								-height 26
								-ebg false
								-tx (getPluginResource("modelingToolkit", "kExtendEdge"))
								-ann (getPluginResource("modelingToolkit", "kExtendAnn"))`;
							string $extendMenu = `popupMenu -b 1 -p $gNexPickExtend`;
								menu -e -pmc ("dR_buildExtendMenu " + $extendMenu) $extendMenu;

							string $liveFrame = nexBuildLiveSurfaceFrame($quaDrawForm, "QuadDraw");

							string $shortcutFrame = `frameLayout -p $quaDrawForm -l (getPluginResource("modelingToolkit", "kShortcuts")) 
								-mw 0 -mh 4 -cll true -cl 1 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;

								text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut0")) -ww true;
								separator;

								rowColumnLayout -numberOfColumns 2 -cw 1 110 -cw 2 110;

									text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + " / " + $mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut1")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut2")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut2a")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut3")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($tab + "+" + $lmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut4")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($tab + "+" + $mmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut5")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($shift + "+" + $lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut6")) -ww true;
									separator;separator;

								setParent ..;
								
								text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut8")) -ww true;
								separator;

								rowColumnLayout -numberOfColumns 2 -cw 1 110 -cw 2 110;

									text -align "left" -font smallBoldLabelFont -ww true -label ($lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut9")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut9a")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $lmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut10")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut11")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($shift + "+" + $lmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut12")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($shift + "+" + $mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut13")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($tab + "+" + $lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut14")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($tab + "+" + $mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut15")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $lmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut16")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $lmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut17")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $mmb + ":");
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut18")) -ww true;
									separator;separator;

									text -align "left" -font smallBoldLabelFont -ww true -label ($ctrl + "+" + $shift + "+" + $rmb + ":") -height 30;
									text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcut19")) -ww true;
									separator;separator;

								setParent ..;

								text -align "left" -label (getPluginResource("modelingToolkit", "kQuadDrawShortcutNote1")) -ww true;
								separator;

							$quadDrawClearDotsBtn = `button -l (getPluginResource("modelingToolkit", "kClearDots")) -c "dR_quadDrawClearDots" -p $quaDrawForm`;
							$quadDrawResetButton = `button -label (getPluginResource("modelingToolkit", "kResetSettings")) -c ("mtk_initToolOptions(1, \"quadraw\"); nexCtx -resetManip; dR_updateCommandPanel;") -p $quaDrawForm`;

			formLayout -edit
				-attachNone	$quaDrawFrame "top"
				-attachForm	$quaDrawFrame "left"	0
				-attachForm	$quaDrawFrame "right"	0
				$gDrQuaDrawPanel;

			formLayout -edit
				-attachForm $autoWeldChk "top" 2
				-attachForm $autoWeldChk "left" 4
				-attachNone $autoWeldChk "right"
				-attachForm $helpBtn "right" 2

				-attachForm $autoWeldIntField "top" 2
				-attachControl $autoWeldIntField "left" 8 $autoWeldChk
				-attachForm $autoWeldIntField "right" 4

				-attachControl $gNexPickRelaxAffects top 2 $autoWeldIntField
				-attachControl $gNexPickRelaxAffects left 9 $relaxAffectsLabel
				-attachNone $gNexPickRelaxAffects right
				-attachNone $gNexPickRelaxAffects bottom

				-attachControl $gNexPickRelaxAffectsText top 2 $autoWeldIntField
				-attachControl $gNexPickRelaxAffectsText left 0 $gNexPickRelaxAffects
				-attachNone $gNexPickRelaxAffectsText bottom
				-attachForm $gNexPickRelaxAffectsText right 6

				-attachControl 	$relaxAffectsLabel "top" 8 $autoWeldIntField
				-attachForm $relaxAffectsLabel "left" 6
				-attachNone 	$relaxAffectsLabel "right"

				-attachNone 	$relaxAffectsLabel "bottom"
				-attachControl 	$extendLabel "top" 8 $gNexPickRelaxAffectsText
				-attachForm $extendLabel "left" 6
				-attachNone 	$extendLabel "right"
				-attachNone 	$extendLabel "bottom"

				-attachControl $gNexPickExtend top 2 $gNexPickRelaxAffectsText
				-attachControl $gNexPickExtend left 2 $extendLabel
				-attachNone $gNexPickExtend right
				-attachNone $gNexPickExtend bottom

				-attachControl $gNexPickExtendText top 2 $gNexPickRelaxAffectsText
				-attachControl $gNexPickExtendText left 0 $gNexPickExtend
				-attachNone $gNexPickExtendText bottom
				-attachForm $gNexPickExtendText right 6

				-attachControl 	$stripSizeLabel "top" 8 $gNexPickExtendText
				-attachForm $stripSizeLabel "left" 6
				-attachNone 	$stripSizeLabel "right"
				-attachNone 	$stripSizeLabel "bottom"

				-attachControl $stripSizeIntField "top" 2 $gNexPickExtendText
				-attachControl $stripSizeIntField "left" 5 $stripSizeLabel
				-attachForm $stripSizeIntField "right" 4

				-attachControl $liveFrame "top" 8 $stripSizeIntField
				-attachForm $liveFrame "left" 2
				-attachForm $liveFrame "right" 2

				-attachControl $quadDrawClearDotsBtn "top" 8 $liveFrame
				-attachForm $quadDrawClearDotsBtn "left" 2
				-attachForm $quadDrawClearDotsBtn "right" 2

				-attachControl $quadDrawResetButton "top" 8 $quadDrawClearDotsBtn
				-attachForm $quadDrawResetButton "left" 2
				-attachForm $quadDrawResetButton "right" 2

				-attachControl $shortcutFrame "top" 8 $quadDrawResetButton
				-attachForm $shortcutFrame "left" 2
				-attachForm $shortcutFrame "right" 2

				$quaDrawForm;

			formLayout -edit
				-attachForm	$gDrTFormLayout "top"	0
				-attachForm	$gDrTFormLayout "left"	0
				-attachForm	$gDrTFormLayout "right"	0
				-attachForm	$gDrQuaDrawPanel "top"	0
				-attachForm	$gDrQuaDrawPanel "left"	0
				-attachForm	$gDrQuaDrawPanel "right"	0
				-attachForm	$gDrConnectFormLayout "top"	0
				-attachForm	$gDrConnectFormLayout "left"	0
				-attachForm	$gDrConnectFormLayout "right"	0
				-attachForm	$gDrBridgeFormLayout "top"	0
				-attachForm	$gDrBridgeFormLayout "left"	0
				-attachForm	$gDrBridgeFormLayout "right"	0
				-attachForm	$gDrVertExtrudeFormLayout "top"	0
				-attachForm	$gDrVertExtrudeFormLayout "left"	0
				-attachForm	$gDrVertExtrudeFormLayout "right"	0
				-attachForm	$gDrVertChamferFormLayout "top"	0
				-attachForm	$gDrVertChamferFormLayout "left"	0
				-attachForm	$gDrVertChamferFormLayout "right"	0
				-attachForm	$gDrFaceExtrudeFormLayout "top"	0
				-attachForm	$gDrFaceExtrudeFormLayout "left"	0
				-attachForm	$gDrFaceExtrudeFormLayout "right"	0
				-attachForm	$gDrBevelFormLayout 	"top"	0
				-attachForm	$gDrBevelFormLayout 	"left"	0
				-attachForm	$gDrBevelFormLayout 	"right"	0
				-attachForm	$gDrCutFormLayout 	"top"	0
				-attachForm	$gDrCutFormLayout 	"left"	0
				-attachForm	$gDrCutFormLayout 	"right"	0
				-attachForm	$gDrTargetWeldFormLayout	"top"	0
				-attachForm	$gDrTargetWeldFormLayout	"left"	0
				-attachForm	$gDrTargetWeldFormLayout	"right"	0
				$gDrOptionPanel;
			formLayout -edit
				-attachForm		$gDRTopPaneComponentsFrame	"top"		4
				-attachForm		$gDRTopPaneComponentsFrame	"left"		0
				-attachControl	$gDRTopPaneComponentsFrame	"bottom"	2	$gDrpanel
				-attachForm		$gDRTopPaneComponentsFrame	"right"		0
				-attachNone		$gDrpanel					"top"
				-attachForm		$gDrpanel					"left"		0
				-attachControl	$gDrpanel					"bottom"	2	$gDrOptionPanel
				-attachForm		$gDrpanel					"right"		0
				-attachNone		$gDrOptionPanel				"top"
				-attachForm		$gDrOptionPanel				"left"		0
				-attachForm		$gDrOptionPanel				"bottom"	0
				-attachForm		$gDrOptionPanel				"right"		0
				$gDRTopPane;
		}
		dR_updateCommandPanel;
		dR_updateCounter;
		evalDeferred ("MTsetToggleMenuItem");
		setUITemplate -popTemplate; 
	}
	proc string dR_getActiveMayaTab() {
		global string $gUIComponentDockControlArray[];
		string $tempIndex;
		int $tempIndNum;
		for($tempIndNum = 0; $tempIndNum < size($gUIComponentDockControlArray); $tempIndNum += 2){
			$tempIndex = $gUIComponentDockControlArray[$tempIndNum + 1];
			if(`workspaceControl -q -raise $tempIndex`)
			{
				return $tempIndex;
			}
		}
		return "";
	}
	global proc dR_init() {
		global string $gNexContext = "nexCtx1";
		global string $gQDContext = "nexQuadDrawCtx1";
		global string $gMultiCutContext = "nexMultiCutCtx1";
		global string $gConnectContext = "nexConnectCtx1";
		global string $gMTSuperContext = "ModelingToolkitSuperCtx";
		if(!`contextInfo -q -ex $gNexContext`) 
		{
			modelingToolkitSuperCtx -image1 "dRCtx.png" $gMTSuperContext;
			nexTRSContext $gNexContext;
			nexQuadDrawContext $gQDContext;
			nexMultiCutContext $gMultiCutContext;
			nexConnectContext $gConnectContext;

			mtk_initToolOptions(0, "all");

			modelingToolkitSuperCtx -edit -attach $gNexContext $gMTSuperContext;
			if (`contextInfo -q -ex transformTexSelectContext`)
				modelingToolkitSuperCtx -edit -attach transformTexSelectContext $gMTSuperContext;
			if (`contextInfo -q -ex texMoveContext`)
				modelingToolkitSuperCtx -edit -attach texMoveContext $gMTSuperContext;
			if (`contextInfo -q -ex texRotateContext`)
				modelingToolkitSuperCtx -edit -attach texRotateContext $gMTSuperContext;
			if (`contextInfo -q -ex texScaleContext`)
				modelingToolkitSuperCtx -edit -attach texScaleContext $gMTSuperContext;
		}

		global string $gStatusLine, $gStatusLineForm;
		global string $gDrpanel;
		global string $gNexRefreshCmd;
		global string $gDRasterModeBtns[];
		global string $gAttributeEditorForm;
		global string $gMainPane;
		global string $gDrPanes;
		global string $gDRTopPane;
		global string $gDRBottomPane;
		global int $gDrCompBtnCount;
		global string $gDrCompBtns_Names[], $gDrCompBtns[];
		global string $gPrevSlideType;
		global string $gPrevSelConsType;
		global int $gPrevMoveStepSnapMode, $gPrevRotateStepSnapMode, $gPrevScaleStepSnapMode;
		global float $gActiveControlColor[];
		$gActiveControlColor = { 0.322, 0.52, 0.65 }; // use our unified Maya highligh color #5285A6 
		global float $gMTKFrameHeadColor[] = {0.235,0.235,0.235};
		
		$gPrevSlideType = "surface";
		$gPrevSelConsType = "border";
		$gPrevCamBasedSelType = "on";
		$gPrevMoveStepSnapMode   = /*relative*/1;
		$gPrevRotateStepSnapMode = /*relative*/1;
		$gPrevScaleStepSnapMode  = /*relative*/1;
		
		$gNexRefreshCmd = "if(`nexOpt -q refreshActiveOnly`) { refresh -cv; } else { refresh; }";
		
		global int $gNexHandleX, $gNexHandleY, $gNexHandleZ, $gNexHandleXY, $gNexHandleYZ, $gNexHandleXZ, $gNexHandleXYZ;
		$gNexHandleX=1;
		$gNexHandleY=2;
		$gNexHandleZ=3;
		$gNexHandleXY=4;
		$gNexHandleYZ=5;
		$gNexHandleXZ=6;
		$gNexHandleXYZ=7;
		dR_brushResizeKeysCB;
		{
			int $alreadyAdded = 0;
			string $gotFormPath = "";
			string $gotBtnPath = "";
			string $layouts[] = `layout -q -ca $gStatusLineForm`;
			string $addRightOf = "ToggleChannelsLayers";
			if(size($layouts)) {
				int $i;
				for($i=0 ; $i < size($layouts) ; $i++) {
					// Try to make as few assumptions about the configuration of
					// these layouts as possible -- some other tools like to add
					// things here too.
					string $childLayouts[];
					if(`layout -q -nch $layouts[$i]` != 0) {
						$childLayouts = `layout -q -ca $layouts[$i]`;
						int $j;
						for($j=0; $j < size($childLayouts); $j++)
						{
							string $fullPath = $gStatusLineForm + "|" + $layouts[$i] + "|" + $childLayouts[$j];
							if(objectTypeUI($fullPath) == "formLayout") {
								string $childControls[] = `layout -q -ca $fullPath`;
								int $controlIdx;
								for($controlIdx=0; $controlIdx < size($childControls); $controlIdx++)
								{
									if(objectTypeUI($childControls[$controlIdx]) == "iconTextButton") {
										if(`iconTextButton -q -c $childControls[$controlIdx]` == $addRightOf) {
											$gotFormPath = $fullPath;
											$gotBtnPath = $fullPath + "|" + $childControls[$controlIdx];
											break;
										}
										if(`iconTextButton -q -c $childControls[$controlIdx]` == "dR_ToggleCommandPanel") {
											$alreadyAdded = 1;
										}
									}
								}
							}
							if($gotBtnPath != "") {
								break;
							}
						}
					}
					if($gotBtnPath != "") {
						break;
					}
				}
			}
			if($gotFormPath != "" && !$alreadyAdded) {
				// Attach the new button
				setParent $gotFormPath;
				string $gNexCmdPanelBtn;
				$gNexCmdPanelBtn = `iconTextButton
					-image1 (dR_xpmToPng("dRBox.xpm"))
					-width 26 -height 26
					-annotation ("Show or hide the NEX Panel")
					-c ("dR_TogglePanel")`;
				formLayout -edit 
					-attachForm $gNexCmdPanelBtn	top	1
					-attachControl $gNexCmdPanelBtn	left	0 	$gotBtnPath
					-attachNone $gNexCmdPanelBtn	bottom
					-attachNone $gNexCmdPanelBtn	right
					$gotFormPath;
			}
		}
		{
			string $hotboxFileName = (`getenv "MAYA_LOCATION"` + "/scripts/startup/HotboxMenus.mel");
			// Now begin reading lines from the hotbox file
			$hotboxFile=`fopen $hotboxFileName "r"`;
			string $gNextLine = `fgetline $hotboxFile`;
			string $prevLine = "";
			string $funcStr = "";
			int $foundStart = false;
			int $startReading = false;
			int $setMenuLine = false;
			while( size( $gNextLine ) > 0) {
				if(gmatch($gNextLine, "*global proc buildHotboxMenus()*")) {
					$startReading = true;
				}
				if(!$setMenuLine) {
					if(gmatch($gNextLine, "*if ($filename != \"\") {*")) {
						$foundStart = 1;
					} else if($foundStart && gmatch($gNextLine, "*} else {*")) {
						$funcStr += "menu -e -pmc (`menu -q -pmc $theMenu` + \" if(`exists drBuildCustomMenus`) { drBuildCustomMenus(); }\") $theMenu;\n";
						$setMenuLine = true;
					}
				}
				if($startReading) {
					$funcStr += $gNextLine;
				}
				if($gNextLine == "}\n") {
					$startReading = false;
				}
				$gNextLine = `fgetline $hotboxFile`;
			}
			fclose $hotboxFile;
			eval $funcStr;
		}
		{
			string $uiCompFilename = (`getenv "MAYA_LOCATION"` + "/scripts/startup/UIComponents.mel");
			// Now begin reading lines from the hotbox file
			$uiCompFile=`fopen $uiCompFilename "r"`;
			string $gNextLine = `fgetline $uiCompFile`;
			string $prevLine = "";
			string $funcStr = "";
			int $foundStart = false;
			int $startReading = false;
			int $setMenuLine = false;
			while( size( $gNextLine ) > 0) {
				if(`match "^proc string getCurrentUIComponent\\(.*" $gNextLine` != "") {
					$startReading = true;
					$funcStr += "global " + $gNextLine;
				} else if($startReading) {
					if(gmatch($gNextLine, "*break;*")) {
						$foundStart = 1;
					} else if($foundStart && gmatch($gNextLine, "*return $current*")) {
						$funcStr += "if($current == \"NEX Panel\") { return \"\"; }\n";
						$setMenuLine = true;
					}
					$funcStr += $gNextLine;
					if($gNextLine == "}\n") {
						$startReading = false;
						break;
					}
				}
				$gNextLine = `fgetline $uiCompFile`;
			}
			fclose $uiCompFile;
			eval $funcStr;
		}
		// Rebuild the menus
		DRRebuildHotboxMenus;
		dR_matchManipSize;
		dR_snapOptionCB;
		dR_manipSizeOptionCB;
		//dR_selTransformKeysCB;
		//dR_toolEditKeysCB;
		if(`nexOpt -q panelDock` == 2) {
			nexOpt -e panelDock 1;
		}

		// Ready the float layout
		global string $gNexFloatForm;
		if( $gNexFloatForm == "" && !`workspaceControl -q -exists NEXDockControl` ) {
			string $prevActiveTab = `dR_getActiveMayaTab`;
			string $LEcomponent = getUIComponentDockControl("Layer Editor", false);

			workspaceControl
				-requiredPlugin "modelingToolkit"
				-tabToControl $LEcomponent -1
				-label (getPluginResource("modelingToolkit", "kMTName"))
				-uiScript "dR_createNEXDockControl();"
				-loadImmediately true
				-vis `nexOpt -q showNEXTabOnStartup`

				-initialWidth `optionVar -q workspacesNarrowPanelInitialWidth`
				-initialHeight `optionVar -q workspacesNarrowPanelInitialHeight`

				-widthProperty "preferred"
				NEXDockControl;

			if($prevActiveTab != "") {
				workspaceControl -e -raise $prevActiveTab;
			}
		}

		evalDeferred ("MTsetToggleMenuItem");

		scriptJob -event "modelEditorChanged" dR_setModelEditorTypes;
		dR_setModelEditorTypes();
	}

	global proc dR_createNEXDockControl()
	{
		workspaceControl -e -minimumWidth `optionVar -q workspacesNarrowPanelInitialWidth` 
							NEXDockControl;
		
		global string $gNexFloatForm, $gDrPanes, $gDRBottomPane, $gNexScrollForm;
		global float $gMTKFrameHeadColor[];

		// we use ModelingToolkitTemplate to give a flat UI consistencey.
		setUITemplate -pushTemplate ModelingToolkitTemplate;

		global string $gNexPanelMenuCont;
		$gNexPanelMenuCont = `menuBarLayout`;
			// Build panel menus
			DRBuildMenus;

			
			int $mtkShelfHeight = `optionVar -q mtkShelfHeight`;
			int $mtkPanelHeight = (100 - $mtkShelfHeight);
			$gDrPanes = `paneLayout -cn "horizontal2" -ps 1 100 $mtkPanelHeight -ps 2 100 $mtkShelfHeight`;
				paneLayout -e -separatorMovedCommand ("dRShelfSizeChanged " + $gDrPanes) $gDrPanes;
				$gNexScrollForm = `scrollLayout -cr 1 -p $gDrPanes`;
					$gNexFloatForm = `formLayout -p $gNexScrollForm`;
				string $drBtSliceCont = `formLayout -p $gDrPanes`;
					string $drBtSlice = `frameLayout -p $drBtSliceCont -mw 0 -mh 0 -l (getPluginResource("modelingToolkit", "kCustomShelf")) -cll 0 -bgc $gMTKFrameHeadColor[0] $gMTKFrameHeadColor[1] $gMTKFrameHeadColor[2]`;
						$gDRBottomPane = `shelfLayout -ann (getPluginResource("modelingToolkit", "kCustomShelfAnn")) -p $drBtSlice`;
						dRRestoreShelves();
				formLayout -edit
					-attachForm		$drBtSlice		"top"		4
					-attachForm		$drBtSlice		"bottom"	2
					-attachForm		$drBtSlice		"left"		2
					-attachForm		$drBtSlice		"right"		2
					$drBtSliceCont;

		setUITemplate -popTemplate;

		// Ready the right side panel
		global string $gNexRightPanel;
		nexBuildPanel($gNexFloatForm);
	}

	global proc dR_setModelEditorTypes()
	{
		string $modelPanels[] = `getPanel -type modelPanel`;
		for($modelPanel in $modelPanels) {
			string $modelEditor = `modelPanel -q -me $modelPanel`;
			if($modelEditor != "") {
				string $viewType = `modelEditor -q -vt $modelEditor`;
				nexCtx -e -modelPanelType $modelPanel $viewType;
			}
		}
	}
	// Mostly for debugging
	global proc reloadNexPanel()
	{
		global string $gNexFloatForm;
		string $fChildren[] = `layout -q -ca $gNexFloatForm`;
		string $child;
		for($child in $fChildren) {
			deleteUI $child;
		}
		nexBuildPanel($gNexFloatForm);
	}
	global proc reloadNex() {
		string $cmd = "source \"" + `getenv "NEX_DRINIT_PATH"`  + "\"";
		eval ( $cmd );
		reloadNexPanel();
	}
	
	global proc dR_numericalInputChangeCommand(string $mode)
	{
		global string $gTransformCoordMT[];
		string $x = $gTransformCoordMT[0];
		string $y = $gTransformCoordMT[1];
		string $z = $gTransformCoordMT[2];

		string $curTool = `nexOpt -q manipType`;
		
		if ($curTool == "move" || $curTool == "rotate" || $curTool == "scale"){
			superContextTransform($mode, capitalizeString($curTool), $x, $y, $z);
		} else if( $curTool == "select"){
			superContextTransform($mode, "Move", $x, $y, $z);
		}
		
		//	Clear the input field.
		statusLineUpdateInputField();

		setFocus `getPanel -wf`;
	}

	global proc dR_SelectToolMarkingMenuPopDown()
	{
		if (modelingTookitActive())
		{
			MarkingMenuPopDown;
		}
		else
		{
			SelectToolOptionsMarkingMenuPopDown;
		}
	}

	global proc dR_TranslateToolMarkingMenuPopDown()
	{
		if (modelingTookitActive())
		{
			MarkingMenuPopDown;
		}
		else
		{
			TranslateToolWithSnapMarkingMenuPopDown;
		}
	}

	global proc dR_RotateToolMarkingMenuPopDown()
	{
		if (modelingTookitActive())
		{
			MarkingMenuPopDown;
		}
		else
		{
			RotateToolWithSnapMarkingMenuPopDown;
		}
	}

	global proc dR_ScaleToolMarkingMenuPopDown()
	{
		if (modelingTookitActive())
		{
			MarkingMenuPopDown;
		}
		else
		{
			ScaleToolWithSnapMarkingMenuPopDown;
		}
	}
}