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);
}
