C# IArrangedElement类代码示例

        internal override Size GetPreferredSize(IArrangedElement container, Size proposedConstraints) {
#if DEBUG        
            if (CompModSwitches.FlowLayout.TraceInfo) {            
                Debug.WriteLine("FlowLayout::GetPreferredSize("
                    + "container=" + container.ToString() + ", "
                    + "proposedConstraints=" + proposedConstraints.ToString() + ")");
                Debug.Indent();
            }
#endif
            Rectangle measureBounds = new Rectangle(new Point(0, 0), proposedConstraints);
            Size prefSize = xLayout(container, measureBounds, /* measureOnly = */ true);

            if(prefSize.Width > proposedConstraints.Width || prefSize.Height> proposedConstraints.Height) {
                // Controls measured earlier than a control which couldn't be fit to constraints may
                // shift around with the new bounds.  We need to make a 2nd pass through the
                // controls using these bounds which are gauranteed to fit.
                measureBounds.Size = prefSize;
                prefSize = xLayout(container, measureBounds, /* measureOnly = */ true);
            }

#if DEBUG
            if (CompModSwitches.FlowLayout.TraceInfo) {
                Debug.Unindent();
                Debug.WriteLine("GetPreferredSize returned " + prefSize);
            }
#endif
            return prefSize;
        }

 internal static void ClearMaximumSize(IArrangedElement element)
 {
     if (element.Properties.ContainsObject(_maximumSizeProperty))
     {
         element.Properties.RemoveObject(_maximumSizeProperty);
     }
 }

 // Repositions a element in this list.
 internal void MoveElement(IArrangedElement element, int fromIndex, int toIndex) {
     int delta = toIndex - fromIndex;
 
     switch (delta) {
         case -1:
         case 1:
             // simple swap
             this.InnerList[fromIndex] = this.InnerList[toIndex];
             break;
 
         default:
             int start = 0;
             int dest = 0;
 
             // which direction are we moving?
             if (delta > 0) {
                 // shift down by the delta to open the new spot
                 start = fromIndex + 1;
                 dest = fromIndex;
             }
             else {
                 // shift up by the delta to open the new spot
                 start = toIndex;
                 dest = toIndex + 1;
 
                 // make it positive
                 delta = -delta;
             }
             Copy(this, start, this, dest, delta);
             break;
     }
     this.InnerList[toIndex] = element;
 }

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

        internal void MoveElement(IArrangedElement element, int fromIndex, int toIndex)
        {
            int length = toIndex - fromIndex;
            switch (length)
            {
                case -1:
                case 1:
                    this.InnerList[fromIndex] = this.InnerList[toIndex];
                    break;

                default:
                {
                    int sourceIndex = 0;
                    int destinationIndex = 0;
                    if (length > 0)
                    {
                        sourceIndex = fromIndex + 1;
                        destinationIndex = fromIndex;
                    }
                    else
                    {
                        sourceIndex = toIndex;
                        destinationIndex = toIndex + 1;
                        length = -length;
                    }
                    Copy(this, sourceIndex, this, destinationIndex, length);
                    break;
                }
            }
            this.InnerList[toIndex] = element;
        }

 internal void EnsureOwnership(IArrangedElement owner)
 {
     this._owner = owner;
     for (int i = 0; i < this.Count; i++)
     {
         this[i].Owner = owner;
     }
 }

 internal static AutoSizeMode GetAutoSizeMode(IArrangedElement element)
 {
     if (GetLayoutState(element)[_autoSizeModeSection] != 0)
     {
         return AutoSizeMode.GrowAndShrink;
     }
     return AutoSizeMode.GrowOnly;
 }

 public static void SetFlowDirection(IArrangedElement container, FlowDirection value)
 {
     if (!System.Windows.Forms.ClientUtils.IsEnumValid(value, (int) value, 0, 3))
     {
         throw new InvalidEnumArgumentException("value", (int) value, typeof(FlowDirection));
     }
     container.Properties.SetInteger(_flowDirectionProperty, (int) value);
     LayoutTransaction.DoLayout(container, container, PropertyNames.FlowDirection);
 }

 public static IDisposable CreateTransactionIf(bool condition, Control controlToLayout, IArrangedElement elementCausingLayout, string property)
 {
     if (condition)
     {
         return new LayoutTransaction(controlToLayout, elementCausingLayout, property);
     }
     CommonProperties.xClearPreferredSizeCache(elementCausingLayout);
     return new NullLayoutTransaction();
 }

 internal static Padding GetMargin(IArrangedElement element)
 {
     bool flag;
     Padding padding = element.Properties.GetPadding(_marginProperty, out flag);
     if (flag)
     {
         return padding;
     }
     return DefaultMargin;
 }

 internal static Size GetLayoutBounds(IArrangedElement element)
 {
     bool flag;
     Size size = element.Properties.GetSize(_layoutBoundsProperty, out flag);
     if (flag)
     {
         return size;
     }
     return Size.Empty;
 }

 internal override Size GetPreferredSize(IArrangedElement container, Size proposedConstraints)
 {
     Rectangle displayRect = new Rectangle(new Point(0, 0), proposedConstraints);
     Size size = this.xLayout(container, displayRect, true);
     if ((size.Width <= proposedConstraints.Width) && (size.Height <= proposedConstraints.Height))
     {
         return size;
     }
     displayRect.Size = size;
     return this.xLayout(container, displayRect, true);
 }

 public static void DoLayout(IArrangedElement elementToLayout, IArrangedElement elementCausingLayout, string property)
 {
     if (elementCausingLayout != null)
     {
         CommonProperties.xClearPreferredSizeCache(elementCausingLayout);
         if (elementToLayout != null)
         {
             CommonProperties.xClearPreferredSizeCache(elementToLayout);
             elementToLayout.PerformLayout(elementCausingLayout, property);
         }
     }
 }

 public static void DoLayoutIf(bool condition, IArrangedElement elementToLayout, IArrangedElement elementCausingLayout, string property)
 {
     if (!condition)
     {
         if (elementCausingLayout != null)
         {
             CommonProperties.xClearPreferredSizeCache(elementCausingLayout);
         }
     }
     else
     {
         DoLayout(elementToLayout, elementCausingLayout, property);
     }
 }

        private static ContainerProxy CreateContainerProxy(IArrangedElement container, FlowDirection flowDirection) {

            switch (flowDirection) {
                case FlowDirection.RightToLeft:
                    return new RightToLeftProxy(container);
                case FlowDirection.TopDown:
                    return new TopDownProxy(container);
                case FlowDirection.BottomUp:
                    return new BottomUpProxy(container);
                case FlowDirection.LeftToRight:
                default:
                    return new ContainerProxy(container);
            }
        
        }