Window.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using System.ComponentModel;
using Microsoft.Xna.Framework.Graphics;
using System.Windows.Forms;

namespace Jypeli
{
    public class JypeliWindow
    {
        class SizeParams
        {
            public int Width;
            public int Height;
            public bool Fullscreen;

            public SizeParams(int w, int h, bool f)
            {
                this.Width = w;
                this.Height = h;
                this.Fullscreen = f;
            }
        }

        public delegate void MoveEvent( int oldX, int oldY, int newX, int newY );

        public delegate void ResizeEvent(int oldWidth, int oldHeight, int newWidth, int newHeight);

#if WINDOWS
        System.Windows.Forms.Form form;
#endif

        GameWindow gwin;
        GraphicsDeviceManager gdm;

        Point? lastPosition;
        Point? desiredPosition = null;

        SizeParams lastSize = null;
        SizeParams desiredSize = null;

        #region Events for XNA compatibility

        [EditorBrowsable( EditorBrowsableState.Never )]
        public event EventHandler<EventArgs> ClientSizeChanged;

        [EditorBrowsable( EditorBrowsableState.Never )]
        public event EventHandler<EventArgs> OrientationChanged;

        [EditorBrowsable( EditorBrowsableState.Never )]
        public event EventHandler<EventArgs> ScreenDeviceNameChanged;

        protected void OnXnaMethod( EventHandler<EventArgs> method, object sender, EventArgs args )
        {
            if ( method != null )
                method( sender, args );
        }

        #endregion

        public event Action EnterFullscreen;

        public event Action ExitFullscreen;

        public event MoveEvent Moved;

        public event ResizeEvent Resizing;

        public event ResizeEvent Resized;

        public bool AllowUserResizing
        {
            get { return gwin.AllowUserResizing; }
            set { gwin.AllowUserResizing = value; }
        }

        public DisplayOrientation CurrentOrientation
        {
            get { return gwin.CurrentOrientation; }
        }

        public string Title
        {
            get { return gwin.Title; }
            set { gwin.Title = value; }
        }

        public int Width
        {
            get { return desiredSize != null ? desiredSize.Width : gwin.ClientBounds.Width; }
            set
            {
                MakeDesiredParams();
                desiredSize.Width = Math.Max( 1, value );
                OnResizing( desiredSize );
            }
        }

        public int Height
        {
            get { return desiredSize != null ? desiredSize.Height : gwin.ClientBounds.Height; }
            set
            {
                MakeDesiredParams();
                desiredSize.Height = Math.Max( 1, value );
                OnResizing( desiredSize );
            }
        }

        public bool Fullscreen
        {
            get { return desiredSize != null ? desiredSize.Fullscreen : gdm.IsFullScreen; }
            set
            {
                MakeDesiredParams();
                desiredSize.Fullscreen = value;
            }
        }

        public IntPtr Handle
        {
            get { return gwin.Handle; }
        }

        public string ScreenDeviceName
        {
            get { return gwin.ScreenDeviceName; }
        }

        public int Left
        {
            get
            {
#if WINDOWS
                return desiredPosition.HasValue ? desiredPosition.Value.X : form.Left;
#else
                return 0;
#endif
            }
            set
            {
                desiredPosition = new Point( value, Top );
            }
        }

        public int Top
        {
            get
            {
#if WINDOWS
                return desiredPosition.HasValue ? desiredPosition.Value.Y : form.Top;
#else
                return 0;
#endif
            }
            set
            {
                desiredPosition = new Point( Left, value );
            }
        }

        public int Right
        {
            get { return Left + Width; }
            set { Left = value - Width; }
        }

        public int Bottom
        {
            get { return Top + Height; }
            set { Top = value - Height; }
        }

        public int X
        {
            get { return Left + Width / 2; }
            set { Left = value - Width / 2; }
        }

        public int Y
        {
            get { return Top + Height / 2; }
            set { Top = value - Height / 2; }
        }

        internal JypeliWindow( GameWindow gameWindow, GraphicsDeviceManager graphicsDeviceManager )
        {
            this.gwin = gameWindow;
            this.gdm = graphicsDeviceManager;



            gameWindow.ClientSizeChanged += ( o, a ) => OnXnaMethod( this.ClientSizeChanged, o, a );
            gameWindow.OrientationChanged += ( o, a ) => OnXnaMethod( this.OrientationChanged, o, a );
            gameWindow.ScreenDeviceNameChanged += ( o, a ) => OnXnaMethod( this.ScreenDeviceNameChanged, o, a );
            gameWindow.ClientSizeChanged += ( o, a ) => OnResized();

#if WINDOWS
            form = (System.Windows.Forms.Form)System.Windows.Forms.Control.FromHandle( gameWindow.Handle );
            form.Move += (o, a) => OnMove();
#endif
        }

        private void MakeDesiredParams()
        {
            if ( desiredSize == null )
                desiredSize = new SizeParams( gwin.ClientBounds.Width, gwin.ClientBounds.Height, gdm.IsFullScreen );
        }

        private void OnMove( SizeParams newParams = null )
        {
            if ( Moved == null || !lastPosition.HasValue )
                return;

#if WINDOWS
            Moved( lastPosition.Value.X + Width / 2, lastPosition.Value.Y - Height / 2, form.Left + form.Width / 2, form.Top - form.Height / 2 );
#endif
        }

        private void OnResizing( SizeParams newParams )
        {
            if ( Resizing == null )
                return;

            if ( newParams.Width != gwin.ClientBounds.Width || newParams.Height != gwin.ClientBounds.Height )
                Resizing( gwin.ClientBounds.Width, gwin.ClientBounds.Height, newParams.Width, newParams.Height );
        }

        private void OnResized( SizeParams newParams = null )
        {
            if ( Resized == null )
                return;

            int newWidth = newParams != null ? newParams.Width : gwin.ClientBounds.Width;
            int newHeight = newParams != null ? newParams.Height : gwin.ClientBounds.Height;

            if ( newWidth != lastSize.Width || newHeight != lastSize.Height )
                Resized( lastSize.Width, lastSize.Height, newWidth, newHeight );
        }

        private void OnFullscreen( SizeParams newParams = null )
        {
            bool newFullscreen = newParams != null ? newParams.Fullscreen : gdm.IsFullScreen;

            if ( EnterFullscreen != null && !lastSize.Fullscreen && newFullscreen )
                EnterFullscreen();

            else if ( ExitFullscreen != null && lastSize.Fullscreen && !newFullscreen )
                ExitFullscreen();
        }

        #region Methods for XNA compatibility

        public Microsoft.Xna.Framework.Rectangle ClientBounds
        {
            get { return gwin.ClientBounds; }
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        public void BeginScreenDeviceChange( bool willBeFullScreen )
        {
            gwin.BeginScreenDeviceChange( willBeFullScreen );
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        public void EndScreenDeviceChange( string screenDeviceName, int clientWidth, int clientHeight )
        {
            gwin.EndScreenDeviceChange( screenDeviceName, clientWidth, clientHeight );
        }

        #endregion

        public void Update()
        {
            if ( lastSize == null )
                lastSize = new SizeParams( gwin.ClientBounds.Width, gwin.ClientBounds.Height, gdm.IsFullScreen );
            else
            {
                lastSize.Width = gwin.ClientBounds.Width;
                lastSize.Height = gwin.ClientBounds.Height;
                lastSize.Fullscreen = gdm.IsFullScreen;
            }

#if WINDOWS
            lastPosition = new Point( form.Left, form.Top );
#endif

            if ( desiredSize != null )
            {
                xnaSetWindowSize( desiredSize );
                OnResized( desiredSize );
                OnFullscreen( desiredSize );
                desiredSize = null;
            }

#if WINDOWS
            if (desiredPosition.HasValue)
            {
                form.Left = this.Left;
                form.Top = this.Top;
                desiredPosition = null;
            }
#endif

        }

        private void xnaSetWindowSize( SizeParams newParams )
        {
            gdm.PreferredBackBufferWidth = newParams.Width;
            gdm.PreferredBackBufferHeight = newParams.Height;
            gdm.IsFullScreen = newParams.Fullscreen;
            gdm.ApplyChanges();
        }

#if WINDOWS
        public void CenterOnScreen()
        {
            int x = (Screen.PrimaryScreen.Bounds.Width - gwin.ClientBounds.Width) / 2;
            int y = (Screen.PrimaryScreen.Bounds.Height - gwin.ClientBounds.Height) / 2;

            Control formControl = Control.FromHandle(Handle);

            if (formControl == null)
                return;

            Form form = (Form)formControl;
            form.DesktopLocation = new System.Drawing.Point(x, y);
        }
#endif
    }
}