// <summary>
        // Gets the underlying ModelItemCollection
        // </summary>
        // <returns>The underlying ModelItemCollection</returns>
        internal ModelItemCollection GetRawCollection()
        {
            ModelPropertyEntry parentAsEntry = ParentValue.ParentProperty as ModelPropertyEntry;

            if (parentAsEntry != null)
            {
                return(parentAsEntry.FirstModelProperty.Collection);
            }

            ModelPropertyIndexer parentAsIndexer = ParentValue.ParentProperty as ModelPropertyIndexer;

            if (parentAsIndexer != null)
            {
                ModelItemCollection modelItemCollection = parentAsIndexer.ModelItem as ModelItemCollection;

                // If the parent is an indexer, that means we are a collection within another collection
                // and the ModelItem of the indexer is really a ModelItemCollection.
                Fx.Assert(modelItemCollection != null, "modelItemCollection should not be null");

                return(modelItemCollection);
            }

            Debug.Fail("A new class was introduced that derives from PropertyEntry.  Need to update ModelPropertyValueCollection code as well.");
            return(null);
        }
Exemple #2
0
        private void ExportBySelSets(SavedItem item, Document doc)
        {
            if (item is FolderItem)
            {
                //рекурсивный вызов для каждого вложенного
                FolderItem folder = item as FolderItem;
                foreach (SavedItem nestedItem in folder.Children)
                {
                    ExportBySelSets(nestedItem, doc);
                }
            }
            else if (item is SelectionSet)
            {
                SelectionSet        selectionSet  = item as SelectionSet;
                ModelItemCollection itemsToExport = selectionSet.GetSelectedItems();
                if (itemsToExport.DescendantsAndSelf.Count() > 0)
                {
                    ModelItemCollection itemsToHide = new ModelItemCollection(itemsToExport);
                    itemsToHide.Invert(doc);
                    doc.Models.SetHidden(itemsToHide, true);
                    doc.Models.SetHidden(itemsToExport, false);

                    FBXExport.FBXFileName = selectionSet.DisplayName + ".fbx";
                    S1NF0_RibbonPanel.ExecuteAddInPlugin("FBXExport." + DEVELOPER_ID);

                    doc.Models.SetHidden(itemsToHide, false);
                }
            }
        }
        // <summary>
        // Basic ctor
        // </summary>
        // <param name="parentValue">Parent PropertyValue</param>
        public ModelPropertyValueCollection(ModelPropertyValue parentValue) : base(parentValue)
        {
            if (parentValue == null)
            {
                throw FxTrace.Exception.ArgumentNull("parentValue");
            }

            // Wrap each existing item in the collection in ModelPropertyEntryIndexer
            ModelItemCollection collection = this.GetRawCollection();

            if (collection != null && collection.Count > 0)
            {
                _values = new List <ModelPropertyIndexer>();
                int i = 0;
                foreach (ModelItem item in collection)
                {
                    _values.Add(CreateModelPropertyIndexer(item, i++));
                }
            }

            // Hook into the collection changed events
            if (collection != null)
            {
                collection.CollectionChanged += new NotifyCollectionChangedEventHandler(OnUnderlyingCollectionChanged);
            }
        }
Exemple #4
0
        public static SearchAndItems SAIsearch(SavedItem item)
        {
            ModelItemCollection mod_col      = ((SelectionSet)item).GetSelectedItems();
            SearchAndItems      SAI          = new SearchAndItems();
            List <Guid>         output_guids = new List <Guid>();
            HashSet <string>    unic_cats    = new HashSet <string>();
            string cat = null;

            if (mod_col != null)
            {
                foreach (ModelItem mditem in mod_col)
                {
                    Guid item_guid = FindGuid(mditem);
                    if (item_guid.ToString() != "00000000-0000-0000-0000-000000000000")
                    {
                        PropertyCategoryCollection mitem_property = mditem.GetUserFilteredPropertyCategories();                                   //свойства объекта для получения его категории, и поиска в категории окон и дверей, следующий номер за количеством папок в Q
                        DataProperty mitem_dataprop = mitem_property.FindPropertyByName("LcRevitData_Element", "LcRevitPropertyElementCategory"); //
                        if (mitem_dataprop != null)
                        {
                            unic_cats.Add(mitem_dataprop.Value.ToDisplayString());
                        }
                    }
                    output_guids.Add(item_guid);
                }
                if (unic_cats.Count == 1 && (unic_cats.Contains("Окна") || unic_cats.Contains("Двери")))
                {
                    cat = "ОкнаДвери";
                }
                //#endregion

                SAI.WriteData(item.DisplayName, output_guids, cat);
            }
            return(SAI);
        }
        public void RowToIndexConverter_Convert_DoesntFindValue_ReturnsMinusOne()
        {
            var converter = new RowToIndexConverter();

            var activityDtos = new List <ActivityDTO> {
                new ActivityDTO("name", "value", 0), new ActivityDTO("name1", "value1", 1), new ActivityDTO("name2", "value2", 2)
            };

            DsfMultiAssignActivity multiAssign = new DsfMultiAssignActivity();

            multiAssign.FieldsCollection = activityDtos;
            ModelItem modelItemThatdoesntExist = ModelItemUtils.CreateModelItem(new ActivityDTO("thing", "stuff", 8));

            dynamic modelItem = ModelItemUtils.CreateModelItem(multiAssign);

            ModelItemCollection collection = modelItem.FieldsCollection as ModelItemCollection;

            //------------Execute Test---------------------------
            if (collection != null)
            {
                var result = converter.Convert(modelItemThatdoesntExist, typeof(int), null, CultureInfo.CurrentCulture);

                //------------Assert Results-------------------------
                Assert.AreEqual(-1, result);
            }
            else
            {
                Assert.Fail();
            }
        }
 /// <summary>
 /// Only one TabItem should have DesignTimeIsSelectedProperty set to true at a time.
 /// DesignTimeSelectedIndexProperty of TabControl should match with that of active tab.
 /// </summary>
 /// <param name="item">The ModelItem representing a TabItem.</param>
 private static void UpdateIsSelectedForOtherTabs(ModelItem item)
 {
     // item.Parent is Tabcontrol
     if (item.Parent != null && item.Parent.IsItemOfType(MyPlatformTypes.TabControl.TypeId))
     {
         if (item.Parent.Content != null)
         {
             ModelItemCollection tabItemCollection = item.Parent.Content.Collection;
             if (tabItemCollection != null && tabItemCollection.Count > 0)
             {
                 foreach (ModelItem tabItem in tabItemCollection)
                 {
                     if (tabItem != item)
                     {
                         // set designer property for other tabItem in TabControl to false.
                         tabItem.SetDesignerProperty(DesignTimeIsSelectedProperty, false);
                     }
                     else
                     {
                         // This tabItem has been activated, update selectedIndex for Tabcontrol
                         tabItem.Parent.SetDesignerProperty(
                             TabControlDesignModeValueProvider.DesignTimeSelectedIndexProperty,
                             tabItemCollection.IndexOf(tabItem));
                     }
                 }
             }
         }
     }
 }
Exemple #7
0
        private void ButFocus_Click(object sender, EventArgs e)//在NW中选择当前选择记录的
        {
            Document Doc        = Autodesk.Navisworks.Api.Application.ActiveDocument;
            TabPage  curTabPage = this.TCL1OfQF.SelectedTab;//获取当前选择的tab页面
            string   strId      = "";

            foreach (Control control in curTabPage.Controls) //遍历控件
            {
                if (control is DataGridView)                 //如果是datagridview,则在视图中选择元素
                {
                    DataGridView dgv = (DataGridView)control;
                    if (dgv.SelectedRows.Count == 0)
                    {
                        MessageBox.Show("未选中行!");
                        return;
                    }
                    for (int i = 0; i < dgv.SelectedRows.Count; i++)
                    {
                        strId = dgv.SelectedRows[i].Cells[0].Value.ToString();
                    }
                    Search search = new Search();
                    search.Selection.SelectAll();
                    //元素ID是int32类型,所以Displaystring找不到
                    search.SearchConditions.Add(SearchCondition.HasPropertyByDisplayName("元素", "Id").EqualValue(VariantData.FromInt32(Int32.Parse(strId))));

                    ModelItemCollection items = search.FindAll(Doc, true);
                    Doc.CurrentSelection.Clear();
                    Doc.CurrentSelection.CopyFrom(items);
                    if (items.Count > 0)
                    {
                        MessageBox.Show("已在视图中选中该元素!", "提示");
                    }
                }
            }
        }
Exemple #8
0
        private void InsertToCollection(IEnumerable <string> listToAdd, ModelItem modelItem)
        {
            var modelProperty = modelItem.Properties["SystemInformationCollection"];

            if (modelProperty != null)
            {
                ModelItemCollection mic = modelProperty.Collection;

                if (mic != null)
                {
                    List <GatherSystemInformationTO> listOfValidRows = SystemInformationCollection.Where(c => !c.CanRemove()).ToList();
                    if (listOfValidRows.Count > 0)
                    {
                        GatherSystemInformationTO gatherSystemInformationTo = SystemInformationCollection.Last(c => !c.CanRemove());
                        int startIndex = SystemInformationCollection.IndexOf(gatherSystemInformationTo) + 1;
                        foreach (string s in listToAdd)
                        {
                            mic.Insert(startIndex, new GatherSystemInformationTO(SystemInformationCollection[startIndex - 1].EnTypeOfSystemInformation, s, startIndex + 1));
                            startIndex++;
                        }
                        CleanUpCollection(mic, modelItem, startIndex);
                    }
                    else
                    {
                        AddToCollection(listToAdd, modelItem);
                    }
                }
            }
        }
Exemple #9
0
        private void listView1_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                ListViewItem item = listView1.GetItemAt(e.X, e.Y);

                if (item != null)
                {
                    if (e.Location.X >= item.Bounds.X - (item.ListView.SmallImageList.ImageSize.Width + 5) &&
                        e.Location.X <= item.Bounds.Right + 1)
                    {
                        ((mainForm)this.DockPanel.Parent).timeSlider1_Scroll(sender, e);

                        SavedItemCollection si = doc.SelectionSets.Value;

                        SelectionSource ss = doc.SelectionSets.CreateSelectionSource(si[item.Index]);
                        Search          s  = new Search(); s.Selection.SelectionSources.Add(ss);

                        modelSelection = new ModelItemCollection(s.Selection.GetSelectedItems(doc));

                        System.Drawing.Color c = System.Drawing.Color.Blue;

                        doc.Models.OverridePermanentColor(modelSelection, new Autodesk.Navisworks.Api.Color(c.R / 255, c.G / 255, c.B / 255));

                        i = modelSelection[0].PropertyCategories.ElementAt(modelSelection[0].PropertyCategories.Count() - 1).Properties[4].Value.ToInt32();
                        j = -1;
                        contextMenuStrip1.Items.Clear();
                        contextMenuStrip1.Items.Add(changePropertiesToolStripMenuItem);
                        contextMenuStrip1.Size = new Size(164, 26);
                        contextMenuStrip1.Show(msTreeView1, e.Location);
                    }
                }
            }
        }
Exemple #10
0
        private object createSearchSet(object name, object category, object property, object value)
        {
            //https://adndevblog.typepad.com/aec/2012/08/add-search-selectionset-in-net.html

            Document doc = Autodesk.Navisworks.Api.Application.ActiveDocument;

            //Create a new search object
            Search          s  = new Search();
            SearchCondition sc = SearchCondition.HasPropertyByDisplayName(category.ToString(), property.ToString());

            s.SearchConditions.Add(sc.EqualValue(VariantData.FromDisplayString(value.ToString())));


            //Set the selection which we wish to search
            s.Selection.SelectAll();
            s.Locations = SearchLocations.DescendantsAndSelf;

            //halt searching below ModelItems which match this
            s.PruneBelowMatch = true;

            //get the resulting collection by applying this search
            ModelItemCollection searchResults = s.FindAll(Autodesk.Navisworks.Api.Application.ActiveDocument, false);
            SelectionSet        selectionSet  = new SelectionSet();

            selectionSet.DisplayName = name.ToString();
            selectionSet.CopyFrom(s);
            Autodesk.Navisworks.Api.Application.ActiveDocument.SelectionSets.InsertCopy(0, selectionSet);
            var ss = Autodesk.Navisworks.Api.Application.ActiveDocument.SelectionSets.ToSavedItemCollection();


            return(ss);
        }
Exemple #11
0
        protected void RemoveAt(int indexNumber, INotifyPropertyChanged notify)
        {
            notify.PropertyChanged -= OnDtoPropertyChanged;
            var idx = indexNumber - 1;

            ModelItemCollection.RemoveAt(idx);
        }
        void LoadTableColumns(System.Action continueWith = null)
        {
            if (!IsTableSelected || _isInitializing)
            {
                if (!_isInitializing)
                {
                    ModelItemCollection.Clear();
                }
                continueWith?.Invoke();
                return;
            }

            var oldColumns = GetInputMappings().ToList();

            ModelItemCollection.Clear();
            var selectedDatabase = SelectedDatabase;
            var selectedTable    = SelectedTable;

            // ReSharper disable ImplicitlyCapturedClosure
            _asyncWorker.Start(() => GetDatabaseTableColumns(selectedDatabase, selectedTable), columnList =>
                               // ReSharper restore ImplicitlyCapturedClosure
            {
                if (columnList.HasErrors)
                {
                    Errors = new List <IActionableErrorInfo>
                    {
                        new ActionableErrorInfo(() => IsSelectedTableFocused = true)
                        {
                            ErrorType = ErrorType.Critical, Message = columnList.Errors
                        }
                    };
                }
                else
                {
                    Errors = null;
                }
                foreach (var mapping in columnList.Items.Select(column => new DataColumnMapping {
                    OutputColumn = column
                }))
                {
                    var mapping1  = mapping;
                    var oldColumn = oldColumns.FirstOrDefault(c => c.OutputColumn.ColumnName == mapping1.OutputColumn.ColumnName);
                    if (oldColumn?.InputColumn != null)
                    {
                        var inputcolumn     = oldColumn.InputColumn;
                        inputcolumn         = inputcolumn.Replace("[", "");
                        inputcolumn         = inputcolumn.Replace("]", "");
                        inputcolumn         = inputcolumn.Replace(" ", "");
                        mapping.InputColumn = string.Format("[[{0}]]", inputcolumn);
                    }
                    if (string.IsNullOrEmpty(mapping.InputColumn))
                    {
                        mapping.InputColumn = string.Format("[[{0}(*).{1}]]", selectedTable.TableName.Replace("[", "").Replace("]", "").Replace(" ", ""), mapping.OutputColumn.ColumnName.Replace("[", "").Replace("]", "").Replace(" ", ""));
                    }

                    ModelItemCollection.Add(mapping);
                }
                continueWith?.Invoke();
            });
        }
Exemple #13
0
        private void InsertToCollection(IEnumerable <string> listToAdd, ModelItem modelItem)
        {
            var modelProperty = modelItem.Properties["ConvertCollection"];

            if (modelProperty != null)
            {
                ModelItemCollection mic = modelProperty.Collection;

                if (mic != null)
                {
                    List <ICaseConvertTO> listOfValidRows = ConvertCollection.Where(c => !c.CanRemove()).ToList();
                    if (listOfValidRows.Count > 0)
                    {
                        int startIndex = ConvertCollection.IndexOf(listOfValidRows.Last()) + 1;
                        foreach (string s in listToAdd)
                        {
                            mic.Insert(startIndex, new CaseConvertTO(s, ConvertCollection[startIndex - 1].ConvertType, s, startIndex + 1));
                            startIndex++;
                        }
                        CleanUpCollection(mic, modelItem, startIndex);
                    }
                    else
                    {
                        AddToCollection(listToAdd, modelItem);
                    }
                }
            }
        }
        public void RowToIndexConverter_Convert_FindsValue_ReturnsIndex()
        {
            //------------Setup for test--------------------------
            var converter = new RowToIndexConverter();

            var activityDtos = new List <ActivityDTO> {
                new ActivityDTO("name", "value", 0), new ActivityDTO("name1", "value1", 1), new ActivityDTO("name2", "value2", 2)
            };

            DsfMultiAssignActivity multiAssign = new DsfMultiAssignActivity();

            multiAssign.FieldsCollection = activityDtos;

            dynamic modelItem = ModelItemUtils.CreateModelItem(multiAssign);

            ModelItemCollection collection = modelItem.FieldsCollection as ModelItemCollection;

            //------------Execute Test---------------------------
            if (collection != null)
            {
                var result = converter.Convert(collection[1], typeof(int), null, CultureInfo.CurrentCulture);

                //------------Assert Results-------------------------
                Assert.AreEqual(2, result);
            }
            else
            {
                Assert.Fail();
            }
        }
Exemple #15
0
        void OnContextChanged()
        {
            this.targetFramework = WorkflowDesigner.GetTargetFramework(this.Context);

            AttachedPropertiesService attachedPropertyService = this.Context.Services.GetService <AttachedPropertiesService>();

            Fx.Assert(attachedPropertyService != null, "AttachedPropertiesService shouldn't be null in EditingContext.");
            attachedPropertyService.AddProperty(CreateAttachedPropertyForNamespace <string>(ErrorMessagePropertyName));
            attachedPropertyService.AddProperty(CreateAttachedPropertyForNamespace <bool>(IsInvalidPropertyName));
            //clear any defaults because it's meant to be set by host and not serialized to XAML
            VisualBasicSettings.Default.ImportReferences.Clear();

            ModelService modelService = this.Context.Services.GetService <ModelService>();

            Fx.Assert(modelService != null, "ModelService shouldn't be null in EditingContext.");
            Fx.Assert(modelService.Root != null, "model must have a root");
            this.importsModelItem = modelService.Root.Properties[NamespaceListPropertyDescriptor.ImportCollectionPropertyName].Collection;
            Fx.Assert(this.importsModelItem != null, "root must have imports");
            this.importsModelItem.CollectionChanged += this.OnImportsModelItemCollectionChanged;

            this.importedNamespacesItem = this.Context.Items.GetValue <ImportedNamespaceContextItem>();
            this.importedNamespacesItem.EnsureInitialized(this.Context);

            if (this.availableNamespaces == null)
            {
                //change to available namespace should not be a model change so we access the dictionary directly
                this.availableNamespaces = this.importsModelItem.Properties[NamespaceListPropertyDescriptor.AvailableNamespacesPropertyName].ComputedValue as Dictionary <string, List <string> >;
                Fx.Assert(this.availableNamespaces != null, "Available namespace dictionary is not in right format");
            }
            RefreshNamespaces();
        }
Exemple #16
0
        //Helper function used by other components if need to update import context item
        public static void AddImport(string importedNamespace, EditingContext editingContext)
        {
            //For types defined without any namespace, Type.Namespace is null instead of empty. We don't need to add any namespace to Import list in this case
            if (string.IsNullOrEmpty(importedNamespace))
            {
                return;
            }

            Fx.Assert(editingContext != null, "EditingContext shouldn't be null.");
            ModelService modelService = editingContext.Services.GetService <ModelService>();

            Fx.Assert(modelService != null, "EditingContext should contains ModelService.");
            ModelItemCollection importsCollection = modelService.Root.Properties[NamespaceListPropertyDescriptor.ImportCollectionPropertyName].Collection;
            NamespaceList       namespaceList     = importsCollection.GetCurrentValue() as NamespaceList;

            if (namespaceList.Lookup(importedNamespace) == -1)
            {
                importsCollection.Add(new NamespaceData {
                    Namespace = importedNamespace
                });
            }
            else
            {
                namespaceList.UpdateAssemblyInfo(importedNamespace);
            }
        }
Exemple #17
0
        public bool DoDrop(IDataObject dataObject)
        {
            var formats = dataObject.GetFormats();

            if (!formats.Any())
            {
                return(false);
            }
            dynamic             mi = ModelItem;
            ModelItemCollection activitiesCollection = mi.Activities;
            var modelItemString = formats.FirstOrDefault(s => s.IndexOf("ModelItemsFormat", StringComparison.Ordinal) >= 0);

            if (!String.IsNullOrEmpty(modelItemString))
            {
                var objectData = dataObject.GetData(modelItemString);
                var data       = objectData as List <ModelItem>;
                if (data != null && data.Count >= 1)
                {
                    foreach (var item in data)
                    {
                        activitiesCollection.Insert(activitiesCollection.Count, item);
                    }
                    _addedFromDesignSurface = true;
                    return(true);
                }
            }
            return(SetModelItemForServiceTypes(dataObject));
        }
        internal override void LoadChildren()
        {
            if (this.PerfEventProvider != null)
            {
                this.PerfEventProvider.DesignerTreeViewLoadChildrenStart();
            }

            base.LoadChildren();

            if (this.Value.IsCollection)
            {
                ModelItemCollection mc = this.Value.Value as ModelItemCollection;
                TreeViewItemViewModel.AddModelItemCollection(this, mc, this.Value);
            }
            else if (this.Value.IsDictionary)
            {
                ModelItemDictionary dictionary = this.Value.Dictionary;
                TreeViewItemViewModel.AddModelItemDictionary(this, dictionary, this.Value);
            }
            else if (this.Value.Value != null)
            {
                TreeViewItemViewModel.AddChild(this, this.Value.Value, this.Value.Value, this.DuplicatedNodeVisible, string.Empty, this.Value);
            }

            if (this.PerfEventProvider != null)
            {
                this.PerfEventProvider.DesignerTreeViewLoadChildrenEnd();
            }
        }
Exemple #19
0
        private void InsertToCollection(IEnumerable <string> listToAdd, ModelItem modelItem)
        {
            var modelProperty = modelItem.Properties["ResultsCollection"];

            if (modelProperty != null)
            {
                ModelItemCollection mic = modelProperty.Collection;

                if (mic != null)
                {
                    List <DataSplitDTO> listOfValidRows = ResultsCollection.Where(c => !c.CanRemove()).ToList();
                    if (listOfValidRows.Count > 0)
                    {
                        DataSplitDTO dataSplitDto = ResultsCollection.Last(c => !c.CanRemove());
                        int          startIndex   = ResultsCollection.IndexOf(dataSplitDto) + 1;
                        foreach (string s in listToAdd)
                        {
                            mic.Insert(startIndex, new DataSplitDTO(s, ResultsCollection[startIndex - 1].SplitType, ResultsCollection[startIndex - 1].At, startIndex + 1));
                            startIndex++;
                        }
                        CleanUpCollection(mic, modelItem, startIndex);
                    }
                    else
                    {
                        AddToCollection(listToAdd, modelItem);
                    }
                }
            }
        }
        private void StructureFilling(XML.St.Object parent, SavedItem item, StructureDataStorage dataStorage, Document doc)
        {
            if (item is FolderItem)
            {
                FolderItem    folder    = item as FolderItem;
                XML.St.Object container = dataStorage.CreateNewContainerObject(parent, folder.DisplayName);
                foreach (SavedItem nestedItem in folder.Children)
                {
                    StructureFilling(container, nestedItem, dataStorage, doc);
                }
            }
            else if (item is SelectionSet)
            {
                SelectionSet selectionSet = item as SelectionSet;

                XML.St.Object container = dataStorage.CreateNewContainerObject(parent, selectionSet.DisplayName);

                ModelItemCollection itemsInSelection = selectionSet.GetSelectedItems();

                Search searchForAllIDs = new Search();
                searchForAllIDs.Selection.CopyFrom(itemsInSelection);
                searchForAllIDs.Locations = SearchLocations.DescendantsAndSelf;
                StructureDataStorage.ConfigureSearchForAllGeometryItemsWithIds(searchForAllIDs, false);
                ModelItemCollection selectedGeometry = searchForAllIDs.FindAll(doc, false);
                foreach (ModelItem modelItem in selectedGeometry)
                {
                    dataStorage.CreateNewModelObject(container, modelItem);
                }
            }
        }
Exemple #21
0
        private void clearAppearance() //清除所有表达
        {
            Search search = new Search();

            search.Selection.SelectAll();

            //oDoc.Models.ResetAllPermanentMaterials();

            VariantData oData = VariantData.FromDisplayString("门");

            SearchCondition oSearchCondition = SearchCondition.HasPropertyByDisplayName("项目", "类型");

            oSearchCondition = oSearchCondition.EqualValue(oData);
            search.SearchConditions.Add(oSearchCondition);
            ModelItemCollection items = search.FindAll(oDoc, false);

            oDoc.Models.OverridePermanentColor(items, Autodesk.Navisworks.Api.Color.Blue);
            oDoc.Models.OverridePermanentTransparency(items, 0.5);

            Search search1 = new Search();

            search1.Selection.SelectAll();
            oData = VariantData.FromDisplayString("房间");

            oSearchCondition = SearchCondition.HasPropertyByDisplayName("项目", "类型");
            oSearchCondition = oSearchCondition.EqualValue(oData);
            search1.SearchConditions.Add(oSearchCondition);
            items = search1.FindAll(oDoc, false);
            oDoc.Models.OverridePermanentColor(items, Autodesk.Navisworks.Api.Color.White);
            oDoc.Models.OverridePermanentTransparency(items, 1);
            //oDoc.CurrentSelection.CopyFrom(items);
        }
        bool ExceptionTypeFilter(Type type)
        {
            if (type == null)
            {
                return(false);
            }

            if (type != typeof(Exception) && !type.IsSubclassOf(typeof(Exception)))
            {
                return(false);
            }

            ModelProperty catchesProperty = this.ModelItem.Properties[CatchesPropertyName];

            Fx.Assert(catchesProperty != null, "TryCatch.Catches could not be null");
            ModelItemCollection catches = catchesProperty.Collection;

            Fx.Assert(catches != null, "Catches.Collection could not be null");
            foreach (ModelItem catchItem in catches)
            {
                ModelProperty exceptionTypeProperty = catchItem.Properties[ExceptionTypePropertyName];
                Fx.Assert(exceptionTypeProperty != null, "Catch.ExceptionType could not be null");
                Type exceptionType = exceptionTypeProperty.ComputedValue as Type;
                Fx.Assert(exceptionType != null, "Catch.ExceptionType.Value could not be null");

                if (exceptionType == type)
                {
                    return(false);
                }
            }

            return(true);
        }
Exemple #23
0
        private void ButQueryModelRecord_Click(object sender, EventArgs e)//查询模型记录
        {
            Document            Doc        = Autodesk.Navisworks.Api.Application.ActiveDocument;
            ModelItemCollection modelItems = Doc.CurrentSelection.SelectedItems;

            if (modelItems.Count != 1)
            {
                MessageBox.Show("请选择一个构件查询", "提示");
                return;
            }
            ModelItem modelItem = modelItems.First;
            int       nId       = -1;

            try
            {
                nId = modelItem.PropertyCategories.FindPropertyByDisplayName("元素", "Id").Value.ToInt32();
            }
            catch (Exception ex)
            {
                MessageBox.Show("查询错误" + ex.Message);
                return;
            }
            string strId = nId.ToString();

            if (!HasRecordInSqlTable(strId))//查询并聚焦
            {
                MessageBox.Show("该构件未查询到信息!", "信息");
            }
        }
Exemple #24
0
        protected override void AddToCollection(IEnumerable <string> sources, bool overwrite)
        {
            if (GetType() == typeof(DataMergeDesignerViewModel))
            {
                var lastPopulated = ModelItemCollection?.LastOrDefault(p => !string.IsNullOrWhiteSpace(p.GetProperty("At").ToString()));
                if (lastPopulated != null)
                {
                    _initialDto = (TDev2TOFn)lastPopulated.GetCurrentValue();
                }
            }
            var indexNumber = GetIndexForAdd(overwrite);

            // Always insert items before blank row
            foreach (var s in sources.Where(s => !string.IsNullOrWhiteSpace(s)))
            {
                AddDto(indexNumber, s);
                indexNumber++;
            }
            AddBlankRow(overwrite);
            var lastModelItem = GetModelItem(ItemCount);

            SetIndexNumber(lastModelItem, indexNumber);

            UpdateDisplayName();

            // Restore
            _initialDto = new TDev2TOFn();
        }
        /// <summary>
        /// Gets the insert index for <see cref="AddToCollection"/>.
        /// Returns the index of the last blank row.
        /// </summary>
        int GetIndexForAdd(bool overwrite)
        {
            var indexNumber = 1;

            if (overwrite)
            {
                ModelItemCollection.Clear();

                // Add blank row
                AddDto(indexNumber);
            }
            else
            {
                var lastDto = GetLastDto();
                indexNumber = ModelItemCollection.IndexOf(GetModelItem(ItemCount)) + 1;

                if (ModelItemCollection.Count == 2)
                {
                    // Check whether we have 2 blank rows
                    var firstDto = GetDto(1);
                    if (firstDto.CanRemove() && lastDto.CanRemove())
                    {
                        RemoveAt(indexNumber, lastDto);
                        indexNumber = indexNumber - 1;
                    }
                }
            }
            return(indexNumber);
        }
        public override int Execute(params string[] parameters)
        {
            // current document
            Document doc = Application.ActiveDocument;
            // COM state object
            InwOpState10 cdoc = ComApiBridge.State;
            // current selected items
            ModelItemCollection items = doc.CurrentSelection.SelectedItems;
            // convert ModelItem to COM Path
            InwOaPath citem = ComApiBridge.ToInwOaPath(items[0]);
            // Get item's PropertyCategoryCollection object
            InwGUIPropertyNode2 cpropcates = (InwGUIPropertyNode2)cdoc.GetGUIPropertyNode(citem, true);
            // Get PropertyCategoryCollection data
            InwGUIAttributesColl propCol = cpropcates.GUIAttributes();

            // loop propertycategory
            foreach (InwGUIAttribute2 i in propCol)
            {
                // if category's name match
                if (i.UserDefined && i.ClassUserName == "Premier League")
                {
                    // overwritten the existing propertycategory with
                    // newly created propertycategory(existing + new)
                    cpropcates.SetUserDefined(1, "Premier League", "PremierLeague_InternalName",
                                              AddNewPropertyToExtgCategory(i));
                }
            }

            return(0);
        }
        protected override void AddToCollection(IEnumerable <string> source, bool overwrite)
        {
            var firstModelItem = ModelItemCollection.FirstOrDefault();

            if (firstModelItem != null)
            {
                _initialDto = (TDev2TOFn)firstModelItem.GetCurrentValue();
            }

            var indexNumber = GetIndexForAdd(overwrite);

            // Always insert items before blank row
            foreach (var s in source.Where(s => !string.IsNullOrWhiteSpace(s)))
            {
                AddDto(indexNumber, s);
                indexNumber++;
            }

            var lastModelItem = GetModelItem(ItemCount);

            SetIndexNumber(lastModelItem, indexNumber);

            UpdateDisplayName();

            // Restore
            _initialDto = new TDev2TOFn();
        }
Exemple #28
0
        protected void InitializeItems(ModelItemCollection modelItemCollection)
        {
            ModelItemCollection = modelItemCollection;
            BindingOperations.EnableCollectionSynchronization(ModelItemCollection, _syncLock);
            // Do this before, because AddDTO() also attaches events
            AttachEvents(0);

            if (modelItemCollection.Count == 1)
            {
                AddDto(2);
            }
            if (modelItemCollection.Count == 0)
            {
                AddDto(1);
                AddDto(2);
            }

            AddBlankRow();
            UpdateDisplayName();

            if (ModelItemCollection != null)
            {
                ModelItemCollection.CollectionChanged += ModelItemCollectionOnCollectionChanged;
            }
        }
        public static void addChilds()
        {
            ModelItemCollection selectionModelItems = new ModelItemCollection();

            if (!navisApp.Application.ActiveDocument.CurrentSelection.SelectedItems.IsEmpty)
            {
                //Copy the selection into a new ModelItemCollection
                navisApp.Application.ActiveDocument.CurrentSelection.SelectedItems.CopyTo(selectionModelItems);
                //Clear the current selection
                Autodesk.Navisworks.Api.Application.ActiveDocument.CurrentSelection.Clear();

                //iterate through the ModelItem's in the selection
                foreach (ModelItem modelItem in selectionModelItems)
                {
                    navisApp.Application.ActiveDocument.CurrentSelection.Add(modelItem);

                    //Add the ModelItem to the current selection
                    foreach (ModelItem childModelItem in modelItem.Children)
                    {
                        //Add the ModelItem to the current selection
                        Autodesk.Navisworks.Api.Application.ActiveDocument.CurrentSelection.Add(childModelItem);
                    }
                }
            }
        }
        void OnCreateSendReplyExecute(object sender, ExecutedRoutedEventArgs e)
        {
            ModelItem container;
            ModelItem flowStepContainer;

            using (ModelEditingScope scope = this.ModelItem.BeginEdit((string)this.FindResource("createSendReplyDescription")))
            {
                //special case handling for Sequence
                if (this.ModelItem.IsItemInSequence(out container))
                {
                    //get activities collection
                    ModelItemCollection activities = container.Properties["Activities"].Collection;
                    //get index of Send within collection and increment by one
                    int index = activities.IndexOf(this.ModelItem) + 1;
                    //insert created reply just after the Receive
                    activities.Insert(index, ReceiveDesigner.CreateSendReply(container, this.ModelItem));
                }
                //special case handling for Flowchart
                else if (this.ModelItem.IsItemInFlowchart(out container, out flowStepContainer))
                {
                    Activity replyActivity = ReceiveDesigner.CreateSendReply(container, this.ModelItem);
                    FlowchartDesigner.DropActivityBelow(this.ViewStateService, this.ModelItem, replyActivity, 30);
                }
                else
                {
                    ErrorReporting.ShowAlertMessage(string.Format(CultureInfo.CurrentUICulture, System.Activities.Core.Presentation.SR.CannotPasteSendReplyOrReceiveReply, typeof(SendReply).Name));
                }
                scope.Complete();
            }
            //always copy reply to clipboard
            Func <ModelItem, object, object> callback = CreateSendReply;

            CutCopyPasteHelper.PutCallbackOnClipBoard(callback, typeof(SendReply), this.ModelItem);
            e.Handled = true;
        }
 private void InitializeDesigning()
 {
     dynamic item = ModelItem;
     WIP.AllowedItemType = (Type)((ModelItem)item.BranchType).GetCurrentValue();
     branchesColl = ((ModelItemCollection)item.Branches);
     branchesColl.CollectionChanged += OnBranchesCollectionChanged;
     foreach (var branchModelItem in branchesColl) InitializeBranchModelItem(branchModelItem);
 }
        public static DynamicActivityProperty Find(ModelItemCollection properties, string propertyName)
        {
            foreach (ModelItem entry in properties)
            {
                DynamicActivityProperty property = (DynamicActivityProperty)entry.GetCurrentValue();

                if (StringComparer.Ordinal.Equals(property.Name, propertyName))
                {
                    return property;
                }
            }

            return null;
        }
 private static void SwapItems(ModelItemCollection collection, ModelItem modelItem1, ModelItem modelItem2)
 {
     int index1 = collection.IndexOf(modelItem1);
     int index2 = collection.IndexOf(modelItem2);
     collection.Remove(modelItem1);
     collection.Insert(index2, modelItem1);
     collection.Remove(modelItem2);
     collection.Insert(index1, modelItem2);
 }
 private ModelItem GetTopmostSelectedArgument(Selection selection, ModelItemCollection arguments)
 {
     foreach (ModelItem argument in arguments)
     {
         foreach (ModelItem candidateArgument in selection.SelectedObjects)
         {
             if (candidateArgument.ItemType == typeof(DesignTimeArgument))
             {
                 // since for arguments, the selection is not the modelitem, it is the fakemodelitem, we cannot do a
                 // simple reference comparing to find the selected argument.
                 DesignTimeArgument designTimeArgument = candidateArgument.GetCurrentValue() as DesignTimeArgument;
                 if (designTimeArgument.ReflectedObject == argument)
                 {
                     return argument;
                 }
             }
         }
     }
     return null;
 }
        internal static void AddModelItemCollection(TreeViewItemViewModel parent, ModelItemCollection collection, ModelProperty trackingProperty)
        {
            parent.GetTracker(trackingProperty).AddCollection(collection);

            bool duplicatedNodeVisible = true;
            string childNodePrefix = string.Empty;
            ShowPropertyInOutlineViewAttribute viewChild = ExtensibilityAccessor.GetAttribute<ShowPropertyInOutlineViewAttribute>(trackingProperty);
            if (viewChild != null)
            {
                duplicatedNodeVisible = viewChild.DuplicatedChildNodesVisible;
                childNodePrefix = viewChild.ChildNodePrefix;
            }

            foreach (ModelItem item in collection)
            {
                AddChild(parent, item, item, duplicatedNodeVisible, childNodePrefix, trackingProperty);
            }
        }
        void OnItemsChanged(ModelItemCollection oldItemsCollection, ModelItemCollection newItemsCollection)
        {
            if (oldItemsCollection != null)
            {
                oldItemsCollection.CollectionChanged -= this.OnCollectionChanged;
            }

            if (newItemsCollection != null)
            {
                newItemsCollection.CollectionChanged += this.OnCollectionChanged;
            }

            if (!isRegisteredWithParent)
            {
                CutCopyPasteHelper.RegisterWithParentViewElement(this);
                isRegisteredWithParent = true;
            }
            populateOnLoad = false;
            PopulateContent();
        }