public async Task ExtendModelWithRelatedNodesAsync(
IModelNode modelNode,
DirectedModelRelationshipType?directedModelRelationshipType = null,
CancellationToken cancellationToken = default(CancellationToken),
IIncrementalProgress progress = null,
bool recursive = false)
{
var roslynModelNode = modelNode as IRoslynModelNode;
if (roslynModelNode == null)
{
return;
}
await ExtendModelWithRelatedNodesRecursiveAsync(
roslynModelNode,
directedModelRelationshipType,
cancellationToken,
progress,
recursive,
new HashSet <ModelNodeId> {
roslynModelNode.Id
}
);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableModelNode"/> class.
/// </summary>
/// <param name="ownerViewModel">The <see cref="ObservableViewModel"/> that owns the new <see cref="ObservableModelNode"/>.</param>
/// <param name="baseName">The base name of this node. Can be null if <see cref="index"/> is not. If so a name will be automatically generated from the index.</param>
/// <param name="isPrimitive">Indicate whether this node should be considered as a primitive node.</param>
/// <param name="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="modelNodePath">The <see cref="ModelNodePath"/> corresponding to the given <see cref="modelNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IModelNode modelNode, ModelNodePath modelNodePath, object index = null)
: base(ownerViewModel, baseName, index)
{
if (modelNode == null) throw new ArgumentNullException(nameof(modelNode));
if (baseName == null && index == null)
throw new ArgumentException("baseName and index can't be both null.");
this.isPrimitive = isPrimitive;
SourceNode = modelNode;
// By default we will always combine items of list of primitive items.
CombineMode = index != null && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll;
targetNode = GetTargetNode(modelNode, index);
SourceNodePath = modelNodePath;
// Override display name if available
var memberDescriptor = GetMemberDescriptor() as MemberDescriptorBase;
if (memberDescriptor != null)
{
if (index == null)
{
var displayAttribute = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute<DisplayAttribute>(memberDescriptor.MemberInfo);
if (!string.IsNullOrEmpty(displayAttribute?.Name))
{
DisplayName = displayAttribute.Name;
}
IsReadOnly = !memberDescriptor.HasSet;
}
}
}
/// <summary>
/// Adds the node to the AddressSpace.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="name">The name.</param>
/// <returns>Unique index in the AddressSpace</returns>
public int AddNode2AddressSpace(IModelNode node, string uniqueName)
{
int index = TryGetAndAddIfNeeded(uniqueName);
Debug.Assert(m_NodesList[index] != null);
if (m_NodesList[index].Type == NodeHandle.NodeType.DanglingReference)
{
m_NodesList[index] = NodeHandle.CreateRegularNode(node);
}
else
{
string msg = "Node: " + node.Name + " is declared twice.";
bool _errorListContainsNode = false;
for (int i = 0; i < m_NodesList[index].Node.ErrorList.Count; i++)
{
if (String.Compare(m_NodesList[index].Node.ErrorList[i].Message, msg) == 0)
{
_errorListContainsNode = true;
break;
}
}
if (!_errorListContainsNode)
{
AssemblyTraceEvent.Tracer.TraceEvent(TraceEventType.Information, 95, "AddNode compiler error '{0}' for node SymbolicName: {1}", msg, node.SymbolicName);
m_NodesList[index].Node.ErrorList.Add(new Diagnostics(msg));
}
}
return(index);
}
protected override object GetNodeValueCore(IModelNode modelNode, string name)
{
var node = ((ModelNode)modelNode);
var modelValueInfo = node.GetValueInfo(name);
return(_getApplyModelNodeValue(node, modelValueInfo));
}
/// <summary>
/// Initializes a new instance of the QuantumConsistencyException class.
/// </summary>
/// <param name="expected">A string representing the expected result.</param>
/// <param name="observed">A string representing the observed result.</param>
/// <param name="node">The node that is related to this error.</param>
public QuantumConsistencyException(string expected, string observed, IModelNode node)
: base(GetMessage(expected, observed))
{
Expected = expected ?? "(NullMessage)";
Observed = observed ?? "(NullMessage)";
Node = node;
}
private static ComparisonResult Compare(IModelNode vertex, IModelNode pattern)
{
if (vertex.QualifiedName.EndsWith(pattern.QualifiedName))
{
var node = (IModelNode)vertex;
var patternNode = (IModelNode)pattern;
if (!node.Children.Any() && !patternNode.Children.Any())
{
return new ComparisonResult(ComparisonResultKind.Same, pattern, vertex);
}
if (!patternNode.Children.Any())
{
return new ComparisonResult(ComparisonResultKind.Partial, pattern, vertex);
}
var childComparisons = node.Children.Zip(patternNode.Children, Compare).AsArray();
return childComparisons.All(x => x.Kind == ComparisonResultKind.Same)
? new ComparisonResult(ComparisonResultKind.Same, pattern, vertex)
: childComparisons.All(x => x.Kind != ComparisonResultKind.Different)
? new ComparisonResult(ComparisonResultKind.Partial, pattern, vertex)
: new ComparisonResult(ComparisonResultKind.Different, pattern, null);
}
return new ComparisonResult(ComparisonResultKind.Different, pattern, null);
}
private static void PrintHierarchyInternal(IModelNode node, int indentation, StringBuilder builder)
{
PrintIndentation(indentation, builder);
builder.Append(node.Guid + " ");
PrintIndentation(indentation, builder);
builder.Append(node.Name ?? "<untitled>");
builder.Append(": [");
builder.Append(node.Content.GetType().Name);
builder.Append("] = ");
if (node.Content.IsReference)
{
if (node.Content.Value != null)
{
builder.Append(node.Content.Value.ToString().Replace(Environment.NewLine, " "));
builder.Append(" > ");
}
builder.Append("Reference -> ");
builder.Append(node.Content.Reference);
}
else if (node.Content.Value == null)
{
builder.Append("(null)");
}
else
{
builder.Append(node.Content.Value.ToString().Replace(Environment.NewLine, " "));
}
builder.AppendLine();
foreach (var child in node.Children)
{
PrintHierarchyInternal(child, indentation + 4, builder);
}
}
protected void ShowModelRelationshipsIfBothEndsAreVisible(IModelNode modelNode, IModel model, IDiagram diagram)
{
foreach (var modelRelationship in model.GetRelationships(modelNode.Id))
{
ShowModelRelationshipIfBothEndsAreVisible(modelRelationship, diagram);
}
}
public override bool IsVisible(IModelNode node, string propertyName) {
var typesInfo = node.Application.GetTypesInfo();
var typeToTypeInfo = typesInfo.FindTypeInfo(typeof(GridListEditorVisibilityCalculatorHelper));
var typeInfo = ReflectionHelper.FindTypeDescendants(typeToTypeInfo).Single();
var calculatorHelper = (GridListEditorVisibilityCalculatorHelper)Activator.CreateInstance(typeInfo.Type);
return calculatorHelper.IsVisible(node, propertyName);
}
private IModelNode TransformVertexRecursive(IModelNode vertex, TransformRule[] transforms)
{
var newName = transforms.Aggregate(
vertex.DisplayName,
(name, rule) => GetTransform(rule.Pattern).Replace(name, rule.Name ?? string.Empty));
var type = vertex.Type;
var linesOfCode = vertex.LinesOfCode;
var maintainabilityIndex = vertex.MaintainabilityIndex;
var cyclomaticComplexity = vertex.CyclomaticComplexity;
var quality = vertex.Quality;
var children = vertex.Children.Select(x => TransformVertexRecursive(x, transforms));
return vertex is StaticModelNode
? new StaticModelNode(
newName,
type,
quality,
linesOfCode,
maintainabilityIndex,
cyclomaticComplexity,
children.ToList())
: new ModelNode(
newName,
type,
quality,
linesOfCode,
maintainabilityIndex,
cyclomaticComplexity,
children.ToList());
}
public override object LayoutControls(IModelNode layoutInfo, ViewItemsCollection detailViewItems) {
var splitLayout = layoutInfo as IModelSplitLayout;
if (IsMasterDetail(layoutInfo, detailViewItems, splitLayout)) {
_detailViewItems = detailViewItems;
var gridView = (Control)detailViewItems[0].Control as ASPxGridView;
if (gridView != null) {
var detailControl = (Control)detailViewItems[1].Control;
SetupViewItems(gridView);
ASPxSplitter splitter = LayoutMasterDetail(detailControl, gridView, splitLayout);
var viewItem = detailViewItems[0] as ListEditorViewItem;
if (viewItem != null) {
var listEditor = viewItem.ListEditor as XpandASPxGridListEditor;
if (listEditor != null) {
listEditor.ViewControlsCreated += (s, e) => SetSplitterInitClientEvent(splitter, e.IsRoot);
}
}
RaiseMasterDetailLayout(new MasterDetailLayoutEventArgs {
MasterViewItem = detailViewItems[0],
DetailViewItem = detailViewItems[1],
SplitterControl = splitter
});
return splitter;
}
throw new NotImplementedException(detailViewItems[0].Control.ToString());
}
return base.LayoutControls(layoutInfo, detailViewItems);
}
public override void UpdateNode(ModelNode node)
{
if (((IModelClass)node.Parent).TypeInfo.Type == typeof(FDSSCustomer))
{
IModelNode modelNode = node.GetNode("SkinFilterProvider");
modelNode.Remove();
}
}
public void OnSelectedItemIsChangedEventHandler(object sender, SelectedItemEventArgs e)
{
if (this != sender)
{
m_SelectedIModelNode = e.SelectedIModelNode;
OnSelectedItemIsChanged(sender, e);
}
}
public void AddNode(IModelNode node)
{
lock (ModelUpdateLockObject)
{
Model = Model.AddNode(node);
ModelChanged?.Invoke(new ModelNodeAddedEvent(Model, node));
}
}
public virtual IModelNode Visit(IModelNode modelNode)
{
if (modelNode != null)
{
return(modelNode.Accept(this));
}
return(null);
}
public static string Id(this IModelNode modelNode, string id = null)
{
if (id != null)
{
((ModelNode)modelNode).Id = id;
}
return(((ModelNode)modelNode).Id);
}
/// <summary>
/// Creates a regular node that is to bne used to replace the dangling reference olready added to the address space.
/// </summary>
/// <param name="node">The node to contain model information..</param>
/// <returns>ModelNode.</returns>
internal static NodeHandle CreateRegularNode(IModelNode node)
{
return(new NodeHandle()
{
Type = NodeType.RegularNode,
Node = node
});
}
private static IDiagramNode CreateInstance(
[NotNull] IModelNode modelNode,
DateTime addedAt,
Point2D topLeft,
Size2D payloadAreaSize,
Size2D childrenAreaSize,
Maybe <ModelNodeId> parentNodeId)
=> new DiagramNode(modelNode, addedAt, topLeft, payloadAreaSize, childrenAreaSize, parentNodeId);
public override bool IsVisible(IModelNode node, string propertyName) {
Type editorType = EditorType(node);
if (editorType == typeof(GridListEditor))
return true;
if (typeof(XpandGridListEditor).IsAssignableFrom(editorType) && !typeof(AdvBandedListEditor).IsAssignableFrom(editorType))
return true;
return false;
}
/// <summary>
/// Indicates whether the current object is equal to another object of the same type.
/// </summary>
/// <returns>
/// <code>true</code> if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
/// </returns>
/// <param name="other">An object to compare with this object.</param>
public bool Equals(IModelNode other)
{
var isEqual = other != null &&
QualifiedName.Equals(other.QualifiedName) &&
Type.Equals(other.Type);
return(isEqual);
}
protected DiagramNodeBase(IModelNode modelNode, Size2D size, Point2D center, DateTime addedAt, ModelNodeId?parentNodeId)
{
ModelNode = modelNode ?? throw new ArgumentNullException(nameof(modelNode));
Size = size;
Center = center;
AddedAt = addedAt;
ParentNodeId = parentNodeId;
}
/// <summary>
/// Bubbles a model change notification.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="handle">The handle.</param>
public void BubbleModelChange(IModelNode source, IUndoRedoHandle handle)
{
ModelChanged(source, handle);
if (Parent != null)
{
Parent.BubbleModelChange(source, handle);
}
}
public bool IsVisible(IModelNode node, string propertyName)
{
var viewItems = ((IModelDashboardViewMasterDetail)node).Items.OfType <IModelDashboardViewItem>().ToArray();
var modelObjectViews = viewItems.Select(item => item.View).OfType <IModelObjectView>().ToArray();
return(modelObjectViews.Length == 2 && modelObjectViews.Length == viewItems.Length &&
modelObjectViews.GroupBy(view => view.ModelClass).Count() == 1 && modelObjectViews.First().GetType() != modelObjectViews.Last().GetType());
}
public static ModelNode AddNode <T>(this IModelNode node, string id, bool checkForDuplicates) where T : IModelNode
{
if (!checkForDuplicates || (((ModelNode)node)[id] == null))
{
return((ModelNode)(IModelNode)node.AddNode <T>(id));
}
throw new DuplicateNameValidationException($"{node}");
}
private static IModelGraph AddNodeCore(
[NotNull] IModelNode newNode,
[NotNull] IModelGraph modelGraph,
[NotNull][ItemNotNull] ICollection <ModelItemEventBase> itemEvents)
{
itemEvents.Add(new ModelNodeAddedEvent(newNode));
return(modelGraph.AddVertex(newNode));
}
protected override IDiagramNode CreateInstance(
IModelNode modelNode,
Size2D size,
Point2D center,
DateTime addedAt,
ModelNodeId?parentNodeId,
ILayoutGroup layoutGroup)
=> new RoslynTypeDiagramNode((IRoslynTypeNode)modelNode, size, center, addedAt, parentNodeId, layoutGroup);
public bool IsVisible(IModelNode node, string propertyName){
var modelLogicRule = (IModelLogicRule)node;
if (modelLogicRule.ModelClass != null){
var names = modelLogicRule.ModelClass.TypeInfo.Members.Select(info => info.Name);
return modelLogicRule.ModelLogicWrapper.ObjectChangedExecutionContextGroup.SelectMany(contexts => contexts).Any(context => context.PropertyNames.Split(';').Any(names.Contains));
}
return false;
}
protected sealed override IDiagramNode CreateInstance(
IModelNode modelNode,
Size2D size,
Point2D center,
DateTime addedAt,
ModelNodeId?parentNodeId)
{
return(CreateInstance(modelNode, size, center, addedAt, parentNodeId, LayoutGroup));
}
public IModelRelationship WithTarget(IModelNode newTargetNode)
{
if (Target.Id != newTargetNode.Id)
{
throw new InvalidOperationException($"New target node must have the same id as the old one. OldId={Source.Id}, NewId={newTargetNode.Id}");
}
return(CreateInstance(Id, Source, newTargetNode, Stereotype));
}
public static IModelList <IModelClass> ModelClasses(this IModelNode modelNode, Type assignableFromType)
{
var modelClasses = modelNode.Application.BOModel.Where(modelClass
=> assignableFromType.IsAssignableFrom(modelClass.TypeInfo.Type) && !modelClass.TypeInfo.IsAbstract &&
new[] { typeof(ISecurityRelated), typeof(ISecurityPermisssionPolicyRelated) }.Any(
type => type.IsAssignableFrom(modelClass.TypeInfo.Type)));
return(new CalculatedModelNodeList <IModelClass>(modelClasses));
}
private static ExpressionEvaluator GetExpressionEvaluator(IModelNode dataSourceNode, CriteriaOperator criteriaOperator)
{
var typeInfo = dataSourceNode.GetGenericListArgument();
var descendants = ReflectionHelper.FindTypeDescendants(typeInfo);
var propertyDescriptors = descendants.SelectMany(info => info.Members).DistinctBy(info => info.Name).Select(info => new XafPropertyDescriptor(info, info.Name)).Cast <PropertyDescriptor>().ToArray();
var evaluatorContextDescriptor = new EvaluatorContextDescriptorDefault(new PropertyDescriptorCollection(propertyDescriptors));
return(new ExpressionEvaluator(evaluatorContextDescriptor, criteriaOperator, false, XpandModuleBase.Dictiorary.CustomFunctionOperators));
}
public void TestNullLists()
{
var obj = new ClassWithNullLists();
var container = new ModelContainer();
IModelNode model = container.GetOrCreateModelNode(obj, obj.GetType());
Helper.PrintModelContainerContent(container, model);
Helper.ConsistencyCheck(container, obj);
}
public static IModelNode MergeWith(this IModelNode node, string xml)
{
var modelXmlReader = new ModelXmlReader();
var modelApplicationBase = node.Application.NewModelApplication();
modelXmlReader.ReadFromString(modelApplicationBase, "", xml);
node.MergeWith(modelApplicationBase);
return(node);
}
public Task <IEnumerable <IValidationResult> > Validate(IModelNode modelTree)
{
return(Task.Factory.StartNew(
() =>
{
var result = Contains(modelTree, _pattern);
return new IValidationResult[] { new BranchResult(result.Kind == ComparisonResultKind.Same, _pattern) }.AsEnumerable();
}));
}
private void BuildLayout(IEnumerable <LayoutItem> items, IModelNode parentNode, IModelDetailView modelDetailView)
{
foreach (var item in items)
{
var newNode = FactorNode(item, parentNode, modelDetailView);
BuildLayout(item, newNode, modelDetailView);
}
}
public void UpdateNode(IModelNode newNode)
{
lock (ModelUpdateLockObject)
{
var oldNode = Model.GetNode(newNode.Id);
Model = Model.ReplaceNode(newNode);
ModelChanged?.Invoke(new ModelNodeUpdatedEvent(Model, oldNode, newNode));
}
}
public Task<IEnumerable<IValidationResult>> Validate(IModelNode modelTree)
{
return Task.Factory.StartNew(
() =>
{
var result = Contains(modelTree, _pattern);
return new IValidationResult[] { new BranchResult(result.Kind == ComparisonResultKind.Same, _pattern) }.AsEnumerable();
});
}
protected Type EditorType(IModelNode node) {
var modelListView = node as IModelListView;
if (modelListView != null)
return modelListView.EditorType;
var modelColumn = node as IModelColumn;
if (modelColumn != null)
return ((IModelListView)modelColumn.ParentView).EditorType;
throw new NotImplementedException(node.GetType().ToString());
}
/// <inheritdoc/>
// TODO: Remove the type argument here
public IModelNode Build(IModelNode referencer, object obj, Type type, Guid guid)
{
Reset();
rootGuid = guid;
var typeDescriptor = TypeDescriptorFactory.Find(obj != null ? obj.GetType() : type);
VisitObject(obj, typeDescriptor as ObjectDescriptor, true);
return rootNode;
}
protected override Type GetDefaultEditorTypeFromModel(IEditorTypeRegistration registration, IAliasRegistration aliasRegistration,
IModelNode modelNode)
{
var memberEditorInfoCalculator = new MemberEditorInfoCalculator();
var parameterTypes = new[] { typeof(IEditorTypeRegistration), typeof(IAliasRegistration), typeof(IModelNode) };
var callMethod = memberEditorInfoCalculator.CallMethod("GetDefaultEditorTypeFromModel", parameterTypes, Flags.NonPublic | Flags.Instance, registration, aliasRegistration, modelNode);
return((Type)callMethod);
}
private void GenerateChildren(IModelNode modelNode, ModelNodePath modelNodePath, bool isUpdating)
{
if (modelNode.Content.IsReference)
{
var referenceEnumerable = modelNode.Content.Reference as ReferenceEnumerable;
if (referenceEnumerable != null)
{
foreach (var reference in referenceEnumerable)
{
// The type might be a boxed primitive type, such as float, if the collection has object as generic argument.
// In this case, we must set the actual type to have type converter working, since they usually can't convert
// a boxed float to double for example. Otherwise, we don't want to have a node type that is value-dependent.
var type = reference.TargetNode != null && reference.TargetNode.Content.IsPrimitive ? reference.TargetNode.Content.Type : reference.Type;
var observableNode = Create(Owner, null, false, this, modelNode, modelNodePath, type, reference.Index);
observableNode.Initialize(isUpdating);
AddChild(observableNode);
}
}
}
else
{
var dictionary = modelNode.Content.Descriptor as DictionaryDescriptor;
var list = modelNode.Content.Descriptor as CollectionDescriptor;
if (dictionary != null && modelNode.Content.Value != null)
{
// Dictionary of primitive objects
foreach (var key in dictionary.GetKeys(modelNode.Content.Value))
{
var observableChild = Create(Owner, null, true, this, modelNode, modelNodePath, dictionary.ValueType, key);
observableChild.Initialize(isUpdating);
AddChild(observableChild);
}
}
else if (list != null && modelNode.Content.Value != null)
{
// List of primitive objects
for (int i = 0; i < list.GetCollectionCount(modelNode.Content.Value); ++i)
{
var observableChild = Create(Owner, null, true, this, modelNode, modelNodePath, list.ElementType, i);
observableChild.Initialize(isUpdating);
AddChild(observableChild);
}
}
else
{
// Single non-reference primitive object
foreach (var child in modelNode.Children)
{
var childPath = ModelNodePath.GetChildPath(modelNodePath, modelNode, child);
var observableChild = Create(Owner, child.Name, child.Content.IsPrimitive, this, child, childPath, child.Content.Type, null);
observableChild.Initialize(isUpdating);
AddChild(observableChild);
}
}
}
}
public static void ReadFromModel(this ModelXmlReader modelXmlReader, IModelNode modelNode,
IModelNode readFrom, Func<string, bool> aspectNamePredicate) {
var modelApplication = ((ModelApplicationBase) readFrom.Application);
for (int i = 0; i < modelApplication.AspectCount; i++) {
string aspect = modelApplication.GetAspect(i);
string xml = new ModelXmlWriter().WriteToString(readFrom, i);
if (!(string.IsNullOrEmpty(xml)))
new ModelXmlReader().ReadFromString(modelNode, aspect, xml);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="ObservableViewModelService"/> to use for this view model.</param>
/// <param name="modelContainer">A <see cref="ModelContainer"/> to use to build view model nodes.</param>
/// <param name="modelNode">The root model node of the view model to generate.</param>
/// <param name="dirtiables">The list of <see cref="IDirtiableViewModel"/> objects linked to this view model.</param>
public ObservableViewModel(IViewModelServiceProvider serviceProvider, ModelContainer modelContainer, IModelNode modelNode, IEnumerable<IDirtiableViewModel> dirtiables)
: this(serviceProvider, modelContainer, dirtiables.SafeArgument("dirtiables").ToList())
{
if (modelNode == null) throw new ArgumentNullException("modelNode");
var node = observableViewModelService.ObservableNodeFactory(this, "Root", modelNode.Content.IsPrimitive, modelNode, new ModelNodePath(modelNode), modelNode.Content.Type, null);
Identifier = new ObservableViewModelIdentifier(node.ModelGuid);
node.Initialize();
RootNode = node;
node.CheckConsistency();
}
private TestDiagramNode(
IModelNode modelNode,
Size2D size,
Point2D center,
DateTime addedAt,
ModelNodeId?parentNodeId,
ILayoutGroup layoutGroup)
: base(modelNode, size, center, addedAt, parentNodeId, layoutGroup)
{
}
public Task<IEnumerable<IValidationResult>> Validate(IModelNode modelTree)
{
return
Task.Factory.StartNew(
() => modelTree.Children.SelectMany(x => x.Flatten())
.Where(x => x.Type == NodeKind.Class)
.Where(x => x.CyclomaticComplexity > _cyclomaticComplexity || x.MaintainabilityIndex < _maintainabilityIndex || x.LinesOfCode > _linesOfCode)
.Select(x => new KpiResult(false, x))
.Cast<IValidationResult>()
.AsArray()
.AsEnumerable());
}
public override object LayoutControls(IModelNode layoutInfo, ViewItemsCollection detailViewItems) {
var splitLayout = layoutInfo as IModelSplitLayout;
if (IsMasterDetail(layoutInfo, detailViewItems, splitLayout)) {
_detailViewItems = detailViewItems;
var gridView = (Control)detailViewItems[0].Control as ASPxGridView;
if (gridView != null) {
var detailControl = (Control)detailViewItems[1].Control;
SetupViewItems(detailControl, gridView);
return LayoutControls(detailControl, gridView, splitLayout);
}
throw new NotImplementedException(detailViewItems[0].Control.ToString());
}
return base.LayoutControls(layoutInfo, detailViewItems);
}
private static ComparisonResult Contains(IModelNode tree, IModelNode pattern)
{
var deepComparison = tree.Flatten().Select(x => Compare(x, pattern)).AsArray();
if (deepComparison.Any(x => x.Kind == ComparisonResultKind.Same))
{
return new ComparisonResult(ComparisonResultKind.Same, pattern, deepComparison.Where(x => x.Kind == ComparisonResultKind.Same).SelectMany(x => x.Matches).Distinct());
}
if (deepComparison.Any(x => x.Kind == ComparisonResultKind.Partial))
{
return new ComparisonResult(ComparisonResultKind.Partial, pattern, deepComparison.Where(x => x.Kind == ComparisonResultKind.Partial).SelectMany(x => x.Matches).Distinct());
}
return new ComparisonResult(ComparisonResultKind.Different, pattern, null);
}
public static void PrintModelContainerContent(ModelContainer container, IModelNode rootNode = null)
{
Console.WriteLine(@"Container content:");
Console.WriteLine(@"------------------");
// Print the root node first, if specified
if (rootNode != null)
Console.WriteLine(rootNode.PrintHierarchy());
// Print other nodes next
// TODO: FIXME
//foreach (var node in container.Guids.Select(container.GetModelNode).Where(x => x != rootNode))
//{
// Console.WriteLine(node.PrintHierarchy());
//}
Console.WriteLine(@"------------------");
}
/// <summary>
/// Initializes a new instance of the QuantumConsistencyException class, with advanced string formatting.
/// </summary>
/// <param name="expected">A string representing the expected result. This string must contains a </param>
/// <param name="expectedArg"></param>
/// <param name="observed">A string representing the observed result.</param>
/// <param name="observedArg"></param>
/// <param name="node">The node that is related to this error.</param>
public QuantumConsistencyException(string expected, string expectedArg, string observed, string observedArg, IModelNode node)
: base(GetMessage(expected, expectedArg, observed, observedArg))
{
try
{
Expected = string.Format(expected ?? "(NullMessage) [{0}]", expectedArg ?? "(NullArgument)");
}
catch (Exception)
{
Expected = expected ?? "(NullMessage) [{0}]";
}
try
{
Observed = string.Format(observed ?? "(NullMessage) [{0}]", observedArg ?? "(NullArgument)");
}
catch (Exception)
{
Observed = observed ?? "(NullMessage) [{0}]";
}
Node = node;
}
public bool IsVisible(IModelNode node, string propertyName){
return ((IModelMemberViewItem) node).PropertyEditorType == typeof (RichEditWinPropertyEditor);
}
bool IsMasterDetail(IModelNode layoutInfo, ViewItemsCollection detailViewItems, IModelSplitLayout splitLayout) {
return splitLayout != null && detailViewItems.Count > 1 && ((IModelListView)layoutInfo.Parent).MasterDetailMode == MasterDetailMode.ListViewAndDetailView;
}
public virtual void SetParent(IModelNode parent)
{
Parent = parent;
QualifiedName = GetQualifiedName();
}
public void RemoveChild(IModelNode child)
{
if (_children.Remove(child))
{
child.SetParent(null);
}
}
/// <summary>
/// Indicates whether the current object is equal to another object of the same type.
/// </summary>
/// <returns>
/// <code>true</code> if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
/// </returns>
/// <param name="other">An object to compare with this object.</param>
public bool Equals(IModelNode other)
{
var isEqual = other != null
&& QualifiedName.Equals(other.QualifiedName)
&& Type.Equals(other.Type);
return isEqual;
}
public bool IsVisible(IModelNode node, string propertyName){
return ((IModelOptionsWin) node.Application.Options).FormStyle == RibbonFormStyle.Standard;
}
public bool IsVisible(IModelNode node, string propertyName) {
return !(node is IModelRuntimeOrphanedColection) || propertyName != "Type";
}
public bool IsVisible(IModelNode node, string propertyName) {
return propertyName != "PropertyEditorType" && propertyName != "PropertyName";
}
public ComparisonResult(ComparisonResultKind kind, IModelNode pattern, params IModelNode[] matches)
: this(kind, pattern, matches == null ? null : matches.AsEnumerable())
{
}
public ComparisonResult(ComparisonResultKind kind, IModelNode pattern, IEnumerable<IModelNode> matches)
{
Kind = kind;
Pattern = pattern;
Matches = matches == null ? null : matches.AsArray();
}
private static ObservableModelNode DefaultCreateNode(ObservableViewModel viewModel, string baseName, bool isPrimitive, IModelNode modelNode, ModelNodePath modelNodePath, Type contentType, object index)
{
return ObservableModelNode.Create(viewModel, baseName, isPrimitive, modelNode, modelNodePath, contentType, index);
}
