ToolStripSeparator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / WinForms / Managed / System / WinForms / ToolStripSeparator.cs / 1 / ToolStripSeparator.cs
                        

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

namespace System.Windows.Forms { 
    using System; 
    using System.Drawing;
    using System.ComponentModel; 
    using System.Windows.Forms.Design;
    using System.Diagnostics.CodeAnalysis;

    ///  
    /// 
    ///     
    ///      Called when the background of the winbar is being rendered 
    ///    
    ///  
    [ToolStripItemDesignerAvailability(ToolStripItemDesignerAvailability.ToolStrip | ToolStripItemDesignerAvailability.ContextMenuStrip)]
    public class ToolStripSeparator : ToolStripItem {
            private const int WINBAR_SEPARATORTHICKNESS = 6;
            private const int WINBAR_SEPARATORHEIGHT = 23; 

            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")] 
            public ToolStripSeparator() { 
                this.ForeColor = SystemColors.ControlDark;
            } 

            /// 
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ] 
            public new bool AutoToolTip {
               get { 
                    return base.AutoToolTip;
               }
               set {
                    base.AutoToolTip = value; 
               }
            } 
 

            ///  
            [
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ]
            public override Image BackgroundImage { 
                get { 
                    return base.BackgroundImage;
 
                }
                set {
                    base.BackgroundImage = value;
                } 
            }
 
            ///  
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ]
            public override ImageLayout BackgroundImageLayout { 
              get {
                  return base.BackgroundImageLayout; 
              } 
              set {
                  base.BackgroundImageLayout = value; 
              }
            }

            ///  
            public override bool CanSelect {
                get  { 
                    return DesignMode; 
                }
            } 


            /// 
            ///  
            ///     Deriving classes can override this to configure a default size for their control.
            ///     This is more efficient than setting the size in the control's constructor. 
            ///  
            protected override Size DefaultSize {
                get { 
                    return new Size(WINBAR_SEPARATORTHICKNESS, WINBAR_SEPARATORTHICKNESS);
                }
            }
 

            ///  
            protected internal override Padding DefaultMargin { 
               get {
                   return Padding.Empty; 
               }
           }

 
           [
           Browsable(false), 
           EditorBrowsable(EditorBrowsableState.Never), 
           DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
           ] 
           public new bool DoubleClickEnabled {
               get {
                   return base.DoubleClickEnabled;
               } 
               set {
                   base.DoubleClickEnabled = value; 
               } 
           }
 
            /// 
            [
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public override bool Enabled { 
                get {
                  return base.Enabled; 
                }
                set {
                  base.Enabled = value;
                } 

            } 
 
            /// 
            ///  
            [Browsable (false), EditorBrowsable (EditorBrowsableState.Never)]
            new public event EventHandler EnabledChanged {
                add {
                    base.EnabledChanged += value; 
                }
                remove { 
                    base.EnabledChanged -= value; 
                }
            } 

            /// 
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ] 
            public new ToolStripItemDisplayStyle DisplayStyle {
                get { 
                    return base.DisplayStyle;
                }
                set {
                   base.DisplayStyle = value; 
                }
            } 
 
            /// 
            ///  
            [Browsable (false), EditorBrowsable (EditorBrowsableState.Never)]
            new public event EventHandler DisplayStyleChanged {
                add {
                    base.DisplayStyleChanged += value; 
                }
                remove { 
                    base.DisplayStyleChanged -= value; 
                }
            } 

            /// 
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ] 
            public override Font Font {
                get { 
                    return base.Font;
                }
                set {
                   base.Font = value; 
                }
            } 
 
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ]
            public new ContentAlignment ImageAlign { 
                get {
                    return base.ImageAlign; 
                } 
                set {
                    base.ImageAlign = value; 
                }
            }

            ///  
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public override Image Image {
                get {
                    return base.Image;
                } 
                set {
                    base.Image = value; 
                } 
            }
 
            /// 
            [
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never), 
            RefreshProperties(RefreshProperties.Repaint),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ] 
            public new int ImageIndex {
                get { 
                    return base.ImageIndex;
                }
                set {
                    base.ImageIndex = value; 
                }
            } 
 
            /// 
            [ 
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public new string ImageKey {
               get { 
                   return base.ImageKey; 
               }
               set { 
                   base.ImageKey = value;
               }
            }
 
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public new Color ImageTransparentColor {
                get {
                    return base.ImageTransparentColor;
                } 
                set {
                   base.ImageTransparentColor = value; 
                } 
            }
 
            [
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ]
            public new ToolStripItemImageScaling ImageScaling { 
                get { 
                    return base.ImageScaling;
                } 
                set {
                    base.ImageScaling = value;
                }
            } 

 
            private bool IsVertical { 
                get {
                    ToolStrip parent = this.ParentInternal; 

                    if (parent == null) {
                        parent = Owner;
                    } 
                    ToolStripDropDownMenu dropDownMenu = parent as ToolStripDropDownMenu;
                    if (dropDownMenu != null) { 
                        return false; 
                    }
                    switch (parent.LayoutStyle) { 
                        case ToolStripLayoutStyle.VerticalStackWithOverflow:
                            return false;
                        case ToolStripLayoutStyle.HorizontalStackWithOverflow:
                        case ToolStripLayoutStyle.Flow: 
                        case ToolStripLayoutStyle.Table:
                        default: 
                            return true; 
                    }
                } 
            }


            ///  
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public override string Text {
              get {
                  return base.Text;
              } 
              set {
                  base.Text = value; 
              } 
            }
 
             /// 
            /// 
            [Browsable (false), EditorBrowsable (EditorBrowsableState.Never)]
            new public event EventHandler TextChanged { 
                add {
                    base.TextChanged += value; 
                } 
                remove {
                    base.TextChanged -= value; 
                }
            }

            ///  
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public new ContentAlignment TextAlign {
                 get {
                     return base.TextAlign;
                 } 
                 set {
                     base.TextAlign = value; 
                 } 
            }
 

            [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DefaultValue(ToolStripTextDirection.Horizontal)]
            public override ToolStripTextDirection TextDirection {
                 get { 
                     return base.TextDirection;
                 } 
                 set { 
                     base.TextDirection = value;
                 } 
            }

            /// 
            [ 
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
            ]
            public new TextImageRelation TextImageRelation { 
               get {
                   return base.TextImageRelation;
               }
               set { 
                   base.TextImageRelation = value;
               } 
            } 

            [ 
            Browsable(false),
            EditorBrowsable(EditorBrowsableState.Never),
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public new string ToolTipText {
                get { 
                    return base.ToolTipText; 
                }
                set { 
                    base.ToolTipText = value;
                }
            }
 
            [
            Browsable(false), 
            EditorBrowsable(EditorBrowsableState.Never), 
            DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
            ] 
            public new bool RightToLeftAutoMirrorImage {
                get {
                    return base.RightToLeftAutoMirrorImage;
                } 
                set {
                    base.RightToLeftAutoMirrorImage = value; 
                } 
            }
 
            [EditorBrowsable(EditorBrowsableState.Advanced)]
            protected override AccessibleObject CreateAccessibilityInstance() {
               return new ToolStripSeparatorAccessibleObject(this);
            } 

 
            ///  
            public override Size GetPreferredSize(Size constrainingSize) {
                ToolStrip parent = this.ParentInternal; 

                if (parent == null) {
                    parent = Owner;
                } 
                if (parent == null) {
                    return new Size(WINBAR_SEPARATORTHICKNESS, WINBAR_SEPARATORTHICKNESS); 
                } 

                ToolStripDropDownMenu dropDownMenu = parent as ToolStripDropDownMenu; 
                if (dropDownMenu != null) {
                    return new Size(parent.Width - (parent.Padding.Horizontal - dropDownMenu.ImageMargin.Width), WINBAR_SEPARATORTHICKNESS);
                }
                else { 
                    if (parent.LayoutStyle != ToolStripLayoutStyle.HorizontalStackWithOverflow || parent.LayoutStyle != ToolStripLayoutStyle.VerticalStackWithOverflow) {
                        // we dont actually know what size to make it, so just keep it a stock size. 
                        constrainingSize.Width = WINBAR_SEPARATORHEIGHT; 
                        constrainingSize.Height = WINBAR_SEPARATORHEIGHT;
                    } 
                    if (IsVertical) {
                        return new Size(WINBAR_SEPARATORTHICKNESS, constrainingSize.Height);
                    }
                    else { 
                        return new Size(constrainingSize.Width, WINBAR_SEPARATORTHICKNESS);
                    } 
                } 

            } 


            /// 
            protected override void OnPaint(System.Windows.Forms.PaintEventArgs e) { 
                if (this.Owner != null && this.ParentInternal != null) {
                    this.Renderer.DrawSeparator(new ToolStripSeparatorRenderEventArgs(e.Graphics, this, IsVertical)); 
                } 
            }
 
            [EditorBrowsable(EditorBrowsableState.Never)]
            protected override void OnFontChanged(EventArgs e) {
                // PERF: dont call base, we dont care if the font changes
                RaiseEvent(EventFontChanged, e); 
            }
 
            [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")] 
            [EditorBrowsable(EditorBrowsableState.Never)]
            internal override bool ShouldSerializeForeColor() { 
                 return (ForeColor != SystemColors.ControlDark);
            }

            internal protected override void SetBounds(Rectangle rect) { 

                ToolStripDropDownMenu dropDownMenu = this.Owner as ToolStripDropDownMenu; 
                if (dropDownMenu != null) { 

                   // Scooch over by the padding amount.  The padding is added to 
                   // the ToolStripDropDownMenu to keep the non-menu item riffraff
                   // aligned to the text rectangle. When flow layout comes through to set our position
                   // via IArrangedElement DEFY IT!
                   if (dropDownMenu != null) { 
                        rect.X = 2;
                        rect.Width = dropDownMenu.Width -4; 
                   } 
                }
                base.SetBounds(rect); 
            }

            /// 
            /// An implementation of AccessibleChild for use with ToolStripItems 
            /// 
            [System.Runtime.InteropServices.ComVisible(true)] 
            internal class ToolStripSeparatorAccessibleObject : ToolStripItemAccessibleObject { 
                private ToolStripSeparator ownerItem = null;
 
                public ToolStripSeparatorAccessibleObject(ToolStripSeparator ownerItem): base(ownerItem) {
                    this.ownerItem = ownerItem;
                }
 
                public override AccessibleRole Role {
                    get { 
                        AccessibleRole role = ownerItem.AccessibleRole; 
                        if (role != AccessibleRole.Default) {
                            return role; 
                        }
                        else {
                            return AccessibleRole.Separator;
                        } 

                    } 
                } 
            }
        } 
 }

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK