/*
<?xml version='1.0' standalone='yes' ?>

<script>
	<name>Circular Array</name>
	<author>Petri Ihalainen</author>
	<version>1.0</version>
	<date>21/09/2008</date>
	<description>
			Create a circular array of the selected objects.
    </description>
</script>
*/

/*
Special thanks to Nik for the help with the widgets :)
*/

// Creating a list of selected objects
// and checking if any objects were selected

scene = window.getScene();
selection=scene.getSelection();

if (selection.length < 1)
{
   new MessageDialog(window, "Select at least one object before launcing the script");
   return;
}

//=====================================================================================
// Defining the widgettd for the dialogbox
//=====================================================================================
if (selection.length == 1){ArrNameText = "Circular Array of "+ scene.getObject(selection[0]).name;}
else{ArrNameText = "Circular Array of "+ selection.length + " objects";}

ArrNameField = new BTextField(ArrNameText);
NumOfSegField = new ValueField(16, ValueField.POSITIVE+ValueField.INTEGER);
chkFullCircle = new BCheckBox(); chkFullCircle.setState(true);
chkRotAlong = new BCheckBox(); chkRotAlong.setState(true);
chkAdd_on_End = new BCheckBox(); chkAdd_on_End.setState(true); chkAdd_on_End.setEnabled(false);

totalPropField = new ValueField(0.0, ValueField.NONE); totalPropField.setEnabled(false);
RotAngleField = new ValueField(360, ValueField.NONE); RotAngleField.setEnabled(false);

rotSlideZ = new ValueSlider(-8.0, 8.0, 2000, 1.0); rotSlideZ.setEnabled(false);
rotSlideX = new ValueSlider(-8.0, 8.0, 2000, 0.0); rotSlideX.setEnabled(false);
rotSlideY = new ValueSlider(-8.0, 8.0, 2000, 0.0); rotSlideY.setEnabled(false);

AxisDef = new RadioButtonGroup();
UseX = new BRadioButton("X", false, AxisDef); UseX.setName("UseX");
UseY = new BRadioButton("Y", false, AxisDef); UseY.setName("UseY");
UseZ = new BRadioButton("Z", true,  AxisDef); UseZ.setName("UseZ");
Use2P = new BRadioButton("Two points", false,  AxisDef); Use2P.setName("Use2P");
AxisDefGrid = new RowContainer();
AxisDefGrid.add(UseX); AxisDefGrid.add(UseY); AxisDefGrid.add(UseZ);AxisDefGrid.add(Use2P);

p1Label = new BLabel("Point1");
p1XF = new ValueField(0.0, ValueField.NONE); p1XF.setEnabled(false);
p1YF = new ValueField(0.0, ValueField.NONE); p1YF.setEnabled(false);
p1ZF = new ValueField(0.0, ValueField.NONE); p1ZF.setEnabled(false);
P1DefGrid = new RowContainer();
P1DefGrid.add(p1Label);P1DefGrid.add(p1XF);P1DefGrid.add(p1YF);P1DefGrid.add(p1ZF);

p2Label = new BLabel("Point2");
p2XF = new ValueField(1.0, ValueField.NONE); p2XF.setEnabled(false);
p2YF = new ValueField(1.0, ValueField.NONE); p2YF.setEnabled(false);
p2ZF = new ValueField(1.0, ValueField.NONE); p2ZF.setEnabled(false);
P2DefGrid = new RowContainer();
P2DefGrid.add(p2Label);P2DefGrid.add(p2XF);P2DefGrid.add(p2YF);P2DefGrid.add(p2ZF);

AngleDef = new RadioButtonGroup();
Angle_per_Total = new BRadioButton("Total angle", true, AngleDef); Angle_per_Total.setEnabled(false);
Angle_per_Segment = new BRadioButton("Angle per segment", false, AngleDef); Angle_per_Segment.setEnabled(false);
AngleDefGrid = new RowContainer();
AngleDefGrid.add(Angle_per_Total);AngleDefGrid.add(Angle_per_Segment);

PropDef = new RadioButtonGroup();
Prop_per_Total = new BRadioButton("Total distance", true, PropDef); Prop_per_Total.setEnabled(false);
Prop_per_Segment = new BRadioButton("Distance per segment", false, PropDef); Prop_per_Segment.setEnabled(false);
PropDefGrid = new RowContainer();
PropDefGrid.add(Prop_per_Total);PropDefGrid.add(Prop_per_Segment);

//=====================================================================================
// Building the interactive features to the dialogbox widgetrs
//=====================================================================================

Use2P.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev1) 
{ p1XF.setEnabled(ev1.getWidget().getState()); 
	p1YF.setEnabled(ev1.getWidget().getState());
	p1ZF.setEnabled(ev1.getWidget().getState());
	p2XF.setEnabled(ev1.getWidget().getState());
	p2YF.setEnabled(ev1.getWidget().getState());
	p2ZF.setEnabled(ev1.getWidget().getState());
}}); 
UseX.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev1) 
{ p1XF.setEnabled(!ev1.getWidget().getState()); 
	p1YF.setEnabled(!ev1.getWidget().getState());
	p1ZF.setEnabled(!ev1.getWidget().getState());
	p2XF.setEnabled(!ev1.getWidget().getState());
	p2YF.setEnabled(!ev1.getWidget().getState());
	p2ZF.setEnabled(!ev1.getWidget().getState());
}}); 
UseY.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev1) 
{ p1XF.setEnabled(!ev1.getWidget().getState()); 
	p1YF.setEnabled(!ev1.getWidget().getState());
	p1ZF.setEnabled(!ev1.getWidget().getState());
	p2XF.setEnabled(!ev1.getWidget().getState());
	p2YF.setEnabled(!ev1.getWidget().getState());
	p2ZF.setEnabled(!ev1.getWidget().getState());
}}); 
UseZ.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev1) 
{ p1XF.setEnabled(!ev1.getWidget().getState()); 
	p1YF.setEnabled(!ev1.getWidget().getState());
	p1ZF.setEnabled(!ev1.getWidget().getState());
	p2XF.setEnabled(!ev1.getWidget().getState());
	p2YF.setEnabled(!ev1.getWidget().getState());
	p2ZF.setEnabled(!ev1.getWidget().getState());
}}); 


chkFullCircle.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev3) 
{ totalPropField.setEnabled(!ev3.getWidget().getState()); 
	RotAngleField.setEnabled(!ev3.getWidget().getState());
	Prop_per_Segment.setEnabled(!ev3.getWidget().getState());
	Prop_per_Total.setEnabled(!ev3.getWidget().getState());
	Angle_per_Segment.setEnabled(!ev3.getWidget().getState());
	Angle_per_Total.setEnabled(!ev3.getWidget().getState());
	chkAdd_on_End.setEnabled(!ev3.getWidget().getState());
} 
}); 

chkRotAlong.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ rotSlideZ.setEnabled(!ev.getWidget().getState()); 
	rotSlideX.setEnabled(!ev.getWidget().getState()); 
	rotSlideY.setEnabled(!ev.getWidget().getState()); 
} 
}); 

Prop_per_Segment.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ if (ev.getWidget().getState() == true){
	totalPropField.setValue(totalPropField.getValue()/NumOfSegField.getValue());
	}
} 
}); 

Prop_per_Total.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ if (ev.getWidget().getState()==true){
	totalPropField.setValue(totalPropField.getValue()*NumOfSegField.getValue());
	}
} 
}); 

Angle_per_Segment.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ if (ev.getWidget().getState() == true){
	RotAngleField.setValue(RotAngleField.getValue()/NumOfSegField.getValue());
	}
} 
}); 

Angle_per_Total.addEventLink(ValueChangedEvent.class, new Object() { 
public void processEvent(WidgetEvent ev) 
{ if (ev.getWidget().getState() == true){
	RotAngleField.setValue(RotAngleField.getValue()*NumOfSegField.getValue());
	}
} 
}); 

//prg = new BProgressBar(0, 1); //Progressbar did not work

//=====================================================================================
// Drawng the dialogbox
//=====================================================================================

dialog = new ComponentsDialog(	window, "Circular Array" ,
														    new Widget [] { new BLabel("Array identification"),
														    								ArrNameField, NumOfSegField, AxisDefGrid, 
														    								P1DefGrid,P2DefGrid,
														    								new  BSeparator(), new BLabel("Define angular and axial propagation"),
														    								chkFullCircle, 
														    								RotAngleField, AngleDefGrid,
														    								totalPropField, PropDefGrid,
														    								chkAdd_on_End, 
														    								new  BSeparator(), new BLabel("Define Local Rotation Weights"),
														    								chkRotAlong, 
														    								rotSlideZ, rotSlideX, rotSlideY, 
														    								
														    								new  BSeparator(), new BLabel(""),
														    								},
														    new String [] { "",
														    								"Name of the Array","Number of Segments","Select axis", 
														    								"","",
														    								"","",
														    								"Make a full Circle", 
														    								"Rotation Angle", "",
														    								"Propagation distance","",
														    								"Add one to the end",
														    								"", "", 
														    								"Fix Rotations", 
														    								"Axial", "Circumferencial", "Radial",
														    								"", ""});
										
if (!dialog.clickedOk()) return; // if clicked something else that OK exit the script

//=====================================================================================
// Getting some values from the dialog....
//=====================================================================================

n = NumOfSegField.getValue();


rotWeightZ = rotSlideZ.getValue();
rotWeightX = rotSlideX.getValue();
rotWeightY = rotSlideY.getValue();


if (chkFullCircle.getState() == true){
	totalProp = 0.0;
	dadeg = 360.0/n;
}
else{
	if (Prop_per_Total.getState() == true)
		{totalProp = totalPropField.getValue();}
	else{totalProp = totalPropField.getValue()*n;}

	if (Angle_per_Total.getState() == true)
		{dadeg = RotAngleField.getValue()/n;}
	else{dadeg = RotAngleField.getValue();}
}

//=====================================================================================
// Repeat the following to all the objects that were selected
//=====================================================================================
for (s=0;s<selection.length;s++){

theInfo   = scene.getObject(selection[s]);
theObject = theInfo.object;
theOrigin = theInfo.coords.getOrigin();
theName   = theInfo.name;

// Defining the coodrtnatesystem to the new array

switch (AxisDef.getSelection().getName()) {
case "UseX":
	ArrayOrigin = new Vec3(0.0,0.0,0.0);
	ArrayAxis = new Vec3(1.0,0.0,0.0);
	ArrayRadDir = theOrigin.times(1.0);
	break;
case "UseY":
	ArrayOrigin = new Vec3(0.0,0.0,0.0);
	ArrayAxis = new Vec3(0.0,1.0,0.0);
	ArrayRadDir = theOrigin.times(1.0);
	break;
case "UseZ":
	ArrayOrigin = new Vec3(0.0,0.0,0.0);
	ArrayAxis = new Vec3(0.0,0.0,1.0);
	ArrayRadDir = theOrigin.times(1.0);
	break;

case "Use2P":
	Point1 = new Vec3(p1XF.getValue(), p1YF.getValue(), p1ZF.getValue());
	Point2 = new Vec3(p2XF.getValue(), p2YF.getValue(), p2ZF.getValue());
	ArrayOrigin = Point1.times(1.0);
	ArrayAxis = Point2.minus(Point1); 
	ArrayRadDir = theOrigin.minus(Point1);
	break;
	
default:
	break;
}

//------------------------------------------------------------
// Trying to make sure that the attempted radiuscoordinate 
// is different from the axis direction
// This may not be fool proof yet. The logic depends on the 
// orientation of the object.
//------------------------------------------------------------

	if (ArrayRadDir.length() == 00)
		ArrayRadDir = theInfo.coords.getZDirection();

	ArrayAxis.normalize();
	ArrayRadDir.normalize();

	if (ArrayRadDir.equals(ArrayAxis) == true)
		ArrayRadDir = theInfo.coords.getUpDirection();

	ArrayRadDir.normalize();
	if (ArrayRadDir.equals(ArrayAxis) == true)
		ArrayRadDir = theInfo.coords.getZDirection();


// Creating a coordinate system for the array
rotCoords = new CoordinateSystem(ArrayOrigin, ArrayAxis, ArrayRadDir);

// Creating a base object for the array as defined by the first object on the selection
if (s == 0){
CircularArrayInfo = new ObjectInfo(new NullObject(),
															rotCoords.duplicate(),
															ArrNameText);
window.addObject(CircularArrayInfo,null);
}

WorkingCoords = new CoordinateSystem();

if (chkFullCircle.getState() == true){
	extra_at_end=0;
}
else{
	if (chkAdd_on_End.getState() == true) 
		{extra_at_end=1;} 
	else 
		{extra_at_end=0;}
}

//prg.setMaximum((int)(n + extra_at_end)); 

//-----------------------------------------------------------
// Do the copying
//-----------------------------------------------------------

//for(int i = 0; i < n*120 + extra_at_end ; i++) 
for(int i = 0; i < n + extra_at_end ; i++) 

{
		//prg.setValue(i); prg.repaint();
		WorkingCoords.transformCoordinates(WorkingCoords.toLocal());
   	theCoords = theInfo.coords.duplicate();
   	theCoords.transformCoordinates(rotCoords.toLocal());
		//------------
		if (chkRotAlong.getState() != true)
		{
			locCoords = new CoordinateSystem();
			prevOrigin = theCoords.getOrigin();

   		locCoords.setOrientation((i)*dadeg*(rotWeightX),
   														 (i)*dadeg*(rotWeightY),
   														 (i)*dadeg*(1.0-rotWeightZ));
   														 
			theCoords.setOrigin(new Vec3(0.0,0.0,0.0));
	 		theCoords.transformCoordinates(locCoords.toLocal());
			theCoords.setOrigin(prevOrigin);
		}
		//----------
		
		WorkingCoords.setOrientation(0.0,0.0, (i)*dadeg);
		
		if (chkFullCircle.getState() == !true){
				WorkingCoords.setOrigin(new Vec3(0.0,0.0, (-i)*totalProp/n));
		}
		
	 	theCoords.transformCoordinates(WorkingCoords.toLocal());
	 	theCoords.transformCoordinates(rotCoords.fromLocal());

   	newInfo = new ObjectInfo(theObject, theCoords, theName + "_" + i);
   	
		CircularArrayInfo.addChild(newInfo,0);
   	window.addObject(newInfo,null);    
		
} //close i-loop
} //close s-loop

window.rebuildItemList();

//========================
// And were done :)
//========================