ObjectStatus.cs

Go to the documentation of this file.

#if !NETFX_CORE && !XAMARIN
//-----------------------------------------------------------------------
// <copyright file="ObjectStatus.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Container for other UI controls that exposes</summary>
//-----------------------------------------------------------------------
using System;
using System.Windows;
using System.ComponentModel;
using Csla.Core;
 
namespace Csla.Xaml
{
  public class ObjectStatus : DataDecoratorBase
  {
#region Per-Type Dependency Properties
 
    private static readonly DependencyProperty CanCreateProperty =
      DependencyProperty.Register("CanCreateObject", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty CanGetProperty =
      DependencyProperty.Register("CanGetObject", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty CanEditProperty =
      DependencyProperty.Register("CanEditObject", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty CanDeleteProperty =
      DependencyProperty.Register("CanDeleteObject", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
 
    public bool CanCreateObject
    {
      get { return (bool)base.GetValue(CanCreateProperty); }
      protected set
      {
        bool old = CanCreateObject;
        base.SetValue(CanCreateProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(CanCreateProperty, old, value));
      }
    }
 
    public bool CanGetObject
    {
      get { return (bool)base.GetValue(CanGetProperty); }
      protected set
      {
        bool old = CanGetObject;
        base.SetValue(CanGetProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(CanGetProperty, old, value));
      }
    }
 
    public bool CanEditObject
    {
      get { return (bool)base.GetValue(CanEditProperty); }
      protected set
      {
        bool old = CanEditObject;
        base.SetValue(CanEditProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(CanEditProperty, old, value));
      }
    }
 
    public bool CanDeleteObject
    {
      get { return (bool)base.GetValue(CanDeleteProperty); }
      protected set
      {
        bool old = CanDeleteObject;
        base.SetValue(CanDeleteProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(CanDeleteProperty, old, value));
      }
    }
 
#endregion
 
#region Per-Instance Dependency Properties
 
    private static readonly DependencyProperty IsDeletedProperty =
      DependencyProperty.Register("IsDeleted", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty IsDirtyProperty =
      DependencyProperty.Register("IsDirty", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty IsNewProperty =
      DependencyProperty.Register("IsNew", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty IsSavableProperty =
      DependencyProperty.Register("IsSavable", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
    private static readonly DependencyProperty IsValidProperty =
      DependencyProperty.Register("IsValid", typeof(bool), typeof(ObjectStatus), new FrameworkPropertyMetadata(false), null);
 
    public bool IsDeleted
    {
      get { return (bool)base.GetValue(IsDeletedProperty); }
      protected set 
      {
        bool old = IsDeleted;
        base.SetValue(IsDeletedProperty, value);
        OnPropertyChanged(
          new DependencyPropertyChangedEventArgs(IsDeletedProperty, old, value));
      }
    }
 
    public bool IsDirty
    {
      get { return (bool)base.GetValue(IsDirtyProperty); }
      protected set
      {
        bool old = IsDirty;
        base.SetValue(IsDirtyProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(IsDirtyProperty, old, value));
      }
    }
 
    public bool IsNew
    {
      get { return (bool)base.GetValue(IsNewProperty); }
      protected set
      {
        bool old = IsNew;
        base.SetValue(IsNewProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(IsNewProperty, old, value));
      }
    }
 
    public bool IsSavable
    {
      get { return (bool)base.GetValue(IsSavableProperty); }
      protected set
      {
        bool old = IsSavable;
        base.SetValue(IsSavableProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(IsSavableProperty, old, value));
      }
    }
 
    public bool IsValid
    {
      get { return (bool)base.GetValue(IsValidProperty); }
      protected set
      {
        bool old = IsValid;
        base.SetValue(IsValidProperty, value);
        if (old != value)
          OnPropertyChanged(
            new DependencyPropertyChangedEventArgs(IsValidProperty, old, value));
      }
    }
 
#endregion
 
#region Base Overrides 
 
    protected override void DataObjectChanged()
    {
      Refresh();
    }
 
    protected override void DataPropertyChanged(PropertyChangedEventArgs e)
    {
      Refresh();
    }
 
    protected override void DataBindingListChanged(ListChangedEventArgs e)
    {
      Refresh();
    }
 
    protected override void DataObservableCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
      Refresh();
    }
 
    public void Refresh()
    {
      // per-type rules
      if (DataObject != null)
      {
        Type sourceType = DataObject.GetType();
        var newValue = Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.CreateObject, DataObject);
        if (CanCreateObject != newValue)
          CanCreateObject = newValue;
        newValue = Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.GetObject, DataObject);
        if (CanGetObject != newValue)
          CanGetObject = newValue;
        newValue = Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, DataObject);
        if (CanEditObject != newValue)
          CanEditObject = newValue;
        newValue = Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.DeleteObject, DataObject);
        if (CanDeleteObject != newValue)
          CanDeleteObject = newValue;
      }
      else
      {
        CanCreateObject = false;
        CanGetObject = false;
        CanEditObject = false;
        CanDeleteObject = false;
      }
 
      IEditableBusinessObject source = DataObject as IEditableBusinessObject;
      if (source != null)
      {
        if (IsDeleted != source.IsDeleted)
          IsDeleted = source.IsDeleted;
        if (IsDirty != source.IsDirty)
          IsDirty = source.IsDirty;
        if (IsNew != source.IsNew)
          IsNew = source.IsNew;
        if (IsSavable != source.IsSavable)
          IsSavable = source.IsSavable;
        if (IsValid != source.IsValid)
          IsValid = source.IsValid;
      }
      else
      {
        IEditableCollection sourceList = DataObject as IEditableCollection;
        if (sourceList != null)
        {
          if (IsDirty != sourceList.IsDirty)
            IsDirty = sourceList.IsDirty;
          if (IsValid != sourceList.IsValid)
            IsValid = sourceList.IsValid;
          if (IsSavable != sourceList.IsSavable)
            IsSavable = sourceList.IsSavable;
          IsDeleted = false;
          IsNew = false;
        }
      }
    }
 
#endregion
  }
}
#endif