C# IArrangedElement.GetPreferredSize方法代码示例

        //Unused
        //private static Size GetFillDockedSize(IArrangedElement element, Size remainingSize, bool measureOnly) {
        //    Size newSize = xGetDockedSize(element, remainingSize, /* constraints = */ remainingSize, measureOnly);
        //    newSize = LayoutUtils.UnionSizes(newSize, remainingSize);

        //    if (!measureOnly) {
        //        newSize = LayoutUtils.IntersectSizes(newSize, remainingSize);
        //    }

        //    Debug.Assert(newSize.Width >= remainingSize.Width && newSize.Height >= remainingSize.Height,
        //        "Error detected in GetFillDockedSize: Element did not stretch to remaning size.");
        //    Debug.Assert(measureOnly || (newSize.Width == remainingSize.Width && newSize.Height == remainingSize.Height),
        //        "Error detected in GetFillDockedSize: Dock size computed incorrectly during layout.");

        //    return newSize;
        //}

        private static Size xGetDockedSize(IArrangedElement element, Size remainingSize, Size constraints, bool measureOnly) {
            Size desiredSize;
            
            if (CommonProperties.GetAutoSize(element)) {
                // Ask control for its desired size using the provided constraints.
                // (e.g., a control docked to top will constrain width to remaining width
                // and minimize height.)
                desiredSize = element.GetPreferredSize(constraints);
            } else {
                desiredSize = element.Bounds.Size;
            }

            Debug.Assert((desiredSize.Width >= 0 && desiredSize.Height >= 0), "Error detected in xGetDockSize: Element size was negative.");
            return desiredSize;
        }

        // Helper method that either sets the element bounds or does the preferredSize computation based on
        // the value of measureOnly.
        private static void xLayoutDockedControl(IArrangedElement element, Rectangle newElementBounds, bool measureOnly, ref Size preferredSize, ref Rectangle remainingBounds) {
            if (measureOnly) {
                Size neededSize = new Size(
                    Math.Max(0, newElementBounds.Width - remainingBounds.Width),
                    Math.Max(0, newElementBounds.Height - remainingBounds.Height));

                DockStyle dockStyle = GetDock(element);
                if ((dockStyle == DockStyle.Top) || (dockStyle == DockStyle.Bottom)) {
                    neededSize.Width = 0;
                }
                if ((dockStyle == DockStyle.Left) || (dockStyle == DockStyle.Right)) {
                    neededSize.Height = 0;
                }
                if (dockStyle != DockStyle.Fill) {
                    preferredSize += neededSize;
                    remainingBounds.Size += neededSize;
                }
                else if(dockStyle == DockStyle.Fill && CommonProperties.GetAutoSize(element)) {
                    Size elementPrefSize = element.GetPreferredSize(neededSize);
                    remainingBounds.Size += elementPrefSize;
                    preferredSize += elementPrefSize;
                }
            } else {
                element.SetBounds(newElementBounds, BoundsSpecified.None);

#if DEBUG
                Control control = element as Control;
                newElementBounds.Size = control.ApplySizeConstraints(newElementBounds.Size);
                // This usually happens when a Control overrides its SetBoundsCore or sets size during OnResize
                // to enforce constraints like AutoSize.  Generally you can just move this code to Control.GetAdjustedSize
                // and then PreferredSize will also pick up these constraints.  See ComboBox as an example.
                //
                if (CommonProperties.GetAutoSize(element) && !CommonProperties.GetSelfAutoSizeInDefaultLayout(element)) {
                    Debug.Assert(
                        (newElementBounds.Width < 0 || element.Bounds.Width == newElementBounds.Width) &&
                        (newElementBounds.Height < 0 || element.Bounds.Height == newElementBounds.Height),
                        "Element modified its bounds during docking -- PreferredSize will be wrong. See comment near this assert.");
                }
#endif
            }
        }

 private static void xLayoutDockedControl(IArrangedElement element, Rectangle newElementBounds, bool measureOnly, ref Size preferredSize, ref Rectangle remainingBounds)
 {
     if (measureOnly)
     {
         Size proposedSize = new Size(Math.Max(0, newElementBounds.Width - remainingBounds.Width), Math.Max(0, newElementBounds.Height - remainingBounds.Height));
         DockStyle dock = GetDock(element);
         switch (dock)
         {
             case DockStyle.Top:
             case DockStyle.Bottom:
                 proposedSize.Width = 0;
                 break;
         }
         if ((dock == DockStyle.Left) || (dock == DockStyle.Right))
         {
             proposedSize.Height = 0;
         }
         if (dock != DockStyle.Fill)
         {
             preferredSize += proposedSize;
             remainingBounds.Size += proposedSize;
         }
         else if ((dock == DockStyle.Fill) && CommonProperties.GetAutoSize(element))
         {
             Size size2 = element.GetPreferredSize(proposedSize);
             remainingBounds.Size += size2;
             preferredSize += size2;
         }
     }
     else
     {
         element.SetBounds(newElementBounds, BoundsSpecified.None);
     }
 }

 private Size GetElementSize(IArrangedElement element, Size proposedConstraints) {
     if(CommonProperties.GetAutoSize(element)) {
         return element.GetPreferredSize(proposedConstraints);
     } else {
         return CommonProperties.GetSpecifiedBounds(element).Size;
     }
 }

 private static Size xGetDockedSize(IArrangedElement element, Size remainingSize, Size constraints, bool measureOnly)
 {
     if (CommonProperties.GetAutoSize(element))
     {
         return element.GetPreferredSize(constraints);
     }
     return element.Bounds.Size;
 }