protected LayoutFloatingWindowControl(ILayoutElement model)
 {
     Loaded += OnLoaded;
     Unloaded += OnUnloaded;
     _model = model;
     UpdateThemeResources();
 }

        private static void SizeLayoutElement(ILayoutElement layoutElement,
                                              float height,
                                              VerticalAlign verticalAlign,
                                              float restrictedHeight,
                                              float? width,
                                              bool variableColumnWidth,
                                              float columnWidth)
        {
            float? newHeight = null;

            // if verticalAlign is "justify" or "contentJustify", 
            // restrict the height to restrictedHeight.  Otherwise, 
            // size it normally
            if (verticalAlign == VerticalAlign.Justify ||
                verticalAlign == VerticalAlign.ContentJustify)
            {
                newHeight = restrictedHeight;
            }
            else
            {
                if (null != layoutElement.PercentHeight)
                    newHeight = CalculatePercentHeight(layoutElement, height);
            }

            if (variableColumnWidth)
                layoutElement.SetLayoutBoundsSize(width, newHeight);
            else
                layoutElement.SetLayoutBoundsSize(columnWidth, newHeight);
        }

 private static float CalculatePercentWidth(ILayoutElement layoutElement, float width)
 {
     float percentWidth = Mathf.Clamp(Mathf.Round((float) (layoutElement.PercentWidth * 0.01f * width)),
                                      LayoutUtil.GetMinBoundsWidth((InvalidationManagerClient)layoutElement),
                                      LayoutUtil.GetMaxBoundsWidth((InvalidationManagerClient) layoutElement));
     return percentWidth < width ? percentWidth : width;
 }

        private static void SizeLayoutElement(ILayoutElement layoutElement,
                                              float width,
                                              HorizontalAlign horizontalAlign,
                                              float restrictedWidth,
                                              float? height,
                                              bool variableRowHeight,
                                              float rowHeight)
        {
            float? newWidth = null;

            // if horizontalAlign is "justify" or "contentJustify", 
            // restrict the width to restrictedWidth.  Otherwise, 
            // size it normally
            if (horizontalAlign == HorizontalAlign.Justify ||
                horizontalAlign == HorizontalAlign.ContentJustify)
            {
                newWidth = restrictedWidth;
            }
            else
            {
                if (null != layoutElement.PercentWidth)
                    newWidth = CalculatePercentWidth(layoutElement, width);
            }

            if (variableRowHeight)
                layoutElement.SetLayoutBoundsSize(newWidth, height);
            else
                layoutElement.SetLayoutBoundsSize(newWidth, rowHeight);
        }

 private static float CalculatePercentHeight(ILayoutElement layoutElement, float height)
 {
     float percentHeight = Mathf.Clamp(Mathf.Round((float)(layoutElement.PercentHeight * 0.01f * height)),
                                      LayoutUtil.GetMinBoundsHeight((InvalidationManagerClient)layoutElement),
                                      LayoutUtil.GetMaxBoundsHeight((InvalidationManagerClient)layoutElement));
     return percentHeight < height ? percentHeight : height;
 }

 protected LayoutFloatingWindowControl(ILayoutElement model)
 {
     this.Loaded += new RoutedEventHandler(OnLoaded);
     this.Unloaded += new RoutedEventHandler(OnUnloaded);
     _model = model;
     UpdateThemeResources();
 }

        /// <summary>
        /// Get the input element that was focused before user left the layout element
        /// </summary>
        /// <param name="model">Element to look for</param>
        /// <returns>Input element </returns>
        internal static IInputElement GetLastFocusedElement(ILayoutElement model)
        {
            IInputElement objectWithFocus;
            if (_modelFocusedElement.GetValue(model, out objectWithFocus))
                return objectWithFocus;

            return null;
        }

 private void ShowProp(ref Rect labelRect, ref Rect valueRect, ref Rect sourceRect, string label, string value, ILayoutElement source)
 {
   GUI.Label(labelRect, label, this.m_Styles.labelStyle);
   GUI.Label(valueRect, value, this.m_Styles.labelStyle);
   GUI.Label(sourceRect, source != null ? source.GetType().Name : "none", this.m_Styles.labelStyle);
   labelRect.y += EditorGUIUtility.singleLineHeight;
   valueRect.y += EditorGUIUtility.singleLineHeight;
   sourceRect.y += EditorGUIUtility.singleLineHeight;
 }

 BaseInfo ConvertLayoutElement(ILayoutElement e)
 {
     if (e is LayoutPanel)
     {
         var panel = e as LayoutPanel;
         var sp = new LayoutPanelInfo
         {
             Width = new GridLengthInfo {Unit = panel.DockWidth.GridUnitType, Value = panel.DockWidth.Value},
             Height = new GridLengthInfo {Unit = panel.DockHeight.GridUnitType, Value = panel.DockHeight.Value}
         };
         foreach (var x in panel.Children)
         {
             sp.Children.Add(ConvertLayoutElement(x));
         }
         return sp;
     }
     else if (e is LayoutRoot)
     {
         var root = e as LayoutRoot;
         var sp = new LayoutRootInfo {Center = (LayoutPanelInfo) ConvertLayoutElement(root.RootPanel)};
         return sp;
     }
     else if (e is LayoutDocumentPane)
     {
         var doc = e as LayoutDocumentPane;
         var sp = new DocumentPaneInfo
         {
             Width = new GridLengthInfo {Unit = doc.DockWidth.GridUnitType, Value = doc.DockWidth.Value},
             Height = new GridLengthInfo {Unit = doc.DockHeight.GridUnitType, Value = doc.DockHeight.Value}
         };
         sp.Content.AddRange(ConvertViews(doc.Children));
         return sp;
     }
     else if (e is LayoutDocumentPaneGroup)
     {
         var doc = e as LayoutDocumentPaneGroup;
         var sp = new LayoutDocumentPaneGroupInfo
         {
             Width = new GridLengthInfo {Unit = doc.DockWidth.GridUnitType, Value = doc.DockWidth.Value},
             Height = new GridLengthInfo {Unit = doc.DockHeight.GridUnitType, Value = doc.DockHeight.Value},
             Orientation = doc.Orientation
         };
         foreach (var x in doc.Children)
         {
             sp.Children.Add(ConvertLayoutElement(x));
         }
         return sp;
     }
     else
         throw new NotSupportedException();
 }

        public static float GetLayoutProperty(RectTransform rect, System.Func<ILayoutElement, float> property, float defaultValue, out ILayoutElement source)
        {
            source = null;
            if (rect == null)
                return 0;
            float min = defaultValue;
            int maxPriority = System.Int32.MinValue;
            var components = ComponentListPool.Get();
            rect.GetComponents(typeof(ILayoutElement), components);

            for (int i = 0; i < components.Count; i++)
            {
                var layoutComp = components[i] as ILayoutElement;
                if (layoutComp is Behaviour && !(layoutComp as Behaviour).enabled)
                    continue;

                int priority = layoutComp.layoutPriority;
                // If this layout components has lower priority than a previously used, ignore it.
                if (priority < maxPriority)
                    continue;
                float prop = property(layoutComp);
                // If this layout property is set to a negative value, it means it should be ignored.
                if (prop < 0)
                    continue;

                // If this layout component has higher priority than all previous ones,
                // overwrite with this one's value.
                if (priority > maxPriority)
                {
                    min = prop;
                    maxPriority = priority;
                    source = layoutComp;
                }
                // If the layout component has the same priority as a previously used,
                // use the largest of the values with the same priority.
                else if (prop > min)
                {
                    min = prop;
                    source = layoutComp;
                }
            }

            ComponentListPool.Release(components);
            return min;
        }

 /**
  *  
  * 
  *  Used only for virtual layout.
  */
 private float? CalculateElementWidth(ILayoutElement elt, float targetWidth, float containerWidth)
 {
    // If percentWidth is specified then the element's width is the percentage
    // of targetWidth clipped to min/maxWidth and to (upper limit) targetWidth.
    float? percentWidth = elt.PercentWidth;
    if (null != percentWidth)
    {
       float width = (float) (percentWidth * 0.01f * targetWidth);
       return Mathf.Min(targetWidth, Mathf.Min(
           LayoutUtil.GetMaxBoundsWidth((InvalidationManagerClient) elt), 
           Mathf.Max(LayoutUtil.GetMinBoundsWidth((InvalidationManagerClient)elt), 
           width
         )));
    }
    switch(_horizontalAlign)
    {
        case HorizontalAlign.Justify: 
            return targetWidth;
        case HorizontalAlign.ContentJustify:
            return Mathf.Max(LayoutUtil.GetPreferredBoundsWidth((InvalidationManagerClient) elt), containerWidth);
    }
    return null;  // not constrained
 }

 public abstract void ReplaceChild(ILayoutElement oldElement, ILayoutElement newElement);

 public abstract void RemoveChild(ILayoutElement element);

 public static float GetLayoutProperty(RectTransform rect, Func<ILayoutElement, float> property, float defaultValue, out ILayoutElement source)
 {
   source = (ILayoutElement) null;
   if ((UnityEngine.Object) rect == (UnityEngine.Object) null)
     return 0.0f;
   float num1 = defaultValue;
   int num2 = int.MinValue;
   List<Component> componentList = ListPool<Component>.Get();
   rect.GetComponents(typeof (ILayoutElement), componentList);
   for (int index = 0; index < componentList.Count; ++index)
   {
     ILayoutElement layoutElement = componentList[index] as ILayoutElement;
     if (!(layoutElement is Behaviour) || ((Behaviour) layoutElement).isActiveAndEnabled)
     {
       int layoutPriority = layoutElement.layoutPriority;
       if (layoutPriority >= num2)
       {
         float num3 = property(layoutElement);
         if ((double) num3 >= 0.0)
         {
           if (layoutPriority > num2)
           {
             num1 = num3;
             num2 = layoutPriority;
             source = layoutElement;
           }
           else if ((double) num3 > (double) num1)
           {
             num1 = num3;
             source = layoutElement;
           }
         }
       }
     }
   }
   ListPool<Component>.Release(componentList);
   return num1;
 }

        /// <summary>
        /// Given a layout element tries to set the focus of the keyword where it was before user moved to another element
        /// </summary>
        /// <param name="model"></param>
        internal static void SetFocusOnLastElement(ILayoutElement model)
        {
            bool focused = false;
            IInputElement objectToFocus;
            if (_modelFocusedElement.GetValue(model, out objectToFocus))
            {
                focused = objectToFocus == Keyboard.Focus(objectToFocus);
            }

            IntPtr handleToFocus;
            if (_modelFocusedWindowHandle.GetValue(model, out handleToFocus))
                focused = IntPtr.Zero != Win32Helper.SetFocus(handleToFocus);


            if (focused)
            {
                _lastFocusedElement = new WeakReference(model);
            }

        }

 /**
  *  
  *  Fills in the result with preferred and min sizes of the element.
  */
 private void GetElementWidth(ILayoutElement element, float? fixedColumnWidth, SizesAndLimit result)
 {
     // Calculate preferred height first, as it's being used to calculate min height below
     float elementPreferredWidth = fixedColumnWidth ?? Mathf.Ceil(LayoutUtil.GetPreferredBoundsWidth((InvalidationManagerClient)element));
     // Calculate min height
     bool flexibleWidth = null != element.PercentWidth;
     float elementMinWidth = flexibleWidth ? Mathf.Ceil(LayoutUtil.GetMinBoundsWidth((InvalidationManagerClient)element)) :
                                                    elementPreferredWidth;
     result.PreferredSize = elementPreferredWidth;
     result.MinSize = elementMinWidth;
 }

		public override void ReplaceChild(ILayoutElement oldElement, ILayoutElement newElement)
		{
			Debug.Assert(oldElement == RootPanel && oldElement != null);
			RootPanel = newElement as LayoutAnchorablePaneGroup;
		}

 public override void ReplaceChild(ILayoutElement oldElement, ILayoutElement newElement)
 {
     Debug.Assert(oldElement == RootDocument && oldElement != null);
     RootDocument = newElement as LayoutDocument;
 }

        public void RemoveChild(ILayoutElement element)
        {
            if (element == RootPanel)
                RootPanel = null;
            else if (_floatingWindows != null && _floatingWindows.Contains(element))
                _floatingWindows.Remove(element as LayoutFloatingWindow);
            else if (_hiddenAnchorables != null && _hiddenAnchorables.Contains(element))
                _hiddenAnchorables.Remove(element as LayoutAnchorable);
            else if (element == TopSide)
                TopSide = null;
            else if (element == RightSide)
                RightSide = null;
            else if (element == BottomSide)
                BottomSide = null;
            else if (element == LeftSide)
                LeftSide = null;

        }

 private static bool ConstraintsDetermineWidth(ILayoutElement layoutElement)
 {
     return null != layoutElement.PercentWidth ||
            null != layoutElement.GetConstraintValue("left") &&
            null != layoutElement.GetConstraintValue("right");
 }