BindingSourceRefresh.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BindingSourceRefresh.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>BindingSourceRefresh contains functionality for refreshing the data bound to controls on Host as well as a mechinism for catching data</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows.Forms;
 
// code from Bill McCarthy
// http://msmvps.com/bill/archive/2005/10/05/69012.aspx
// used with permission
 
namespace Csla.Windows
{
  [DesignerCategory("")]
  [ProvideProperty("ReadValuesOnChange", typeof(BindingSource))]
  public class BindingSourceRefresh : Component, IExtenderProvider, ISupportInitialize
  {
    #region Fields
    private readonly Dictionary<BindingSource, bool> _sources = new Dictionary<BindingSource, bool>();
    #endregion
    #region Events
    public event BindingErrorEventHandler BindingError = null;
    #endregion
    #region Constructors
    public BindingSourceRefresh()
    {
      InitializeComponent();
    }
    public BindingSourceRefresh(IContainer container)
    {
      container.Add(this);
      InitializeComponent();
    }
    #endregion
 
    #region Designer Functionality
    private System.ComponentModel.IContainer components = null;
    protected override void Dispose(bool disposing)
    {
      if (disposing && (components != null))
      {
        components.Dispose();
      }
      base.Dispose(disposing);
    }
    #region Component Designer generated code
    private void InitializeComponent()
    {
      components = new System.ComponentModel.Container();
    }
    #endregion
    #endregion
    #region Public Methods
 
    public bool CanExtend(object extendee)
    {
      return (extendee is BindingSource);
    }
    [Category("Csla")]
    public bool GetReadValuesOnChange(BindingSource source)
    {
      bool result;
      if (_sources.TryGetValue(source, out result))
        return result;
      else
        return false;
    }
    [Category("Csla")]
    public void SetReadValuesOnChange(
      BindingSource source, bool value)
    {
      _sources[source] = value;
      if (!_isInitialising)
      {
        RegisterControlEvents(source, value);
      }
    }
    #endregion
 
    #region Properties
 
    [Browsable(false)]
    [DefaultValue(null)]
#if NETSTANDARD2_0 || NET5_0
    [System.ComponentModel.DataAnnotations.ScaffoldColumn(false)]
#endif
    public ContainerControl Host { get; set; }
 
    [Browsable(true)]
    [DefaultValue(false)]
    public bool RefreshOnException { get; set; }
 
    #endregion
 
    #region Private Methods
    private void RegisterControlEvents(ICurrencyManagerProvider container, bool register)
    {
      var currencyManager = container.CurrencyManager;
      // If we are to register the events the do so.
      if (register)
      {
        currencyManager.Bindings.CollectionChanged += Bindings_CollectionChanged;
        currencyManager.Bindings.CollectionChanging += Bindings_CollectionChanging;
      }
      // Else unregister them.
      else
      {
        currencyManager.Bindings.CollectionChanged -= Bindings_CollectionChanged;
        currencyManager.Bindings.CollectionChanging -= Bindings_CollectionChanging;
      }
      // Reigster the binding complete events for the currencymanagers bindings.
      RegisterBindingEvents(currencyManager.Bindings, register);
    }
 
 
    private void RegisterBindingEvents(BindingsCollection source, bool register)
    {
      foreach (Binding binding in source)
      {
        RegisterBindingEvent(binding, register);
      }
    }
    private void RegisterBindingEvent(Binding binding, bool register)
    {
      if (register)
      {
        binding.BindingComplete += Control_BindingComplete;
      }
      else
      {
        binding.BindingComplete -= Control_BindingComplete;
      }
    }
    #endregion
    #region Event Methods
 
    private void Bindings_CollectionChanging(object sender, CollectionChangeEventArgs e)
    {
      switch (e.Action)
      {
        case CollectionChangeAction.Refresh:
          // remove events for entire list
          RegisterBindingEvents((BindingsCollection)sender, false);
          break;
        case CollectionChangeAction.Add:
          // adding new element -  remove events for element
          RegisterBindingEvent((Binding)e.Element, false);
          break;
        case CollectionChangeAction.Remove:
          // removing element - remove events for element
          RegisterBindingEvent((Binding)e.Element, false);
          break;
      }
    }
 
    private void Bindings_CollectionChanged(object sender, CollectionChangeEventArgs e)
    {
      switch (e.Action)
      {
        case CollectionChangeAction.Refresh:
          // refresh entire list  - add event to all items
          RegisterBindingEvents((BindingsCollection)sender, true);
          break;
        case CollectionChangeAction.Add:
          // new element added - add event to element
          RegisterBindingEvent((Binding)e.Element, true);
          break;
        case CollectionChangeAction.Remove:
          // element has been removed - do nothing
          break;
      }
    }
 
    private void Control_BindingComplete(object sender, BindingCompleteEventArgs e)
    {
      switch (e.BindingCompleteState)
      {
        case BindingCompleteState.Exception:
          if ((RefreshOnException)
        && e.Binding.DataSource is BindingSource
        && GetReadValuesOnChange((BindingSource)e.Binding.DataSource))
          {
            e.Binding.ReadValue();
          }
          if (BindingError != null)
          {
            BindingError(this, new BindingErrorEventArgs(e.Binding, e.Exception));
          }
          break;
        default:
          if ((e.BindingCompleteContext == BindingCompleteContext.DataSourceUpdate)
                  && e.Binding.DataSource is BindingSource
                  && GetReadValuesOnChange((BindingSource)e.Binding.DataSource))
          {
            e.Binding.ReadValue();
          }
          break;
      }
    }
 
    #endregion
    #region ISupportInitialize Interface
    private bool _isInitialising = false;
    void ISupportInitialize.BeginInit()
    {
      _isInitialising = true;
    }
    void ISupportInitialize.EndInit()
    {
      _isInitialising = false;
      foreach (var source in _sources)
      {
        if (source.Value)
          RegisterControlEvents(source.Key, true);
      }
    }
    #endregion
  }
 
  #region Delegates
 
  public delegate void BindingErrorEventHandler(object sender, BindingErrorEventArgs e);
 
  #endregion
 
  #region BindingErrorEventArgs Class
 
  public class BindingErrorEventArgs : EventArgs
  {
 
    #region Property Fields
 
    private Exception _exception = null;
    private Binding _binding = null;
 
    #endregion
 
    #region Properties
 
    public Exception Exception
    {
      get { return (_exception); }
    }
 
    public Binding Binding
    {
      get { return (_binding); }
    }
 
    #endregion
 
    #region Constructors
 
    public BindingErrorEventArgs(Binding binding, Exception exception)
    {
      _binding = binding;
      _exception = exception;
    }
 
    #endregion
 
  }
 
  #endregion
}