Win-Form/Web-Form Generic Components using the same Controller

using System;
using System.ComponentModel;
using System.Collections;
using System.Diagnostics;
using System.Text;
using System.Data;
using System.Windows.Forms;
using Framework.baInterfaces;
using Framework.UI.baController;
using Framework.Lib;

namespace Framework.UI.baWinControls
{
    public class baTreeView : Framework.UI.baWinControls.TreeViewStrategy, ITreeView, IState
    {
        private IBindingManager oBindingManager;
        private string textField;
        private string valueField;
        private string valueParentField;
        private DataProviderDatabase _dataProvider = null;
        private TransactionStateKind oTransactionState = TransactionStateKind.Null;
        private ComponentUsage oBehaviour = ComponentUsage.None;
        private TransactionStateCtrl stateMachineCtrl = null;
        
        #region DisableBackColor
        private System.Drawing.Color disableBackColor = System.Drawing.Color.Empty;
        /// <summary>
        /// When the control becomes disble, its back color will
        /// be set to the value specified in DisableBackColor property
        /// </summary>
        public System.Drawing.Color DisableBackColor
        {
            get
            {
                if (disableBackColor == System.Drawing.Color.Empty)
                    disableBackColor = System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor.ButtonFace);
                return disableBackColor;
            }
            set
            {
                disableBackColor = value;
            }
        }
        #endregion

        #region EnableBackColor
        private System.Drawing.Color enableBackColor = System.Drawing.Color.Empty;
        /// <summary>
        /// When the control becomes enable, its back color will
        /// be set to the value specified in EnableBackColor property
        /// </summary>
        public System.Drawing.Color EnableBackColor
        {
            get
            {
                if (enableBackColor == System.Drawing.Color.Empty)
                    enableBackColor = this.BackColor;
                return enableBackColor;
            }
            set
            {
                enableBackColor = value;
            }
        }
        #endregion

        #region Enabled
        new public bool Enabled
        {
            get
            {
                return base.Enabled;
            }
            set
            {
                if (value)
                {
                    if (EnableBackColor != System.Drawing.Color.Empty)
                        this.BackColor = EnableBackColor;
                }
                else
                {
                    if (DisableBackColor != System.Drawing.Color.Empty)
                        this.BackColor = DisableBackColor;
                }
                base.Enabled = value;
            }
        }
        #endregion

        #region Behaviour
        /// <summary>
        /// If set to null, the component wouldn't be changed when
        /// the transaction state of its Binding Manager changed
        /// else it will be changed accortding to the state machine
        /// being set in this property
        /// </summary>
        public ComponentUsage Behaviour
        {
            get
            {
                return oBehaviour;
            }
            set
            {
                try
                {
                    if (value == ComponentUsage.None)
                        stateMachineCtrl = null;
                    else
                        stateMachineCtrl = TransactionStateCtrl.GetTransactionStateCtrl(this, value);
                    oBehaviour = value;
                }
                catch (Exception baExp)
                {
                    throw new baException(baExp, System.Reflection.MethodBase.GetCurrentMethod());
                }
            }
        }
        #endregion 

        #region OnAfterSelect(TreeViewEventArgs e)
        /// <summary>
        /// After a user selects a node in tree, Re position it's Binding Manager
        /// on the proper row pinting to tree node
        /// </summary>
        /// <param name="e"></param>
        protected override void OnAfterSelect(TreeViewEventArgs e)
        {
            int SelectedID = ((TreeNodeDatabase)this.SelectedNode).Id;
            if (oBindingManager != null)
            {
                int bindingID = Convert.ToInt32(oBindingManager[valueField]);
                if (SelectedID != bindingID)
                    oBindingManager.Find(SelectedID);
            }
            base.OnAfterSelect(e);
        }
        #endregion

        #region Bind2DataSource(IBindingManager value)
        /// <summary>
        /// When all the properties of the data binding for the 
        /// tree are being set, bind the tree to the given datasource
        /// </summary>
        /// <param name="value"></param>
        private void Bind2DataSource(IBindingManager value)
        {
            try
            {
                if ((value != null) && (_dataProvider == null) &&
                    (StringLib<object>.EmptyString2Null(ValueField) != null) &&
                    (StringLib<object>.EmptyString2Null(ValueParentField) != null) &&
                    (StringLib<object>.EmptyString2Null(TextField) != null))
                {
                    // create data provider
                    _dataProvider = new DataProviderDatabase(ValueField, ValueParentField, TextField);
                    _dataProvider.DataTable = (System.Data.DataTable)(value.DataSource);
                    // assign data provider and fill the tree view's root nodes.
                    base.DataSource = _dataProvider;
                    base.Fill();
                    value.TransactionStateChanging += new TransactionStateChangeEventHandler(value_TransactionStateChanging);
                    value.TransactionStateChanged += new TransactionStateChangeEventHandler(value_TransactionStateChanged);
                    value.PositionChanged += new EventHandler(oBindingManager_PositionChanged);
                    SetNodePosition(oBindingManager[valueField]);
                }
            }
            catch (Exception baExp)
            {
                throw new baException(baExp, System.Reflection.MethodBase.GetCurrentMethod());
            }
        }
        #endregion

        #region value_TransactionStateChanging(object sender, TransactionStateChangeArgs Was, TransactionStateChangeArgs Will)
        void value_TransactionStateChanging(object sender, TransactionStateChangeArgs Was, TransactionStateChangeArgs Will)
        {
            /// Change the transaction state of this 
            /// contol to its Binding Manager State            
            if (BindingManager != null)
                this.TransactionState = Will.TransactionState;
        }
        #endregion

        #region value_TransactionStateChanged(object sender, TransactionStateChangeArgs Was, TransactionStateChangeArgs Will)
        void value_TransactionStateChanged(object sender, TransactionStateChangeArgs Was, TransactionStateChangeArgs Will)
        {
            try
            {
                if (stateMachineCtrl != null)
                    stateMachineCtrl.SetTransactionStateState(Will.TransactionState);
            }
            catch (Exception baExp)
            {
                throw new baException(baExp, System.Reflection.MethodBase.GetCurrentMethod());
            }
        }
        #endregion

        #region oBindingManager_PositionChanged
        /// <summary>
        /// When a row is being changed in Datasource,
        /// set its position
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void oBindingManager_PositionChanged(object sender, EventArgs e)
        {
            SetNodePosition(oBindingManager[valueField]);
        }
        #endregion

        #region SetNodePosition()
        /// <summary>
        /// Set the selected row to Binding Manager current row
        /// </summary>
        private void SetNodePosition(object key)
        {
            try
            {
                if ((_dataProvider != null) && (oBindingManager != null))
                {
                    TreeNodeDatabase tnb = _dataProvider.FindNodeById(this.Nodes, Convert.ToInt32(key));
                    if (tnb != null)
                        this.SelectedNode = tnb;
                }
            }
            catch (Exception baExp)
            {
                throw new baControllerException(baExp, System.Reflection.MethodBase.GetCurrentMethod());
            }
        }
        #endregion

        #region BindingManager
        /// <summary>
        /// The Binding Manager datasource for this tree control
        /// </summary>
        public IBindingManager BindingManager
        {
            get
            {
                return oBindingManager;
            }
            set
            {
                try
                {
                    _dataProvider = null;
                    oBindingManager = value;
                    if(value!=null)
                    {
                        ((IBindable)oBindingManager).Binded += new EventHandler(baTreeView_Binded);
                    }
                }
                catch (Exception baExp)
                {
                    throw new baException(baExp, System.Reflection.MethodBase.GetCurrentMethod());
                }
            }
        }
        /// <summary>
        /// This event accures when data being fetched into
        /// dataset for the table of this Binding manager
        /// </summary>
        void baTreeView_Binded(object sender, EventArgs e)
        {
            Bind2DataSource(BindingManager);
        }
        #endregion

        #region ITransactionState Members
        public TransactionStateKind TransactionState
        {
            get
            {
                return oTransactionState;
            }
            set
            {
                try
                {
                    if (BindingManager != null)
                    {
                        switch(value)
                        {
                            case TransactionStateKind.EmptyDataSource:
                                {
                                    if (this.SelectedNode!=null)
                                        this.Nodes.Remove(this.SelectedNode);
                                    break;
                                }
                            case TransactionStateKind.EditOnly:
                            case TransactionStateKind.Confirm:
                                {
                                    #region Transaction is becoming Confirmed
                                    switch (BindingManager.TransactionState)
                                    {
                                        #region TransactionStateKind.Add:
                                        case TransactionStateKind.Add:
                                            {
                                                if (oBindingManager[valueParentField] != null)
                                                {
                                                    // Create a new node
                                                    TreeNodeDatabase newNode =
                                                        new TreeNodeDatabase(new DataBaseNodeInfo(oBindingManager[textField].ToString(),
                                                                                    int.Parse(oBindingManager[valueField].ToString()),
                                                                                    int.Parse(oBindingManager[valueParentField].ToString())));
                                                    // Add the new node to tree. It was added 
                                                    // to database with the same information
                                                    if (this.SelectedNode == null)
                                                        this.Nodes.Add(newNode);
                                                    else
                                                        this.SelectedNode.Nodes.Add(newNode);
                                                    if (oBindingManager.Find(Convert.ToInt32(oBindingManager[valueParentField])) < 0)
                                                        this.SelectedNode = this.TopNode;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region TransactionStateKind.Delete:
                                        case TransactionStateKind.Delete:
                                            {
                                                /// Remove the selected node from the tree
                                                /// It was deleted from the database
                                                /// May 6,06: (SelectedNode!=null) 
                                                /// && (value!=TransactionStateKind.EditOnly) added 
                                                if ((oBindingManager != null) && (SelectedNode != null) && (value!=TransactionStateKind.EditOnly))
                                                {
                                                    /// June 9, 06
                                                    /// Save the current BindingManager to disable
                                                    /// it temporary in order to prevent OnAfterSelect
                                                    /// event to be happen so BindingManager wouldnt repositioned
                                                    IBindingManager oldBindingManager = oBindingManager;
                                                    //int ParentNodeID = int.MinValue;
                                                    try
                                                    {
                                                        //ParentNodeID = Convert.ToInt32(oBindingManager[valueParentField]);

                                                        oBindingManager = null;
                                                        TreeNode pn = this.SelectedNode.PrevNode;
                                                        this.SelectedNode.Remove();
                                                        if (pn!=null)
                                                            this.SelectedNode = pn;
                                                        //oBindingManager.Find(ParentNodeID);
                                                    }
                                                    finally
                                                    {
                                                        oBindingManager = oldBindingManager;
                                                        //if (ParentNodeID > int.MinValue)
                                                        //    oBindingManager.Find(ParentNodeID);
                                                    }
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region TransactionStateKind.Edit:
                                        case TransactionStateKind.Edit:
                                            {
                                                if (this.SelectedNode != null)
                                                {
                                                    this.SelectedNode.TreeView.LabelEdit = true;
                                                    this.SelectedNode.BeginEdit();
                                                    this.SelectedNode.Text = oBindingManager[textField].ToString();
                                                    this.SelectedNode.EndEdit(false);
                                                    this.SelectedNode.EnsureVisible();
                                                    this.SelectedNode.TreeView.LabelEdit = false;
                                                }
                                                break;
                                            }
                                        #endregion
                                        case TransactionStateKind.Null:
                                        case TransactionStateKind.Initial:
                                        case TransactionStateKind.EditOnly:
                                        case TransactionStateKind.AddEditOnly:
                                        case TransactionStateKind.SearchOnly:
                                        case TransactionStateKind.EmptyDataSource:
                                        case TransactionStateKind.Confirm:
                                            {
                                                break;
                                            }
                                    }
                                    #endregion
                                    break;
                                }
                        }
                    }
                    oTransactionState = value;
                }
                catch (Exception baExp)
                {
                    throw new baException(baExp, System.Reflection.MethodBase.GetCurrentMethod());
                }
            }
        }
        #endregion

        #region TextField
        /// <summary>
        /// The Text field in the binded datasource that
        /// would be showen in the tree view
        /// </summary>
        public string TextField
        {
            get
            {
                return textField;
            }
            set
            {
                textField = value;
            }
        }
        #endregion

        #region ValueParentField
        /// <summary>
        /// The value field (ParentID field) of datasource that
        /// would have a reference to the ID of the parent node of the tree
        /// </summary>
        public string ValueParentField
        {
            get
            {
                return valueParentField;
            }
            set
            {
                valueParentField = value;
            }
        }
        #endregion

        #region ValueField
        /// <summary>
        /// The Value Field (ID Field) that is the Primary key of the datasource
        /// </summary>
        public string ValueField
        {
            get
            {
                return valueField;
            }
            set
            {
                valueField = value;
            }
        }
        #endregion

        #region private int TotalNodes
        private int TotalNodes(TreeNodeCollection ParentNodes)
        {
            int TotalNode = 0;
            foreach (TreeNode aNode in ParentNodes)
            {
                TotalNode++;
                TotalNode += TotalNodes(aNode.Nodes);

            }
            return TotalNode;
        }
        #endregion

        #region int Count
        public int Count
        {
            get
            {
                return TotalNodes(this.Nodes);
            }
        }
        #endregion
    }
}