Font.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using Microsoft.Xna.Framework.Graphics;
using System.Text;
using XnaV2 = Microsoft.Xna.Framework.Vector2;
using FontStashSharp;
using System.IO;
using Microsoft.Xna.Framework.Content;
using System.ComponentModel;
using System.Collections.Generic;
 
namespace Jypeli
{
    internal enum ContentSource
    {
        GameContent,
        ResourceContent
    }
 
 
    public class Font
    {
        private static string defaultFont = "Roboto-Regular.ttf";
        private static string defaultFontBold = "Roboto-Bold.ttf";
 
        public static readonly Font Default = new Font(defaultFont, ContentSource.ResourceContent, 25);
 
        public static readonly Font DefaultBold = new Font(defaultFontBold, ContentSource.ResourceContent, 25);
 
        private DynamicSpriteFont xnaFont;
        private FontSystem fontSystem;
        private string name;
        private int size;
        private ContentSource source;
 
        private int blurAmount = 0;
        private int strokeAmount = 0;
 
        private List<string> mergedFonts = new List<string>();
 
        internal DynamicSpriteFont XnaFont
        {
            get { DoLoad(); return xnaFont; }
        }
 
        internal FontSystem FontSystem
        {
            get { DoLoad(); return fontSystem; }
        }
 
        public int Size
        {
            get { return size; }
            set
            {
                DoLoad();
                if (value <= 0) throw new Exception("Fontsize must be greater than zero.");
                size = value;
                xnaFont = fontSystem.GetFont(size);                
                fontSystem = null;
                DoLoad();
            }
        }
 
        public int BlurAmount
        {
            get { return blurAmount; }
            set
            {
                DoLoad();
                blurAmount = value;
                strokeAmount = 0;
                fontSystem = null;
                DoLoad();
            }
        }
 
        public int StrokeAmount
        {
            get { return strokeAmount; }
            set
            {
                DoLoad();
                strokeAmount = value;
                blurAmount = 0;
                fontSystem = null;
                DoLoad();
            }
        }
 
        public double CharacterWidth
        {
            get { return XnaFont.MeasureString( "X" ).X; } // TODO: pitäisi todellisuudessa etsiä fontin suurin merkki ja katsoa sen mitat.
        }
 
        public double CharacterHeight
        {
            get { return XnaFont.MeasureString( "X" ).Y; }
        }
 
        public static Font FromContent(string name)
        {
            Font font = new Font("Content/" + name, ContentSource.GameContent);
            return font;
        }
 
        public Font(int fontSize=25) : this(defaultFont, ContentSource.ResourceContent, fontSize)
        {
        }
 
        public Font(int fontSize, bool bold) : this(bold ? defaultFontBold : defaultFont, ContentSource.ResourceContent, fontSize)
        {
        }
 
        public Font(string name) : this(name, ContentSource.GameContent) { }
 
        public Font(string name, int fontSize) : this(name, ContentSource.GameContent, fontSize) { }
 
        internal Font(string name, ContentSource source)
        {
            this.xnaFont = null;
            this.name = name;
            this.source = source;
            this.size = 25;
        }
 
        internal Font( string name, ContentSource source, int fontSize)
        {
            this.xnaFont = null;
            this.name = name;
            this.source = source;
            this.size = fontSize;
        }
 
        internal Font( DynamicSpriteFont xnaFont )
        {
            this.xnaFont = xnaFont;
            this.name = null;
            this.source = ContentSource.ResourceContent;
        }
 
        private void DoLoad()
        {
            if (fontSystem == null)
            {
                fontSystem = new FontSystem(StbTrueTypeSharpFontLoader.Instance, new Texture2DManager(Game.GraphicsDevice), 1024, 1024, blurAmount, StrokeAmount);
 
                Stream s;
                if (this.source == ContentSource.ResourceContent) s = Game.ResourceContent.StreamInternalFont(name);
                else s = File.Open(name, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); // Tässä pitää jostain syystä olla ReadWrite, vaikka tiedosto ainoastaan luetaan.
 
                fontSystem.AddFont(s);
                xnaFont = fontSystem.GetFont(size);
 
                mergedFonts.ForEach(name => MergeFont(name));
                
                s.Dispose();
            }
        }
 
        public void AddFont(string filename)
        {
            DoLoad();
            MergeFont(filename);
            mergedFonts.Add(filename);
        }
 
 
        private void MergeFont(string filename)
        {
            Stream s = File.Open("Content/" + filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            fontSystem.AddFont(s);
        }
 
        public Vector GetCharacterSize( char c )
        {
            return XnaFont.MeasureString(c.ToString());
        }
 
        public string TruncateText( string str, double maxLineWidth )
        {
            StringBuilder builder = new StringBuilder( str );
            double realWidth = XnaFont.MeasureString( str ).X;
 
            while ( realWidth > maxLineWidth )
            {
                builder.Remove( builder.Length - 1, 1 );
                realWidth = XnaFont.MeasureString( builder ).X;
            }
 
            return builder.ToString();
        }
 
        public Vector MeasureSize(string str)
        {
            var xnaVector2 = XnaFont.MeasureString(str);
            return new Vector(xnaVector2.X, xnaVector2.Y);
        }
 
        private static void appendLine(StringBuilder dest, StringBuilder line)
        {
            if ( dest.Length > 0 ) dest.Append( "\n" );
            line.RemoveLeading( c => Char.IsWhiteSpace( c ) );
            line.PutTo( dest );
        }
 
        public string WrapText( string text, double softLineWidth, double hardLineWidth )
        {
            if ( softLineWidth <= 0 || hardLineWidth <= 0 )
            {
                throw new ArgumentException( "Width must be positive." );
            }
 
            StringBuilder src = new StringBuilder( text );
            StringBuilder word = new StringBuilder();
            StringBuilder line = new StringBuilder();
            StringBuilder dest = new StringBuilder();
            double lineWidth = 0;
 
            while ( src.Length > 0 || word.Length > 0 )
            {
                if (word.Length == 0)
                    src.TakeFirstWord( word );
 
                var wordWidth = XnaFont.MeasureString( word ).X;
 
                if ( lineWidth + wordWidth > softLineWidth )
                {
                    appendLine( dest, line );
                    word.PutTo( line );
                    lineWidth = 0;
                }
                else if (lineWidth + wordWidth > hardLineWidth)
                {
                    int wi = FindWrapIndex(word, hardLineWidth - lineWidth, false);
                    word.PutTo(line, 0, wi + 1);
                    appendLine(dest, line);
                    lineWidth = 0;
                }
                else
                {
                    word.PutTo( line );
                    lineWidth += wordWidth;
                }
            }
 
            if ( line.Length > 0 )
                appendLine( dest, line );
 
            return dest.ToString();
        }
 
        private int FindWrapIndex( StringBuilder text, double maxWidth, bool fromRight )
        {
            
            double currentWidth = -xnaFont.FontSystem.CharacterSpacing;
            int i = fromRight ? text.Length - 1 : 0;
            int step = fromRight ? -1 : 1;
 
            //for ( int i = 0; i < text.Length; i++ )
            while ( ( fromRight && i >= 0 ) || ( !fromRight && i < text.Length ) )
            {
                currentWidth += xnaFont.FontSystem.CharacterSpacing + GetCharacterSize( text[i] ).X;
                if ( currentWidth >= maxWidth ) return i;
                i += step;
            }
 
            return fromRight ? -1 : text.Length;
        }
    }
}