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 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 { }
}
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 List <ModelObject> ToList(this ModelObjectEnumerator modelObjectEnumerator)
{
ModelObjectEnumerator.AutoFetch = true;
try
{
if (modelObjectEnumerator == null)
{
return(null);
}
var objs = new List <ModelObject>();
modelObjectEnumerator.Reset();
foreach (ModelObject modelObject in modelObjectEnumerator)
{
objs.Add(modelObject);
}
return(objs);
}
catch
{
return(new List <ModelObject>());
};
}
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 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 { }
}
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 bool ClashCheck()
{
bool result = false;
_selector = new ModelObectSelector();
_clashes = new ArrayList();
_clashCheckDone = false;
ArrayList objectsToSelect = new ArrayList();
objectsToSelect = InsertThreeClashingParts();
#region 전체 모델의 충돌에 대해 확인
ModelObjectEnumerator modelObjectEnumerator = _model.GetModelObjectSelector().GetAllObjects();
foreach (ModelObject modelObject in modelObjectEnumerator)
{
objectsToSelect.Add(modelObject);
}
#endregion
_selector.Select(objectsToSelect);
_model.CommitChanges();
result = RunClashCheck();
if (TsEvent != null)
{
TsEvent.UnRegister();
}
return(result);
}
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)
{
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 static IEnumerable <ModelObject> ToIEnumerable(ModelObjectEnumerator enumerator)
{
while (enumerator.MoveNext())
{
yield return(enumerator.Current);
}
}
private static void GetCoordinateSystemAndNameOfSelectedObject(ModelObjectEnumerator SelectedModelObjects, out Tekla.Structures.Geometry3d.CoordinateSystem ModelObjectCoordSys, out string ModelObjectName)
{
if (SelectedModelObjects.Current is Tekla.Structures.Model.Part)
{
ModelObjectCoordSys = (SelectedModelObjects.Current as Tekla.Structures.Model.Part)
.GetCoordinateSystem();
ModelObjectName = (SelectedModelObjects.Current as Tekla.Structures.Model.Part)
.GetPartMark();
}
else if (SelectedModelObjects.Current is Tekla.Structures.Model.Assembly)
{
ModelObjectCoordSys = (SelectedModelObjects.Current as Tekla.Structures.Model.Assembly)
.GetMainPart().GetCoordinateSystem();
ModelObjectName = (SelectedModelObjects.Current as Tekla.Structures.Model.Assembly)
.AssemblyNumber.Prefix +
(SelectedModelObjects.Current as Tekla.Structures.Model.Assembly).AssemblyNumber.StartNumber;
}
else if (SelectedModelObjects.Current is Tekla.Structures.Model.BaseComponent)
{
ModelObjectCoordSys = (SelectedModelObjects.Current as Tekla.Structures.Model.BaseComponent)
.GetCoordinateSystem();
ModelObjectName = (SelectedModelObjects.Current as Tekla.Structures.Model.BaseComponent)
.Name;
}
else
{
ModelObjectCoordSys = new Tekla.Structures.Geometry3d.CoordinateSystem();
ModelObjectName = "";
}
}
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 { }
}
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();
}
} // 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;
}
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();
}
}
}
private static ModelObjectEnumerator getSelectedObjects()
{
var selector = new TSM.UI.ModelObjectSelector();
ModelObjectEnumerator selectionEnum = selector.GetSelectedObjects();
return(selectionEnum);
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
MyModel.GetWorkPlaneHandler().SetCurrentTransformationPlane(new TransformationPlane());
Tekla.Structures.Model.UI.ModelObjectSelector MS = new Tekla.Structures.Model.UI.ModelObjectSelector();
ModelObjectEnumerator Menum = MS.GetSelectedObjects();
List <Beam> AllPartList = EnumtoArray(Menum).OfType <Beam>().ToList();
List <int> AllPartListIds = AllPartList.Select(x => x.Identifier.ID).ToList();
List <Beam> BeamList = AllPartList.Where(x => x.Name == "BEAM").ToList();
int ConCount = 0;
foreach (Beam bem in BeamList)
{
bem.Select();
// Start Side
Beam StartBeam = GetPrimary(bem, AllPartListIds, "Start");
if (StartBeam != null && !IsConnectionApplied(bem, StartBeam))
{
//MessageBox.Show(StartBeam.Identifier.ID.ToString());
ApplyConn(StartBeam, bem, "Start");
ConCount++;
}
Beam EndBeam = GetPrimary(bem, AllPartListIds, "End");
if (EndBeam != null && !IsConnectionApplied(bem, EndBeam))
{
ApplyConn(EndBeam, bem, "End");
ConCount++;
}
}
MessageBox.Show("Total Connection Applied : " + ConCount.ToString());
}
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 dynamic GetTSObject(ModelObjectEnumerator dynObject)
{
if (dynObject is null)
{
return(null);
}
return(dynObject.teklaObject);
}
public string GetInfo()
{
Model model = new Model();
Tekla.Structures.Model.UI.ModelObjectSelector selector = new Tekla.Structures.Model.UI.ModelObjectSelector();
ModelObjectEnumerator enumerator = selector.GetSelectedObjects();
return(enumerator.GetSize().ToString());
}
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 void Run(Tekla.Technology.Akit.IScript akit)
{
Model myModel = new Model();
ModelObjectEnumerator selectedObjects = getSelectedObjects();
ArrayList selectedAssemblys = getSelectedAssemblys(selectedObjects);
foreach (Assembly currentAssembly in selectedAssemblys)
{
assemblyManager(currentAssembly, akit);
}
}
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 createSeamOfMultipleParts(string name, int number)
{
Seam seam = new Seam();
seam.Name = name;
seam.Number = number;
Picker picker = new Picker();
try
{
seam.SetPrimaryObject(picker.PickObject(Picker.PickObjectEnum.PICK_ONE_PART, "Wybierz element główny"));
ModelObjectEnumerator partsEnumerator = picker.PickObjects(Picker.PickObjectsEnum.PICK_N_OBJECTS, "Wybierz elementy podrzędne");
ArrayList secondaryParts = new ArrayList();
foreach (ModelObject modelObject in partsEnumerator)
{
secondaryParts.Add(modelObject);
}
seam.SetSecondaryObjects(secondaryParts);
seam.SetInputPositions(picker.PickPoint(), picker.PickPoint());
}
catch (ApplicationException ex)
{
Operation.DisplayPrompt("Przerwano operację");
return;
}
if (number != BaseComponent.CUSTOM_OBJECT_NUMBER)
{
seam.Insert();
}
else
{
try
{
if (isExisting(seam))
{
seam.Insert();
}
else
{
importCustomComponent(seam);
seam.Insert();
}
}
catch (Exception ex)
{
MessageBox.Show("Nie udało się wstawić komponentu", "Error");
}
}
MyModel.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();
}
}
public static void Run(Tekla.Technology.Akit.IScript akit)
{
Model myModel = new Model();
ModelObjectEnumerator selectedObjects = getSelectedObjects();
ArrayList selectedParts = getSelectedRebarGroups(selectedObjects);
foreach (TSM.RebarGroup currentRebarGroup in selectedParts)
{
ungroupRebar(currentRebarGroup);
}
myModel.CommitChanges();
}
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 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 bool IgnoreObject(ModelObject modelObject)
{
Model model = new Model();
string gUIDByIdentifier = model.GetGUIDByIdentifier(modelObject.Identifier);
bool result = false;
if (this.settings.ObjectsToIgnore.Contains(gUIDByIdentifier))
{
result = true;
}
else
{
int count = this.settings.FilterList.Count;
for (int i = 0; i < count; i++)
{
string filterName = this.settings.FilterList[i];
if (Operation.ObjectMatchesToFilter(modelObject, filterName))
{
result = true;
}
}
}
return result;
}*/
private bool CheckIfIgnored(ModelObjectEnumerator modelObjectEnumerator, ModelObject part)
{
bool result = false;
if (modelObjectEnumerator != null)
{
foreach (ModelObject modelObject in modelObjectEnumerator)
{
if (part.Identifier.ID == modelObject.Identifier.ID)
{
return true;
}
}
return result;
}
return result;
}
private void CheckObjectList(ref List<ObjectInfo> problemObjects, ModelObjectEnumerator partList, ref int partFoundCount, ref int ignorePartCount)
{
partList.SelectInstances = false;
Tekla.Structures.Model.Model model = new Model();
if (!model.GetConnectionStatus())
{
MessageBox.Show("Tekla is not open.");
Environment.Exit(1);
}
foreach (ModelObject modelObject in partList)
{
if (true) // !this.IgnoreObject(modelObject))
{
Part part = modelObject as Part;
if (part != null)
{
partFoundCount++;
string profile = "";
string profileType = "";
double height = new double();
double width = new double();
double wallThickness = new double();
string[] profileList;
part.GetReportProperty("PROFILE", ref profile);
part.GetReportProperty("PROFILE_TYPE", ref profileType);
part.GetReportProperty("HEIGHT", ref height);
part.GetReportProperty("WIDTH", ref width);
part.GetReportProperty("PROFILE.PLATE_THICKNESS", ref wallThickness);
// splits profile string into segments, uses numerical values as split separators
profileList = Regex.Split(profile, @"[0-9]+");
MessageBox.Show(
"profile:\n" +
profile +
"\n profile Type: \n" +
profileType +
"\n profileList:\n" +
profileList[0] +
"\n height:" + height +
"\n width:" + width);
// round dimensions to 0 or 1 digits
height = DimensionRound(height);
width = DimensionRound(width);
wallThickness = DimensionRound(wallThickness);
if (profileType == "M" && profileList != null) // M for rectangular tubes
{
if (profileList.Length >= 2)
{
if (profileList[0] != "RHS" || profileList[1] != "X")
{
// SHS profiles dont' have parameter 'width'
if (width == 0) width = height;
part.Select();
// System.Globalization.CultureInfo.InvariantCulture is used, to always get dots (and not commas) in cases,
// where one of profile parameters is rounded to 1 digit (e.g. 88.9 instead of 88,9)
part.Profile.ProfileString =
"RHS" +
height.ToString(System.Globalization.CultureInfo.InvariantCulture) +
"X" +
width.ToString(System.Globalization.CultureInfo.InvariantCulture) +
"X" +
wallThickness;
try
{
part.Modify();
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}
}
}
if (profileType == "RO") // RO for circular tubes
{
if (profileList.Length >= 2)
{
if (profileList[0] != "Ø" || profileList[1] != "X")
{
part.Select();
part.Profile.ProfileString =
"Ø" +
height.ToString(System.Globalization.CultureInfo.InvariantCulture) +
"X" +
wallThickness.ToString(System.Globalization.CultureInfo.InvariantCulture);
part.Modify();
}
}
}
if (profileType == "RU") // RU for circular rods
{
if (profileList.Length >= 1)
{
if (profileList[0] != "D")
{
part.Profile.ProfileString = "D" + height.ToString(System.Globalization.CultureInfo.InvariantCulture);
part.Modify();
}
}
}
/*
if (!(this.settings.PropertyName == "AssemblyPrefix") || IsMainPart(part))
{
string item = "asdfghjkl9999";
if (!part.GetReportProperty(this.settings.PropertyReportField, ref item) || !this.settings.ProjectProperties.Contains(item))
{
problemObjects.Add(new ObjectInfo(part));
}
}
*/
}
}
else
{
ignorePartCount++;
}
}
}
