WPF - Position und Größe auf einer Leinwand sperren

Question

Ich habe eine Leinwand, auf der ich Elemente erstellen und ablegen kann. Ich kann sie verschieben und mit einem Daumen oder durch Bindung an ein Eigenschaftsraster skalieren.

Jetzt muss ich eine Funktion implementieren, um Position und Größe zu "sperren". Ich begann mit Versuch und setzte min und max height \ width auf die tatsächliche Höhe \ width. Die anfängliche Anstrengung war nicht so groß. Und ich habe immer noch keine Strategie, um den Standort zu fixieren.

Also, bevor ich gehe und durch 25 Ansätze, die nicht funktionieren, waten, hat vielleicht jemand einen Vorschlag. Ich würde es sehr schätzen.

Danke, jeff

Answer 1

könnten Sie deaktivieren nur die Thumb und die PropertyGrid ...

Natürlich für Property es nicht ideal ... ist es besser wäre, es zu halten aktiviert ist, aber schreibgeschützt, leider hat die PropertyGrid keine ReadOnly Eigenschaft ... Eine mögliche Lösung wäre, Ihr Objekt in einen benutzerdefinierten Typdeskriptor zu verpacken, der die Eigenschaften als schreibgeschützt darstellen würde. Hier sind zwei Klassen, die (sorry für den langen Code ...) zu erreichen:

ReadOnlyTypeDescriptor:

public class ReadOnlyTypeDescriptor : ICustomTypeDescriptor 
{ 
    public ReadOnlyTypeDescriptor(object target) 
    { 
     TypeDescriptionProvider provider = TypeDescriptor.GetProvider(target); 
     _originalDescriptor = provider.GetTypeDescriptor(target); 
    } 

    public ReadOnlyTypeDescriptor(ICustomTypeDescriptor descriptor) 
    { 
     _originalDescriptor = descriptor; 
    } 

    private ICustomTypeDescriptor _originalDescriptor; 

    private PropertyDescriptor MakeReadOnly(PropertyDescriptor propertyDescriptor) 
    { 
     return new ReadOnlyPropertyDescriptor(propertyDescriptor); 
    } 

    private PropertyDescriptorCollection MakeReadOnly(PropertyDescriptorCollection propertyDescriptors) 
    { 
     var descriptors = propertyDescriptors 
          .Cast<PropertyDescriptor>() 
          .Select(pd => new ReadOnlyPropertyDescriptor(pd)) 
          .ToArray(); 
     return new PropertyDescriptorCollection(descriptors, true); 
    } 

    #region ICustomTypeDescriptor Members 

    public AttributeCollection GetAttributes() 
    { 
     return _originalDescriptor.GetAttributes(); 
    } 

    public string GetClassName() 
    { 
     return _originalDescriptor.GetClassName(); 
    } 

    public string GetComponentName() 
    { 
     return _originalDescriptor.GetComponentName(); 
    } 

    public TypeConverter GetConverter() 
    { 
     return _originalDescriptor.GetConverter(); 
    } 

    public EventDescriptor GetDefaultEvent() 
    { 
     return _originalDescriptor.GetDefaultEvent(); 
    } 

    public PropertyDescriptor GetDefaultProperty() 
    { 
     return MakeReadOnly(_originalDescriptor.GetDefaultProperty()); 
    } 

    public object GetEditor(Type editorBaseType) 
    { 
     return _originalDescriptor.GetEditor(editorBaseType); 
    } 

    public EventDescriptorCollection GetEvents(Attribute[] attributes) 
    { 
     return _originalDescriptor.GetEvents(attributes); 
    } 

    public EventDescriptorCollection GetEvents() 
    { 
     return _originalDescriptor.GetEvents(); 
    } 

    public PropertyDescriptorCollection GetProperties(Attribute[] attributes) 
    { 
     return MakeReadOnly(_originalDescriptor.GetProperties(attributes)); 
    } 

    public PropertyDescriptorCollection GetProperties() 
    { 
     return MakeReadOnly(_originalDescriptor.GetProperties()); 
    } 

    public object GetPropertyOwner(PropertyDescriptor pd) 
    { 
     return _originalDescriptor.GetPropertyOwner(pd); 
    } 

    #endregion 
} 

ReadOnlyPropertyDescriptor:

public class ReadOnlyPropertyDescriptor : PropertyDescriptor 
{ 
    public ReadOnlyPropertyDescriptor(PropertyDescriptor descriptor) 
     : base(
      descriptor.Name, 
      descriptor.Attributes.Cast<Attribute>().ToArray()) 
    { 
     _originalDescriptor = descriptor; 
    } 

    private PropertyDescriptor _originalDescriptor; 

    public override bool CanResetValue(object component) 
    { 
     return false; 
    } 

    public override Type ComponentType 
    { 
     get { return _originalDescriptor.ComponentType; } 
    } 

    public override object GetValue(object component) 
    { 
     return _originalDescriptor.GetValue(component); 
    } 

    public override bool IsReadOnly 
    { 
     get { return true; } 
    } 

    public override Type PropertyType 
    { 
     get { return _originalDescriptor.PropertyType; } 
    } 

    public override void ResetValue(object component) 
    { 
     throw new NotSupportedException(); 
    } 

    public override void SetValue(object component, object value) 
    { 
     throw new NotSupportedException(); 
    } 

    public override bool ShouldSerializeValue(object component) 
    { 
     return _originalDescriptor.ShouldSerializeValue(component); 
    } 
} 

Um das Objekt target als schreibgeschützt zu zeigen in die PropertyGrid, genau das zu tun:

propertyGrid.SelectedObject = new ReadOnlyTypeDescriptor(target); 

Es wird die gleichen Eigenschaften zeigen, aber sie werden nicht bearbeitet werden können ...

OK, diese Lösung ist wahrscheinlich ein wenig Overkill für Ihre Bedürfnisse ... aber ich denke, dass es in einigen Fällen nützlich sein kann;)