Layout.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli.GameObjects;

namespace Jypeli
{
    public partial class GameObject
    {
        private ILayout _layout = null;

        private Sizing _horizontalSizing = Sizing.FixedSize;
        private Sizing _verticalSizing = Sizing.FixedSize;
        private Vector _preferredSize = new Vector( 50, 50 );
        private bool _sizeByLayout = true;
        private bool _layoutNeedsRefreshing = false;

        public virtual Sizing HorizontalSizing
        {
            get
            {
                if ( SizingByLayout && ( Layout != null ) )
                    return Layout.HorizontalSizing;
                return _horizontalSizing;
            }
            set
            {
                _horizontalSizing = value;
                NotifyParentAboutChangedSizingAttributes();
            }
        }

        public virtual Sizing VerticalSizing
        {
            get
            {
                if ( SizingByLayout && ( Layout != null ) )
                    return Layout.VerticalSizing;
                return _verticalSizing;
            }
            set
            {
                _verticalSizing = value;
                NotifyParentAboutChangedSizingAttributes();
            }
        }

        public virtual Vector PreferredSize
        {
            get
            {
                if ( Layout != null )
                    return Layout.PreferredSize;
                return _preferredSize;
            }
            set
            {
                _preferredSize = value;
                NotifyParentAboutChangedSizingAttributes();
            }
        }

        public bool SizingByLayout
        {
            get { return _sizeByLayout; }
            set { _sizeByLayout = value; }
        }

        internal protected void NotifyParentAboutChangedSizingAttributes()
        {
            if ( Parent == null )
            {
                _layoutNeedsRefreshing = true;
            }
            else if ( Parent is GameObject )
            {
                ( (GameObject)Parent ).NotifyParentAboutChangedSizingAttributes();
            }
        }

        public ILayout Layout
        {
            get { return _layout; }
            set
            {
                if ( _layout != null )
                {
                    ILayout old = _layout;
                    _layout = null;
                    old.Parent = null;
                }

                InitChildren();
                _layout = value;
                _layout.Parent = this;
                NotifyParentAboutChangedSizingAttributes();
            }
        }

        public void InitLayout( double width, double height )
        {
            autoResizeChildObjects = false;
            this.PreferredSize = new Vector( width, height );
        }

        public void InitLayout( double width, double height, ILayout layout )
        {
            this.Layout = layout;
            InitLayout( width, height );
        }

        public void RefreshLayout()
        {
            if ( Layout != null )
            {
                _childObjects.UpdateChanges();

                // First, lets ask how big the child objects need to be.
                UpdateSizeHints();

                // Then, lets set the size accordingly, if we are allowed to do so.
                if ( SizingByLayout )
                {
                    Vector newSize = Layout.PreferredSize;
                    Vector maxSize = this.GetMaximumSize();

                    if ( newSize.X > maxSize.X )
                        newSize.X = maxSize.X;
                    if ( newSize.Y > maxSize.Y )
                        newSize.Y = maxSize.Y;

                    _size = newSize;
                }

                // Finally, lets position the child objects into the space we have available
                // for them.
                UpdateLayout( _size );
            }
        }

        private void UpdateSizeHints()
        {
            if ( _childObjects == null ) return;

            foreach ( var child in _childObjects )
            {
                child.UpdateSizeHints();
            }

            if ( Layout != null )
                Layout.UpdateSizeHints( _childObjects.items );
        }

        private void UpdateLayout( Vector maximumSize )
        {
            if ( Layout != null )
                Layout.Update( Objects.items, maximumSize );

            if ( _childObjects != null )
            {
                foreach ( var child in _childObjects )
                {
                    child.UpdateLayout( child.Size );
                }
            }
        }

        protected virtual Vector GetMaximumSize()
        {
            return new Vector( double.PositiveInfinity, double.PositiveInfinity );
        }
    }
}