C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/StateManager/ScreenManager.cs

//-----------------------------------------------------------------------------
// ScreenManager.cs
// (Based on XNA Community Game Platform Demo, Microsoft Corp., 2008)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.StateManager
{
    using System.Collections.Generic;
    using System.Diagnostics;

    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Media;

    using NewGamePhysics.Utilities;

    public class ScreenManager : DrawableGameComponent
    {
        #region Fields

        private List<GameScreen> screens = new List<GameScreen>();

        private List<GameScreen> screensToUpdate = new List<GameScreen>();

        private InputState input = new InputState();

        private SpriteBatch spriteBatch;

        private PrimitiveBatch primitiveBatch;

        private VideoPlayer videoPlayer;

        private Dictionary<string, Texture2D> textures;

        private Dictionary<string, SpriteFont> fonts;

        private Dictionary<string, Model> models;

        private Dictionary<string, SoundEffect> sounds;

        private AudioEngine engine;

        private SoundBank soundBank;

        private WaveBank waveBank;

        private bool isInitialized;

        private bool traceEnabled;

        #endregion

        #region Properties

        public SpriteBatch SpriteBatch
        {
            get { return this.spriteBatch; }
        }

        public PrimitiveBatch PrimitiveBatch
        {
            get { return this.primitiveBatch; }
        }

        public VideoPlayer VideoPlayer
        {
            get { return this.videoPlayer; }
        }

        public Dictionary<string, Texture2D> Textures
        {
            get { return this.textures; }
        }

        public Dictionary<string, SpriteFont> Fonts
        {
            get { return this.fonts; }
        }

        public Dictionary<string, Model> Models
        {
            get { return this.models; }
        }

        public Dictionary<string, SoundEffect> Sounds
        {
            get { return this.sounds; }
        }

        public SoundBank SoundBank
        {
            get { return this.soundBank; }
        }

        public bool TraceEnabled
        {
            get { return this.traceEnabled; }
            set { this.traceEnabled = value; }
        }

        #endregion

        #region Initialization

        public ScreenManager(Game game)
            : base(game)
        {
        }

        public override void Initialize()
        {
            base.Initialize();

            // Initialize audio objects.
            this.engine = new AudioEngine("Content\\Sounds\\audio.xgs");
            this.soundBank = new SoundBank(engine, "Content\\Sounds\\Sound Bank.xsb");
            this.waveBank = new WaveBank(engine, "Content\\Sounds\\Wave Bank.xwb");

            isInitialized = true;
        }

        protected override void LoadContent()
        {
            // Load content belonging to the screen manager.
            ContentManager content = Game.Content;
            this.spriteBatch = new SpriteBatch(GraphicsDevice);
            this.primitiveBatch = new PrimitiveBatch(GraphicsDevice);
            this.videoPlayer = new VideoPlayer();

            // Prepare caches
            this.textures = new Dictionary<string, Texture2D>();
            this.fonts = new Dictionary<string, SpriteFont>();
            this.models = new Dictionary<string, Model>();
            this.sounds = new Dictionary<string, SoundEffect>();

            // Prep font cache
            this.fonts.Add("menu", content.Load<SpriteFont>(@"Fonts\menufont"));
            this.fonts.Add("game", content.Load<SpriteFont>(@"Fonts\gamefont"));
            this.fonts.Add("small", content.Load<SpriteFont>(@"Fonts\smallfont"));
            
            // Prep texture cache
            this.textures.Add("blank",content.Load<Texture2D>(@"Sprites\blank"));

            // Tell each of the screens to load their content.
            foreach (GameScreen screen in screens)
            {
                screen.LoadContent();
            }
        }

        protected override void UnloadContent()
        {
            // Tell each of the screens to unload their content.
            foreach (GameScreen screen in screens)
            {
                screen.UnloadContent();
            }
        }

        #endregion

        #region Update and Draw

        public override void Update(GameTime gameTime)
        {
            // Read the keyboard and gamepad.
            this.input.Update();

            // Update the sound engine
            this.engine.Update();

            // Make a copy of the master screen list, to avoid confusion if
            // the process of updating one screen adds or removes others.
            screensToUpdate.Clear();

            foreach (GameScreen screen in screens)
            {
                screensToUpdate.Add(screen);
            }

            bool otherScreenHasFocus = !Game.IsActive;
            bool coveredByOtherScreen = false;

            // Loop as long as there are screens waiting to be updated.
            while (screensToUpdate.Count > 0)
            {
                // Pop the topmost screen off the waiting list.
                GameScreen screen = screensToUpdate[screensToUpdate.Count - 1];

                screensToUpdate.RemoveAt(screensToUpdate.Count - 1);

                // Update the screen.
                screen.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

                if (screen.ScreenState == ScreenState.TransitionOn ||
                    screen.ScreenState == ScreenState.Active)
                {
                    // If this is the first active screen we came across,
                    // give it a chance to handle input.
                    if (!otherScreenHasFocus)
                    {
                        screen.HandleInput(input);

                        otherScreenHasFocus = true;
                    }

                    // If this is an active non-popup, inform any subsequent
                    // screens that they are covered by it.
                    if (!screen.IsPopup)
                    {
                        coveredByOtherScreen = true;
                    }
                }
            }

            // Print debug trace?
            if (traceEnabled)
            {
                TraceScreens();
            }
        }

        void TraceScreens()
        {
            List<string> screenNames = new List<string>();

            foreach (GameScreen screen in screens)
            {
                screenNames.Add(screen.GetType().Name);
            }

            Trace.WriteLine(string.Join(", ", screenNames.ToArray()));
        }

        public override void Draw(GameTime gameTime)
        {
            foreach (GameScreen screen in screens)
            {
                if (screen.ScreenState == ScreenState.Hidden)
                {
                    continue;
                }

                screen.Draw(gameTime);
            }
        }

        #endregion
        
        #region Public Methods

        public void AddTexture(string textureKey, string texturePath)
        {
            if (!this.textures.ContainsKey(textureKey))
            {
                this.textures.Add(textureKey, Game.Content.Load<Texture2D>(texturePath));
            }
        }

        public void AddFont(string fontKey, string fontPath)
        {
            if (!this.fonts.ContainsKey(fontKey))
            {
                this.fonts.Add(fontKey, Game.Content.Load<SpriteFont>(fontPath));
            }
        }

        public void AddSound(string soundKey, string soundPath)
        {
            if (!this.sounds.ContainsKey(soundKey))
            {
                this.sounds.Add(soundKey, Game.Content.Load<SoundEffect>(soundPath));
            }
        }

        public void AddScreen(GameScreen screen, PlayerIndex? controllingPlayer)
        {
            screen.ControllingPlayer = controllingPlayer;
            screen.ScreenManager = this;
            screen.IsExiting = false;

            // If we have a graphics device, tell the screen to load content.
            if (isInitialized)
            {
                screen.LoadContent();
            }

            screens.Add(screen);
        }

        public void RemoveScreen(GameScreen screen)
        {
            // If we have a graphics device, tell the screen to unload content.
            if (isInitialized)
            {
                screen.UnloadContent();
            }

            screens.Remove(screen);
            screensToUpdate.Remove(screen);
        }

        public GameScreen[] GetScreens()
        {
            return screens.ToArray();
        }

        public void FadeBackBufferToBlack(int alpha)
        {
            Viewport viewport = GraphicsDevice.Viewport;

            spriteBatch.Begin();

            spriteBatch.Draw(this.Textures["blank"],
                             new Rectangle(0, 0, viewport.Width, viewport.Height),
                             new Color(0, 0, 0, (byte)alpha));

            spriteBatch.End();
        }

        public void SetVolume(string category, float volume)
        {
            AudioCategory musicCategory = this.engine.GetCategory(category);
            if (null != musicCategory)
            {
                musicCategory.SetVolume(volume);
            }
        }

        #endregion
    }
}

---