private void ClickWindow(Point point, Canvas canvas) { count++; if (count > 10) { return; } Path path = new Path(); //path.Fill = AttachedProperty.GetFillColor(path); path.Stroke = AttachedProperty.GetFillColor(path); path.Opacity = 1 - count * 0.1 >= 0.5 ? 1 - count * 0.1 : 0.5; DropShadowEffect dropShadowEffect = new DropShadowEffect(); dropShadowEffect.BlurRadius = 10; dropShadowEffect.Color = Colors.LightGray; dropShadowEffect.ShadowDepth = 1; dropShadowEffect.Direction = 90; path.Effect = dropShadowEffect; EllipseGeometry ellipseGeometry = new EllipseGeometry(point, 1 + 3 * count, 1 + 3 * count); path.Data = ellipseGeometry; canvas.Children.Add(path); }
/// <summary> /// Serializes a PropertyPath. /// </summary> /// <param name = "path">The path being serialized.</param> /// <param name = "propertyName">The name of the property being serialized.</param> /// <param name = "propNs">The namespace for the property being serialized.</param> /// <param name = "writer">The writer being used for serialization.</param> /// <param name = "prefixMappings">A mapping of xml namespaces to prefixes.</param> /// <param name = "cycleCheckObjects">The set of objects on the stack (for cycle detection).</param> protected virtual void VisitPropertyPath(string path, string propertyName, string propNs, XmlWriter writer, IDictionary <string, string> prefixMappings, ISet <object> cycleCheckObjects) { string newPropertyPath = path; MatchCollection apMatches = AttachedPropertyPathRegex.Matches(path); foreach (Match m in apMatches) { string prefix = m.Groups["prefix"].Value; string className = m.Groups["className"].Value; string propName = m.Groups["propName"].Value; AttachedProperty ap = this.FindAttachedProperty(className, propName); string ns = this.GetNamespace(ap.Getter.DeclaringType, prefixMappings); string xmlPrefix = writer.LookupPrefix(ns); if (xmlPrefix == null || !xmlPrefix.Equals(prefix)) { writer.WriteAttributeString("xmlns", prefix, null, ns); } } if (propNs == null) { writer.WriteAttributeString(propertyName, newPropertyPath); } else { writer.WriteAttributeString(this.GetPrefix(propNs, prefixMappings, writer), propertyName, propNs, newPropertyPath); } }
internal void RegisterAttachedProperty <T>(string propertyName, bool isBrowsable, bool isVisibleToModelItem, T defaultValue) { AttachedProperty <T> attachedProperty = new AttachedProperty <T> { IsBrowsable = isBrowsable, IsVisibleToModelItem = isVisibleToModelItem, Name = propertyName, OwnerType = modelType, Getter = (modelItem) => { T result = (T)viewStateService.RetrieveViewState(modelItem, propertyName); return(result == null ? defaultValue : result); }, Setter = (modelItem, value) => { if (value == null || value.Equals(defaultValue)) { viewStateService.StoreViewStateWithUndo(modelItem, propertyName, null); } else { viewStateService.StoreViewStateWithUndo(modelItem, propertyName, value); } } }; attachedPropertiesService.AddProperty(attachedProperty); attachedProperties.Add(propertyName, attachedProperty); }
public override void GenerateAttachedPropertyDescriptor(AttachedProperty attachedProperty, Source staticMembers) { string readOnlyParam = attachedProperty.IsReadOnly ? ", readOnly:true" : ""; staticMembers.AddLine( $"public static readonly AttachedUIProperty {PropertyDescriptorName(attachedProperty)} = new AttachedUIProperty(\"{attachedProperty.Name}\", {DefaultValue(attachedProperty)}{readOnlyParam});"); }
public AttachedEngineTests() { sut = new AttachedPropertyEngine(o => ((BaseObject)o).Parent); property = sut.RegisterProperty("Column", typeof(Grid), typeof(int), new AttachedPropertyMetadata { DefaultValue = DefaultValue, Inherits = true }); }
public override void Initialize(EditingContext context) { this.context = context; AttachedPropertiesService propertiesService = this.context.Services.GetService <AttachedPropertiesService>(); helpService = this.context.Services.GetService <IIntegratedHelpService>(); oldSelection = this.context.Items.GetValue <Selection>(); isPrimarySelectionProperty = new AttachedProperty <bool>() { Getter = (modelItem) => (this.context.Items.GetValue <Selection>().PrimarySelection == modelItem), Name = "IsPrimarySelection", OwnerType = typeof(Object) }; isSelectionProperty = new AttachedProperty <bool>() { Getter = (modelItem) => (((IList)this.context.Items.GetValue <Selection>().SelectedObjects).Contains(modelItem)), Name = "IsSelection", OwnerType = typeof(Object) }; propertiesService.AddProperty(isPrimarySelectionProperty); propertiesService.AddProperty(isSelectionProperty); if (this.context.Services.GetService <ViewService>() == null) { view = new System.Activities.Presentation.View.DesignerView(this.context); WorkflowViewService viewService = new WorkflowViewService(context); WorkflowViewStateService viewStateService = new WorkflowViewStateService(context); this.context.Services.Publish <ViewService>(viewService); this.context.Services.Publish <VirtualizedContainerService>(new VirtualizedContainerService(this.context)); this.context.Services.Publish <ViewStateService>(viewStateService); this.context.Services.Publish <DesignerView>(view); WorkflowAnnotationAdornerService annotationService = new WorkflowAnnotationAdornerService(); annotationService.Initialize(this.context, view.scrollViewer); this.context.Services.Publish <AnnotationAdornerService>(annotationService); this.context.Services.Subscribe <ModelService>(delegate(ModelService modelService) { this.modelService = modelService; if (modelService.Root != null) { view.MakeRootDesigner(modelService.Root); } view.RestoreDesignerStates(); this.context.Items.Subscribe <Selection>(new SubscribeContextCallback <Selection>(OnItemSelected)); }); } if (helpService != null) { helpService.AddContextAttribute(string.Empty, KeywordForWorkflowDesignerHomePage, HelpKeywordType.F1Keyword); } }
JsonObject DumpVisualTree(JsonValue payload) { var payloadObj = payload.GetObject(); var accessibilityId = payloadObj.GetNamedString("accessibilityId"); var additionalProperties = new List <string>(); if (payloadObj.ContainsKey("additionalProperties")) { foreach (JsonValue prop in payloadObj.GetNamedArray("additionalProperties")) { additionalProperties.Add(prop.GetString()); } } var attachedProperties = new AttachedProperty[] { new AttachedProperty() { Name = "Top", Property = Microsoft.ReactNative.ViewPanel.TopProperty }, new AttachedProperty() { Name = "Left", Property = Microsoft.ReactNative.ViewPanel.LeftProperty } }; var rootDump = VisualTreeDumper.DumpTree(this, null, additionalProperties, attachedProperties); var element = VisualTreeDumper.FindElementByAutomationId(JsonObject.Parse(rootDump), accessibilityId); if (element != null) { return(element); } if (accessibilityId.StartsWith("*")) { accessibilityId = accessibilityId.Substring(1); foreach (var popup in VisualTreeHelper.GetOpenPopups(Window.Current)) { // XAML's VisualTreeHelper returns 0 for GetChildrenCount of a popup root, so use the popup's child var popupChildDump = VisualTreeDumper.DumpTree(popup.Child, null, additionalProperties, attachedProperties); var json = JsonObject.Parse(popupChildDump); if (accessibilityId == "") { element = json; } else { element = VisualTreeDumper.FindElementByAutomationId(json, accessibilityId); } if (element != null) { break; } } } return(element); }
public void RegisterDouble() { const string Name = "MyPropertyRegisterDouble"; _ = AttachedProperty.Register <AttachedPropertyTests, int>(Name); new Action(() => _ = AttachedProperty.Register <AttachedPropertyTests, int>(Name)).Should().Throw <ArgumentException>() .WithMessage("*already registered*").WithMessage($"*{typeof(AttachedPropertyTests).Name}*").WithMessage($"*{Name}*"); }
public void ThrowsOnSetNullContext() { var context = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, string>("CanSetAndGet", context); var tested = new object(); Assert.Throws <ArgumentNullException>(() => tested.SetAttachedValue(attachedProperty, "asdf", null)); }
public void ThrowsOnGetNullInstance() { var context = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, string>("CanSetAndGet", context); object tested = null; Assert.Throws <ArgumentNullException>(() => tested.GetAttachedValue(attachedProperty, context)); }
public void IsAttached_Returns_True() { var property = new AttachedProperty <string>( "Foo", typeof(Class1), new StyledPropertyMetadata <string>()); Assert.True(property.IsAttached); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TResult"></typeparam> /// <param name="instance"></param> /// <param name="attachedProperty"></param> /// <param name="value"></param> /// <param name="context"></param> public static void SetAttachedValue <T, TResult>(this T instance, AttachedProperty <T, TResult> attachedProperty, TResult value, AttachedPropertyContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } context.SetInstanceValue(instance, attachedProperty, value); }
public void RegisterWithSuffix() { AttachedProperty <string> property = AttachedProperty.Register <AttachedPropertyTests, string>(() => MyStringProperty, "8"); property.DefaultValue.Should().Be("8"); property.DefaultValueUntyped.Should().Be("8"); property.Name.Should().Be("MyString"); property.OwnerType.Should().Be <AttachedPropertyTests>(); }
public void RegisterAttached() { AttachedProperty <int> property = AttachedProperty.Register <AttachedPropertyTests, int>("MyPropertyRegisterAttached", 9); property.DefaultValue.Should().Be(9); property.DefaultValueUntyped.Should().Be(9); property.Name.Should().Be("MyPropertyRegisterAttached"); property.OwnerType.Should().Be <AttachedPropertyTests>(); }
public void RegisterWithoutSuffix() { AttachedProperty <char> property = AttachedProperty.Register <AttachedPropertyTests, char>(() => MyChar, '7'); property.DefaultValue.Should().Be('7'); property.DefaultValueUntyped.Should().Be('7'); property.Name.Should().Be(nameof(MyChar)); property.OwnerType.Should().Be <AttachedPropertyTests>(); }
public void IsAttached_Returns_True() { var property = new AttachedProperty<string>( "Foo", typeof(Class1), new StyledPropertyMetadata<string>()); Assert.True(property.IsAttached); }
public void CanCreate() { var context = new AttachedPropertyContext(); var tested = new AttachedProperty <object, int>("SomeName", context); Assert.Equal("System.Object.SomeName", tested.FullName); Assert.Equal(typeof(object), tested.OwnerType); Assert.Equal(typeof(int), tested.PropertyType); }
public void ThrowsOnCreateDuplicate() { var context = new AttachedPropertyContext(); var first = new AttachedProperty <object, int>("asdf", context); Assert.NotNull(first); Assert.Throws <AttachedPropertyException>(() => new AttachedProperty <object, int>("asdf", context)); }
public void CanGetDefaultWithoutSet() { var context = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, string>("CanGetDefaultWithoutSet", context); var tested = new object(); var value = tested.GetAttachedValue(attachedProperty, context); Assert.Equal(default(string), value); }
public void NullArguments() { var name = "MyPropertyCreateNullArguments"; var nameExpression = (IntPropertyExpression)(() => MyIntProperty); var identifier = new AttachableMemberIdentifier(typeof(AttachedPropertyTests), name); new Action(() => _ = AttachedProperty.Register <AttachedPropertyTests, int>((string)null, 1)).Should().Throw <ArgumentNullException>().Which.ParamName.Should().Be(nameof(name)); new Action(() => _ = AttachedProperty.Register <AttachedPropertyTests, int>((IntPropertyExpression)null, 1)).Should().Throw <ArgumentNullException>().Which.ParamName.Should().Be(nameof(nameExpression)); new Action(() => _ = AttachedProperty.Get(null)).Should().Throw <ArgumentNullException>().Which.ParamName.Should().Be(nameof(identifier)); }
public void Create() { var identifier = new AttachableMemberIdentifier(typeof(AttachedPropertyTests), "MyPropertyCreate"); var property = new AttachedProperty(identifier, "DefaultValue"); property.DefaultValueUntyped.Should().Be("DefaultValue"); property.Identifier.Should().Be(identifier); property.Name.Should().Be("MyPropertyCreate"); property.OwnerType.Should().Be <AttachedPropertyTests>(); }
public void CanSetAndGet() { var context = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, string>("CanSetAndGet", context); var tested = new object(); tested.SetAttachedValue(attachedProperty, "asdf", context); var value = tested.GetAttachedValue(attachedProperty, context); Assert.Equal("asdf", value); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TResult"></typeparam> /// <param name="instance"></param> /// <param name="attachedProperty"></param> /// <param name="context"></param> /// <returns></returns> public static TResult GetAttachedValue <T, TResult>(this T instance, AttachedProperty <T, TResult> attachedProperty, AttachedPropertyContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var value = context.GetInstanceValue(instance, attachedProperty); return(value); }
public void Registered_Properties_Count_Reflects_Newly_Added_Attached_Property() { var registry = new AvaloniaPropertyRegistry(); var metadata = new StyledPropertyMetadata <int>(); var property = new AttachedProperty <int>("test", typeof(object), metadata, true); registry.Register(typeof(object), property); registry.RegisterAttached(typeof(AvaloniaPropertyRegistryTests), property); Assert.Equal(1, registry.Properties.Count); }
public void ThrowsOnGetNotRegistered() { var context = new AttachedPropertyContext(); var tested = new object(); var attachedProperty = new AttachedProperty <object, int>("asdf", context); Assert.Throws <AttachedPropertyException>(() => { var _ = tested.GetAttachedValue(attachedProperty); }); }
public void CanGetInstancesDefaultValue() { var tested = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, int>("PropertyName", tested); var instance = new object(); instance.SetAttachedValue(attachedProperty, default(int), tested); var instances = tested.GetInstances(); Assert.Equal(0, instances.Count); }
public void CanSetDefaultValueDoesNotStore() { var tested = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, string>("CanGetDefaultWithoutSet", tested); var instance = new object(); instance.SetAttachedValue(attachedProperty, default(string), tested); var properties = tested.GetInstanceProperties(instance); Assert.Equal(0, properties.Count); }
public override void GenerateAttachedPropertyAttachedClassMethods(AttachedProperty attachedProperty, Source methods) { string targetOutputTypeName = AttachedTargetOutputTypeName(attachedProperty); string propertyOutputTypeName = PropertyOutputTypeName(attachedProperty); bool classPropertyTypeDiffersFromInterface = attachedProperty.Type.ToString() != propertyOutputTypeName; methods.AddBlankLineIfNonempty(); methods.AddLine($"public {propertyOutputTypeName} Get{attachedProperty.Name}({attachedProperty.TargetTypeName} {attachedProperty.TargetParameterName}) => {attachedProperty.Interface.FrameworkClassName}.Get{attachedProperty.Name}(({targetOutputTypeName}) {attachedProperty.TargetParameterName});"); if (attachedProperty.SetterMethod != null) { methods.AddLine($"public void Set{attachedProperty.Name}({attachedProperty.TargetTypeName} {attachedProperty.TargetParameterName}, {propertyOutputTypeName} value) => {attachedProperty.Interface.FrameworkClassName}.Set{attachedProperty.Name}(({targetOutputTypeName}) {attachedProperty.TargetParameterName}, value);"); } }
private void CommentButtonDesigner_OnLoaded(object sender, RoutedEventArgs e) { AttachedProperty <Type> typeArgumentProperty = new AttachedProperty <Type> { Name = TypeArgumentPropertyName, OwnerType = typeof(CommentButton <>), Getter = (modelItem) => modelItem.Parent == null ? null : GetTypeArgument(modelItem), Setter = (modelItem, value) => UpdateTypeArgument(modelItem, value), IsBrowsable = true }; Context.Services.GetService <AttachedPropertiesService>().AddProperty(typeArgumentProperty); }
public void CanGetNonObjectGetValueNoSet() { var tested = new AttachedPropertyContext(); var attachedProperty = new AttachedProperty <object, int>("CanGetNonObjectGetValueNoSet", tested); var another = new AttachedProperty <object, int>("Another", tested); var instance = new object(); instance.SetAttachedValue(another, 1, tested); var value = instance.GetAttachedValue(attachedProperty, tested); Assert.Equal(0, value); }
private static AttachedProperty <TTarget, TType> AttachedPropertyFactory(TTarget source, object state) { var member = (AttachedBindingMemberInfo <TTarget, TType>)state; var property = new AttachedProperty <TTarget, TType> { Value = member.GetDefaultValue(source) }; if (member._memberChangedHandler != null) { property.Member = member; } return(property); }