recrownedathenaeum/RecrownedAthenaeum/UI/SkinSystem/Skin.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using RecrownedAthenaeum.SpecialTypes;
using RecrownedAthenaeum.UI.SkinSystem.Definitions;
using System;
using System.Collections.Generic;

namespace RecrownedAthenaeum.UI.SkinSystem
{
    /// <summary>
    /// A skin is used to group a theme which can then be applied to the UI via the use of modules.
    /// </summary>
    public class Skin : IDisposable, ISkin
    {
        /// <summary>
        /// Whether or not this skin is completed being built and thus ready to use.
        /// </summary>
        public bool Laminated { get; private set; }
        private bool disposed;

        private TextureAtlas textureAtlas;

        Dictionary<string, Color> colors;

        Dictionary<Type, Dictionary<string, ISkinDefinitionData>> definitions;

        /// <summary>
        /// The texture for the cursor.
        /// </summary>
        public virtual Texture2D CursorTexture { get; private set; }

        /// <summary>
        /// Creates a basic unfilled skin.
        /// </summary>
        /// <param name="textureAtlas">The texture atlas to use for this skin.</param>
        /// <param name="cursorTexture">The texture the cursor will be.</param>
        public Skin(TextureAtlas textureAtlas, Texture2D cursorTexture)
        {
            this.textureAtlas = textureAtlas;
            this.CursorTexture = cursorTexture;
            colors = new Dictionary<string, Color>();
            definitions = new Dictionary<Type, Dictionary<string, ISkinDefinitionData>>();
        }

        /// <summary>
        /// Returns a <see cref="TextureAtlas.Region"/> with given name of region.
        /// </summary>
        /// <param name="name">Name of region.</param>
        /// <returns>The region corresponding to the name.</returns>
        public virtual TextureAtlas.Region GetTextureAtlasRegion(string name)
        {
            return textureAtlas[name];
        }

        /// <summary>
        /// Returns a <see cref="Color"/> with given name of defined color;
        /// </summary>
        /// <param name="name">Name of defined color.</param>
        /// <returns>The defined color based on the name given.</returns>
        public virtual Color GetColor(string name)
        {
            return colors[name];
        }

        /// <summary>
        /// Draws a region from the texture atlas.
        /// </summary>
        /// <param name="regionName">Region to draw.</param>
        /// <param name="color">The color to tint the region.</param>
        /// <param name="batch">The batch to use.</param>
        /// <param name="destination">The destination to draw to.</param>
        /// <param name="rotation">The rotation to use in radians.</param>
        /// <param name="origin">The origin for the rotation.</param>
        public virtual void Draw(string regionName, string color, SpriteBatch batch, Rectangle destination, float rotation = 0, Vector2 origin = default(Vector2))
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            textureAtlas.Draw(regionName, batch, destination, colors[color], rotation, origin);
        }

        /// <summary>
        /// Returns an <see cref="ISkinDefinitionData"/> of the given name and type.
        /// </summary>
        /// <param name="definitionName">Name of definition of the <paramref name="type"/></param>
        /// <param name="type">The UIModule the definition defines.</param>
        /// <returns>The interface for the definition.</returns>
        public virtual ISkinDefinitionData ObtainDefinition(string definitionName, Type type)
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            if (!Laminated) throw new InvalidOperationException("Skin has yet to be laminated yet.");
            if (definitionName == null) definitionName = "default";
            if (!definitions.ContainsKey(type) || !definitions[type].ContainsKey(definitionName)) throw new KeyNotFoundException("Could not find skin of type " + type.Name + " with name " + definitionName);
            return definitions[type][definitionName];
        }

        /// <summary>
        /// Returns the default <see cref="ISkinDefinitionData"/> of the given parameters.
        /// </summary>
        /// <param name="type">The type of definition the default should be coming from.</param>
        /// <returns>The default definition for the given type.</returns>
        public virtual ISkinDefinitionData ObtainDefinition(Type type)
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            return ObtainDefinition(null, type);
        }

        /// <summary>
        /// Returns the proper definition for the given parameters or throws exception in the case the requested definition does not exist.
        /// </summary>
        /// <typeparam name="T">Convenience to cast to the needed definition type.</typeparam>
        /// <param name="definitionName">The name of the definition.</param>
        /// <param name="type">UIModule type the definition defines.</param>
        /// <returns>The definition cast to T.</returns>
        public virtual T ObtainDefinition<T>(string definitionName, Type type) where T : ISkinDefinitionData
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            if (definitionName == null) definitionName = "default";
            return (T)ObtainDefinition(definitionName, type);
        }

        /// <summary>
        /// Returns the default definition.
        /// </summary>
        /// <typeparam name="T">Convenience to cast to T.</typeparam>
        /// <param name="type">The type of the UIModule to retrieve the default from.</param>
        /// <returns>The default definition for the given type.</returns>
        public virtual T ObtainDefinition<T>(Type type) where T : ISkinDefinitionData
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            return ObtainDefinition<T>(null, type);
        }

        /// <summary>
        /// Adds the definition.
        /// </summary>
        /// <param name="definitionName">The name of the definition.</param>
        /// <param name="skinDefinition">The definition itself.</param>
        public virtual void AddDefinition(string definitionName, ISkinDefinitionData skinDefinition)
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            if (Laminated) throw new InvalidOperationException("This object has been laminated and cannot be edited.");
            if (!definitions.ContainsKey(skinDefinition.UIModuleType))
            {
                definitions.Add(skinDefinition.UIModuleType, new Dictionary<string, ISkinDefinitionData>());
            } else if (definitions[skinDefinition.UIModuleType].ContainsKey(definitionName)) throw new ArgumentException("Type of definition with that name already exists!");

            definitions[skinDefinition.UIModuleType].Add(definitionName, skinDefinition);
        }

        /// <summary>
        /// Adds color to skin.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="color"></param>
        public virtual void AddColor(string name, Color color)
        {
            if (Laminated) throw new InvalidOperationException("This object has been laminated and cannot be edited.");
            colors.Add(name, color);
        }

        /// <summary>
        /// Laminates the skin. Making sure no more additions are done and sets the skin to be ready for use.
        /// Needs to be called before any use of skin. Building skin needs to be done before lamination.
        /// </summary>
        public void Laminate()
        {
            Laminated = true;
        }

        /// <summary>
        /// Disposes <see cref="textureAtlas"/> and the <see cref="Texture2D"/> holding the cursor texture.
        /// </summary>
        public void Dispose()
        {
            if (disposed) throw new ObjectDisposedException(GetType().Name);
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Overridable dispose function.
        /// </summary>
        /// <param name="disposing">true when it's a user call to dispose.</param>
        public virtual void Dispose(bool disposing)
        {
            disposed = true;
            if (disposing && !disposed)
            {
                textureAtlas.Dispose();
                CursorTexture.Dispose();
            }
        }

        /// <summary>
        /// Destructor. Calls the dispose with false.
        /// </summary>
        ~Skin()
        {
            Dispose(false);
        }
    }
}