// ===========================================================================
// Copyright 2018 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
//
//  Creation Date:  4 April 1997
//
//
//  Description:
//
//
//  Procedure Name:
//      performPolyPrimitive
//
//  Description:
//        perform a bevel of the selected polygon edges
//        
//  Input Arguments:
//        $option : Whether to set the options to default values.
//  Return Value:
//        command string iff $option==2
//

//$name contains the name of platonic solid or soccer ball
global string $gPlatonicSolidName;
//$type contains the type of platonic solid or 0 for soccer ball
global string $gPlatonicSolidType;
//Ratios of length to radius
global float $gSoccerBallRatio   = 0.4036;
global float $gDodecahedronRatio = 0.7137;
global float $gIcosahedronRatio  = 1.0515;
global float $gOctahedronRatio   = 1.4143;
global float $gTetrahedronRatio  = 1.7321;

proc ovar (string $name, int $defval, int $fs) {
	if ($fs || !`optionVar -exists $name`)
		optionVar -intValue $name $defval;
}

proc ofvar (string $name, float $defval, int $fs) {
	if ($fs || !`optionVar -exists $name`)
		optionVar -floatValue $name $defval;
}

proc orvar (string $name, int $val, int $fs) {
	if ($fs || !`optionVar -exists $name`)
		optionVar -intValue $name $val;
}

proc setOptionVars (int $fs, string $op)
{
	string $ovb=("polyPrimitive"+$op);
	string $ov;
	if ($op == "Sphere") {
		ovar(($ovb+"SX"), 20, $fs);
		ovar(($ovb+"SY"), 20, $fs);
		ofvar(($ovb+"Radius"), 1., $fs);
		orvar(($ovb+"Axis"), 2, $fs);	// Y axis
		orvar(($ovb+"UVType"), 2, $fs);		
		ovar(($ovb+"CreateUVs"), 1, $fs);	
	} else if ($op == "Cube") {
		ovar(($ovb+"SX"), 1, $fs);
		ovar(($ovb+"SY"), 1, $fs);
		ovar(($ovb+"SZ"), 1, $fs);
		ofvar(($ovb+"Width"), 1., $fs);
		ofvar(($ovb+"Height"), 1., $fs);
		ofvar(($ovb+"Depth"), 1., $fs);
		orvar(($ovb+"Axis"), 2, $fs);	// Y axis
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		ovar(($ovb+"Normalize"), 1, $fs);
		orvar(($ovb+"NormalizeType"), 1, $fs);		
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
	} else if ($op == "Cone" || $op == "Cylinder") {
		ofvar(($ovb+"Radius"), 1.0, $fs);
		ofvar(($ovb+"Height"), 2.0, $fs);
		ovar(($ovb+"SX"), 20, $fs);
		ovar(($ovb+"SY"), 1, $fs);
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		ovar(($ovb+"Normalize"), 1, $fs);
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
		if ($op == "Cone")
 			ovar(($ovb+"SZ"), 0, $fs);
 		else ovar(($ovb+"SZ"), 1, $fs);
		orvar(($ovb+"Axis"), 2, $fs);	// Y axis
		ovar(($ovb+"RoundCap"), 0, $fs);
	} else if ($op=="Plane") {
		ovar(($ovb+"SX"), 10, $fs);
		ovar(($ovb+"SY"), 10, $fs);
		ofvar(($ovb+"Width"), 1., $fs);
		ofvar(($ovb+"Height"), 1., $fs);
		orvar(($ovb+"Axis"), 2, $fs);	// Y axis
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
	} else if ($op == "Torus") {
		ofvar(($ovb+"Radius"), 1.0, $fs);
		ofvar(($ovb+"SectionRadius"), .50, $fs);
		ofvar(($ovb+"Twist"), .0, $fs);
		ovar(($ovb+"SX"), 20, $fs);
		ovar(($ovb+"SY"), 20, $fs);
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		orvar(($ovb+"Axis"), 2, $fs); 	// Y axis
	} else if ($op == "Prism") {
		ofvar(($ovb+"Length"), 2.0, $fs);
		ofvar(($ovb+"SideLength"), 1.0, $fs);
		ovar(($ovb+"NS"), 3, $fs);
		ovar(($ovb+"SH"), 1, $fs);
		ovar(($ovb+"SC"), 0, $fs);
		orvar(($ovb+"Axis"), 2, $fs); 	// Y axis
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		ovar(($ovb+"Normalize"), 1, $fs);
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
	} else if ($op == "Pyramid") {
		ofvar(($ovb+"SideLength"), 1.0, $fs);
		ovar(($ovb+"NS"), 2, $fs); // default sides = 4
		ovar(($ovb+"SH"), 1, $fs);
		ovar(($ovb+"SC"), 0, $fs);
		orvar(($ovb+"Axis"), 2, $fs); 	// Y axis
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		ovar(($ovb+"Normalize"), 1, $fs);
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
	} else if ($op == "Pipe") {
		ofvar(($ovb+"Radius"), 1.0, $fs);
		ofvar(($ovb+"Height"), 2.0, $fs);
		ofvar(($ovb+"Thickness"), 0.5, $fs);
		ovar(($ovb+"SA"), 20, $fs);
		ovar(($ovb+"SH"), 1, $fs);
		ovar(($ovb+"SC"), 0, $fs);
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		orvar(($ovb+"Axis"), 2, $fs); 	// Y axis		
		ovar(($ovb+"RoundCap"), 0, $fs);
	} else if ($op == "Helix") {
		ofvar(($ovb+"Coils"), 3, $fs);
		ofvar(($ovb+"Height"), 2.0, $fs);
		ofvar(($ovb+"Width"), 2.0, $fs);
		ofvar(($ovb+"Radius"), 0.4, $fs);
		ovar(($ovb+"SA"), 8, $fs);
		ovar(($ovb+"SCO"), 50, $fs);
		ovar(($ovb+"SC"), 0, $fs);
		ovar(($ovb+"Direction"), 1, $fs);
		orvar(($ovb+"Axis"), 2, $fs); 	// Y axis
		ovar(($ovb+"CreateUVs"), 1, $fs);	
		ovar(($ovb+"Normalize"), 1, $fs);
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
		ovar(($ovb+"RoundCap"), 0, $fs);
	} else if ($op == "PlatonicSolid") {
		ofvar(($ovb+"Radius"), 1.0, $fs);
		ofvar(($ovb+"SideLength"), 0.7137, $fs);
		orvar(($ovb+"Axis"), 2, $fs);
		orvar(($ovb+"SolidType"), 0, $fs);
		ovar(($ovb+"CreateUVs"), 1, $fs);
		ovar(($ovb+"Normalize"), 1, $fs);
		orvar(($ovb+"NormalizeType"), 1, $fs);		
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
	} else if ($op == "Misc") {
		ofvar(($ovb+"Radius"), 1.0, $fs);
		ofvar(($ovb+"SideLength"), 0.4036, $fs);	
		orvar(($ovb+"Axis"), 2, $fs);
		ovar(($ovb+"CreateUVs"), 1, $fs);
		ovar(($ovb+"Normalize"), 1, $fs);
		orvar(($ovb+"NormalizeType"), 1, $fs);		
		ovar(($ovb+"PreserveAspectRatio"), 1, $fs);
	}

	if ($op != "Helix" && $op != "Prism") {
		ovar(($ovb+"Texture"), 1, $fs);
	}
}

proc oset (string $var) {	
	int $ival = `optionVar -query $var`;
    intSliderGrp -edit -value $ival $var;
}

global proc updatePlatonicSolidType()
{
	global string $gPlatonicSolidName;
    global string $gPlatonicSolidType;
	if($gPlatonicSolidName == "polyPrimitiveMisc" ) {
		$gPlatonicSolidType = "SoccerBall" ;
		return ;
	}
	string $var = $gPlatonicSolidName + "SolidType";	
	int $val = (`optionMenuGrp -query -sl $var`) - 1;

	if( $val == 0 )
		$gPlatonicSolidType = "Dodecahedron";
	if( $val == 1 )
		$gPlatonicSolidType = "Icosahedron";
	if( $val == 2 )
		$gPlatonicSolidType = "Octahedron";
	if( $val == 3 )
		$gPlatonicSolidType = "Tetrahedron";
}

global proc setRadiusCallback(float $value) {
    global string $gPlatonicSolidName;
    global string $gPlatonicSolidType;
    global float  $gSoccerBallRatio;
    global float  $gDodecahedronRatio;
    global float  $gIcosahedronRatio;
    global float  $gOctahedronRatio;
    global float  $gTetrahedronRatio;
           float  $length;
	
	updatePlatonicSolidType();

    if ($gPlatonicSolidType == "SoccerBall") {
        $length = $value*$gSoccerBallRatio;
    } else if ($gPlatonicSolidType == "Dodecahedron") {
        $length = $value*$gDodecahedronRatio;
    } else if($gPlatonicSolidType == "Icosahedron") {
        $length = $value*$gIcosahedronRatio;
    } else if($gPlatonicSolidType == "Octahedron") {
        $length = $value*$gOctahedronRatio;
    } else if($gPlatonicSolidType == "Tetrahedron") {
        $length = $value*$gTetrahedronRatio;
    }
	
    //Set edge length
    string $lengthSlider = $gPlatonicSolidName + "SideLength";
	optionVar -fv $lengthSlider $length;
    floatSliderGrp -edit -value $length $lengthSlider;
}

proc setRadius(string $var1, string $var2, string $var3) {
    global string $gPlatonicSolidName;
    global string $gPlatonicSolidType;
    $value = `optionVar -query $var1`;
    $gPlatonicSolidName  = $var2;
    $gPlatonicSolidType  = $var3;	
	
	updatePlatonicSolidType();

    floatSliderGrp -edit -value $value -dc "setRadiusCallback \"#1\"" -cc "setRadiusCallback \"#1\"" $var1;
}

global proc setEdgeCallback(float $value) {
    global string $gPlatonicSolidName;
    global string $gPlatonicSolidType;
    global float  $gSoccerBallRatio;
    global float  $gDodecahedronRatio;
    global float  $gIcosahedronRatio;
    global float  $gOctahedronRatio;
    global float  $gTetrahedronRatio;
           float  $radius;

	updatePlatonicSolidType();

    if ($gPlatonicSolidType == "SoccerBall") {
        $radius = $value/$gSoccerBallRatio;
    } else if ($gPlatonicSolidType == "Dodecahedron") {
        $radius = $value/$gDodecahedronRatio;
    } else if($gPlatonicSolidType == "Icosahedron") {
        $radius = $value/$gIcosahedronRatio;
    } else if($gPlatonicSolidType == "Octahedron") {
        $radius = $value/$gOctahedronRatio;
    } else if($gPlatonicSolidType == "Tetrahedron") {
        $radius = $value/$gTetrahedronRatio;
    }
    //Set radius
    string $radiusSlider = $gPlatonicSolidName + "Radius";
    optionVar -fv $radiusSlider $radius;
    floatSliderGrp -edit -value $radius $radiusSlider;
}

proc setEdge(string $var1, string $var2, string $var3) {
    global string $gPlatonicSolidName;
    global string $gPlatonicSolidType;
    $value = `optionVar -query $var1`;
    $gPlatonicSolidName  = $var2;
    $gPlatonicSolidType  = $var3;
	
	updatePlatonicSolidType();

    floatSliderGrp -edit -value $value -dc "setEdgeCallback \"#1\"" -cc "setEdgeCallback \"#1\"" $var1;
}

proc ofset (string $var) {
	float $fval = `optionVar -query $var`;
	floatSliderGrp -edit -value $fval $var;
}


proc orset (string $var) {
	int $val = `optionVar -query $var`;
	radioButtonGrp -edit -sl $val $var;
}

proc ornsset (string $var) {
	int $val = `optionVar -query $var`;

	int $valueToSet = 2; // default button

	if($val == 3)
		$valueToSet = 1;
	else if($val == 5)
		$valueToSet = 3;

	radioButtonGrp -edit -sl $valueToSet $var;
}

proc ocset (string $var) {
	int $val = `optionVar -query $var`;
	checkBoxGrp -edit -value1 $val $var;
}

proc omset (string $var) {
	int $val = `optionVar -query $var` + 1;
	optionMenuGrp -edit -sl $val $var;
}

global proc performPolyPrimitiveSetup (string $op, string $parent, int $forceFactorySettings )
{
	setOptionVars($forceFactorySettings, $op);
	setParent $parent;
    string $ovb=("polyPrimitive"+$op);
	if ($op == "Sphere") {
		ofset(($ovb+"Radius"));
		oset(($ovb+"SX"));
		oset(($ovb+"SY"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		orset(($ovb+"UVType"));
		if ($forceFactorySettings) radioButtonGrp -edit -enable true ($ovb+"UVType");
	} else if ($op == "Cube") {
		ofset(($ovb+"Width"));
		ofset(($ovb+"Height"));
		ofset(($ovb+"Depth"));
		oset(($ovb+"SX"));
		oset(($ovb+"SY"));
		oset(($ovb+"SZ"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		orset(($ovb+"NormalizeType"));
		ocset(($ovb+"PreserveAspectRatio"));
	} else if ($op == "Cone" || $op == "Cylinder") {
		ofset(($ovb+"Radius"));
		ofset(($ovb+"Height"));
		oset(($ovb+"SX"));
		oset(($ovb+"SY"));
		oset(($ovb+"SZ"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		ocset(($ovb+"PreserveAspectRatio"));
		ocset(($ovb+"RoundCap"));
	} else if ($op=="Plane") {
		ofset(($ovb+"Width"));
		ofset(($ovb+"Height"));
		oset(($ovb+"SX"));
		oset(($ovb+"SY"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"PreserveAspectRatio"));
	} else if ($op == "Torus") {
		ofset(($ovb+"Radius"));
		ofset(($ovb+"SectionRadius"));
		ofset(($ovb+"Twist"));
		oset(($ovb+"SX"));
		oset(($ovb+"SY"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
	} else if ($op == "Prism") {
		ofset(($ovb+"Length"));
		ofset(($ovb+"SideLength"));
		oset(($ovb+"NS"));
		oset(($ovb+"SH"));
		oset(($ovb+"SC"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		ocset(($ovb+"PreserveAspectRatio"));
	} else if ($op == "Pyramid") {
		ofset(($ovb+"SideLength"));
		ornsset(($ovb+"NS"));
		oset(($ovb+"SH"));
		oset(($ovb+"SC"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		ocset(($ovb+"PreserveAspectRatio"));
	} else if ($op == "PlatonicSolid") {
        setRadius(($ovb+"Radius"),$ovb,$op);
        setEdge(($ovb+"SideLength"),$ovb,$op);
		orset(($ovb+"Axis"));
		omset(($ovb+"SolidType"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		orset(($ovb+"NormalizeType"));
		ocset(($ovb+"PreserveAspectRatio"));
	} else if ($op == "Pipe") {
		ofset(($ovb+"Radius"));
		ofset(($ovb+"Height"));
        ofset(($ovb+"Thickness"));
		oset(($ovb+"SA"));
		oset(($ovb+"SH"));
		oset(($ovb+"SC"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"RoundCap"));
	} else if ($op == "Helix") {
		ofset(($ovb+"Coils"));
		ofset(($ovb+"Height"));
        ofset(($ovb+"Width"));
        ofset(($ovb+"Radius"));
        oset(($ovb+"SA"));
		oset(($ovb+"SCO"));
		oset(($ovb+"SC"));
        omset(($ovb+"Direction"));
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		ocset(($ovb+"PreserveAspectRatio"));
		ocset(($ovb+"RoundCap"));
	} else if ($op == "Misc") {
		setRadius(($ovb+"Radius"),$ovb,$op);
		setEdge(($ovb+"SideLength"),$ovb,$op);
		orset(($ovb+"Axis"));
		ocset(($ovb+"CreateUVs"));
		ocset(($ovb+"Normalize"));
		orset(($ovb+"NormalizeType"));
		ocset(($ovb+"PreserveAspectRatio"));
	}
}

proc ocallback (string $var) {
	optionVar -intValue $var `intSliderGrp -query -value $var`;
} 
proc ofcallback (string $var) {
	optionVar -floatValue $var `floatSliderGrp -query -value $var`;
}

proc orcallback (string $var) {
	optionVar -intValue $var `radioButtonGrp -query -sl $var`;
}

proc occallback (string $var) {
	optionVar -intValue $var `checkBoxGrp -query -value1 $var`;
}

proc omcallback (string $var) {
	optionVar -intValue $var (`optionMenuGrp -query -sl $var` - 1);
}

global proc performPolyPrimitiveCallback (string $op, string $parent, int $doIt)
{
	setParent $parent;
	string $ovb=("polyPrimitive"+$op);
	if ($op == "Sphere") {
		ofcallback(($ovb+"Radius"));
		ocallback(($ovb+"SX"));
		ocallback(($ovb+"SY"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		orcallback(($ovb+"UVType"));
	} else if ($op == "Cube") {
		ofcallback(($ovb+"Width"));
		ofcallback(($ovb+"Height"));
		ofcallback(($ovb+"Depth"));
		ocallback(($ovb+"SX"));
		ocallback(($ovb+"SY"));
		ocallback(($ovb+"SZ"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		orcallback(($ovb+"NormalizeType"));
		occallback(($ovb + "PreserveAspectRatio"));
	} else if ($op == "Cone" || $op == "Cylinder") {
		ofcallback(($ovb+"Radius"));
		ofcallback(($ovb+"Height"));
		ocallback(($ovb+"SX"));
		ocallback(($ovb+"SY"));
		ocallback(($ovb+"SZ"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		occallback(($ovb + "PreserveAspectRatio"));			
		occallback(($ovb + "RoundCap"));			
	} else if ($op=="Plane") {
		ofcallback(($ovb+"Width"));
		ofcallback(($ovb+"Height"));
		ocallback(($ovb+"SX"));
		ocallback(($ovb+"SY"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "PreserveAspectRatio"));			
	} else if ($op == "Torus") {
		ofcallback(($ovb+"Radius"));
		ofcallback(($ovb+"SectionRadius"));
		ofcallback(($ovb+"Twist"));
		ocallback(($ovb+"SX"));
		ocallback(($ovb+"SY"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
	} else if ($op == "Prism") {
		ofcallback(($ovb+"Length"));
		ofcallback(($ovb+"SideLength"));
		ocallback(($ovb+"NS"));
		ocallback(($ovb+"SH"));
		ocallback(($ovb+"SC"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		occallback(($ovb + "PreserveAspectRatio"));			
	} else if ($op == "Pyramid") {
		ofcallback(($ovb+"SideLength"));
		orcallback(($ovb+"NS"));
		ocallback(($ovb+"SH"));
		ocallback(($ovb+"SC"));
		orcallback(($ovb+"Axis")); 	// Y axis
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		occallback(($ovb + "PreserveAspectRatio"));			
	} else if ($op == "PlatonicSolid") {
		ofcallback(($ovb+"Radius"));
		ofcallback(($ovb+"SideLength"));
 		orcallback(($ovb+"Axis"));
		omcallback(($ovb + "SolidType"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		orcallback(($ovb+"NormalizeType"));
		occallback(($ovb + "PreserveAspectRatio"));
	} else if ($op == "Pipe") {
		ofcallback(($ovb+"Radius"));
		ofcallback(($ovb+"Height"));
        ofcallback(($ovb+"Thickness"));
		ocallback(($ovb+"SA"));
		ocallback(($ovb+"SH"));
		ocallback(($ovb+"SC"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "RoundCap"));			
	} else if ($op == "Helix") {
		ofcallback(($ovb+"Coils"));
		ofcallback(($ovb+"Height"));
        ofcallback(($ovb+"Width"));
        ofcallback(($ovb+"Radius"));
        ocallback(($ovb+"SA"));
		ocallback(($ovb+"SCO"));
		ocallback(($ovb+"SC"));
        omcallback(($ovb+"Direction"));
        orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		occallback(($ovb + "PreserveAspectRatio"));			
		occallback(($ovb + "RoundCap"));			
	} else if ($op == "Misc") {
		ofcallback(($ovb+"Radius"));
		ofcallback(($ovb+"SideLength"));
		orcallback(($ovb+"Axis"));
		occallback(($ovb + "CreateUVs"));
		occallback(($ovb + "Normalize"));
		orcallback(($ovb+"NormalizeType"));
		occallback(($ovb + "PreserveAspectRatio"));
	}
	
	if ($doIt) {
		performPolyPrimitive $op 0;
		string $tmpCmd = "performPolyPrimitive \"" + $op + "\" 0";
		addToRecentCommandQueue $tmpCmd "PolyPrimitive";
	}
}

proc ooption (string $ovar, string $name, int $min, int $max, int $fmin, int $fmax)
{
	string $subdLabel;
	switch ($name) {
	case "X":
		if ($ovar == "polyPrimitivePlaneSX" || $ovar == "polyPrimitiveCubeSX") {
			$subdLabel = (uiRes("m_performPolyPrimitive.kWidthDivisions"));
		} else if($ovar == "polyPrimitivePrismNS" || $ovar == "polyPrimitivePyramidNS"){
                        $subdLabel = (uiRes("m_performPolyPrimitive.kNumberOfSidesInBase"));
                }else{
			$subdLabel = (uiRes("m_performPolyPrimitive.kAxisDivisions"));
		}
		break;
	case "Y":
		if ($ovar == "polyPrimitiveHelixSCO") {
				$subdLabel = (uiRes("m_performPolyPrimitive.kCoilDivisions"));
			} else {
				$subdLabel = (uiRes("m_performPolyPrimitive.kHeightDivisions"));
			}
		break;
	case "Z":
		if ($ovar == "polyPrimitiveCubeSZ") {
			$subdLabel = (uiRes("m_performPolyPrimitive.kDepthDivisions"));
		} else {
			$subdLabel = (uiRes("m_performPolyPrimitive.kCapDivisions"));
		}
		break;
	case "C":
		$subdLabel = (uiRes("m_performPolyPrimitive.kCoilsOption"));
		break;
	}
    
	intSliderGrp -label ($subdLabel) 
		-min $min -max $max -fmn $fmin -fmx $fmax $ovar;
}

proc ofoption (string $ovar, string $name)
{
	float $maxVal = 1000000000;
	floatSliderGrp -label $name -min 0. -max 10. -fmn 0. -fmx $maxVal $ovar;
}

proc oroption (string $ovar)
{
	radioButtonGrp -label (uiRes("m_performPolyPrimitive.kAxis")) -numberOfRadioButtons 3
		-label1 (uiRes("m_performPolyPrimitive.kOptionX"))
		-label2 (uiRes("m_performPolyPrimitive.kOptionY"))
		-label3 (uiRes("m_performPolyPrimitive.kOptionZ"))
		$ovar;
}

global proc selectSolidType()
{
    global string $gPlatonicSolidName;
    global string $gPlatonicSolidType;

	string $var = $gPlatonicSolidName + "SolidType" ;
	int $val = (`optionMenuGrp -query -sl $var`) - 1 ;	

	switch($val) {
		case 0:
			$gPlatonicSolidType = "Dodecahedron" ;
			break ;
		case 1:
			$gPlatonicSolidType = "Icosahedron" ;
			break ;
		case 2:
			$gPlatonicSolidType = "Octahedron" ;
			break ;
		case 3:
			$gPlatonicSolidType = "Tetrahedron" ;
			break ;
	}
	// query for one of the value from the scale & 
	// adjust the other value proportionatly
	float $radius;
	$radius = `floatSliderGrp -query -value polyPrimitivePlatonicSolidRadius` ;
	setRadiusCallback($radius) ;
}

proc oloption (string $ovar, string $op1, string $op2, string $op3, string $op4)
{
    optionMenuGrp -label (uiRes("m_performPolyPrimitive.kPlatonicType")) -cc "selectSolidType" $ovar;
    menuItem -label $op1;
    menuItem -label $op2;
    menuItem -label $op3;
    menuItem -label $op4;
    setParent -menu ..;
}

proc ornsoption (string $ovar)
{
	radioButtonGrp -label (uiRes("m_performPolyPrimitive.kNumberOfSidesInBaseOption")) -numberOfRadioButtons 3
		-label1 (uiRes("m_performPolyPrimitive.kOption3"))
		-label2 (uiRes("m_performPolyPrimitive.kOption4"))
		-label3 (uiRes("m_performPolyPrimitive.kOption5"))
		$ovar;
}

proc otoption(string $ovar, string $op1, string $op2, string $op3)
{
	optionMenuGrp -label (uiRes("m_performPolyPrimitive.kTexture")) $ovar;
	menuItem -label $op1;
    menuItem -label $op2;
    menuItem -label $op3;
    setParent -menu ..;
}

proc odoption(string $ovar, string $op1, string $op2)
{
    optionMenuGrp -label (uiRes("m_performPolyPrimitive.kDirection")) $ovar;
    menuItem -label $op1;
    menuItem -label $op2;
    setParent -menu ..;
}

proc polyPrimitiveOptions (string $op)
{
	string $commandName = "performPolyPrimitive";
	string $callback = ($commandName + "Callback " + $op);
	string $setup = ($commandName + "Setup " + $op );
	   
	string $layout = getOptionBox();
	setParent $layout;
	setUITemplate -pushTemplate DefaultTemplate;
	waitCursor -state 1;
	
	string $parent = `columnLayout -adjustableColumn 1`;

	string $ovb=("polyPrimitive"+$op);
	string $createuv		= (uiRes("m_performPolyPrimitive.kCreateUVs"));
	string $normalize		= (uiRes("m_performPolyPrimitive.kNormalize"));
	string $aspratio		= (uiRes("m_performPolyPrimitive.kPreserveAspectRatio"));
	string $roundcap		= (uiRes("m_performPolyPrimitive.kRoundCap"));
	string $spoles			= (uiRes("m_performPolyPrimitive.kSawtoothatPoles"));
	string $collectively		= (uiRes("m_performPolyPrimitive.kCollectively"));
	string $face			= (uiRes("m_performPolyPrimitive.kEachfaceSeparately"));
	string $sidelength		= (uiRes("m_performPolyPrimitive.kSideLength"));
	string $radius			= (uiRes("m_performPolyPrimitive.kRadius"));
	string $width			= (uiRes("m_performPolyPrimitive.kWidth"));
	string $height			= (uiRes("m_performPolyPrimitive.kHeight"));
	string $length			= (uiRes("m_performPolyPrimitive.kLength"));
	string $depth			= (uiRes("m_performPolyPrimitive.kDepth"));
	string $coils			= (uiRes("m_performPolyPrimitive.kCoils"));
	string $twist			= (uiRes("m_performPolyPrimitive.kTwist"));
	string $thickness		= (uiRes("m_performPolyPrimitive.kThickness"));
	string $texturemapping		= (uiRes("m_performPolyPrimitive.kTextureMapping"));
	string $sectionradius		= (uiRes("m_performPolyPrimitive.kSectionRadius"));
	string $icosahedron		= (uiRes("m_performPolyPrimitive.kIcosahedron"));
	string $octahedron		= (uiRes("m_performPolyPrimitive.kOctahedron"));
	string $tetrahedron		= (uiRes("m_performPolyPrimitive.kTetrahedron"));
	string $dodecahedron		= (uiRes("m_performPolyPrimitive.kDodecahedron"));
	string $clockwise		= (uiRes("m_performPolyPrimitive.kClockwise"));
	string $counterclockwise	= (uiRes("m_performPolyPrimitive.kCounterclockwise"));
	string $pinchedatpoles		= (uiRes("m_performPolyPrimitive.kPinchedAtPoles"));

	if ($op == "Sphere") {
		ofoption(($ovb+"Radius"), $radius);
		ooption(($ovb+"SX"), "X", 3, 50, 3, 1000);
		ooption(($ovb+"SY"), "Y", 3, 50, 3, 1000);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc "sphereUVCallBack" ($ovb+"CreateUVs") ;
		radioButtonGrp 
            - vertical
			-numberOfRadioButtons 2
			-labelArray2 $pinchedatpoles $spoles
			($ovb+"UVType");
	} else if ($op == "Cube") {
		ofoption(($ovb+"Width"), $width);
		ofoption(($ovb+"Height"), $height);
		ofoption(($ovb+"Depth"), $depth);
		ooption(($ovb+"SX"), "X", 1, 50, 1, 1000);
		ooption(($ovb+"SY"), "Y", 1, 50, 1, 1000);
		ooption(($ovb+"SZ"), "Z", 1, 50, 1, 1000);
		oroption(($ovb+"Axis"));

		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		radioButtonGrp 
            - vertical
			-numberOfRadioButtons 2
			-labelArray2 $collectively $face
			-cc ("solidNormalizeTypeCallBack "+$op)
			($ovb+"NormalizeType");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
		
	} else if ($op == "Cone" || $op == "Cylinder") {
		ofoption(($ovb+"Radius"), $radius);
		ofoption(($ovb+"Height"), $height);
		ooption(($ovb+"SX"), "X", 3, 50, 3, 1000);
		ooption(($ovb+"SY"), "Y", 1, 50, 1, 1000);
		ooption(($ovb+"SZ"), "Z", 0, 50, 0, 1000);
		checkBoxGrp
			-label1 $roundcap
			-onCommand1 ("if( `intSliderGrp -query -value " + $ovb + "SZ` == 0 ) { intSliderGrp -edit -value 1 " + $ovb + "SZ; }")
			 ($ovb+"RoundCap");
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
	} else if ($op=="Plane") {
		ofoption(($ovb+"Width"), $width);
		ofoption(($ovb+"Height"), $height);
		ooption(($ovb+"SX"), "X", 1, 50, 1, 2048);
		ooption(($ovb+"SY"), "Y", 1, 50, 1, 2048);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
	} else if ($op == "Torus") {
		ofoption(($ovb+"Radius"), $radius);
		ofoption(($ovb+"SectionRadius"), $sectionradius);
		floatSliderGrp -label $twist -min 0. -max 360. -fmn 0. -fmx 360. ($ovb+"Twist");
		ooption(($ovb+"SX"), "X", 3, 50, 1, 1000);
		ooption(($ovb+"SY"), "Y", 3, 50, 1, 1000);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv ($ovb+"CreateUVs");
	} else if ($op == "Prism") {
		ofoption(($ovb+"Length"), $length);
		ofoption(($ovb+"SideLength"), $sidelength);
		ooption(($ovb+"NS"), "X", 3, 50, 3, 1000);
		ooption(($ovb+"SH"), "Y", 1, 50, 1, 1000);
		ooption(($ovb+"SC"), "Z", 0, 50, 0, 1000);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
	} else if ($op == "Pyramid") {
		ofoption(($ovb+"SideLength"), $sidelength);
        ornsoption(($ovb+"NS"));
		ooption(($ovb+"SH"), "Y", 1, 50, 1, 1000);
		ooption(($ovb+"SC"), "Z", 0, 50, 0, 1000);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
	} else if ($op == "PlatonicSolid") {
        ofoption(($ovb+"Radius"), $radius);
        ofoption(($ovb+"SideLength"), $sidelength);
 		oroption(($ovb+"Axis"));
		oloption (($ovb+"SolidType"), $dodecahedron, $icosahedron, $octahedron, $tetrahedron);
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		radioButtonGrp 
            - vertical
			-numberOfRadioButtons 2
			-labelArray2 $collectively $face
			-cc ("solidNormalizeTypeCallBack "+$op)
			($ovb+"NormalizeType");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");

	} else if ($op == "Pipe") {
		ofoption(($ovb+"Radius"), $radius);
		ofoption(($ovb+"Height"), $height);
        ofoption(($ovb+"Thickness"), $thickness);
		ooption(($ovb+"SA"), "X", 3, 50, 3, 1000);
		ooption(($ovb+"SH"), "Y", 1, 50, 1, 1000);
		ooption(($ovb+"SC"), "Z", 0, 50, 0, 1000);
		checkBoxGrp
			-label1 $roundcap
			-onCommand1 ("if( `intSliderGrp -query -value " + $ovb + "SC` < 2 ) { intSliderGrp -edit -value 2 " + $ovb + "SC; }")
			($ovb+"RoundCap");
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv ($ovb+"CreateUVs");
	}  else if ($op == "Helix") {
		ofoption(($ovb+"Coils"), $coils);
		ofoption(($ovb+"Height"), $height);
        ofoption(($ovb+"Width"), $width);
        ofoption(($ovb+"Radius"), $radius);
        ooption(($ovb+"SA"), "X", 3, 50, 3, 1000);
		ooption(($ovb+"SCO"), "Y", 50, 500, 2, 1000);
		ooption(($ovb+"SC"), "C", 0, 50, 0, 1000);
		checkBoxGrp 
			-label1 $roundcap  
			-onCommand1 ("if( `intSliderGrp -query -value " + $ovb + "SC` == 0 ) { intSliderGrp -edit -value 1 " + $ovb + "SC; }")
			($ovb+"RoundCap");
        odoption(($ovb+"Direction"),$clockwise,
                                    $counterclockwise);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
	}else if ($op == "Misc") {
		ofoption(($ovb+"Radius"), $radius);
		ofoption(($ovb+"SideLength"), $sidelength);
		oroption(($ovb+"Axis"));
		checkBoxGrp -label $texturemapping -label1 $createuv -cc ("solidsUVCallBack "+$op) ($ovb+"CreateUVs");
		checkBoxGrp -label1 $normalize -cc ("solidNormalizeCallBack "+$op) ($ovb+"Normalize");
		radioButtonGrp 
            - vertical
			-numberOfRadioButtons 2
			-labelArray2 $collectively $face
			-cc ("solidNormalizeTypeCallBack "+$op)
			($ovb+"NormalizeType");
		checkBoxGrp -label1 $aspratio ($ovb+"PreserveAspectRatio");
	}
    waitCursor -state 0;
  	setUITemplate -popTemplate;

  	string $applyBtn = getOptionBoxApplyBtn();
  	button -edit -label (uiRes("m_performPolyPrimitive.kCreate"))
  	       -command ($callback + " " + $parent + " " + 1)
  		$applyBtn;
  	string $saveBtn = getOptionBoxSaveBtn();
  	button -edit 
  		-command ($callback + " " + $parent + " " + 0 + "; hideOptionBox")
		$saveBtn;
	string $resetBtn = getOptionBoxResetBtn();
	button -edit 
		-command ($setup + " " + $parent + " " + 1)
		$resetBtn;

	//	Customize the 'Help' menu item text.
	//
	switch ($op) {
		case "Sphere":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonSphereOptions"));
			setOptionBoxHelpTag( "PolySphere" );
			break;
		case "Cube":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonCubeOptions"));
			setOptionBoxHelpTag( "PolyCube" );
			break;
		case "Cone":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonConeOptions"));
			setOptionBoxHelpTag( "PolyCone" );
			break;
		case "Cylinder":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonCylinderOptions"));
			setOptionBoxHelpTag( "PolyCylinder" );
			break;
		case "Plane":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonPlaneOptions"));
			setOptionBoxHelpTag( "PolyPlane" );
			break;
		case "Torus":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonTorusOptions"));
			setOptionBoxHelpTag( "PolyTorus" );
			break;
		case "Prism":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonPrismOptions"));
			setOptionBoxHelpTag( "PolyPrism" );
			break;
		case "Pyramid":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonPyramidOptions"));
			setOptionBoxHelpTag( "PolyPyramid" );
			break;
		case "Pipe":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonPipeOptions"));
			setOptionBoxHelpTag( "PolyPipe" );
			break;
		case "PlatonicSolid":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonPlatonicSolidOptions"));
			setOptionBoxHelpTag( "PolyPlatonicSolid" );
			break;
		case "Helix":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonHelixOptions"));
			setOptionBoxHelpTag( "PolyHelix" );
			break;
		case "Misc":
			setOptionBoxTitle (uiRes("m_performPolyPrimitive.kPolygonMiscOptions"));
			setOptionBoxHelpTag( "PolyPrimitiveMisc" );
			break;
	}	

	eval (($setup + " " + $parent + " " + 0));      
	showOptionBox();
}

proc string oval (string $res, string $ovar, string $pname)
{
	return $retVal =  ($res + " -" + $pname + " " + `optionVar -query $ovar`);
}

proc string orval (string $res, string $ovar)
{
	int $val = `optionVar -query $ovar`;
	if( $val == 1 )
		$res = ($res + " -ax " + "1 0 0");
	if( $val == 2 )
		$res = ($res + " -ax " + "0 1 0");
	if( $val == 3 )
		$res = ($res + " -ax " + "0 0 1");
	return $res;
}

proc string ornsval (string $res, string $ovar)
{
	int $val = `optionVar -query $ovar`;
	if( $val == 1 )
		$res = ($res + " -ns " + "3");
	if( $val == 2 )
		$res = ($res + " -ns " + "4");
	if( $val == 3 )
		$res = ($res + " -ns " + "5");
	return $res;
}

proc string orstval (string $res, string $ovar)
{
	int $val = `optionVar -query $ovar`;
	$res = ($res + " -st " + $val + " ");
	return $res;
}

proc string assembleActionCmd(string $op, string $cmd)
{
	string $ovb=("polyPrimitive"+$op);
	if ($op == "Sphere") {
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"SX"), "sx");
		$cmd = oval($cmd,($ovb+"SY"), "sy");
		$cmd = orval($cmd,($ovb+"Axis"));

		if (`optionVar -query polyPrimitiveSphereCreateUVs`)  {
			$cmd = oval($cmd,($ovb+"UVType"), "cuv");
		}
		else{
			$cmd = oval($cmd,($ovb+"CreateUVs"), "cuv");
		}			
	} else if ($op == "Cube") {
		$cmd = oval($cmd,($ovb+"Width"), "w");
		$cmd = oval($cmd,($ovb+"Height"), "h");
		$cmd = oval($cmd,($ovb+"Depth"), "d");
		$cmd = oval($cmd,($ovb+"SX"), "sx");
		$cmd = oval($cmd,($ovb+"SY"), "sy");
		$cmd = oval($cmd,($ovb+"SZ"), "sz");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = solidsCommand($cmd, $op);
	} else if ($op == "Cone" || $op == "Cylinder") {
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"Height"), "h");
		$cmd = oval($cmd,($ovb+"SX"), "sx");
		$cmd = oval($cmd,($ovb+"SY"), "sy");
		$cmd = oval($cmd,($ovb+"SZ"), "sz");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = oval($cmd,($ovb+"RoundCap"), "rcp");
		$cmd = solidsCommand($cmd, $op);
	} else if ($op=="Plane") {
		$cmd = oval($cmd,($ovb+"Width"), "w");
		$cmd = oval($cmd,($ovb+"Height"), "h");
		$cmd = oval($cmd,($ovb+"SX"), "sx");
		$cmd = oval($cmd,($ovb+"SY"), "sy");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = solidsCommand($cmd, $op);
	} else if ($op == "Torus") {
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"SectionRadius"), "sr");
		$cmd = oval($cmd,($ovb+"Twist"), "tw");
		$cmd = oval($cmd,($ovb+"SX"), "sx");
		$cmd = oval($cmd,($ovb+"SY"), "sy");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = oval($cmd,($ovb+"CreateUVs"), "cuv");
	} else if ($op == "Prism") {
		$cmd = oval($cmd,($ovb+"Length"), "l");
		$cmd = oval($cmd,($ovb+"SideLength"), "w");
		$cmd = oval($cmd,($ovb+"NS"), "ns");
		$cmd = oval($cmd,($ovb+"SH"), "sh");
		$cmd = oval($cmd,($ovb+"SC"), "sc");
		$cmd = orval($cmd,($ovb+"Axis"));      
		$cmd = solidsCommand($cmd, $op);
	} else if ($op == "Pyramid") {  
		$cmd = oval($cmd,($ovb+"SideLength"), "w");
		$cmd = ornsval($cmd,($ovb+"NS"));
		$cmd = oval($cmd,($ovb+"SH"), "sh");
		$cmd = oval($cmd,($ovb+"SC"), "sc");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = solidsCommand($cmd, $op);
	} else if ($op == "PlatonicSolid") {
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"SideLength"), "l");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = orstval($cmd,($ovb+"SolidType"));
		$cmd = solidsCommand($cmd, $op);
	} else if ($op == "Pipe") {  
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"Height"), "h");
		$cmd = oval($cmd,($ovb+"Thickness"), "t");
		$cmd = oval($cmd,($ovb+"SA"), "sa");
		$cmd = oval($cmd,($ovb+"SH"), "sh");
		$cmd = oval($cmd,($ovb+"SC"), "sc");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = oval($cmd,($ovb+"CreateUVs"), "cuv");
		$cmd = oval($cmd,($ovb+"RoundCap"), "rcp");
	} else if ($op == "Helix") {  
		$cmd = oval($cmd,($ovb+"Coils"), "c");
		$cmd = oval($cmd,($ovb+"Height"), "h");
		$cmd = oval($cmd,($ovb+"Width"), "w");
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"SA"), "sa");
		$cmd = oval($cmd,($ovb+"SCO"), "sco");
		$cmd = oval($cmd,($ovb+"SC"), "sc");
		$cmd = oval($cmd,($ovb+"Direction"), "d");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = oval($cmd,($ovb+"RoundCap"), "rcp");
		$cmd = solidsCommand($cmd, $op);
	} else if ($op == "Misc") {
		$cmd = oval($cmd,($ovb+"Radius"), "r");
		$cmd = oval($cmd,($ovb+"SideLength"), "l");
		$cmd = orval($cmd,($ovb+"Axis"));
		$cmd = $cmd + " -pt 0 ";
		$cmd = solidsCommand($cmd, $op);
	}
		// History
		//
		int $doHistory = `constructionHistory -q -toggle`;
		$cmd = ($cmd + " -ch " + $doHistory);
		return $cmd;
}

proc string assembleToolCmd(string $op, string $cmd)
{
	int $useNewContext = false;
	
	// Get the Action command and feed it into tool
	$cmd = assembleActionCmd($op, $cmd);

	string $ctxName;
	string $icon = "vacantCell.png";

	switch($op) {
		case "Sphere": $icon = "polySphere.png"; $useNewContext = true; $ctxName = "CreatePolySphereCtx"; break;
		case "Cube":  $icon = "polyCube.png"; $useNewContext = true; $ctxName = "CreatePolyCubeCtx"; break;
		case "Cone": $icon = "polyCone.png"; $useNewContext = true; $ctxName = "CreatePolyConeCtx"; break;
		case "Cylinder": $icon = "polyCylinder.png"; $useNewContext = true; $ctxName = "CreatePolyCylinderCtx"; break;
		case "Plane": $icon = "polyMesh.png"; $useNewContext = true; $ctxName = "CreatePolyPlaneCtx"; break;
		case "Torus": $icon = "polyTorus.png"; $useNewContext = true; $ctxName = "CreatePolyTorusCtx"; break;
		case "Prism": $icon = "polyPrism.png"; $useNewContext = true; $ctxName = "CreatePolyPrismCtx"; break;
		case "Pyramid": $icon = "polyPyramid.png"; $useNewContext = true; $ctxName = "CreatePolyPyramidCtx"; break;  
		case "PlatonicSolid": $icon = "polyPlatonic.png"; $useNewContext = true; $ctxName = "CreatePolyPlatonicSolidCtx"; break;  
		case "Pipe": $icon = "polyPipe.png"; $useNewContext = true; $ctxName = "CreatePolyPipeCtx"; break;  
		case "Helix": $icon = "polyHelix.png"; $useNewContext = true; $ctxName = "CreatePolyHelixCtx"; break;  
		case "Misc": $icon = "polySoccerBall.png"; $useNewContext = true; $ctxName = "CreatePolySoccerBallCtx"; break;  
	}
	
	if ($useNewContext)
		$cmd = "setToolTo " + $ctxName;
	else
		$cmd = "createPrimitiveToolWithIcon(\"" + $cmd + "\", \"" + $icon + "\"); setToolTo createPrimitiveContext";
		
	return $cmd;
}

proc string assembleCmd (string $op)
{
	string $cmd;	
	if($op == "PlatonicSolid"){
		$cmd = "polyPlatonicSolid";
	} 
	// the operation is for miscellanious polygon
	// currently we have only soccer ball 
	else if($op == "Misc") {
		$cmd = ("polyPrimitive");
	}
	else {
		$cmd = ("poly" + $op);
	}
	setOptionVars(false, $op);

	if(`optionVar -q createPolyPrimitiveAsTool`) {
		$cmd = assembleToolCmd($op, $cmd);
	} else {
		$cmd = assembleActionCmd($op, $cmd);
	}
	
	return $cmd;
}

global proc string performPolyPrimitive (string $operation, int $option)
{
	string $cmd="";
	switch ($option) {
	case 0:
		setOptionVars(false, $operation);
		$cmd = `assembleCmd $operation`;
		
		if(`optionVar -q createPolyPrimitiveAsTool`) {
			evalEcho $cmd;
		} else {
			string $currentTool=`currentCtx`;
			setToolTo selectSuperContext;
			evalEcho $cmd;
			
			// Initialize the just created mesh node with global settings
			setupNewMesh();
			
			if (`exists objectMoveCommand`)
				objectMoveCommand;
			if( `contextInfo -exists $currentTool`) {
				setToolTo $currentTool;
			}
		}
		break;
	case 1: 
		if(`optionVar -q createPolyPrimitiveAsTool`) {
			$cmd = `assembleCmd $operation`;
			evalEcho $cmd;
			toolPropertyWindow;
		} else {
			polyPrimitiveOptions $operation; break;
		}
	default:
		setOptionVars(false, $operation);
		$cmd = `assembleCmd $operation`;
		if (!(`optionVar -q createPolyPrimitiveAsTool`) && `exists objectMoveCommand`)
			$cmd = ($cmd + "; objectMoveCommand;");
	}
	return $cmd;
}
//Callback for Sphere 
global proc sphereUVCallBack () {
	if(`checkBoxGrp -query -value1 polyPrimitiveSphereCreateUVs`)
		radioButtonGrp -edit -enable true polyPrimitiveSphereUVType;
	else
		radioButtonGrp -edit -enable false polyPrimitiveSphereUVType;
}

//Check the UV & Normalization condtitions for Cube, Platonic Solids, Soccer Ball & Cone..
global proc solidsUVCallBack (string $op) {

	string $ovb=("polyPrimitive"+$op);
	
	if(`checkBoxGrp -query -value1 ($ovb+"CreateUVs")`){
		if($op == "Plane")
			checkBoxGrp -edit -enable true -value1 1 ($ovb+"PreserveAspectRatio");
		else if($op == "Cone" || $op == "Pyramid" || $op == "Cylinder" || $op == "Prism" || $op == "Helix"){ 
			checkBoxGrp -edit -enable true -value1 1 ($ovb+"Normalize");
			checkBoxGrp -edit -enable true -value1 1 ($ovb+"PreserveAspectRatio");
		}
		else{
			checkBoxGrp -edit -enable true -value1 1 ($ovb+"Normalize");
			radioButtonGrp -edit -enable true ($ovb+"NormalizeType");
			if(`radioButtonGrp -query -select ($ovb+"NormalizeType")`==1)
				checkBoxGrp -edit -enable true -value1 1 ($ovb+"PreserveAspectRatio");
			else
				checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		}
	}
	else{
		if($op == "Plane")
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		else if($op == "Cone" || $op == "Pyramid" || $op == "Cylinder" || $op == "Prism" || $op == "Helix"){
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"Normalize");
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		}
		else{			
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"Normalize");
			radioButtonGrp -edit -enable false ($ovb+"NormalizeType");
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		}
	}
}
//Check the UV & Normalization conditions for Cube, Platonic Solids  & Cone.
global proc solidNormalizeCallBack (string $op) {

	string $ovb=("polyPrimitive"+$op);
	
	if(`checkBoxGrp -query -value1 ($ovb+"Normalize")`){
		if($op == "Cone" || $op == "Pyramid" || $op == "Cylinder" || $op == "Prism" || $op == "Helix")
			checkBoxGrp -edit -enable true -value1 1 ($ovb+"PreserveAspectRatio");
		else{
			radioButtonGrp -edit -enable true ($ovb+"NormalizeType");			
			if(`radioButtonGrp -query -select ($ovb+"NormalizeType")`==1)
				checkBoxGrp -edit -enable true -value1 1 ($ovb+"PreserveAspectRatio");
			else
				checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		}
	}
	else{
		if($op == "Cone" || $op == "Pyramid" || $op == "Cylinder" || $op == "Prism" || $op == "Helix")
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		else{
			radioButtonGrp -edit -enable false ($ovb+"NormalizeType");
			checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
		}
	}
}
//Check the UV & Normalization condtitions for Cube & Platonic Solids.
global proc solidNormalizeTypeCallBack (string $op) {
	
	string $ovb=("polyPrimitive"+$op);
	
	if(`radioButtonGrp -query -select ($ovb+"NormalizeType")`==1)
		checkBoxGrp -edit -enable true -value1 1 ($ovb+"PreserveAspectRatio");
	else
		checkBoxGrp -edit -enable false -value1 0 ($ovb+"PreserveAspectRatio");
}
//Set command values for cube, platonic solids, soccer ball & cone.
global proc string solidsCommand (string $res, string $op)
{
	string $ovb=("polyPrimitive"+$op);
	if (`optionVar -query ($ovb+"CreateUVs")`){ //CreateUVs On
	
		if($op=="Plane"){
			if (`optionVar -query ($ovb+"PreserveAspectRatio")`) //Normalize & preserve aspect ratio
				$res += " -cuv 2";
			else //Normalize (no preserving aspect ratio)
				$res += " -cuv 1";
		}
		else{
			if (`optionVar -query ($ovb+"Normalize")`){ //Normalization On
				if($op=="Cone" || $op == "Pyramid" || $op == "Cylinder" || $op == "Prism" || $op == "Helix"){
					if (`optionVar -query ($ovb+"PreserveAspectRatio")`) //Normalize & preserve aspect ratio
						$res += " -cuv 3";
					else //Normalize (no preserving aspect ratio)
						$res += " -cuv 2";
				}
				else{
					if (`optionVar -query ($ovb+"NormalizeType")`==1){ //Set Normalize type
						if (`optionVar -query ($ovb+"PreserveAspectRatio")`) //Normalize collectively & preserve aspect ratio
							$res += " -cuv 4";
						else //Normalize collectively (no preserving aspect ratio)
							$res += " -cuv 3";
					}						
					else //Normalize each face separately
						$res += " -cuv 2";
				}
			}
			else //Normalization off
				$res += " -cuv 1";
		}
	}
	else //CreateUVs off
		$res += " -cuv 0";
	return $res;
}