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 FontStashSharp;
using Jypeli.Widgets;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace Jypeli
{
    public enum TextSizeMode
    {
        None,
 
        AutoSize,
 
        StretchText,
 
        Wrapped,
    }
 
 
    public class Label : BindableWidget
    {
        private Font font;
        private string title = "";
        private string originalText = "";
        private string visibleText = "";
        private TextSizeMode sizeMode = TextSizeMode.None;
        private int decimalPlaces = 2;
        private string doubleFormatString = "{0:N2}";
        private string intFormatString = "{0:D1}";
        private double _xMargin;
        private double _yMargin;
        private bool useDefaultHeight = false;
        private bool initialized = false;
        private const double DefaultWidth = 100;
        private Color[] characterColors;
 
        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;
                UpdateValue();
            }
 
        }
 
 
        public string IntFormatString
        {
            get { return intFormatString; }
            set
            {
                intFormatString = value;
                UpdateValue();
            }
 
        }
 
        public string Title { get; set; }
 
        public TextSizeMode SizeMode
        {
            get { return sizeMode; }
            set { sizeMode = value; updateSize(); }
        }
 
        public Vector TextSize { get; private set; }
 
        public Color TextColor { get; set; }
 
        public Color[] CharacterColors 
        { 
            get { return characterColors; } 
            set { characterColors = value; }
        }
 
        public virtual 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
            {
                base.Size = value;
                this.updateSize();
            }
        }
 
        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( 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 = Title + string.Format( intFormatString, newNumber );
            }
            else if ( Meter is DoubleMeter )
            {
                double newNumber = ( (DoubleMeter)Meter ).Value;
                Text = Title + string.Format( doubleFormatString, newNumber );
            }
        }
 
        private void updateSize()
        {
            DynamicSpriteFont 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 );
            Vector clientArea = new Vector( this.Width - 2 * XMargin, this.Height - 2 * YMargin );
            Vector fullTextDims = new Vector( _textScale.X * rawTextDims.X, _textScale.Y * rawTextDims.Y );
            TextSize = new Vector( fullTextDims.X, fullTextDims.Y );
 
            switch ( SizeMode )
            {
                case TextSizeMode.None:
                    TruncateText();
                    break;
 
                case TextSizeMode.StretchText:
                    _textScale = new Vector( clientArea.X / rawTextDims.X, clientArea.Y / rawTextDims.Y );
                    TextSize = clientArea;
                    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()
        {
            DynamicSpriteFont 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, softBreak, hardBreak );
            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 0;
                case HorizontalAlignment.Left:
                    return ( -Width + TextSize.X ) / 2 + XMargin;
                case HorizontalAlignment.Right:
                    return ( Width - TextSize.X ) / 2 - XMargin;
                default:
                    return XMargin;
            }
        }
 
        private double GetVerticalAlignment()
        {
            switch ( VerticalAlignment )
            {
                case VerticalAlignment.Center:
                    return 0;
                case VerticalAlignment.Top:
                    return ( Size.Y - TextSize.Y ) / 2 - YMargin;
                case VerticalAlignment.Bottom:
                    return ( -Size.Y + TextSize.Y ) / 2 + YMargin;
                default:
                    return YMargin;
            }
        }
 
        public override void Draw( Matrix parentTransformation, Matrix transformation )
        {
            Draw( parentTransformation, transformation, visibleText );
        }
 
        protected void Draw( Matrix parentTransformation, Matrix transformation, string text )
        {
            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 )
                * parentTransformation;
 
            if(CharacterColors == null)
                Renderer.DrawText( text, ref m, Font, TextColor );
            else
                Renderer.DrawText(text, ref m, Font, CharacterColors);
            base.Draw( parentTransformation, transformation );
        }
    }
}