DataGridViewBand.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / WinForms / Managed / System / WinForms / DataGridViewBand.cs / 1305376 / DataGridViewBand.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Windows.Forms 
{ 
    using System.ComponentModel;
    using System.Diagnostics; 
    using System.Drawing;
    using System.Text;
    using System;
    using System.Globalization; 
    using System.Security;
    using System.Security.Permissions; 
 
    /// 
    ///  
    ///    Identifies a band or column in the dataGridView.
    /// 
    public class DataGridViewBand : DataGridViewElement, ICloneable, IDisposable
    { 
        private static readonly int PropContextMenuStrip = PropertyStore.CreateKey();
        private static readonly int PropDefaultCellStyle = PropertyStore.CreateKey(); 
        private static readonly int PropDefaultHeaderCellType = PropertyStore.CreateKey(); 
        private static readonly int PropDividerThickness = PropertyStore.CreateKey();
        private static readonly int PropHeaderCell = PropertyStore.CreateKey(); 
        private static readonly int PropUserData = PropertyStore.CreateKey();

        internal const int minBandThickness = 2;
        internal const int maxBandThickness = 65536; 

        private PropertyStore propertyStore;          // Contains all properties that are not always set. 
        private int thickness, cachedThickness; 
        private int minimumThickness;
        private int bandIndex; 
        internal bool bandIsRow;

        /// 
        ///  
        ///    
        ///       Initializes a new instance of the  class. 
        ///     
        /// 
        internal DataGridViewBand() 
        {
            this.propertyStore = new PropertyStore();
            this.bandIndex = -1;
        } 

        ///  
        ~DataGridViewBand() 
        {
            Dispose(false); 
        }

        internal int CachedThickness
        { 
            get
            { 
                return this.cachedThickness; 
            }
            set 
            {
                this.cachedThickness = value;
            }
        } 

        ///  
        [ 
            DefaultValue(null)
        ] 
        public virtual ContextMenuStrip ContextMenuStrip
        {
            get
            { 
                if (this.bandIsRow)
                { 
                    return ((DataGridViewRow) this).GetContextMenuStrip(this.Index); 
                }
                return this.ContextMenuStripInternal; 
            }
            set
            {
                this.ContextMenuStripInternal = value; 
            }
        } 
 
        internal ContextMenuStrip ContextMenuStripInternal
        { 
            get
            {
                return (ContextMenuStrip)this.Properties.GetObject(PropContextMenuStrip);
            } 
            set
            { 
                ContextMenuStrip oldValue = (ContextMenuStrip)this.Properties.GetObject(PropContextMenuStrip); 
                if (oldValue != value)
                { 
                    EventHandler disposedHandler = new EventHandler(DetachContextMenuStrip);
                    if (oldValue != null)
                    {
                        oldValue.Disposed -= disposedHandler; 
                    }
                    this.Properties.SetObject(PropContextMenuStrip, value); 
                    if (value != null) 
                    {
                        value.Disposed += disposedHandler; 
                    }
                    if (this.DataGridView != null)
                    {
                        this.DataGridView.OnBandContextMenuStripChanged(this); 
                    }
                } 
            } 
        }
 
        /// 
        [
            Browsable(false)
        ] 
        public virtual DataGridViewCellStyle DefaultCellStyle
        { 
            get 
            {
                DataGridViewCellStyle dgvcs = (DataGridViewCellStyle)this.Properties.GetObject(PropDefaultCellStyle); 
                if (dgvcs == null)
                {
                    dgvcs = new DataGridViewCellStyle();
                    dgvcs.AddScope(this.DataGridView, 
                        this.bandIsRow ? DataGridViewCellStyleScopes.Row : DataGridViewCellStyleScopes.Column);
                    this.Properties.SetObject(PropDefaultCellStyle, dgvcs); 
                } 
                return dgvcs;
            } 
            set
            {
                DataGridViewCellStyle dgvcs = null;
                if (this.HasDefaultCellStyle) 
                {
                    dgvcs = this.DefaultCellStyle; 
                    dgvcs.RemoveScope(this.bandIsRow ? DataGridViewCellStyleScopes.Row : DataGridViewCellStyleScopes.Column); 
                }
                if (value != null || this.Properties.ContainsObject(PropDefaultCellStyle)) 
                {
                    if (value != null)
                    {
                        value.AddScope(this.DataGridView, 
                            this.bandIsRow ? DataGridViewCellStyleScopes.Row : DataGridViewCellStyleScopes.Column);
                    } 
                    this.Properties.SetObject(PropDefaultCellStyle, value); 
                }
                if (((dgvcs != null && value == null) || 
                    (dgvcs == null && value != null) ||
                    (dgvcs != null && value != null && !dgvcs.Equals(this.DefaultCellStyle))) && this.DataGridView != null)
                {
                    this.DataGridView.OnBandDefaultCellStyleChanged(this); 
                }
            } 
        } 

        ///  
        [
            Browsable(false)
        ]
        public Type DefaultHeaderCellType 
        {
            get 
            { 
                Type dhct = (Type)this.Properties.GetObject(PropDefaultHeaderCellType);
                if (dhct == null) 
                {
                    if (this.bandIsRow)
                    {
                        dhct = typeof(System.Windows.Forms.DataGridViewRowHeaderCell); 
                    }
                    else 
                    { 
                        dhct = typeof(System.Windows.Forms.DataGridViewColumnHeaderCell);
                    } 
                }
                return dhct;
            }
            set 
            {
                if (value != null || this.Properties.ContainsObject(PropDefaultHeaderCellType)) 
                { 
                    if (Type.GetType("System.Windows.Forms.DataGridViewHeaderCell").IsAssignableFrom(value))
                    { 
                        this.Properties.SetObject(PropDefaultHeaderCellType, value);
                    }
                    else
                    { 
                        throw new ArgumentException(SR.GetString(SR.DataGridView_WrongType, "DefaultHeaderCellType", "System.Windows.Forms.DataGridViewHeaderCell"));
                    } 
                } 
            }
        } 

        /// 
        [
            Browsable(false), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ] 
        public virtual bool Displayed 
        {
            get 
            {
                Debug.Assert(!this.bandIsRow);
                bool displayed = (this.State & DataGridViewElementStates.Displayed) != 0;
                // Only attached and visible columns can be displayed. 
                // Debug.Assert(!displayed || (this.DataGridView != null && this.DataGridView.Visible && this.Visible));
                return displayed; 
            } 
        }
 
        internal bool DisplayedInternal
        {
            set
            { 
                Debug.Assert(value != this.Displayed);
                if (value) 
                { 
                    this.StateInternal = this.State | DataGridViewElementStates.Displayed;
                } 
                else
                {
                    this.StateInternal = this.State & ~DataGridViewElementStates.Displayed;
                } 
                if (this.DataGridView != null)
                { 
                    OnStateChanged(DataGridViewElementStates.Displayed); 
                }
            } 
        }

        internal int DividerThickness
        { 
            get
            { 
                bool found; 
                int dividerThickness = this.Properties.GetInteger(PropDividerThickness, out found);
                return found ? dividerThickness : 0; 
            }
            set
            {
                if (value < 0) 
                {
                    if (this.bandIsRow) 
                    { 
                        throw new ArgumentOutOfRangeException("DividerHeight", SR.GetString(SR.InvalidLowBoundArgumentEx, "DividerHeight", (value).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
                    } 
                    else
                    {
                        throw new ArgumentOutOfRangeException("DividerWidth", SR.GetString(SR.InvalidLowBoundArgumentEx, "DividerWidth", (value).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
                    } 
                }
                if (value > maxBandThickness) 
                { 
                    if (this.bandIsRow)
                    { 
                        throw new ArgumentOutOfRangeException("DividerHeight", SR.GetString(SR.InvalidHighBoundArgumentEx, "DividerHeight", (value).ToString(CultureInfo.CurrentCulture), (maxBandThickness).ToString(CultureInfo.CurrentCulture)));
                    }
                    else
                    { 
                        throw new ArgumentOutOfRangeException("DividerWidth", SR.GetString(SR.InvalidHighBoundArgumentEx, "DividerWidth", (value).ToString(CultureInfo.CurrentCulture), (maxBandThickness).ToString(CultureInfo.CurrentCulture)));
                    } 
                } 
                if (value != this.DividerThickness)
                { 
                    this.Properties.SetInteger(PropDividerThickness, (int)value);
                    if (this.DataGridView != null)
                    {
                        this.DataGridView.OnBandDividerThicknessChanged(this); 
                    }
                } 
            } 
        }
 
        /// 
        [
            DefaultValue(false),
        ] 
        public virtual bool Frozen
        { 
            get 
            {
                Debug.Assert(!this.bandIsRow); 
                return (this.State & DataGridViewElementStates.Frozen) != 0;
            }
            set
            { 
                if (((this.State & DataGridViewElementStates.Frozen) != 0) != value)
                { 
                    OnStateChanging(DataGridViewElementStates.Frozen); 
                    if (value)
                    { 
                        this.StateInternal = this.State | DataGridViewElementStates.Frozen;
                    }
                    else
                    { 
                        this.StateInternal = this.State & ~DataGridViewElementStates.Frozen;
                    } 
                    OnStateChanged(DataGridViewElementStates.Frozen); 
                }
            } 
        }

        /// 
        [ 
            Browsable(false)
        ] 
        public bool HasDefaultCellStyle 
        {
            get 
            {
                return this.Properties.ContainsObject(PropDefaultCellStyle) && this.Properties.GetObject(PropDefaultCellStyle) != null;
            }
        } 

        internal bool HasDefaultHeaderCellType 
        { 
            get
            { 
                return this.Properties.ContainsObject(PropDefaultHeaderCellType) && this.Properties.GetObject(PropDefaultHeaderCellType) != null;
            }
        }
 
        internal bool HasHeaderCell
        { 
            get 
            {
                return this.Properties.ContainsObject(PropHeaderCell) && this.Properties.GetObject(PropHeaderCell) != null; 
            }
        }

        ///  
        [
            Browsable(false), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        protected DataGridViewHeaderCell HeaderCellCore 
        {
            get
            {
                DataGridViewHeaderCell headerCell = (DataGridViewHeaderCell)this.Properties.GetObject(PropHeaderCell); 
                if (headerCell == null)
                { 
                    Type cellType = this.DefaultHeaderCellType; 

                    headerCell = (DataGridViewHeaderCell) SecurityUtils.SecureCreateInstance(cellType); 
                    headerCell.DataGridViewInternal = this.DataGridView;
                    if (this.bandIsRow)
                    {
                        headerCell.OwningRowInternal = (DataGridViewRow)this;   // may be a shared row 
                        this.Properties.SetObject(PropHeaderCell, headerCell);
                    } 
                    else 
                    {
                        DataGridViewColumn dataGridViewColumn = this as DataGridViewColumn; 
                        headerCell.OwningColumnInternal = dataGridViewColumn;
                        // Set the headerCell in the property store before setting the SortOrder.
                        // vsWhidbey 411787.
                        this.Properties.SetObject(PropHeaderCell, headerCell); 
                        if (this.DataGridView != null && this.DataGridView.SortedColumn == dataGridViewColumn)
                        { 
                            DataGridViewColumnHeaderCell dataGridViewColumnHeaderCell = headerCell as DataGridViewColumnHeaderCell; 
                            Debug.Assert(dataGridViewColumnHeaderCell != null);
                            dataGridViewColumnHeaderCell.SortGlyphDirection = this.DataGridView.SortOrder; 
                        }
                    }
                }
                return headerCell; 
            }
            set 
            { 
                DataGridViewHeaderCell headerCell = (DataGridViewHeaderCell)this.Properties.GetObject(PropHeaderCell);
                if (value != null || this.Properties.ContainsObject(PropHeaderCell)) 
                {
                    if (headerCell != null)
                    {
                        headerCell.DataGridViewInternal = null; 
                        if (this.bandIsRow)
                        { 
                            headerCell.OwningRowInternal = null; 
                        }
                        else 
                        {
                            headerCell.OwningColumnInternal = null;
                            ((DataGridViewColumnHeaderCell)headerCell).SortGlyphDirectionInternal = SortOrder.None;
                        } 
                    }
 
                    if (value != null) 
                    {
                        if (this.bandIsRow) 
                        {
                            if (!(value is DataGridViewRowHeaderCell))
                            {
                                throw new ArgumentException(SR.GetString(SR.DataGridView_WrongType, "HeaderCell", "System.Windows.Forms.DataGridViewRowHeaderCell")); 
                            }
                            // A HeaderCell can only be used by one band. 
                            if (value.OwningRow != null) 
                            {
                                value.OwningRow.HeaderCell = null; 
                            }
                            Debug.Assert(value.OwningRow == null);
                            value.OwningRowInternal = (DataGridViewRow)this;   // may be a shared row
                        } 
                        else
                        { 
                            DataGridViewColumnHeaderCell dataGridViewColumnHeaderCell = value as DataGridViewColumnHeaderCell; 
                            if (dataGridViewColumnHeaderCell == null)
                            { 
                                throw new ArgumentException(SR.GetString(SR.DataGridView_WrongType, "HeaderCell", "System.Windows.Forms.DataGridViewColumnHeaderCell"));
                            }
                            // A HeaderCell can only be used by one band.
                            if (value.OwningColumn != null) 
                            {
                                value.OwningColumn.HeaderCell = null; 
                            } 
                            Debug.Assert(dataGridViewColumnHeaderCell.SortGlyphDirection == SortOrder.None);
                            Debug.Assert(value.OwningColumn == null); 
                            value.OwningColumnInternal = (DataGridViewColumn)this;
                        }
                        Debug.Assert(value.DataGridView == null);
                        value.DataGridViewInternal = this.DataGridView; 
                    }
 
                    this.Properties.SetObject(PropHeaderCell, value); 
                }
                if (((value == null && headerCell != null) || (value != null && headerCell == null) || (value != null && headerCell != null && !headerCell.Equals(value))) && this.DataGridView != null) 
                {
                    this.DataGridView.OnBandHeaderCellChanged(this);
                }
            } 
        }
 
        ///  
        /// 
        ///  
        /// 
        [
            Browsable(false)
        ] 
        public int Index
        { 
            get 
            {
                return this.bandIndex; 
            }
        }

        internal int IndexInternal 
        {
            set 
            { 
                this.bandIndex = value;
            } 
        }

        /// 
        [ 
            Browsable(false)
        ] 
        public virtual DataGridViewCellStyle InheritedStyle 
        {
            get 
            {
                return null;
            }
        } 

        ///  
        protected bool IsRow 
        {
            get 
            {
                return this.bandIsRow;
            }
        } 

        internal int MinimumThickness 
        { 
            get
            { 
                if (this.bandIsRow && this.bandIndex > -1)
                {
                    int height, minimumHeight;
                    GetHeightInfo(this.bandIndex, out height, out minimumHeight); 
                    return minimumHeight;
                } 
                return this.minimumThickness; 
            }
            set 
            {
                if (this.minimumThickness != value)
                {
                    if (value < minBandThickness) 
                    {
                        if (this.bandIsRow) 
                        { 
                            throw new ArgumentOutOfRangeException("MinimumHeight", value, SR.GetString(SR.DataGridViewBand_MinimumHeightSmallerThanOne, (DataGridViewBand.minBandThickness).ToString(CultureInfo.CurrentCulture)));
                        } 
                        else
                        {
                            throw new ArgumentOutOfRangeException("MinimumWidth", value, SR.GetString(SR.DataGridViewBand_MinimumWidthSmallerThanOne, (DataGridViewBand.minBandThickness).ToString(CultureInfo.CurrentCulture)));
                        } 
                    }
                    if (this.Thickness < value) 
                    { 
                        // Force the new minimum width on potential auto fill column.
                        if (this.DataGridView != null && !this.bandIsRow) 
                        {
                            this.DataGridView.OnColumnMinimumWidthChanging((DataGridViewColumn)this, value);
                        }
                        this.Thickness = value; 
                    }
                    this.minimumThickness = value; 
                    if (this.DataGridView != null) 
                    {
                        this.DataGridView.OnBandMinimumThicknessChanged(this); 
                    }
                }
            }
        } 

        internal PropertyStore Properties 
        { 
            get
            { 
                return this.propertyStore;
            }
        }
 
        /// 
        [ 
            DefaultValue(false) 
        ]
        public virtual bool ReadOnly 
        {
            get
            {
                Debug.Assert(!this.bandIsRow); 
                return ((this.State & DataGridViewElementStates.ReadOnly) != 0 ||
                    (this.DataGridView != null && this.DataGridView.ReadOnly)); 
            } 
            set
            { 
                if (this.DataGridView != null)
                {
                    if (this.DataGridView.ReadOnly)
                    { 
                        // if (!value): Trying to make a band read-write when the whole grid is read-only.
                        // if (value):  Trying to make a band read-only when the whole grid is read-only. 
                        // Ignoring the request and returning. 
                        return;
                    } 

                    // this may trigger a call to set_ReadOnlyInternal
                    if (this.bandIsRow)
                    { 
                        if (this.bandIndex == -1)
                        { 
                            throw new InvalidOperationException(SR.GetString(SR.DataGridView_InvalidPropertySetOnSharedRow, "ReadOnly")); 
                        }
                        OnStateChanging(DataGridViewElementStates.ReadOnly); 
                        this.DataGridView.SetReadOnlyRowCore(this.bandIndex, value);
                    }
                    else
                    { 
                        Debug.Assert(this.bandIndex >= 0);
                        OnStateChanging(DataGridViewElementStates.ReadOnly); 
                        this.DataGridView.SetReadOnlyColumnCore(this.bandIndex, value); 
                    }
                } 
                else
                {
                    if (((this.State & DataGridViewElementStates.ReadOnly) != 0) != value)
                    { 
                        if (value)
                        { 
                            if (this.bandIsRow) 
                            {
                                foreach (DataGridViewCell dataGridViewCell in ((DataGridViewRow) this).Cells) 
                                {
                                    if (dataGridViewCell.ReadOnly)
                                    {
                                        dataGridViewCell.ReadOnlyInternal = false; 
                                    }
                                } 
                            } 
                            this.StateInternal = this.State | DataGridViewElementStates.ReadOnly;
                        } 
                        else
                        {
                            this.StateInternal = this.State & ~DataGridViewElementStates.ReadOnly;
                        } 
                    }
                } 
            } 
        }
 
        internal bool ReadOnlyInternal
        {
            set
            { 
                Debug.Assert(value != this.ReadOnly);
                if (value) 
                { 
                    this.StateInternal = this.State | DataGridViewElementStates.ReadOnly;
                } 
                else
                {
                    this.StateInternal = this.State & ~DataGridViewElementStates.ReadOnly;
                } 
                Debug.Assert(this.DataGridView != null);
                OnStateChanged(DataGridViewElementStates.ReadOnly); 
            } 
        }
 
        /// 
        [
            Browsable(true)
        ] 
        public virtual DataGridViewTriState Resizable
        { 
            get 
            {
                Debug.Assert(!this.bandIsRow); 
                if ((this.State & DataGridViewElementStates.ResizableSet) != 0)
                {
                    return ((this.State & DataGridViewElementStates.Resizable) != 0) ? DataGridViewTriState.True : DataGridViewTriState.False;
                } 
                if (this.DataGridView != null)
                { 
                    return this.DataGridView.AllowUserToResizeColumns ? DataGridViewTriState.True : DataGridViewTriState.False; 
                }
                else 
                {
                    return DataGridViewTriState.NotSet;
                }
            } 
            set
            { 
                DataGridViewTriState oldResizable = this.Resizable; 
                if (value == DataGridViewTriState.NotSet)
                { 
                    this.StateInternal = this.State & ~DataGridViewElementStates.ResizableSet;
                }
                else
                { 
                    this.StateInternal = this.State | DataGridViewElementStates.ResizableSet;
                    if (((this.State & DataGridViewElementStates.Resizable) != 0) != (value == DataGridViewTriState.True)) 
                    { 
                        if (value == DataGridViewTriState.True)
                        { 
                            this.StateInternal = this.State | DataGridViewElementStates.Resizable;
                        }
                        else
                        { 
                            Debug.Assert(value == DataGridViewTriState.False, "TriState only supports NotSet, True, False");
                            this.StateInternal = this.State & ~DataGridViewElementStates.Resizable; 
                        } 
                    }
                } 
                if (oldResizable != this.Resizable)
                {
                    OnStateChanged(DataGridViewElementStates.Resizable);
                } 
            }
        } 
 
        /// 
        [ 
            Browsable(false),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual bool Selected 
        {
            get 
            { 
                Debug.Assert(!this.bandIsRow);
                return (this.State & DataGridViewElementStates.Selected) != 0; 
            }
            set
            {
                if (this.DataGridView != null) 
                {
                    // this may trigger a call to set_SelectedInternal 
                    if (this.bandIsRow) 
                    {
                        if (this.bandIndex == -1) 
                        {
                            throw new InvalidOperationException(SR.GetString(SR.DataGridView_InvalidPropertySetOnSharedRow, "Selected"));
                        }
                        if (this.DataGridView.SelectionMode == DataGridViewSelectionMode.FullRowSelect || this.DataGridView.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect) 
                        {
                            this.DataGridView.SetSelectedRowCoreInternal(this.bandIndex, value); 
                        } 
                    }
                    else 
                    {
                        Debug.Assert(this.bandIndex >= 0);
                        if (this.DataGridView.SelectionMode == DataGridViewSelectionMode.FullColumnSelect || this.DataGridView.SelectionMode == DataGridViewSelectionMode.ColumnHeaderSelect)
                        { 
                            this.DataGridView.SetSelectedColumnCoreInternal(this.bandIndex, value);
                        } 
                    } 
                }
                else if (value) 
                {
                    // We do not allow the selection of a band before it gets added to the dataGridView.
                    throw new InvalidOperationException(SR.GetString(SR.DataGridViewBand_CannotSelect));
                } 
            }
        } 
 
        internal bool SelectedInternal
        { 
            set
            {
                Debug.Assert(value != this.Selected);
                if (value) 
                {
                    this.StateInternal = this.State | DataGridViewElementStates.Selected; 
                } 
                else
                { 
                    this.StateInternal = this.State & ~DataGridViewElementStates.Selected;
                }
                if (this.DataGridView != null)
                { 
                    OnStateChanged(DataGridViewElementStates.Selected);
                } 
            } 
        }
 
        /// 
        [
            Browsable(false),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public object Tag 
        { 
            get
            { 
                return Properties.GetObject(PropUserData);
            }
            set
            { 
                if (value != null || this.Properties.ContainsObject(PropUserData))
                { 
                    Properties.SetObject(PropUserData, value); 
                }
            } 
        }

        internal int Thickness
        { 
            get
            { 
                if (this.bandIsRow && this.bandIndex > -1) 
                {
                    int height, minimumHeight; 
                    GetHeightInfo(this.bandIndex, out height, out minimumHeight);
                    return height;
                }
                return this.thickness; 
            }
            set 
            { 
                int minimumThickness = this.MinimumThickness;
                if (value < minimumThickness) 
                {
                    value = minimumThickness;
                }
                if (value > maxBandThickness) 
                {
                    if (this.bandIsRow) 
                    { 
                        throw new ArgumentOutOfRangeException("Height", SR.GetString(SR.InvalidHighBoundArgumentEx, "Height", (value).ToString(CultureInfo.CurrentCulture), (maxBandThickness).ToString(CultureInfo.CurrentCulture)));
                    } 
                    else
                    {
                        throw new ArgumentOutOfRangeException("Width", SR.GetString(SR.InvalidHighBoundArgumentEx, "Width", (value).ToString(CultureInfo.CurrentCulture), (maxBandThickness).ToString(CultureInfo.CurrentCulture)));
                    } 
                }
                bool setThickness = true; 
                if (this.bandIsRow) 
                {
                    if (this.DataGridView != null && this.DataGridView.AutoSizeRowsMode != DataGridViewAutoSizeRowsMode.None) 
                    {
                        this.cachedThickness = value;
                        setThickness = false;
                    } 
                }
                else 
                { 
                    DataGridViewColumn dataGridViewColumn = (DataGridViewColumn) this;
                    DataGridViewAutoSizeColumnMode inheritedAutoSizeMode = dataGridViewColumn.InheritedAutoSizeMode; 
                    if (inheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill &&
                        inheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.None &&
                        inheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.NotSet)
                    { 
                        this.cachedThickness = value;
                        setThickness = false; 
                    } 
                    else if (inheritedAutoSizeMode == DataGridViewAutoSizeColumnMode.Fill && this.DataGridView != null)
                    { 
                        if (dataGridViewColumn.Visible)
                        {
                            IntPtr handle = this.DataGridView.Handle;
                            this.DataGridView.AdjustFillingColumn(dataGridViewColumn, value); 
                            setThickness = false;
                        } 
                    } 
                }
 
                if (setThickness && this.thickness != value)
                {
                    if (this.DataGridView != null)
                    { 
                        this.DataGridView.OnBandThicknessChanging();
                    } 
                    this.ThicknessInternal = value; 
                }
            } 
        }

        internal int ThicknessInternal
        { 
            get
            { 
                return this.thickness; 
            }
            set 
            {
                Debug.Assert(this.thickness != value);
                Debug.Assert(value >= this.minimumThickness);
                Debug.Assert(value <= maxBandThickness); 

                this.thickness = value; 
                if (this.DataGridView != null) 
                {
                    this.DataGridView.OnBandThicknessChanged(this); 
                }
            }
        }
 
        /// 
        [ 
            DefaultValue(true), 
        ]
        public virtual bool Visible 
        {
            get
            {
                Debug.Assert(!this.bandIsRow); 
                return (this.State & DataGridViewElementStates.Visible) != 0;
            } 
            set 
            {
                if (((this.State & DataGridViewElementStates.Visible) != 0) != value) 
                {
                    if (this.DataGridView != null &&
                        this.bandIsRow &&
                        this.DataGridView.NewRowIndex != -1 && 
                        this.DataGridView.NewRowIndex == this.bandIndex &&
                        !value) 
                    { 
                        // the 'new' row cannot be made invisble.
                        throw new InvalidOperationException(SR.GetString(SR.DataGridViewBand_NewRowCannotBeInvisible)); 
                    }
                    OnStateChanging(DataGridViewElementStates.Visible);
                    if (value)
                    { 
                        this.StateInternal = this.State | DataGridViewElementStates.Visible;
                    } 
                    else 
                    {
                        this.StateInternal = this.State & ~DataGridViewElementStates.Visible; 
                    }
                    OnStateChanged(DataGridViewElementStates.Visible);
                }
            } 
        }
 
        ///  
        public virtual object Clone()
        { 
            // SECREVIEW : Late-binding does not represent a security thread, see bug#411899 for more info..
            //
            DataGridViewBand dataGridViewBand = (DataGridViewBand) System.Activator.CreateInstance(this.GetType());
            if (dataGridViewBand != null) 
            {
                CloneInternal(dataGridViewBand); 
            } 
            return dataGridViewBand;
        } 

        internal void CloneInternal(DataGridViewBand dataGridViewBand)
        {
            dataGridViewBand.propertyStore = new PropertyStore(); 
            dataGridViewBand.bandIndex = -1;
            dataGridViewBand.bandIsRow = this.bandIsRow; 
            if (!this.bandIsRow || this.bandIndex >= 0 || this.DataGridView == null) 
            {
                dataGridViewBand.StateInternal = this.State & ~(DataGridViewElementStates.Selected | DataGridViewElementStates.Displayed); 
            }
            dataGridViewBand.thickness = this.Thickness;
            dataGridViewBand.MinimumThickness = this.MinimumThickness;
            dataGridViewBand.cachedThickness = this.CachedThickness; 
            dataGridViewBand.DividerThickness = this.DividerThickness;
            dataGridViewBand.Tag = this.Tag; 
            if (this.HasDefaultCellStyle) 
            {
                dataGridViewBand.DefaultCellStyle = new DataGridViewCellStyle(this.DefaultCellStyle); 
            }
            if (this.HasDefaultHeaderCellType)
            {
                dataGridViewBand.DefaultHeaderCellType = this.DefaultHeaderCellType; 
            }
            if (this.ContextMenuStripInternal != null) 
            { 
                dataGridViewBand.ContextMenuStrip = this.ContextMenuStripInternal.Clone();
            } 
        }

        private void DetachContextMenuStrip(object sender, EventArgs e)
        { 
            this.ContextMenuStripInternal = null;
        } 
 
        /// 
        public void Dispose() 
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        } 

        ///  
        protected virtual void Dispose(bool disposing) 
        {
            if (disposing) 
            {
                ContextMenuStrip contextMenuStrip = (ContextMenuStrip)this.ContextMenuStripInternal;
                if (contextMenuStrip != null)
                { 
                    contextMenuStrip.Disposed -= new EventHandler(DetachContextMenuStrip);
                } 
            } 
        }
 
        internal void GetHeightInfo(int rowIndex, out int height, out int minimumHeight)
        {
            Debug.Assert(this.bandIsRow);
            if (this.DataGridView != null && 
                (this.DataGridView.VirtualMode || this.DataGridView.DataSource != null) &&
                this.DataGridView.AutoSizeRowsMode == DataGridViewAutoSizeRowsMode.None) 
            { 
                Debug.Assert(rowIndex > -1);
                DataGridViewRowHeightInfoNeededEventArgs dgvrhine = this.DataGridView.OnRowHeightInfoNeeded(rowIndex, this.thickness, this.minimumThickness); 
                height = dgvrhine.Height;
                minimumHeight = dgvrhine.MinimumHeight;
                return;
            } 
            height = this.thickness;
            minimumHeight = this.minimumThickness; 
        } 

        internal void OnStateChanged(DataGridViewElementStates elementState) 
        {
            if (this.DataGridView != null)
            {
                // maybe move this code into OnDataGridViewElementStateChanged 
                if (this.bandIsRow)
                { 
                    // we could be smarter about what needs to be invalidated. 
                    this.DataGridView.Rows.InvalidateCachedRowCount(elementState);
                    this.DataGridView.Rows.InvalidateCachedRowsHeight(elementState); 
                    if (this.bandIndex != -1)
                    {
                        this.DataGridView.OnDataGridViewElementStateChanged(this, -1, elementState);
                    } 
                }
                else 
                { 
                    // we could be smarter about what needs to be invalidated.
                    this.DataGridView.Columns.InvalidateCachedColumnCount(elementState); 
                    this.DataGridView.Columns.InvalidateCachedColumnsWidth(elementState);
                    this.DataGridView.OnDataGridViewElementStateChanged(this, -1, elementState);
                }
            } 
        }
 
        private void OnStateChanging(DataGridViewElementStates elementState) 
        {
            if (this.DataGridView != null) 
            {
                if (this.bandIsRow)
                {
                    if (this.bandIndex != -1) 
                    {
                        this.DataGridView.OnDataGridViewElementStateChanging(this, -1, elementState); 
                    } 
                }
                else 
                {
                    this.DataGridView.OnDataGridViewElementStateChanging(this, -1, elementState);
                }
            } 
        }
 
        ///  
        protected override void OnDataGridViewChanged()
        { 
            if (this.HasDefaultCellStyle)
            {
                if (this.DataGridView == null)
                { 
                    this.DefaultCellStyle.RemoveScope(this.bandIsRow ? DataGridViewCellStyleScopes.Row : DataGridViewCellStyleScopes.Column);
                } 
                else 
                {
                    this.DefaultCellStyle.AddScope(this.DataGridView, 
                        this.bandIsRow ? DataGridViewCellStyleScopes.Row : DataGridViewCellStyleScopes.Column);
                }
            }
            base.OnDataGridViewChanged(); 
        }
 
        private bool ShouldSerializeDefaultHeaderCellType() 
        {
            Type dhct = (Type)this.Properties.GetObject(PropDefaultHeaderCellType); 
            return dhct != null;
        }

        // internal because DataGridViewColumn needs to access it 
        internal bool ShouldSerializeResizable()
        { 
            return (this.State & DataGridViewElementStates.ResizableSet) != 0; 
        }
 
        /// 
        /// 
        ///    
        ///  
        public override string ToString()
        { 
            StringBuilder sb = new StringBuilder(36); 
            sb.Append("DataGridViewBand { Index=");
            sb.Append(this.Index.ToString(CultureInfo.CurrentCulture)); 
            sb.Append(" }");
            return sb.ToString();
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.


                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• RequestStatusBarUpdateEventArgs.cs
• SoundPlayerAction.cs
• MasterPageBuildProvider.cs
• ImageField.cs
• FontStretch.cs
• ImmutableObjectAttribute.cs
• SpinLock.cs
• EasingKeyFrames.cs
• PreparingEnlistment.cs
• TextServicesDisplayAttribute.cs
• InputBinder.cs
• UndoManager.cs
• Ray3DHitTestResult.cs
• FrameworkElementFactoryMarkupObject.cs
• FixedPageProcessor.cs
• Effect.cs
• TextServicesManager.cs
• CodeEventReferenceExpression.cs
• Vector3DAnimation.cs
• DataFormats.cs
• FreezableDefaultValueFactory.cs
• SingleBodyParameterMessageFormatter.cs
• ScriptHandlerFactory.cs
• FactoryMaker.cs
• ProfileBuildProvider.cs
• Vector3D.cs
• SmtpCommands.cs
• HttpRuntimeSection.cs
• HttpModulesSection.cs
• RemoveStoryboard.cs
• PrimitiveList.cs
• PagesSection.cs
• control.ime.cs
• Style.cs
• TableLayout.cs
• StringArrayConverter.cs
• XPathAncestorIterator.cs
• AvTraceFormat.cs
• DoubleStorage.cs
• OdbcEnvironment.cs
• OrderedDictionaryStateHelper.cs
• DbParameterHelper.cs
• PathParser.cs
• RepeatInfo.cs
• NameScopePropertyAttribute.cs
• TableLayoutColumnStyleCollection.cs
• MSHTMLHost.cs
• CodeMemberMethod.cs
• DrawingImage.cs
• RuleSettingsCollection.cs
• Bookmark.cs
• XmlDataSourceView.cs
• TextTreeTextNode.cs
• TypeLibConverter.cs
• StickyNote.cs
• SmtpMail.cs
• WizardPanelChangingEventArgs.cs
• GenericTextProperties.cs
• TagMapCollection.cs
• ScaleTransform3D.cs
• VisualTreeHelper.cs
• codemethodreferenceexpression.cs
• ToolStripItemClickedEventArgs.cs
• TextTreeInsertUndoUnit.cs
• Stacktrace.cs
• XpsFilter.cs
• EditorServiceContext.cs
• QueryCoreOp.cs
• GroupBoxAutomationPeer.cs
• WaitForChangedResult.cs
• DrawTreeNodeEventArgs.cs
• UpdatePanel.cs
• XmlElementCollection.cs
• QueryableFilterRepeater.cs
• FullTextState.cs
• Int32.cs
• CroppedBitmap.cs
• CollectionAdapters.cs
• XamlSerializationHelper.cs
• TraversalRequest.cs
• Metadata.cs
• MarkupCompilePass2.cs
• BidirectionalDictionary.cs
• EventLogEntry.cs
• DataSourceCache.cs
• DragDeltaEventArgs.cs
• MergablePropertyAttribute.cs
• ViewGenerator.cs
• ClipboardData.cs
• FileSystemWatcher.cs
• SqlDependency.cs
• NullableFloatSumAggregationOperator.cs
• DynamicUpdateCommand.cs
• CustomCategoryAttribute.cs
• SqlOuterApplyReducer.cs
• SystemThemeKey.cs
• XomlCompilerError.cs
• HtmlImage.cs
• InvalidPrinterException.cs
• BehaviorEditorPart.cs