VisXnaConrol.cs

#region Using Statements
using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.Xna.Framework.Graphics;
#endregion

namespace visLU
{
    //use System.Drawing.Color and Microsoft.Xna.Framework.Rectangle definitions
    using Color = System.Drawing.Color;
    using Rectangle = Microsoft.Xna.Framework.Rectangle;

    abstract public class VisXnaConrol: Control
    {
        #region Variables
        VisGraphicsDevice visGraphicsDevice;
        VisServiceContainer services = new VisServiceContainer();
        public bool swapBuffers = true;
       
       
        #endregion

        #region Properties
        public GraphicsDevice GraphicsDevice
        {
            get { return visGraphicsDevice.GraphicsDevice; }
        }

        public VisServiceContainer Services
        {
            get { return services; }
        }
        #endregion

        #region Initialize


        protected override void OnCreateControl()
        {
            // Don't initialize the graphics device if we are running in the designer.
            if (!DesignMode)
            {
                visGraphicsDevice = VisGraphicsDevice.Add(Handle, ClientSize.Width, ClientSize.Height);
               
                // Register the service, so components like ContentManager can find it.
                
                services.AddService<IGraphicsDeviceService>(visGraphicsDevice);
                // Give derived classes a chance to initialize themselves. 

                Initialize();
                LoadContent();

                //Update();
            }

            base.OnCreateControl();
        }


        protected override void Dispose(bool disposing)
        {
            if (visGraphicsDevice != null)
            {
                visGraphicsDevice.Release(disposing);
                visGraphicsDevice = null;
            }

            base.Dispose(disposing);
        }


        #endregion

        #region Windows Form Update 
        protected override void OnInvalidated(InvalidateEventArgs e)
        {
            //Update();
            base.OnInvalidated(e);
            Console.WriteLine("Call OnInvalidated");
            //Console.WriteLine(System.Environment.StackTrace);
            //base.Update();


        }

        /*public override void Refresh()
        {
            //Update();
            base.Refresh();
        }*/
        #endregion

        #region resize
        //implement onResize Event
        #endregion

        #region Windows Form Paint
        protected override void OnPaint(PaintEventArgs e)
        {
            Console.WriteLine("Call OnPaint");
            Update();
            //call update for the child controls
            //if (Controls.Count > 0)
            //{
              //  Console.WriteLine("Child: " + Controls.Count);
                /*foreach (Control c in Controls)
                {
                    if(c.GetType().Equals("Data"))
                         ((Data)c).Update();
                    
                }*/
            //}

            string beginDrawError = BeginDraw(); //xna BeginDraw

            if (string.IsNullOrEmpty(beginDrawError))
            {
                // Draw the control using the GraphicsDevice.
                Draw(); //xna Draw
                EndDraw(); //xna EndDraw
            }
            else
            {
                // If BeginDraw failed, show an error message using System.Drawing.
                PaintUsingSystemDrawing(e.Graphics, beginDrawError);
            }

            //todo: call draw for all child controls
        }


        string BeginDraw()
        {
            // If we have no graphics device, we must be running in the designer.
            if (visGraphicsDevice == null)
            {
                return Text + "\n\n" + GetType();
            }

            // Make sure the graphics device is big enough, and is not lost.
            string deviceResetError = HandleDeviceReset();

            if (!string.IsNullOrEmpty(deviceResetError))
            {
                return deviceResetError;
            }

            // Many GraphicsDeviceControl instances can be sharing the same
            // GraphicsDevice. The device backbuffer will be resized to fit the
            // largest of these controls. But what if we are currently drawing
            // a smaller control? To avoid unwanted stretching, we set the
            // viewport to only use the top left portion of the full backbuffer.
            Viewport viewport = new Viewport();

            viewport.X = 0;
            viewport.Y = 0;

            viewport.Width = ClientSize.Width;
            viewport.Height = ClientSize.Height;

            viewport.MinDepth = 0;
            viewport.MaxDepth = 1;

            GraphicsDevice.Viewport = viewport;

            return null;
        }


        void EndDraw()
        {
            if (swapBuffers)
            {


                try
                {
                    Rectangle sourceRectangle = new Rectangle(0, 0, ClientSize.Width,
                                                                    ClientSize.Height);

                    GraphicsDevice.Present(sourceRectangle, null, this.Handle);
                    //GraphicsDevice.Present();
                }
                catch
                {
                    // Present might throw if the device became lost while we were
                    // drawing. The lost device will be handled by the next BeginDraw,
                    // so we just swallow the exception.
                }
            }
            else 
            {
                swapBuffers = true;
            }
        }


        string HandleDeviceReset()
        {
            bool deviceNeedsReset = false;

            switch (GraphicsDevice.GraphicsDeviceStatus)
            {
                case GraphicsDeviceStatus.Lost:
                    // If the graphics device is lost, we cannot use it at all.
                    return "Graphics device lost";

                case GraphicsDeviceStatus.NotReset:
                    // If device is in the not-reset state, we should try to reset it.
                    deviceNeedsReset = true;
                    break;

                default:
                    // If the device state is ok, check whether it is big enough.
                    PresentationParameters pp = GraphicsDevice.PresentationParameters;

                    deviceNeedsReset = (ClientSize.Width > pp.BackBufferWidth) ||
                                       (ClientSize.Height > pp.BackBufferHeight);
                    break;
            }

            // Do we need to reset the device?
            if (deviceNeedsReset)
            {
                try
                {
                    visGraphicsDevice.ResetDevice(ClientSize.Width,
                                                      ClientSize.Height);
                }
                catch (Exception e)
                {
                    return "Graphics device reset failed\n\n" + e;
                }
            }

            return null;
        }


        protected virtual void PaintUsingSystemDrawing(Graphics graphics, string text)
        {
            graphics.Clear(Color.CornflowerBlue);

            using (Brush brush = new SolidBrush(Color.Black))
            {
                using (StringFormat format = new StringFormat())
                {
                    format.Alignment = StringAlignment.Center;
                    format.LineAlignment = StringAlignment.Center;

                    graphics.DrawString(text, Font, brush, ClientRectangle, format);
                }
            }
        }


        protected override void OnPaintBackground(PaintEventArgs pevent)
        {
        }


        #endregion

        #region Control Properties Events
        protected override void OnSizeChanged(EventArgs e)
        { 
            base.OnSizeChanged(e);
            //Update();
        }
        #endregion

        //methods to implement in the engine and data classes
        #region Abstract Methods

        protected abstract void Initialize();
        protected abstract void LoadContent();
        protected abstract new void Update();
        protected abstract void Draw();
        
        #endregion
    }
}