コード例 #1
0
        //Example from official documentation: developer.tekla.com
        public void CreateSelectionFilter()
        {
            // Creates the filter expressions
            PartFilterExpressions.Name     PartName = new PartFilterExpressions.Name();
            StringConstantFilterExpression Beam1    = new StringConstantFilterExpression("BEAM1");
            StringConstantFilterExpression Beam2    = new StringConstantFilterExpression("BEAM2");
            StringConstantFilterExpression Beam3    = new StringConstantFilterExpression("BEAM3");

            // Creates a custom part filter
            PartFilterExpressions.CustomString PartComment = new PartFilterExpressions.CustomString("Comment");
            StringConstantFilterExpression     Test        = new StringConstantFilterExpression("test");

            // Creates the binary filter expressions
            BinaryFilterExpression Expression1 = new BinaryFilterExpression(PartName, StringOperatorType.IS_EQUAL, Beam1);
            BinaryFilterExpression Expression2 = new BinaryFilterExpression(PartName, StringOperatorType.IS_EQUAL, Beam2);
            BinaryFilterExpression Expression3 = new BinaryFilterExpression(PartName, StringOperatorType.IS_EQUAL, Beam3);
            BinaryFilterExpression Expression4 = new BinaryFilterExpression(PartComment, StringOperatorType.STARTS_WITH, Test);

            // Creates the binary filter expression collection
            BinaryFilterExpressionCollection ExpressionCollection = new BinaryFilterExpressionCollection();

            ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression1, BinaryFilterOperatorType.BOOLEAN_OR));
            ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression2, BinaryFilterOperatorType.BOOLEAN_OR));
            ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression3, BinaryFilterOperatorType.BOOLEAN_OR));
            ExpressionCollection.Add(new BinaryFilterExpressionItem(Expression4));

            var    modelPath      = new TSM.Model().GetInfo().ModelPath;
            string AttributesPath = Path.Combine(modelPath, "attributes");
            string FilterName     = Path.Combine(AttributesPath, this.filterName);

            Filter Filter = new Filter(ExpressionCollection);

            // Generates the filter file
            Filter.CreateFile(FilterExpressionFileType.OBJECT_GROUP_SELECTION, FilterName);
        }
コード例 #2
0
ファイル: Form1.cs プロジェクト: gStar1245/TeklaExamples
        private void BtnPourUnits_Click(object sender, EventArgs e)
        {
            var filterDefinition = new BinaryFilterExpressionCollection();

            if (checkBox_PUName.Checked && textBox_PUName != null && !string.IsNullOrEmpty(textBox_PUName.Text))
            {
                var filterExpression1 = new BinaryFilterExpression
                                        (
                    new PourUnitFilterExpressions.Name(), StringOperatorType.IS_EQUAL,
                    new StringConstantFilterExpression(textBox_PUName.Text)
                                        );
                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression1, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            var filterExpression2 = new BinaryFilterExpression
                                    (
                new ObjectFilterExpressions.Type(), NumericOperatorType.IS_EQUAL,
                new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.DB_POUR_UNIT)
                                    );

            filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression2));

            var model      = new Model();
            var selector   = model.GetModelObjectSelector();
            var enumerator = selector.GetObjectsByFilter(filterDefinition);

            if (enumerator != null)
            {
                filteredPU.Text = enumerator.GetSize().ToString();
            }
        }
 public static dynamic GetTSObject(BinaryFilterExpressionCollection dynObject)
 {
     if (dynObject is null)
     {
         return(null);
     }
     return(dynObject.teklaObject);
 }
コード例 #4
0
        /// <summary>Selects all objects which are on the phase</summary>
        /// <param name="phaseNumber">Number of the phase</param>
        /// <exception cref="Exceptions.FilteringToolTeklaSettingsException">When macro directory not exsists</exception>
        public static void SelectObjects(int phaseNumber)
        {
            var assemblyPhase = new TemplateFilterExpressions.CustomString("ASSEMBLY.PHASE");
            var phase         = new StringConstantFilterExpression(phaseNumber.ToString());
            var expresion1    = new BinaryFilterExpression(assemblyPhase, StringOperatorType.IS_EQUAL, phase);

            var objectType = new ObjectFilterExpressions.Type();
            var partF      = new NumericConstantFilterExpression(Tekla.Structures.TeklaStructuresDatabaseTypeEnum.PART);
            var expresion2 = new BinaryFilterExpression(objectType, NumericOperatorType.IS_EQUAL, partF);

            var expresion = new BinaryFilterExpressionCollection();

            expresion.Add(new BinaryFilterExpressionItem(expresion1, BinaryFilterOperatorType.BOOLEAN_AND));
            expresion.Add(new BinaryFilterExpressionItem(expresion2, BinaryFilterOperatorType.BOOLEAN_AND));

            var filter = new Filter(expresion);

            var objects = new Tekla.Structures.Model.Model().GetModelObjectSelector().GetObjectsByFilter(expresion);

            objects.SelectInstances = false;

            var ar = new System.Collections.ArrayList();

            while (objects.MoveNext())
            {
                var part = objects.Current as Tekla.Structures.Model.Part;
                if (part != null)
                {
                    var assembly = part.GetAssembly();
                    ar.Add(assembly);
                    break;
                }
            }

            var mos = new Tekla.Structures.Model.UI.ModelObjectSelector();

            mos.Select(new System.Collections.ArrayList());
            mos.Select(ar);

            if (Tekla.Structures.TeklaStructures.Connect())
            {
                TeklaMacroDirectory.CheckIfExists();
                var akit = new Tekla.Structures.MacroBuilder();

                akit.PushButton("butCancel", "diaPhaseManager");
                akit.Callback("acmd_display_active_system_dialog", "", "main_frame");
                akit.PushButton("butSelectPhases", "diaPhaseManager");
                akit.PushButton("butSelectObjects", "diaPhaseManager");
                akit.PushButton("butCancel", "diaPhaseManager");

                akit.Run();
                akit = null;
            }
        }
コード例 #5
0
ファイル: Form1.cs プロジェクト: gStar1245/TeklaExamples
        private void BtnPourObject_Click(object sender, EventArgs e)
        {
            var filterDefinition = new BinaryFilterExpressionCollection();

            // CheckBox_PourNumber 가 체크됬고, textBox에 값이 존재할 때,
            if (checkBox_pourNumber.Checked && textBox_pourNumber != null && !string.IsNullOrEmpty(textBox_pourNumber.Text))
            {
                var filterExpression1 = new BinaryFilterExpression
                                        (
                    new PourObjectFilterExpressions.PourNumber(), StringOperatorType.IS_EQUAL,
                    new StringConstantFilterExpression(textBox_pourNumber.Text)
                                        );

                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression1, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            if (checkBox_pourType.Checked && textBox_pourType != null && !string.IsNullOrEmpty(textBox_pourType.Text))
            {
                var filterExpression2 = new BinaryFilterExpression
                                        (
                    new PourObjectFilterExpressions.PourType(), StringOperatorType.IS_EQUAL,
                    new StringConstantFilterExpression(textBox_pourType.Text)
                                        );
                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression2, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            if (checkBox_pourCM.Checked && textBox_CM != null && !string.IsNullOrEmpty(textBox_CM.Text))
            {
                var filterExpression3 = new BinaryFilterExpression
                                        (
                    new PourObjectFilterExpressions.ConcreteMixture(), StringOperatorType.IS_EQUAL,
                    new StringConstantFilterExpression(textBox_CM.Text)
                                        );
                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression3, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            var filterExpression4 = new BinaryFilterExpression
                                    (
                new ObjectFilterExpressions.Type(), NumericOperatorType.IS_EQUAL,
                new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.DB_POUR_OBJECT)
                                    );

            filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression4));

            var model      = new Model();
            var selector   = model.GetModelObjectSelector();
            var enumerator = selector.GetObjectsByFilter(filterDefinition);

            if (enumerator != null)
            {
                filteredPours.Text = enumerator.GetSize().ToString();
            }
        }
コード例 #6
0
ファイル: Form1.cs プロジェクト: gStar1245/TeklaExamples
        private void BtnFilterSurface_Click(object sender, EventArgs e)
        {
            var filterDefinition = new BinaryFilterExpressionCollection();

            if (checkBox_surfaceName.Checked && textBox_surfaceName != null && !string.IsNullOrEmpty(this.textBox_surfaceName.Text))
            {
                var filterExpression1 = new BinaryFilterExpression(
                    new SurfaceFilterExpressions.Name(), StringOperatorType.IS_EQUAL,
                    new StringConstantFilterExpression(this.textBox_surfaceName.Text));
                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression1, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            if (checkBox_surfaceType.Checked && textBox_surfaceType != null && !string.IsNullOrEmpty(textBox_surfaceType.Text))
            {
                var filterExpression2 = new BinaryFilterExpression(
                    new SurfaceFilterExpressions.Type(), StringOperatorType.IS_EQUAL,
                    new StringConstantFilterExpression(textBox_surfaceType.Text));
                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression2, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            if (checkBox_surfaceClass.Checked && textBox_surfaceClass != null && !string.IsNullOrEmpty(textBox_surfaceClass.Text))
            {
                var filterExpression3 = new BinaryFilterExpression(
                    new SurfaceFilterExpressions.Class(), NumericOperatorType.IS_EQUAL,
                    new NumericConstantFilterExpression(Int32.Parse(textBox_surfaceClass.Text)));
                filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression3, BinaryFilterOperatorType.BOOLEAN_AND));
            }

            var filterExpression4 = new BinaryFilterExpression(new ObjectFilterExpressions.Type(),
                                                               NumericOperatorType.IS_EQUAL, new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.SURFACE_OBJECT));

            filterDefinition.Add(new BinaryFilterExpressionItem(filterExpression4));

            var model      = new Model();
            var selector   = model.GetModelObjectSelector();
            var enumerator = selector.GetObjectsByFilter(filterDefinition);

            if (enumerator != null)
            {
                filteredSurfaces.Text = enumerator.GetSize().ToString();
            }
        }
コード例 #7
0
        public static List <Part> GetParts(this Model model, bool autoFetch)
        {
            ObjectFilterExpressions.Type    objectType = new ObjectFilterExpressions.Type();
            NumericConstantFilterExpression type       =
                new NumericConstantFilterExpression(TeklaStructuresDatabaseTypeEnum.PART);

            var expression2 = new BinaryFilterExpression(objectType, NumericOperatorType.IS_EQUAL, type);

            BinaryFilterExpressionCollection filterCollection =
                new BinaryFilterExpressionCollection
            {
                new BinaryFilterExpressionItem(expression2, BinaryFilterOperatorType.BOOLEAN_AND),
            };

            //IMPORTANT!!!
            ModelObjectEnumerator.AutoFetch = autoFetch;

            return(model
                   .GetModelObjectSelector()
                   .GetObjectsByFilter(filterCollection)
                   .ToAList <Part>());
        }