recrownedathenaeum/RecrownedAthenaeum/UI/Modular/Modules/UIScrollable.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using RecrownedAthenaeum.Input;
using RecrownedAthenaeum.Render;
using RecrownedAthenaeum.SpecialTypes;
using RecrownedAthenaeum.UI.SkinSystem;
using RecrownedAthenaeum.UI.SkinSystem.Definitions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RecrownedAthenaeum.UI.Modular.Modules
{
    public class UIScrollable : UIModule
    {
        UIModuleGroup group;

        float opacityOfBar;
        bool showingBars;
        int shiftX, shiftY;
        int furthestX;
        int furthestY;
        UIModule furthestXMod, furthestYMod;

        bool horScrollAvailable, vertScrollAvailable;

        Rectangle horizontalScrollBarBounds, verticalScrollBarBounds;
        /// <summary>
        /// How fast the bars fade away in opacity (0 to 254) per second.
        /// </summary>
        public float barFadeSpeed;

        ISpecialDrawable horizontalScrollBar, verticalScrollBar;
        ISpecialDrawable background, horizontalBarTrack, verticalBarTrack;

        private int topPadding, bottomPadding, leftPadding, rightPadding;
        public int PadTop { get { return topPadding; } set { topPadding = value; HeightOrYChange(); } }
        public int PadBottom { get { return bottomPadding; } set { bottomPadding = value; HeightOrYChange(); } }
        public int PadLeft { get { return leftPadding; } set { leftPadding = value; WidthOrXChange(); } }
        public int PadRight { get { return rightPadding; } set { rightPadding = value; WidthOrXChange(); } }

        /// <summary>
        /// The minimum bar length for the scroll bar.
        /// </summary>
        public int minimumBarLength = 16;
        /// <summary>
        /// The thickness of the scroll bars.
        /// </summary>
        int horizontalBarThickness, verticalBarThickness;
        public int HorizontalBarThickness { get { return horizontalBarThickness; } set { horizontalBarThickness = value; HeightOrYChange(); } }
        public int VerticalBarThickness { get { return verticalBarThickness; } set { verticalBarThickness = value; WidthOrXChange(); } }

        /// <summary>
        /// Whether or not to hide scroll bars.
        /// </summary>
        public bool HideScrollBars
        {
            get { return hideScrollBars; }
            set
            {
                hideScrollBars = value;
                WidthOrXChange();
                HeightOrYChange();
            }
        }

        bool hideScrollBars = true;

        /// <summary>
        /// Set to true to change from the normal position to the new position.
        /// </summary>
        public bool verticalBarLeftPosition, horizontalBarTopPosition;


        public override int Width
        {
            get
            {
                return base.Width;
            }
            set
            {
                base.Width = value;
                WidthOrXChange();
            }
        }

        public override int Height
        {
            get
            {
                return base.Height;
            }
            set
            {
                base.Height = value;
                HeightOrYChange();
            }
        }

        public override int X
        {
            get
            {
                return base.X;
            }
            set
            {
                WidthOrXChange(true);
                base.X = value;
            }
        }

        public override int Y
        {
            get
            {
                return base.Y;
            }
            set
            {
                HeightOrYChange(true);
                base.Y = value;
            }
        }

        public UIScrollable(ISpecialDrawable horizontalScrollBar, ISpecialDrawable verticalScrollBar, ISpecialDrawable horizontalBarTrack = null, ISpecialDrawable verticalBarTrack = null, ISpecialDrawable background = null)
        {
            this.horizontalScrollBar = horizontalScrollBar;
            this.verticalScrollBar = verticalScrollBar;
            this.horizontalBarTrack = horizontalBarTrack;
            this.verticalBarTrack = verticalBarTrack;
            this.background = background;

            group = new UIModuleGroup(new BasicScissor());
        }

        public UIScrollable(ISkin skin, string definition) : 
            this(skin.GetTextureAtlasRegion(skin.ObtainDefinition<UIScrollableSkinDefinition>().horizontalBar, true), 
                skin.GetTextureAtlasRegion(skin.ObtainDefinition<UIScrollableSkinDefinition>().verticalBar, true), 
                skin.GetTextureAtlasRegion(skin.ObtainDefinition<UIScrollableSkinDefinition>().horizontalBarTrack), 
                skin.GetTextureAtlasRegion(skin.ObtainDefinition<UIScrollableSkinDefinition>().verticalBarTrack), 
                skin.GetTextureAtlasRegion(skin.ObtainDefinition<UIScrollableSkinDefinition>().background))
        {
        }

        public override void Update(GameTime gameTime)
        {
            if (hideScrollBars)
            {
                if (!showingBars)
                {
                    if (opacityOfBar <= 0)
                    {
                        opacityOfBar -= (barFadeSpeed / 255f) * gameTime.ElapsedGameTime.Seconds;
                    }
                }
                else
                {
                    opacityOfBar = 1f;
                }
            }

            if (horScrollAvailable)
            {
                horizontalScrollBarBounds.X = (int)(((float)-shiftX / furthestX) * (group.Width - horizontalScrollBarBounds.Width));
            }

            if (vertScrollAvailable)
            {
                verticalScrollBarBounds.Y = (int)(((float)-shiftY / furthestY) * (group.Height - verticalScrollBarBounds.Height));
            }

            base.Update(gameTime);
        }

        public override void Draw(ConsistentSpriteBatch spriteBatch)
        {
            background.Draw(spriteBatch, Boundaries, color, origin: origin);
            if (horScrollAvailable)
            {
                horizontalScrollBar.Draw(spriteBatch, horizontalScrollBarBounds, color);
            }
            if (vertScrollAvailable)
            {
                horizontalScrollBar.Draw(spriteBatch, verticalScrollBarBounds, color);
            }
            base.Draw(spriteBatch);
        }

        public void AddModules(params UIModule[] addModules)
        {
            group.AddModules(addModules);

            for (int i = 0; i < addModules.Length; i++)
            {
                UIModule m = addModules[i];
                int mFurthestX = m.Boundaries.X + m.Boundaries.Width;
                int mFurthestY = m.Boundaries.Y + m.Boundaries.Height;
                if (mFurthestX > furthestX)
                {
                    furthestXMod = m;
                    furthestX = mFurthestX;
                }
                if (mFurthestY > furthestY)
                {
                    furthestYMod = m;
                    furthestY = mFurthestY;
                }
            }
        }

        public void RemoveModule(UIModule module)
        {
            group.RemoveModule(module);

            if (module == furthestXMod)
            {
                furthestX = 0;
                UIModule[] modules = group.GetCopyOfModules();
                for (int i = 0; i < modules.Length; i++)
                {
                    UIModule m = modules[i];
                    int mFurthestX = m.Boundaries.X + m.Boundaries.Width;
                    if (mFurthestX > furthestX)
                    {
                        furthestXMod = m;
                        furthestX = mFurthestX;
                    }
                }
            }

            if (module == furthestYMod)
            {
                furthestY = 0;
                UIModule[] modules = group.GetCopyOfModules();

                for (int i = 0; i < modules.Length; i++)
                {
                    UIModule m = modules[i];
                    int mFurthestY = m.Boundaries.Y + m.Boundaries.Height;
                    if (mFurthestY > furthestY)
                    {
                        furthestYMod = m;
                        furthestY = mFurthestY;
                    }
                }
            }
        }

        private void WidthOrXChange(bool onlyXChange = false)
        {
            group.X = X + leftPadding;
            if (!onlyXChange)
            {
                group.Width = Width - rightPadding - leftPadding;
                if (Width < furthestX)
                {
                    horScrollAvailable = true;
                    horizontalScrollBarBounds.Width = (int)(Width * ((float)Width / furthestX));
                    horizontalScrollBarBounds.Width = Math.Max(horizontalScrollBarBounds.Width, minimumBarLength);
                }
                else { horScrollAvailable = false; }


                if (!hideScrollBars)
                {
                    if (verticalBarLeftPosition)
                    {
                        group.X += verticalBarThickness;
                        group.Width -= verticalBarThickness;
                    }
                    group.Height -= verticalBarThickness;
                }
            }
        }

        private void HeightOrYChange(bool onlyYChange = false)
        {
            group.Y = Y + bottomPadding;
            if (!onlyYChange)
            {
                group.Height = Height - bottomPadding - topPadding;
                if (Height < furthestY)
                {
                    horScrollAvailable = true;
                    verticalScrollBarBounds.Height = (int)(Height * ((float)Height / furthestY));
                    verticalScrollBarBounds.Height = Math.Max(verticalScrollBarBounds.Height, minimumBarLength);
                }
                else { vertScrollAvailable = false; }

                if (!hideScrollBars)
                {
                    if (!horizontalBarTopPosition)
                    {
                        group.Y += horizontalBarThickness;
                        group.Height -= horizontalBarThickness;
                    }
                    group.Height -= horizontalBarThickness;
                }
            }
        }

        public override bool MouseStateChanged(MouseState state)
        {
            if (InputUtilities.MouseWithinBoundries(Boundaries))
            {
                showingBars = true;
            }
            else
            {
                showingBars = false;
            }
            return base.MouseStateChanged(state);
        }
    }
}