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