ArrangedElement.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

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

                        
                             
namespace System.Windows.Forms {


 
      using System.Drawing;
      using System.Windows.Forms.Layout; 
      using System.Collections.Specialized; 
      using System.Collections;
      using System.ComponentModel; 
      using System.Diagnostics;


      internal abstract class ArrangedElement : Component, IArrangedElement { 

          ///  
          ///  
          /// 
 
          private Rectangle bounds = Rectangle.Empty;
          private IArrangedElement parent = null;
          private BitVector32 state = new BitVector32();
          private PropertyStore propertyStore = new PropertyStore();  // Contains all properties that are not always set. 
          private int suspendCount = 0;
 
          private static readonly int stateVisible   = BitVector32.CreateMask(); 
          private static readonly int stateDisposing = BitVector32.CreateMask(stateVisible);
          private static readonly int stateLocked    = BitVector32.CreateMask(stateDisposing); 


          private static readonly int PropControlsCollection = PropertyStore.CreateKey();
          private Control spacer = new Control(); 

          internal ArrangedElement() { 
            this.Padding = DefaultPadding; 
            this.Margin  = DefaultMargin;
            state[stateVisible] = true; 
          }

          public Rectangle Bounds {
              get { 
                  return bounds;
              } 
          } 

          ArrangedElementCollection IArrangedElement.Children { 
                get { return GetChildren(); }
          }

          IArrangedElement IArrangedElement.Container { 
              get { return GetContainer(); }
          } 
 
          protected virtual Padding DefaultMargin {
              get { return Padding.Empty; } 
          }

          protected virtual Padding DefaultPadding {
              get { return Padding.Empty; } 
          }
 
          public virtual Rectangle DisplayRectangle { 
              get {
                  Rectangle displayRectangle = this.Bounds; 
                  return displayRectangle;
              }
           }
 
           public abstract LayoutEngine LayoutEngine {
               get; 
           } 

           public Padding Margin { 
               get { return CommonProperties.GetMargin(this); }
               set {

                Debug.Assert((value.Right >= 0 && value.Left >= 0 && value.Top >= 0 && value.Bottom >=0),  "who's setting margin negative?"); 
                value = LayoutUtils.ClampNegativePaddingToZero(value);
                if (Margin != value ) { CommonProperties.SetMargin(this, value); } 
 
               }
           } 

           public virtual Padding Padding {
               get { return CommonProperties.GetPadding(this, DefaultPadding); }
               set { 
                   Debug.Assert((value.Right >= 0 && value.Left >= 0 && value.Top >= 0 && value.Bottom >=0),  "who's setting padding negative?");
                   value = LayoutUtils.ClampNegativePaddingToZero(value); 
                   if (Padding != value) { CommonProperties.SetPadding(this, value); } 
               }
           } 

          public virtual IArrangedElement Parent {
              get {
                  return parent; 
              }
              set { 
                  parent = value as IArrangedElement; 
              }
          } 

          public virtual bool ParticipatesInLayout {
              get {
                  return Visible; 
              }
          } 
 
          PropertyStore IArrangedElement.Properties {
              get { 
                  return this.Properties;
              }
          }
 

          private PropertyStore Properties { 
               get { 
                   return propertyStore;
               } 
           }

          public virtual bool Visible {
               get { 
                   return state[stateVisible];
               } 
               set { 
                   if ( state[stateVisible] != value) {
                       state[stateVisible] = value; 
                       if (Parent != null){
                           LayoutTransaction.DoLayout(this.Parent, this, PropertyNames.Visible);
                       }
                   } 
               }
           } 
 
          protected abstract IArrangedElement GetContainer();
 
          protected abstract ArrangedElementCollection GetChildren();

          public virtual Size GetPreferredSize(Size constrainingSize) {
              Size preferredSize = LayoutEngine.GetPreferredSize(this, constrainingSize - Padding.Size) + Padding.Size; 

              return preferredSize; 
          } 

          public virtual void PerformLayout(IArrangedElement container, string propertyName) { 
              if (suspendCount <= 0) {
                  OnLayout(new LayoutEventArgs(container, propertyName));
              }
          } 

          protected virtual void OnLayout(LayoutEventArgs e) { 
              bool parentNeedsLayout = LayoutEngine.Layout(this, e); 
          }
 
          protected virtual void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
              ((IArrangedElement)this).PerformLayout((IArrangedElement)this, PropertyNames.Size);
          }
 
          public void SetBounds(Rectangle bounds, BoundsSpecified specified) {
              // in this case the parent is telling us to refresh our bounds - dont 
              // call PerformLayout 
              SetBoundsCore(bounds, specified);
          } 


          protected virtual void SetBoundsCore(Rectangle bounds, BoundsSpecified specified) {
              if (bounds != this.bounds) { 
                  Rectangle oldBounds = this.bounds;
 
                  this.bounds = bounds; 
                  OnBoundsChanged(oldBounds, bounds);
              } 
          }

      }
 
}
 
 

// 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