private bool RenameProperty(string rawName) { SampleCompositeType effectiveParentType1 = this.DataSchemaNode.EffectiveParentType; SampleProperty sampleProperty1 = effectiveParentType1.GetSampleProperty(this.DataSchemaNode.PathName); SampleProperty propertyToRename1 = DataSchemaItem.GetHierarchicalPropertyToRename(sampleProperty1); if (propertyToRename1 == null || propertyToRename1 != sampleProperty1) { return(this.RenamePropertyInternal(sampleProperty1, propertyToRename1, rawName)); } for (DataSchemaItem dataSchemaItem = this.Parent as DataSchemaItem; dataSchemaItem != null; dataSchemaItem = dataSchemaItem.Parent as DataSchemaItem) { SampleCompositeType effectiveParentType2 = dataSchemaItem.DataSchemaNode.EffectiveParentType; if (effectiveParentType2 != effectiveParentType1) { SampleProperty sampleProperty2 = effectiveParentType2 != null?effectiveParentType2.GetSampleProperty(dataSchemaItem.DataSchemaNode.PathName) : (SampleProperty)null; if (sampleProperty2 == null) { return(this.RenamePropertyInternal(sampleProperty1, (SampleProperty)null, rawName)); } SampleProperty propertyToRename2 = DataSchemaItem.GetHierarchicalPropertyToRename(sampleProperty2); if (propertyToRename2 != sampleProperty1) { return(this.RenamePropertyInternal(sampleProperty1, (SampleProperty)null, rawName)); } return(dataSchemaItem.RenamePropertyInternal(sampleProperty2, propertyToRename2, rawName)); } } return(this.RenamePropertyInternal(sampleProperty1, (SampleProperty)null, rawName)); }
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { DataSchemaItem dataSchemaItem = values[0] as DataSchemaItem; bool flag = values.Length == 2 && (bool)values[1]; if (dataSchemaItem != null) { if (dataSchemaItem.IsHierarchicalCollection) { return((object)this.hierarchicalCollectionImage); } if (dataSchemaItem.DataSchemaNode.IsCollection) { if (!flag) { return((object)this.detailsCollectionImage); } return((object)this.masterCollectionImage); } if (dataSchemaItem.HasChildren) { return((object)this.compositeImage); } if (SampleDataSet.SampleDataTypeFromType(dataSchemaItem.DataSchemaNode.Type) is SampleCompositeType) { return((object)this.compositeImage); } } return((object)null); }
public void MakeHierarchicalCollection() { if (!this.schemaItem.Schema.DataSource.IsSampleDataSource) { return; } SampleDataSet sampleData = this.schemaItem.Schema.DataSource.SampleData; SampleCompositeType effectiveType = this.DataSchemaNode.EffectiveType; if (effectiveType == null) { return; } this.model.SelectionContext.Clear(); SampleNonBasicType sampleNonBasicType = (SampleNonBasicType)this.DataSchemaNode.SampleType; string uniquePropertyName1 = effectiveType.GetUniquePropertyName(this.DataSchemaNode.PathName); SampleProperty hierarchicalProperty = effectiveType.AddProperty(uniquePropertyName1, (SampleType)sampleNonBasicType); SampleProperty sampleProperty = this.DataSchemaNode.EffectiveParentType.GetSampleProperty(this.DataSchemaNode.PathName); string uniquePropertyName2 = DataSchemaItem.GetUniquePropertyName(sampleProperty, hierarchicalProperty, uniquePropertyName1); string schemaNodePath = DataSchemaItem.ProvideNodePathForPendingEdit(this, uniquePropertyName2, sampleProperty, hierarchicalProperty); sampleProperty.Rename(uniquePropertyName2); hierarchicalProperty.Rename(uniquePropertyName2); this.model.RenameSampleDataSchemaItemUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.model.ExtendSelectionUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.IsExpanded = true; using (TemporaryCursor.SetWaitCursor()) sampleData.CommitChanges(this.ViewModel.DesignerContext.MessageDisplayService); }
public override DataTemplate SelectTemplate(object item, DependencyObject container) { DataSchemaItem dataSchemaItem = item as DataSchemaItem; if (dataSchemaItem == null) { return((DataTemplate)null); } DataSourceNode dataSourceNode = dataSchemaItem.DataSourceNode; if (dataSourceNode == null) { return((DataTemplate)null); } DataTemplate dataTemplate = (DataTemplate)null; if (dataSourceNode.IsDesignData) { dataTemplate = this.DesignData.GetTemplate(dataSchemaItem); } else if (dataSourceNode.IsSampleDataSource) { dataTemplate = this.SampleData.GetTemplate(dataSchemaItem); } if (dataTemplate == null) { dataTemplate = this.LiveData.GetTemplate(dataSchemaItem); } return(dataTemplate); }
public void AddCollection() { if (!this.schemaItem.Schema.DataSource.IsSampleDataSource) { return; } SampleDataSet sampleData = this.schemaItem.Schema.DataSource.SampleData; SampleCompositeType effectiveType = this.DataSchemaNode.EffectiveType; if (effectiveType == null) { return; } this.model.SelectionContext.Clear(); string uniquePropertyName = effectiveType.GetUniquePropertyName("Collection"); string uniqueTypeName = sampleData.GetUniqueTypeName(uniquePropertyName + "Item"); SampleCompositeType compositeType = sampleData.CreateCompositeType(uniqueTypeName); SampleCollectionType collectionType = sampleData.CreateCollectionType((SampleNonBasicType)compositeType); effectiveType.AddProperty(uniquePropertyName, (SampleType)collectionType); string schemaNodePath = DataSchemaItem.ProvideNodePathForPendingEdit(this, uniquePropertyName); this.model.RenameSampleDataSchemaItemUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.model.ExtendSelectionUponRebuild(this.schemaItem.Schema.DataSource, schemaNodePath); this.IsExpanded = true; using (TemporaryCursor.SetWaitCursor()) sampleData.CommitChanges(this.ViewModel.DesignerContext.MessageDisplayService); }
private bool RenamePropertyInternal(SampleProperty sampleProperty, SampleProperty hierarchicalProperty, string rawName) { string uniquePropertyName = DataSchemaItem.GetUniquePropertyName(sampleProperty, hierarchicalProperty, rawName); if (string.IsNullOrEmpty(uniquePropertyName) || uniquePropertyName == sampleProperty.Name && (hierarchicalProperty == null || hierarchicalProperty.Name == uniquePropertyName)) { return(false); } this.pendingName = uniquePropertyName; Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, (Delegate)(() => this.ChangeEffectivePropertyIfValid((DataSchemaItem.ModifySamplePropertyOperation)((parentType, property) => { string schemaNodePath = (string)null; if (this.IsSelected) { this.model.SelectionContext.Remove((DataModelItemBase)this); schemaNodePath = DataSchemaItem.ProvideNodePathForPendingEdit(this.Parent as DataSchemaItem, this.pendingName, sampleProperty, hierarchicalProperty); } string typeName = rawName.Trim(); DataSchemaItem.RenamePropertyAndType(sampleProperty, this.pendingName, typeName); if (hierarchicalProperty != null) { DataSchemaItem.RenamePropertyAndType(hierarchicalProperty, this.pendingName, typeName); } if (schemaNodePath != null) { this.model.ExtendSelectionUponRebuild(this.DataSourceNode, schemaNodePath); } this.pendingName = (string)null; })))); return(true); }
private void InitializeDataSource(string dataSourceName, string path) { this.CurrentBindingSource = (IBindingSourceModel)this.dataSourceModel; DataSourceItem dataSourceItem1 = (DataSourceItem)null; foreach (DataSourceItem dataSourceItem2 in this.dataSourceModel.Model.DataSources) { if (dataSourceItem2.DataSourceNode.Name == dataSourceName) { dataSourceItem1 = dataSourceItem2; break; } } if (dataSourceItem1 == null) { return; } this.dataSourceModel.Model.SelectionContext.SetSelection((DataModelItemBase)dataSourceItem1); DataSchemaItem itemFromPath = dataSourceItem1.SchemaItem.GetItemFromPath(path); if (itemFromPath == null) { return; } dataSourceItem1.SchemaItem.SelectedItem = itemFromPath; itemFromPath.ExpandAncestors(); }
public DataPaneCallback(DataSchemaItem dataSchemaItem) { DataSchemaNode node = dataSchemaItem.DataSchemaNodePath.Node; this.property = ((SampleCompositeType)node.Parent.SampleType).GetSampleProperty(node.PathName); this.configuration = new SampleDataPropertyConfiguration(this.property); this.messageService = dataSchemaItem.ViewModel.DesignerContext.MessageDisplayService; }
public DataPanePopupCallback(DataSchemaItem dataSchemaItem) { DataSchemaNode parent = dataSchemaItem.DataSchemaNode.Parent; dataSchemaItem.DataSourceNode.DocumentNode.TypeResolver.GetType(parent.Type); this.property = DesignDataConfigurationButton.WritablePropertyFromSchemaItem(dataSchemaItem); this.designDataFile = DesignDataHelper.GetDesignDataFile(dataSchemaItem.DataSourceNode.DocumentNode); this.stringConfigurator = new SampleStringConfiguration(SampleDataFormatHelper.NormalizeFormat(SampleBasicType.String, (string)null, false), (string)null); }
private void InitializeExplicitDataContext(string path) { this.CurrentBindingSource = (IBindingSourceModel)this.explicitDataContextModel; DataSchemaItem itemFromPath = this.explicitDataContextModel.SchemaItem.GetItemFromPath(path); if (itemFromPath == null) { return; } this.explicitDataContextModel.SchemaItem.SelectedItem = itemFromPath; itemFromPath.ExpandAncestors(); }
public void RefreshDataSchemaItemFilter(DataSchemaItem item) { if (!item.HasLoadedChildren) { return; } item.RefreshFilter(); foreach (DataSchemaItem dataSchemaItem in Enumerable.OfType <DataSchemaItem>((IEnumerable)item.Children)) { this.RefreshDataSchemaItemFilter(dataSchemaItem); } }
private void ClearDataSchemaItemFilter(DataSchemaItem item) { if (!item.HasLoadedChildren) { return; } item.SetFilter((DataSchemaItemFilter)null); foreach (DataSchemaItem dataSchemaItem in Enumerable.OfType <DataSchemaItem>((IEnumerable)item.Children)) { this.ClearDataSchemaItemFilter(dataSchemaItem); } }
public static IProperty WritablePropertyFromSchemaItem(DataSchemaItem dataSchemaItem) { IProperty property = (IProperty)null; DataSchemaNode dataSchemaNode = dataSchemaItem.DataSchemaNode; if (dataSchemaNode.Parent != null && dataSchemaNode.IsProperty) { DataSchemaNode parent = dataSchemaNode.Parent; property = (IProperty)dataSchemaItem.DataSourceNode.DocumentNode.TypeResolver.GetType(parent.Type).GetMember(MemberType.Property, dataSchemaNode.PathName, MemberAccessTypes.All); if (!DesignDataGenerator.IsPropertyWritable(property, (ITypeResolver)dataSchemaItem.ViewModel.ProjectContext)) { property = (IProperty)null; } } return(property); }
private void ClearSchemaItemTree(DataSchemaItem item) { if (item == null) { return; } item.Dispose(); if (!item.HasLoadedChildren) { return; } foreach (DataSchemaItem dataSchemaItem in Enumerable.OfType <DataSchemaItem>((IEnumerable)item.Children)) { this.ClearSchemaItemTree(dataSchemaItem); } }
private void UpdateBounds() { Rect empty = Rect.Empty; if (this.IsEnabled && this.treeView != null) { DataSchemaItem dataSchemaItem = this.DataContext as DataSchemaItem; DataModelItemBase parent = dataSchemaItem.Parent; int num1 = parent != null?parent.Children.IndexOf((DataModelItemBase)dataSchemaItem) : -1; DataModelItemBase dataModelItemBase = parent == null || num1 >= parent.Children.Count - 1 ? (DataModelItemBase)null : parent.Children[num1 + 1]; int index = this.treeView.Items.IndexOf((object)dataSchemaItem); int num2 = dataModelItemBase != null?this.treeView.Items.IndexOf((object)dataModelItemBase) : this.treeView.Items.Count; FrameworkElement frameworkElement1 = VisualTreeHelper.GetParent((DependencyObject)this) as FrameworkElement; if (dataSchemaItem != null && parent != null && (index >= 0 && num2 >= 0)) { FrameworkElement frameworkElement2 = this.treeView.ItemContainerGenerator.ContainerFromIndex(index) as FrameworkElement; if (frameworkElement2 != null) { Rect rect = frameworkElement2.TransformToVisual((Visual)frameworkElement1).TransformBounds(new Rect(0.0, 0.0, frameworkElement2.ActualWidth, frameworkElement2.ActualHeight)); empty.Union(rect); } if (num2 > index) { FrameworkElement frameworkElement3 = this.treeView.ItemContainerGenerator.ContainerFromIndex(num2 - 1) as FrameworkElement; if (frameworkElement3 != null) { Rect rect = frameworkElement3.TransformToVisual((Visual)frameworkElement1).TransformBounds(new Rect(0.0, 0.0, frameworkElement3.ActualWidth, frameworkElement3.ActualHeight)); empty.Union(rect); } } } } if (empty.IsEmpty) { this.Visibility = Visibility.Collapsed; } else { this.Visibility = Visibility.Visible; this.RenderTransform = (Transform) new TranslateTransform(empty.Left, empty.Top); this.Height = empty.Height; } }
public override DataTemplate GetTemplate(DataSchemaItem dataSchemaItem) { DataTemplate dataTemplate = (DataTemplate)null; if (dataSchemaItem.IsSampleBasicType) { dataTemplate = this.BasicTemplate; } else if (dataSchemaItem.IsSampleCollectionType) { dataTemplate = this.CollectionTemplate; } else if (dataSchemaItem.SampleType != null) { dataTemplate = this.CompositeTemplate; } return(dataTemplate); }
public SchemaItem(ISchema schema, DataPanelModel model, SelectionContext <DataModelItemBase> selectionContext) { this.model = model; this.itemSelectionContext = selectionContext ?? (SelectionContext <DataModelItemBase>) new SingleSelectionContext <DataModelItemBase>(); this.itemSelectionContext.PropertyChanged += new PropertyChangedEventHandler(this.itemSelectionContext_PropertyChanged); this.schema = schema; this.flattener = new VirtualizingTreeItemFlattener <DataModelItemBase>((ITreeViewItemProvider <DataModelItemBase>) this); if (this.schema.Root != null) { DataSchemaNodePath nodePath = new DataSchemaNodePath(this.schema, this.schema.Root); this.itemSelectionContext.Clear(); this.ClearSchemaItemTree(this.root); this.root = new DataSchemaItem(nodePath, this, this.model, this.itemSelectionContext); this.root.EnsureChildrenExpanded(); } this.OnPropertyChanged("Root"); this.flattener.RebuildList(); }
private List <DataModelItemBase> GenerateSiblingSchemaItemRange(DataSchemaItem first, DataSchemaItem last, DataModelItemBase parent) { int num1 = parent.Children.IndexOf((DataModelItemBase)last); int num2 = parent.Children.IndexOf((DataModelItemBase)first); int num3 = num2 < num1 ? 1 : -1; List <DataModelItemBase> list = new List <DataModelItemBase>(); int index = num2; while (index != num1 + num3) { DataSchemaItem dataSchemaItem = parent.Children[index] as DataSchemaItem; if (dataSchemaItem != null) { list.Add((DataModelItemBase)dataSchemaItem); } index += num3; } return(list); }
private bool BindingFilter(DataSchemaItem item) { switch (this.CurrentBindingFilterMode) { case BindingFilterMode.None: return(true); case BindingFilterMode.FilterByType: DataSchemaItem dataSchemaItem = item; IProjectContext projectContext = this.TargetElement.ProjectContext; if (item.Parent != null && !BindingEditor.CanBindToSchemaNode(this.TargetElement, (IPropertyId)this.TargetProperty, dataSchemaItem.DataSchemaNode)) { return(dataSchemaItem.HasChildren); } return(true); default: return(true); } }
private DataSchemaItem GetItemForNode(DataSchemaItem currentItem, DataSchemaNode nextNode, out DataSchemaNode adjustedNextNode) { currentItem.EnsureChildrenExpanded(); adjustedNextNode = nextNode; foreach (DataSchemaItem dataSchemaItem in Enumerable.OfType <DataSchemaItem>((IEnumerable)currentItem.Children)) { if (dataSchemaItem.DataSchemaNode == nextNode) { while (adjustedNextNode.IsCollection && adjustedNextNode.CollectionItem != null && adjustedNextNode.CollectionItem.Type != typeof(object)) { adjustedNextNode = adjustedNextNode.CollectionItem; } return(dataSchemaItem); } } if (currentItem.DataSchemaNode.CollectionItem == nextNode) { return(currentItem); } return((DataSchemaItem)null); }
public void ProcessChildren(DataSchemaItem dataSchemaItem) { DataSchemaNodePath dataSchemaNodePath = dataSchemaItem.DataSchemaNodePath; DataSchemaNode dataSchemaNode = dataSchemaNodePath.Node; bool flag = true; while (dataSchemaNode.IsCollection && dataSchemaNode.CollectionItem != null && dataSchemaNode.CollectionItem.Type != typeof(object)) { dataSchemaNode = dataSchemaNode.CollectionItem; } if (dataSchemaNode.Type == typeof(string) && !(dataSchemaItem.DataSchemaNodePath.Schema is XmlSchema)) { flag = false; } else if (dataSchemaItem.SampleType is SampleBasicType) { flag = false; } else if (dataSchemaNode != dataSchemaNodePath.Node) { SampleCollectionType sampleCollectionType = dataSchemaNodePath.Node.SampleType as SampleCollectionType; if (sampleCollectionType != null && sampleCollectionType.ItemSampleType is SampleBasicType) { flag = false; } } if (flag) { foreach (DataSchemaNode node in dataSchemaNode.Children) { DataSchemaItem dataSchemaItem1 = new DataSchemaItem(dataSchemaNodePath.GetExtendedPath(node), this, this.model, this.itemSelectionContext); dataSchemaItem.AddChild((DataModelItemBase)dataSchemaItem1); } } if (this.lastFilter == null) { return; } dataSchemaItem.SetFilter(this.lastFilter); }
private void InitializeElementName(string elementName, string path) { this.CurrentBindingSource = (IBindingSourceModel)this.elementPropertyModel; if (elementName == null) { return; } ElementBindingSourceNode elementNodeByName = this.elementPropertyModel.FindElementNodeByName(elementName); if (elementNodeByName == null) { return; } elementNodeByName.ExpandAncestors(); this.elementPropertyModel.SelectedNode = elementNodeByName; DataSchemaItem itemFromPath = elementNodeByName.SchemaItem.GetItemFromPath(path); if (itemFromPath == null) { return; } elementNodeByName.SchemaItem.SelectedItem = itemFromPath; itemFromPath.ExpandAncestors(); }
public DataSchemaItem FindDataSchemaItemForNode(DataSchemaNodePath descendant) { DataSchemaItem currentItem = this.root; Stack <DataSchemaNode> stack = new Stack <DataSchemaNode>(); for (DataSchemaNode dataSchemaNode = descendant.Node; dataSchemaNode != this.root.DataSchemaNode; dataSchemaNode = dataSchemaNode.Parent) { stack.Push(dataSchemaNode); } while (stack.Count > 0) { DataSchemaNode nextNode = stack.Pop(); DataSchemaNode adjustedNextNode; currentItem = this.GetItemForNode(currentItem, nextNode, out adjustedNextNode); if (adjustedNextNode != nextNode) { do { ; }while (stack.Count > 0 && stack.Pop() != adjustedNextNode); } } return(currentItem); }
public override DataConfigurationPopup CreatePopup(DataSchemaItem dataSchemaItem) { return((DataConfigurationPopup) new SampleDataConfigurationPopup(dataSchemaItem)); }
public override int CompareTo(DataModelItemBase treeItem) { DataSchemaItem dataSchemaItem = (DataSchemaItem)treeItem; return(StringLogicalComparer.Instance.Compare(this.PathName, dataSchemaItem.PathName)); }
public SampleDataConfigurationPopup(DataSchemaItem dataSchemaItem) : base((IPopupControlCallback) new SampleDataConfigurationPopup.DataPaneCallback(dataSchemaItem), ConfigurationPlaceholder.Type) { }
private static string ProvideNodePathForPendingEdit(DataSchemaItem parentItem, string newPropertyName, params SampleProperty[] renamedProperties) { DataSchemaNodePath dataSchemaNodePath = parentItem.DataSchemaNodePath; DataSchemaNode endNode = (DataSchemaNode)null; if (dataSchemaNodePath.IsCollection) { endNode = dataSchemaNodePath.EffectiveCollectionItemNode; } if (endNode == null) { endNode = dataSchemaNodePath.Node; } if (endNode == null) { return(newPropertyName); } string inheritedPath = (string)null; if (renamedProperties.Length == 0) { if (endNode != dataSchemaNodePath.Node) { dataSchemaNodePath = new DataSchemaNodePath(dataSchemaNodePath.Schema, endNode); } return(ClrObjectSchema.CombinePaths(dataSchemaNodePath.Path, newPropertyName)); } List <string> list = new List <string>() { newPropertyName }; string pathName = endNode.PathName; for (DataSchemaNode parent = endNode.Parent; parent != null; parent = parent.Parent) { SampleCompositeType sampleCompositeType = parent.SampleType as SampleCompositeType; if (sampleCompositeType == null) { list.Add(pathName); } else { string name = pathName; SampleProperty sampleProperty = sampleCompositeType.GetSampleProperty(name); if (Enumerable.FirstOrDefault <SampleProperty>((IEnumerable <SampleProperty>)renamedProperties, (Func <SampleProperty, bool>)(p => p == sampleProperty)) != null) { name = newPropertyName; } list.Add(name); } if (parent != dataSchemaNodePath.Schema.Root) { pathName = parent.PathName; } else { break; } } for (int index = list.Count - 1; index >= 0; --index) { inheritedPath = ClrObjectSchema.CombinePaths(inheritedPath, list[index]); } return(inheritedPath); }
public DesignDataTypeConfigurationPopup(DataSchemaItem dataSchemaItem) : base((IPopupControlCallback) new DesignDataTypeConfigurationPopup.DataPanePopupCallback(dataSchemaItem), ConfigurationPlaceholder.StringFormat) { this.IsPerformingSchemaChange = !DesignDataHelper.GetDesignDataFile(dataSchemaItem.DataSourceNode.DocumentNode).IsOpen; }
public override DataConfigurationPopup CreatePopup(DataSchemaItem dataSchemaItem) { return((DataConfigurationPopup) new DesignDataTypeConfigurationPopup(dataSchemaItem)); }
internal void RefreshSchema(ISchema schema) { this.schemaItem = new SchemaItem(schema, this.model, this.model.SelectionContext); this.activeChildItem = (DataSchemaItem)null; this.OnPropertyChanged((string)null); }