Beispiel #1
0
        protected virtual IEnumerable <KeyValuePair <IVisualElement, ValueRenderRectangle> > GetRenderables(
            Orientations orientation,
            IRenderRectangle bounds)
        {
            lock (_measureLock)
            {
                var current = ValueRenderRectangle.Empty;

                foreach (var child in _currentlyRendering)
                {
                    current = GetElementBounds(child, current);

                    current = GetElementRenderBounds(child, current, orientation,
                                                     bounds);

                    yield return(new KeyValuePair <IVisualElement, ValueRenderRectangle>(child, current));
                }
            }
        }
Beispiel #2
0
 public static Boolean AreRenderRectsEquals <TRect>(TRect left,
                                                    IRenderRectangle right)
     where TRect : IRenderRectangle
 {
     return(AreRectsEqual(left, right) && left.Size.Offset.Equals(right.Size.Offset));
 }
Beispiel #3
0
        private static ValueRenderRectangle GetElementRenderBounds(IVisualElement child,
                                                                   ValueRenderRectangle current,
                                                                   Orientations orientation,
                                                                   IRenderRectangle bounds)
        {
            var useX = current.X;
            var useY = current.Y;

            switch (orientation)
            {
            case Orientations.Vertical:
                // may need to adjust the X based on alignment

                var useHorzAlign = child.HorizontalAlignment;

                switch (useHorzAlign)
                {
                case HorizontalAlignments.Right:
                    useX += bounds.Width - current.Width;
                    break;

                case HorizontalAlignments.Center:
                    useX += (bounds.Width - current.Width) / 2;
                    break;

                case HorizontalAlignments.Left:
                case HorizontalAlignments.Default:
                case HorizontalAlignments.Stretch:

                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }

                break;

            case Orientations.Horizontal:

                var useVertAlign = child.VerticalAlignment;

                switch (useVertAlign)
                {
                case VerticalAlignments.Bottom:
                    useY += bounds.Height - current.Height;
                    break;

                case VerticalAlignments.Center:
                    useY += (bounds.Height - current.Height) / 2;
                    break;

                case VerticalAlignments.Top:
                case VerticalAlignments.Default:
                case VerticalAlignments.Stretch:

                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                break;
            }

            current = new ValueRenderRectangle(useX, useY,
                                               //bounds.Width, //this draws things (picture frame) too wide
                                               current.Width,
                                               current.Height, current.Offset);

            return(current);
        }
 public ValueRenderRectangle(IRenderRectangle rect,
                             Thickness?padding)
     : this(rect.Location, rect.Size, rect.Size.Offset, padding)
 {
 }
 public Boolean Equals(IRenderRectangle other)
 {
     return(GeometryHelper.AreRenderRectsEquals(this, other));
 }