MessageDisplay.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009-2011 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */

using System;
using System.ComponentModel;
using System.Collections.Generic;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;

using XnaRect = Microsoft.Xna.Framework.Rectangle;
using XnaColor = Microsoft.Xna.Framework.Color;

namespace Jypeli.Widgets
{
    public class MessageDisplay : Widget
    {
        private struct Message
        {
            public String Text;
            public Color Color;
            public TimeSpan Expires;

            public bool Expired
            {
                get { return Expires < Game.Time.SinceStartOfGame; }
            }

            public TimeSpan TimeLeft
            {
                get { return Expired ? TimeSpan.Zero : Expires - Game.Time.SinceStartOfGame; }
            }

            public Message( string text, Color color, TimeSpan lifetime )
            {
                Text = text;
                Color = color;
                Expires = Game.Time.SinceStartOfGame + lifetime;
            }
        }

        public int MaxMessageCount { get; set; }

        public TimeSpan MessageTime { get; set; }

        public Font Font
        {
            get { return _font; }
            set
            {
                _font = value;
                fontHeight = value.XnaFont.MeasureString( "A" ).Y;
                UpdateTexture();
            }
        }

        public Color TextColor { get; set; }

        public Color BackgroundColor
        {
            get { return bgColor; }
            set
            {
                bgColor = value;
                UpdateTexture();
            }
        }

        public bool RealTime { get; set; }

        private Color bgColor = Color.Transparent;
        private Image bgImage = null;
        private Font _font;
        private float fontHeight;
        private List<Message> messages = new List<Message>();
        private Queue<String> unseen = new Queue<string>();

        private Timer removeTimer;
        
        public MessageDisplay()
            : base( Game.Screen.WidthSafe, Game.Screen.HeightSafe )
        {
            removeTimer = new Timer();
            removeTimer.Timeout += removeMessages;

            TextColor = Color.Black;
            Color = Color.Transparent;

            MaxMessageCount = 20;
            MessageTime = TimeSpan.FromSeconds( 5 );
            Font = Font.Default;

            // default position to top-left-corner
            this.Position = new Vector( Game.Screen.LeftSafe + Game.Screen.WidthSafe / 2,
                                        Game.Screen.TopSafe - Game.Screen.HeightSafe / 2 );
        }

        private void removeMessages()
        {
            removeTimer.Stop();

            while ( messages.Count > 0 && messages[0].Expired )
            {
                messages.RemoveAt( 0 );
                if ( unseen.Count > 0 ) Add( unseen.Dequeue() );
            }

            if ( messages.Count > 0 )
            {
                removeTimer.Interval = messages[0].TimeLeft.TotalSeconds;
                removeTimer.Start();
            }

            UpdateTexture();
        }
        
        protected override void Draw( Matrix parentTransformation, Matrix transformation )
        {
            SpriteBatch spriteBatch = Graphics.SpriteBatch;
            Matrix m =
                Matrix.CreateTranslation( (float)Position.X, (float)Position.Y, 0 )
                * parentTransformation;

            spriteBatch.Begin( SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.Default, RasterizerState.CullCounterClockwise, null, m );

            if ( bgImage != null )
                spriteBatch.Draw( bgImage.XNATexture, Vector2.Zero, XnaColor.White );

            for ( int i = 0; i < messages.Count; i++ )
            {
                spriteBatch.DrawString( this.Font.XnaFont, messages[i].Text, new Vector2( 0, i * fontHeight ), messages[i].Color.AsXnaColor() );
            }

            spriteBatch.End();

            base.Draw( parentTransformation, transformation );
        }

        private void UpdateTexture()
        {
            if ( messages.Count == 0 || bgColor == Color.Transparent )
            {
                bgImage = null;
                return;
            }

            double maxW = 0;

            for ( int i = 0; i < messages.Count; i++ )
            {
                Vector2 dims = Font.XnaFont.MeasureString( messages[i].Text );
                if ( dims.X > maxW ) maxW = dims.X;
            }

            bgImage = new Image( maxW, messages.Count * fontHeight, bgColor );
        }

        public void Add( string message )
        {
            if ( messages.Count > MaxMessageCount )
            {
                if ( RealTime )
                {
                    messages.RemoveRange( 0, messages.Count - MaxMessageCount + 1 );
                }
                else
                {
                    unseen.Enqueue( message );
                    return;
                }
            }

            messages.Add( new Message( message, TextColor, MessageTime ) );
            UpdateTexture();

            if ( !removeTimer.Enabled )
            {
                removeTimer.Interval = MessageTime.TotalSeconds;
                removeTimer.Start();
            }
        }

        public void Add( string message, Color color )
        {
            if ( messages.Count > MaxMessageCount )
            {
                if ( RealTime )
                {
                    messages.RemoveRange( 0, messages.Count - MaxMessageCount + 1 );
                }
                else
                {
                    unseen.Enqueue( message );
                    return;
                }
            }

            messages.Add( new Message( message, color, MessageTime ) );
            UpdateTexture();

            if ( !removeTimer.Enabled )
            {
                removeTimer.Interval = MessageTime.TotalSeconds;
                removeTimer.Start();
            }
        }

        public void Clear()
        {
            messages.Clear();
            UpdateTexture();
        }
    }
}