private void WriteHoles(XmlTextWriter writer, Part part)
{
if (part != null)
{
ModelObjectEnumerator myHoleEnum = part.GetChildren();
while (myHoleEnum.MoveNext())
{
BooleanPart myHole = myHoleEnum.Current as BooleanPart;
if (myHole != null)
{
double Width = 0;
double Height = 0;
myHole.GetReportProperty("WIDTH", ref Width);
myHole.GetReportProperty("HEIGHT", ref Height);
writer.WriteStartElement("hole", null);
writer.WriteAttributeString("id", myHole.Identifier.ID.ToString());
writer.WriteElementString("width", Width.ToString("#####."));
writer.WriteElementString("height", Height.ToString("#####."));
writer.WriteEndElement();
}
}
}
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
try
{
Model model = new Model();
TransformationPlane transformationplane = model.GetWorkPlaneHandler().GetCurrentTransformationPlane();
model.GetWorkPlaneHandler().SetCurrentTransformationPlane(new TransformationPlane());
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
if (modelObjectEnum.GetSize() == 1)
{
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Tekla.Structures.Model.Part)
{
Tekla.Structures.Model.Part part = modelObjectEnum.Current as Tekla.Structures.Model.Part;
double level = 0; part.GetReportProperty("TOP_LEVEL_UNFORMATTED", ref level);
akit.CommandStart("ail_create_basic_view", "", "main_frame");
akit.ValueChange("Modelling create view", "v1_coordinate", level.ToString("F02"));
akit.PushButton("v1_create", "Modelling create view");
}
}
}
model.GetWorkPlaneHandler().SetCurrentTransformationPlane(transformationplane);
}
catch { }
}
internal void ModifyGrid(ref Model myModel)
{
bool Success = false;
ModelObjectEnumerator Enumerator = myModel.GetModelObjectSelector().GetAllObjects();
while (!Success && Enumerator.MoveNext())
{
ModelObject ModelObject = Enumerator.Current as ModelObject;
Type ObjectType = ModelObject.GetType();
while (ObjectType != typeof(Grid) && ObjectType.BaseType != null)
{
ObjectType = ObjectType.BaseType;
}
if (ObjectType == typeof(Grid))
{
Success = true;
}
}
Grid curGr = Enumerator.Current as Grid;
var ff = GetGridXString();
curGr.CoordinateX = ff.Item1;
curGr.CoordinateY = string.Format("{0:F2} 2*{1:F2}", BeamWidth * -0.5, BeamWidth * 0.5);
curGr.LabelX = ff.Item2;
curGr.LabelY = "R C L";
curGr.Modify();
myModel.CommitChanges();
}
public static IEnumerable <ModelObject> ToIEnumerable(ModelObjectEnumerator enumerator)
{
while (enumerator.MoveNext())
{
yield return(enumerator.Current);
}
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
Model model = new Model();
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
Tekla.Structures.Model.UI.Picker picker = new Tekla.Structures.Model.UI.Picker();
if (modelObjectEnum.GetSize() == 0)
{
modelObjectEnum = picker.PickObjects(Tekla.Structures.Model.UI.Picker.PickObjectsEnum.PICK_N_PARTS);
}
ArrayList arrayPoints = picker.PickPoints(Tekla.Structures.Model.UI.Picker.PickPointEnum.PICK_TWO_POINTS);
Point point1 = (Tekla.Structures.Geometry3d.Point)arrayPoints[0];
Point point2 = (Tekla.Structures.Geometry3d.Point)arrayPoints[1];
Line line = new Tekla.Structures.Geometry3d.Line(point1, point2);
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Beam)
{
Beam beam = (Beam)modelObjectEnum.Current;
Line line2 = new Line(beam.StartPoint, beam.EndPoint);
Point intersection = Intersection.LineToLine(line, line2).Point1;
Tekla.Structures.Model.Operations.Operation.Split(beam, intersection);
}
}
model.CommitChanges();
}
public PDLength()
{
System.Type[] selectionType = new System.Type[1];
selectionType.SetValue(typeof(TSM.CustomPart), 0);
Model myModel = new Model();
ModelObjectEnumerator allObjects = myModel.GetModelObjectSelector().GetAllObjectsWithType(selectionType);
while (allObjects.MoveNext())
{
if (allObjects.Current is TSM.CustomPart)
{
TSM.CustomPart currentComponent = allObjects.Current as TSM.CustomPart;
if (currentComponent.Name == "EB_PD")
{
double curWidth = 0.0;
double curLength = 0.0;
currentComponent.GetUserProperty("w", ref curWidth);
currentComponent.GetUserProperty("L", ref curLength);
string newName = "PD" + curWidth.ToString() + " L=" + curLength.ToString();
currentComponent.SetUserProperty("P1a", newName);
currentComponent.Modify();
}
}
}
myModel.CommitChanges();
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
try
{
Model model = new Model();
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
if (modelObjectEnum.GetSize() > 0)
{
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Tekla.Structures.Model.Part)
{
Tekla.Structures.Model.Part part = (Tekla.Structures.Model.Part)modelObjectEnum.Current;
string mark = "";
Hashtable strProps = new Hashtable();
ArrayList PartStrRepPropNames = new ArrayList();
PartStrRepPropNames.Add("ASSEMBLY_POS");
part.GetStringReportProperties(PartStrRepPropNames, ref strProps);
if ((mark = (string)strProps["ASSEMBLY_POS"]) == null)
{
mark = "";
}
mark = mark.Replace("(?)", "");
part.SetUserProperty("USER_FIELD_4", mark);
part.Modify();
}
}
model.CommitChanges();
MessageBox.Show("Process Complete");
}
}
catch { }
}
} // Read
protected Dictionary<string, T> ReadModObj<T>() where T : ModelObject
{
var result = new Dictionary<string, T>();
selector = model.GetModelObjectSelector();
Type[] Types = new Type[1];
Types.SetValue(typeof(T), 0);
ModelObjectEnumerator objParts = selector.GetAllObjectsWithType(Types);
int totalCnt = objParts.GetSize();
var progress = new Operation.ProgressBar();
bool displayResult = progress.Display(100, "TSmatch", "Reading model. Pass component records:", "Cancel", " ");
int iProgress = 0;
while(objParts.MoveNext())
{
T myObj = objParts.Current as T;
if (myObj == null) continue;
string guid = string.Empty;
myObj.GetReportProperty("GUID", ref guid);
result.Add(guid, myObj);
iProgress++;
if (iProgress % 500 == 0)
{
progress.SetProgress(iProgress.ToString(), 100 * iProgress / totalCnt);
if (progress.Canceled()) break;
}
}
progress.Close();
return result;
}
private void AddReinforcements(Part part, TreeNode partNode)
{
ModelObjectEnumerator rebarEnum = part.GetReinforcements();
while (rebarEnum.MoveNext())
{
Reinforcement rebar = null;
try
{
rebar = rebarEnum.Current as Reinforcement;
}
catch
{
}
if (rebar != null)
{
TreeNode childNode = new TreeNode(rebar.Name);
childNode.Tag = rebar.Identifier;
childNode.Name = rebar.Identifier.ID.ToString();
partNode.Nodes.Add(childNode);
}
}
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
try
{
Model model = new Model();
DrawingHandler drawingHandler = new DrawingHandler();
ArrayList ModelObjectArray = new ArrayList();
if (drawingHandler.GetActiveDrawing() != null)
{
DrawingObjectEnumerator drawingObjectEnum = drawingHandler.GetDrawingObjectSelector().GetSelected();
while (drawingObjectEnum.MoveNext())
{
Tekla.Structures.Drawing.ModelObject dModelObject = (Tekla.Structures.Drawing.ModelObject)drawingObjectEnum.Current;
ModelObjectArray.Add(model.SelectModelObject(dModelObject.ModelIdentifier));
}
}
else
{
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
while (modelObjectEnum.MoveNext())
{
Tekla.Structures.Model.ModelObject modelObject = (Tekla.Structures.Model.ModelObject)modelObjectEnum.Current;
ModelObjectArray.Add(model.SelectModelObject(modelObject.Identifier));
}
}
Tekla.Structures.Model.UI.ModelObjectSelector modelObjectSelector = new Tekla.Structures.Model.UI.ModelObjectSelector();
modelObjectSelector.Select(ModelObjectArray);
akit.Callback("acmdCreateViewBySelectedObjectsExtrema", "", "main_frame");
akit.Callback("acmd_interrupt", "", "main_frame");
}
catch { }
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
try
{
Model model = new Model();
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
System.Collections.ArrayList array = new System.Collections.ArrayList();
if (modelObjectEnum.GetSize() == 0)
{
Picker picker = new Picker();
Part part = (Part)picker.PickObject(Tekla.Structures.Model.UI.Picker.PickObjectEnum.PICK_ONE_PART);
part.Insert();
array.Add(part);
}
else
{
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Part)
{
Part part = (Part)modelObjectEnum.Current;
part.Insert();
array.Add(part);
}
}
}
model.CommitChanges();
Tekla.Structures.Model.UI.ModelObjectSelector modelobjsel = new Tekla.Structures.Model.UI.ModelObjectSelector();
modelobjsel.Select(array);
}
catch { }
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
try
{
Model model = new Model();
TSMUI.ModelObjectSelector modelObjectSelector = new TSMUI.ModelObjectSelector();
ModelObjectEnumerator objectsToCopyEnum = modelObjectSelector.GetSelectedObjects();
ArrayList objectsToCopyArray = new ArrayList();
while (objectsToCopyEnum.MoveNext())
{
objectsToCopyArray.Add(objectsToCopyEnum.Current);
}
Beam sourceBeam = PickBeam();
ArrayList modelObjectSelectorArray = new ArrayList();
modelObjectSelectorArray.Add(sourceBeam);
modelObjectSelector.Select(modelObjectSelectorArray);
modelObjectSelectorArray.Clear();
CopyToAnotherBeamByEndPoint(objectsToCopyArray, sourceBeam);
}
catch { }
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
try
{
Model model = new Model();
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
if (modelObjectEnum.GetSize() > 0)
{
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Tekla.Structures.Model.Part)
{
Tekla.Structures.Model.Part part = (Tekla.Structures.Model.Part)modelObjectEnum.Current;
string USER_FIELD_3 = "", USER_FIELD_4 = "", PRELIM_MARK = "";
part.GetUserProperty("USER_FIELD_3", ref USER_FIELD_3);
part.GetUserProperty("USER_FIELD_4", ref USER_FIELD_4);
part.GetUserProperty("PRELIM_MARK", ref PRELIM_MARK);
USER_FIELD_4 = USER_FIELD_4.Replace("(?)", "");
if (USER_FIELD_3 == "Z")
{
part.SetUserProperty("USER_FIELD_2", PRELIM_MARK);
part.SetUserProperty("PRELIM_MARK", USER_FIELD_3 + USER_FIELD_4);
part.Modify();
}
}
}
model.CommitChanges();
MessageBox.Show("Process Complete");
}
}
catch { }
}
public void GetProperties()
{
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
if (modelObjectEnum.GetSize() == 1)
{
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Tekla.Structures.Model.Grid)
{
Grid grid = (Grid)modelObjectEnum.Current;
coordinateX = grid.CoordinateX;
coordinateY = grid.CoordinateY;
coordinateZ = grid.CoordinateZ;
labelX = grid.LabelX;
labelY = grid.LabelY;
labelZ = grid.LabelZ;
}
}
}
if (modelObjectEnum.GetSize() > 1)
{
coordinateX = "";
coordinateY = "";
coordinateZ = "";
labelX = "";
labelY = "";
labelZ = "";
}
}
public CurrentSelectedObjects(string channelProfile, string channelClass, Model Model)
{
Model ThisModel = Model;
//User interface for the model
TSMUI.ModelObjectSelector GetSelectedObjects = new TSMUI.ModelObjectSelector();
// Model Object Enumerator (from Tekla.Structures.Model namespace) collection of selected objects
ModelObjectEnumerator SelectedObjects = GetSelectedObjects.GetSelectedObjects();
// Change channel profile to value passed in constructor
ChannelProfile = channelProfile;
// Set class to value passed in constructor
ChannelClass = channelClass;
// go through objects in model objects enumerator MoveNext returns false at end of collection
while (SelectedObjects.MoveNext())
{
// cast as beam, model 'object' class is just an abstract class, we must call out beams specifically.
Beam ThisBeam = SelectedObjects.Current as Beam;
if (ThisBeam != null)
{
// Pass profile and class for beam from constructor
ThisBeam.Profile.ProfileString = ChannelProfile;
ThisBeam.Class = ChannelClass;
//Apply new start point and end point
ThisBeam.StartPoint = new T3D.Point(1000, 0, 0);
ThisBeam.EndPoint = new T3D.Point(4000, 1000, 0);
// Method to modify beam and apply changes
ThisBeam.Modify();
}
}
}
public static List <ModelObject> ToList(this ModelObjectEnumerator enumerator)
{
var modelObjects = new List <ModelObject>();
while (enumerator.MoveNext())
{
var modelObject = enumerator.Current;
modelObjects.Add(modelObject);
}
return(modelObjects);
}
public static List <ModelObject> ToList(this ModelObjectEnumerator enumerator, bool selectInstances = false)
{
enumerator.SelectInstances = selectInstances;
var output = new List <ModelObject>(enumerator.GetSize());
while (enumerator.MoveNext())
{
output.Add(enumerator.Current);
}
return(output);
}
GetModelObjectsAsList(ModelObjectEnumerator enumerator)
{
var modelObjects = new List <ModelObject>();
while (enumerator.MoveNext())
{
var modelObject = enumerator.Current;
modelObjects.Add(modelObject);
}
return(modelObjects);
}
private void MallinnaLaatta()
{
ModelObjectSelector mSelector = malli.GetModelObjectSelector();
ModelObjectEnumerator enumer = mSelector.GetAllObjects();
for (int i = 0; i < enumer.GetSize(); i++)
{
ModelObject obj = enumer.Current;
if (obj is ContourPlate)
{
if (((ContourPlate)obj).Name == "LASKETTU_LAATTA")
{
ContourPlate laattaTemp = (ContourPlate)obj;
laattaTemp.Contour.ContourPoints[0] = new ContourPoint(new Point(0, 0, 3000), null);
laattaTemp.Contour.ContourPoints[1] = new ContourPoint(new Point(0, laatanKorkeus, 3000), null);
laattaTemp.Contour.ContourPoints[2] = new ContourPoint(new Point(laatanLeveys, laatanKorkeus, 3000), null);
laattaTemp.Contour.ContourPoints[3] = new ContourPoint(new Point(laatanLeveys, 0, 3000), null);
PoistaRaudoitus(laattaTemp);
laattaTemp.Modify();
malli.CommitChanges();
return;
}
}
enumer.MoveNext();
}
ContourPlate laatta = new ContourPlate();
laatta.Name = "LASKETTU_LAATTA";
ContourPoint vasenAlanurkka = new ContourPoint(new Point(0, 0, 3000), null);
ContourPoint vasenYlanurkka = new ContourPoint(new Point(0, laatanKorkeus, 3000), null);
ContourPoint oikeaYlanurkka = new ContourPoint(new Point(laatanLeveys, laatanKorkeus, 3000), null);
ContourPoint oikeaAlanurkka = new ContourPoint(new Point(laatanLeveys, 0, 3000), null);
laatta.AddContourPoint(vasenAlanurkka);
laatta.AddContourPoint(vasenYlanurkka);
laatta.AddContourPoint(oikeaYlanurkka);
laatta.AddContourPoint(oikeaAlanurkka);
laatta.Profile.ProfileString = Asetukset.LaatanPaksuus.ToString();
if (!string.IsNullOrWhiteSpace(Asetukset.BetoninLujuus.ToString()))
{
laatta.Material.MaterialString = betonimateriaalit[Asetukset.BetoninLujuus];
}
else
{
laatta.Material.MaterialString = "Concrete_Undefined";
}
laatta.Position.Depth = Position.DepthEnum.FRONT;
laatta.Insert();
malli.CommitChanges();
}
private void PoistaRaudoitus(ModelObject laatta)
{
ModelObjectEnumerator rautaEnum = malli.GetModelObjectSelector().GetAllObjects();
for (int j = 0; j < rautaEnum.GetSize(); j++)
{
if (rautaEnum.Current != null && rautaEnum.Current is RebarMesh)
{
((RebarMesh)rautaEnum.Current).Delete();
}
rautaEnum.MoveNext();
}
}
private static ArrayList getSelectedAssemblys(ModelObjectEnumerator selectedObjects)
{
ArrayList selectedAssemblys = new ArrayList();
while (selectedObjects.MoveNext())
{
if (selectedObjects.Current is Assembly)
{
selectedAssemblys.Add(selectedObjects.Current as Assembly);
}
}
return(selectedAssemblys);
}
public void Modify(PropertyValueChangedEventArgs e)
{
string label = e.ChangedItem.Label;
ModelObjectEnumerator modelObjectEnum = model.GetModelObjectSelector().GetSelectedObjects();
while (modelObjectEnum.MoveNext())
{
if (modelObjectEnum.Current is Connection)
{
Connection connection = (Connection)modelObjectEnum.Current;
}
}
}
private static List <Assembly> getSelectedAssemblys(ModelObjectEnumerator selectedObjects)
{
List <Assembly> selectedAssemblys = new List <Assembly>();
while (selectedObjects.MoveNext())
{
if (selectedObjects.Current is Assembly)
{
selectedAssemblys.Add(selectedObjects.Current as Assembly);
}
}
return(selectedAssemblys);
}
private static ArrayList getSelectedBooleans(ModelObjectEnumerator selectedObjects)
{
ArrayList selectedParts = new ArrayList();
while (selectedObjects.MoveNext())
{
if (selectedObjects.Current is TSM.BooleanPart)
{
selectedParts.Add(selectedObjects.Current);
}
}
return selectedParts;
}
private void connectParts()
{
List <BoltGroup> boltGroups = new List <BoltGroup>();
Picker picker = new Picker();
Tekla.Structures.Model.UI.ModelObjectSelector selector = new Tekla.Structures.Model.UI.ModelObjectSelector();
ModelObjectEnumerator enumerator = selector.GetSelectedObjects();
foreach (ModelObject modelObject in enumerator)
{
BoltGroup boltGroup = (BoltGroup)modelObject;
boltGroups.Add(boltGroup);
}
foreach (BoltGroup group in boltGroups)
{
int partsBoltedBefore;
int partsBoltedAfter;
do
{
Solid solid = group.GetSolid();
partsBoltedBefore = group.GetOtherPartsToBolt().Count;
Double boltLength = 0.0;
Point maximumPoint = solid.MaximumPoint;
Point minimumPoint = solid.MinimumPoint;
Tekla.Structures.Model.ModelObjectSelector groupSelector = model.GetModelObjectSelector();
ModelObjectEnumerator collidingObjects = groupSelector.GetObjectsByBoundingBox(minimumPoint, maximumPoint);
while (collidingObjects.MoveNext())
{
Part part = collidingObjects.Current as Part;
if (part != null)
{
group.AddOtherPartToBolt(part);
}
}
group.BoltStandard = "4017-8.8";
group.Modify();
group.GetReportProperty("LENGTH", ref boltLength);
if (group.BoltStandard == "4017-8.8" && boltLength % 10 != 0)
{
group.BoltStandard = "4014-8.8";
}
group.Modify();
partsBoltedAfter = group.GetOtherPartsToBolt().Count;
group.CutLength = boltLength + 20;
} while (partsBoltedBefore != partsBoltedAfter);
}
model.CommitChanges();
}
static private ArrayList getSelectedBooleans(ModelObjectEnumerator selectedObjects)
{
ArrayList selectedParts = new ArrayList();
while (selectedObjects.MoveNext())
{
if (selectedObjects.Current is TSM.BooleanPart)
{
selectedParts.Add(selectedObjects.Current);
}
}
return(selectedParts);
}
private void button2_Click(object sender, EventArgs e)
{
Model _model = new Model();
Tekla.Structures.Model.UI.ModelObjectSelector mos = new Tekla.Structures.Model.UI.ModelObjectSelector();
ModelObjectEnumerator moe = mos.GetSelectedObjects();
while (moe.MoveNext())
{
ModelObject mo = moe.Current as ModelObject;
// mo.
}
}
public void LuetteleObjektit()
{
ModelObjectEnumerator objEnum = malli.GetModelObjectSelector().GetAllObjects();
string objektit = "";
for (int i = 0; i < objEnum.GetSize(); i++)
{
if (objEnum.Current != null)
{
objektit += objEnum.Current.ToString() + "\n";
}
objEnum.MoveNext();
}
System.Windows.Forms.MessageBox.Show(objektit);
}
public static void RemoveWeldsAndBolts(Part part)
{
ModelObjectEnumerator weldEnum = part.GetWelds();
ModelObjectEnumerator boltEnum = part.GetBolts();
while (weldEnum.MoveNext())
{
weldEnum.Current.Delete();
}
while (boltEnum.MoveNext())
{
boltEnum.Current.Delete();
}
}
public static List <T> ToList <T>(this ModelObjectEnumerator enumerator, bool selectInstances = false) where T : ModelObject
{
enumerator.SelectInstances = selectInstances;
var output = new List <T>(enumerator.GetSize());
while (enumerator.MoveNext())
{
if (enumerator.Current is T t)
{
output.Add(t);
}
}
return(output);
}
public ThisDataToFile(bool allObjects, Model model)
{
this.AllObjects = allObjects;
this.Model = model;
ModelObjectEnumerator ModelObjectsToWriteOut = null;
if (allObjects)
{
// Select all objects in the model that are beams and add to enumeration
ModelObjectsToWriteOut = model.GetModelObjectSelector().GetAllObjectsWithType(ModelObject.ModelObjectEnum.BEAM);
}
else
{
// use model object selector to get selected objects
TSMUI.ModelObjectSelector GetSelectedObjects = new TSMUI.ModelObjectSelector();
// Get selected objects in model and add to enumeration
ModelObjectsToWriteOut = GetSelectedObjects.GetSelectedObjects();
}
// get file name
string FileName = "BeamsToTextFile";
// Write directly into model folder using System.IO namespace.
string FinalFileName = Path.Combine(model.GetInfo().ModelPath, FileName);
// use new StreamWriter from System.IO to write new text file in specified location
using (StreamWriter FileWriter = new StreamWriter(FinalFileName))
{
while (ModelObjectsToWriteOut.MoveNext())
{
// Move through beams in collection
Beam ThisBeam = ModelObjectsToWriteOut.Current as Beam;
if (ThisBeam != null)
{
string DataLineForFile = "GUID: " + model.GetGUIDByIdentifier(ThisBeam.Identifier) + "," +
"Profile: " + ThisBeam.Profile.ProfileString + "," + // Write beam profile
"Material: " + ThisBeam.Material.MaterialString + "," + // write beam material
"Class: " + ThisBeam.Class; // write beam class
FileWriter.WriteLine(DataLineForFile);
}
}
}
// Inform user that file has been exported
MessageBox.Show("File Exported");
Tekla.Structures.Model.Operations.Operation.DisplayPrompt("File Exported and Written to Model Folder");
}
private static List<Assembly> getSelectedAssemblys(ModelObjectEnumerator selectedObjects)
{
List<Assembly> selectedAssemblys = new List<Assembly>();
while (selectedObjects.MoveNext())
{
if (selectedObjects.Current is Assembly)
{
selectedAssemblys.Add(selectedObjects.Current as Assembly);
}
}
return selectedAssemblys;
}
