Label.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: Tomi Karppinen, Tero Jäntti
 */

using System;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Jypeli.Widgets
{
    public enum TextSizeMode
    {
        None,

        AutoSize,

        StretchText,

        Wrapped,
    }


    public class Label : BindableWidget
    {
        Font font;
        string _title = "";
        string originalText = "";
        string visibleText = "";
        TextSizeMode sizeMode = TextSizeMode.None;
        int decimalPlaces = 2;
        string doubleFormatString = "{0:N2}";
        string intFormatString = "{0:D1}";
        string doubleFormatStringWithTitle = "{0:N2}";
        string intFormatStringWithTitle = "{0:D1}";
        double _xMargin;
        private double _yMargin;
        bool useDefaultHeight = false;
        bool initialized = false;

        const double DefaultWidth = 100;

        static double GetDefaultHeight()
        {
            Vector2 fontDims = Font.Default.XnaFont.MeasureString( "A" );
            return fontDims.Y;
        }

        public virtual string Text
        {
            get { return originalText; }
            set
            {
                if ( value == null )
                    throw new ArgumentException( "Text must not be null" );
                originalText = value;
                updateSize();
            }
        }

        public bool IsTruncated
        {
            get { return visibleText.Length < ( originalText.Length ); }
        }
        
        Vector3 _textScale = new Vector3(1, 1, 1);

        public Vector TextScale
        {
            get { return new Vector(_textScale.X, _textScale.Y); }
            set
            {
                _textScale = new Vector3((float)value.X, (float)value.Y, 1.0f);
                updateSize();
            }
        }


        public int DecimalPlaces
        {
            get { return decimalPlaces; }
            set
            {
                decimalPlaces = value;
                DoubleFormatString = "{0:N" + decimalPlaces + "}";
            }
        }


        public string DoubleFormatString
        {
            get { return doubleFormatString; }
            set
            {
                doubleFormatString = value;
                doubleFormatStringWithTitle = Title + ": " + value;
                UpdateValue();
            }
        }


        public string IntFormatString
        {
            get { return intFormatString; }
            set
            {
                intFormatString = value;
                intFormatStringWithTitle = Title + ": " + value;
                UpdateValue();
            }

        }

        public string Title
        {
            get
            {
                return _title;
            }
            set
            {
                _title = value;
                intFormatStringWithTitle = _title == "" ? IntFormatString : value + ": " + IntFormatString;
                doubleFormatStringWithTitle = _title == "" ? DoubleFormatString : value + ": " + DoubleFormatString;
            }
        }

        public TextSizeMode SizeMode
        {
            get { return sizeMode; }
            set { sizeMode = value; updateSize(); }
        }

        public Vector TextSize { get; private set; }

        public Color TextColor { get; set; }

        public Font Font
        {
            get { return font; }
            set { font = value; updateSize(); }
        }

        public HorizontalAlignment HorizontalAlignment { get; set; }

        public VerticalAlignment VerticalAlignment { get; set; }

        public double XMargin
        {
            get { return _xMargin; }
            set { _xMargin = value; updateSize(); }
        }

        public double YMargin 
        {
            get { return _yMargin; }
            set { _yMargin = value; updateSize(); }
        }

        public override Vector Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                if ( sizeMode == TextSizeMode.StretchText )
                    TextScale = new Vector( TextScale.X * value.X / base.Size.X, TextScale.Y * value.Y / base.Size.Y );

                useDefaultHeight = false;
                base.Size = value;

                switch ( SizeMode )
                {
                    case TextSizeMode.None:
                        TruncateText();
                        break;
                    case TextSizeMode.Wrapped:
                        WrapText();
                        break;
                }
            }
        }

        public Label()
            : this( DefaultWidth, 10 )
        {
            sizeMode = TextSizeMode.AutoSize;

            if ( Game.Instance != null )
            {
                this.Height = GetDefaultHeight();
                updateSize();
            }
            else
                Game.InstanceInitialized += setDefaultHeight;
        }

        public Label( string text )
            : this( DefaultWidth, 10, text )
        {
            sizeMode = TextSizeMode.AutoSize;

            if ( Game.Instance != null )
            {
                this.Height = GetDefaultHeight();
                updateSize();
            }
            else
                Game.InstanceInitialized += setDefaultHeight;
        }

        public Label(Meter meter)
            : this()
        {
            this.BindTo(meter);
        }

        public Label( Animation animation )
            : base( animation )
        {
            Game.AssertInitialized( Initialize );
        }

        public Label( double width, double height )
            : this( width, height, "" )
        {
        }

        public Label( double width, double height, string text )
            : base( width, height, Shape.Rectangle )
        {
            this.sizeMode = TextSizeMode.None;
            this.originalText = text;
            Game.AssertInitialized( Initialize );
        }

        private void setDefaultHeight()
        {
            if ( !useDefaultHeight ) return;
            this.Height = GetDefaultHeight();
        }

        private void Initialize()
        {
            font = Font.Default;
            Color = Color.Transparent;
            TextColor = Color.Black;
            HorizontalAlignment = HorizontalAlignment.Center;
            VerticalAlignment = VerticalAlignment.Center;
            updateSize();
            initialized = true;
            UpdateValue();
        }

        protected override void UpdateValue()
        {
            if ( !initialized || !Bound ) return;

            if ( Meter is IntMeter )
            {
                int newNumber = ( (IntMeter)Meter ).Value;
                Text = string.Format( intFormatString, newNumber );
            }
            else if ( Meter is DoubleMeter )
            {
                double newNumber = ( (DoubleMeter)Meter ).Value;
                Text = string.Format( doubleFormatString, newNumber );
            }
        }

        private void updateSize()
        {
            SpriteFont xnaFont = this.Font.XnaFont;
            visibleText = (_title.Length > 0) ? (_title + ": " + originalText) : originalText;

            if ( visibleText.Length == 0 )
            {
                this.TextSize = Vector.Zero;
                NotifyParentAboutChangedSizingAttributes();
                return;
            }

            Vector2 rawTextDims = xnaFont.MeasureString( visibleText );
            Vector2 fullTextDims = new Vector2( _textScale.X * rawTextDims.X, _textScale.Y * rawTextDims.Y );

            TextSize = new Vector( fullTextDims.X, fullTextDims.Y );

            switch ( SizeMode )
            {
                case TextSizeMode.None:
                    TruncateText();
                    break;

                case TextSizeMode.AutoSize:
                    base.Size = PreferredSize = new Vector( fullTextDims.X + 2 * XMargin, fullTextDims.Y + 2 * YMargin );
                    break;

                case TextSizeMode.Wrapped:
                    WrapText();
                    break;
            }

            NotifyParentAboutChangedSizingAttributes();
        }

        private void TruncateText()
        {
            double textWidth = this.Width - 2 * XMargin;
            if ( textWidth <= 0 )
            {
                textWidth = this.Width;
            }

            visibleText = font.TruncateText( Text, textWidth );

            Vector2 textDims = Font.XnaFont.MeasureString( visibleText );
            TextSize = new Vector( textDims.X, textDims.Y );
        }

        private void WrapText()
        {
            SpriteFont xnaFont = this.Font.XnaFont;
            Vector2 rawTextDims = xnaFont.MeasureString( visibleText );
            Vector2 fullTextDims = new Vector2( _textScale.X * rawTextDims.X, _textScale.Y * rawTextDims.Y );

            if ( Width <= 0 || fullTextDims.X <= Width )
                return;

            double hardBreak = base.Size.X - 2 * XMargin;
            double softBreak = Math.Max( hardBreak / 2, hardBreak - 5 * Font.CharacterWidth );

            visibleText = Font.WrapText( visibleText, hardBreak, softBreak );
            Vector2 textDims = xnaFont.MeasureString( visibleText );
            base.Size = PreferredSize = new Vector( base.Size.X, textDims.Y + 2 * YMargin );
            TextSize = new Vector( textDims.X, textDims.Y );
        }

        private double GetHorizontalAlignment()
        {
            switch ( HorizontalAlignment )
            {
                case HorizontalAlignment.Center:
                    return -TextSize.X / 2;
                case HorizontalAlignment.Left:
                    return -Width / 2 + XMargin;
                case HorizontalAlignment.Right:
                    return Width / 2 - TextSize.X - XMargin;
                default:
                    return XMargin;
            }
        }

        private double GetVerticalAlignment()
        {
            switch ( VerticalAlignment )
            {
                case VerticalAlignment.Center:
                    return -TextSize.Y / 2;
                case VerticalAlignment.Top:
                    return -Size.Y / 2 - YMargin;
                case VerticalAlignment.Bottom:
                    return Size.Y / 2 - TextSize.Y + YMargin;
                default:
                    return -YMargin;
            }
        }

        protected override void Draw( Matrix parentTransformation, Matrix transformation )
        {
            Draw( parentTransformation, transformation, visibleText );
        }

        protected void Draw( Matrix parentTransformation, Matrix transformation, string text )
        {
            // Reverse the Y axis of the parent transformation
            Matrix p = parentTransformation;
            p.Translation = new Vector3( p.Translation.X, -p.Translation.Y, p.Translation.Z );

            Matrix m =
                    Matrix.CreateScale( _textScale )
                    * Matrix.CreateTranslation( (float)GetHorizontalAlignment(), (float)GetVerticalAlignment(), 0 )
                    * Matrix.CreateRotationZ( (float)-Angle.Radians )
                    * Matrix.CreateTranslation( (float)Position.X, -(float)Position.Y, 0 )
                    * p
                    * Matrix.CreateTranslation( (float)( Game.Screen.Width / 2 ), (float)( Game.Screen.Height / 2 ), 0 );

            Renderer.DrawText( text, ref m, Font, TextColor );

            base.Draw( parentTransformation, transformation );
        }
    }
}