WSHCommon/Common/CommonUnity3D/UGUIEditor/UI/UEGauge.cs

using CommonLang.Xml;
using CommonUnity3D.UGUI;
using System;
using System.Xml;
using UnityEngine;
using CommonUI.Data;
using TextAnchor = CommonUI.Data.TextAnchor;
using FontStyle = CommonUI.Data.FontStyle;
using CommonLang.Property;

namespace CommonUnity3D.UGUIEditor.UI
{
    public class UEGauge : UIComponent
    {
        protected readonly UIComponent mStrip;
        protected DisplayText mTextSprite;

        private double mGaugeMinValue = 0, mGaugeMaxValue = 100, mGaugeValue = 50;
        private GaugeOrientation mOrientation = GaugeOrientation.LEFT_2_RIGHT;
        private string mText = "";
        private bool mIsShowPercent = false;
        protected readonly bool mUseBitmapFont;

        public UEGauge(bool use_bitmap)
        {
            this.mUseBitmapFont = use_bitmap;
            this.mStrip = new UIComponent("strip");
            this.mStrip.Layout = UILayout.CreateUILayoutColor(new Color(1f, 1f, 1f, 0.5f), Color.black);
            this.mStrip.Enable = false;
            this.mStrip.EnableChildren = false;
            this.AddChild(mStrip);
            this.Enable = false;
            this.EnableChildren = false;
        }
        public UEGauge() : this(UIEditor.GlobalUseBitmapText)
        {

        }

        public UIComponent Strip
        {
            get { return mStrip; }
        }
        public UILayout StripLayout
        {
            get { return mStrip.Layout; }
            set { mStrip.Layout = value; ; }
        }
        public DisplayText TextSprite
        {
            get { return mTextSprite; }
        }
        public GaugeOrientation Orientation
        {
            get { return mOrientation; }
            set
            {
                mOrientation = value;
                ChangeFillMode(this.mOrientation);
            }
        }
        public double Value
        {
            get { return mGaugeValue; }
            set
            {
                if (value > mGaugeMaxValue) throw new Exception(string.Format("Gauge value [{0}] out of range [{1}-{2}]", value, mGaugeMinValue, mGaugeMaxValue));
                if (value < mGaugeMinValue) throw new Exception(string.Format("Gauge value [{0}] out of range [{1}-{2}]", value, mGaugeMinValue, mGaugeMaxValue));
                if (mGaugeValue != value)
                {
                    mGaugeValue = value;
                    DoValueChanged();
                }
            }
        }
        public float ValuePercent
        {
            get
            {
                if (mGaugeMaxValue - mGaugeMinValue == 0) { return 0; }
                else { return (float)((mGaugeValue - mGaugeMinValue) / (mGaugeMaxValue - mGaugeMinValue) * 100f); }
            }
            set
            {
                if (value < 0 || value > 100) throw new Exception(string.Format("Gauge ValuePercent [{0}] out of range [0-100]", value));
                Value = mGaugeMinValue + (mGaugeMaxValue - mGaugeMinValue) * value * 0.01;
            }
        }
        public bool IsShowPercent
        {
            get { return mIsShowPercent; }
            set
            {
                if (mIsShowPercent != value)
                {
                    mIsShowPercent = value;
                    DoTextChanged();
                }
            }
        }

        //-----------------------------------------------------------------------------------------------

        public string Text
        {
            get { return mText; }
            set
            {
                if (IsDispose) return;
                if (!string.Equals(mText, value))
                {
                    mText = value;
                    DoTextChanged();
                }
            }
        }
        public int FontSize
        {
            get { return mTextSprite.FontSize; }
            set { mTextSprite.FontSize = value; }
        }
        public UnityEngine.Color FontColor
        {
            get { return mTextSprite.FontColor; }
            set { mTextSprite.FontColor = value; }
        }
        public TextAnchor EditTextAnchor
        {
            get { return mTextSprite.Anchor; }
            set { mTextSprite.Anchor = value; }
        }
        public Vector2 TextOffset
        {
            get { return mTextSprite.TextOffset; }
            set { mTextSprite.TextOffset = value; }
        }

        //-----------------------------------------------------------------------------------------------

        public double GaugeMinValue
        {
            get { return mGaugeMinValue; }
        }

        public double GaugeMaxValue
        {
            get { return mGaugeMaxValue; }
        }

        public void SetGaugeMinMax(double min, double max)
        {
            if (min > max) CommonLang.CUtils.Swap<double>(ref min, ref max);
            bool needDoChange = (mGaugeMinValue != min) || (mGaugeMaxValue != min);

            mGaugeMaxValue = max;
            mGaugeMinValue = min;
            double value = this.Value;
            value = Math.Max(min, value);
            value = Math.Min(max, value);

            if (needDoChange && value == this.Value)
            {
                DoValueChanged();
            }
            this.Value = value;
        }

        /// <summary>
        /// 设置填充模式.
        /// EG.SetFillMode(UnityEngine.UI.Image.FillMethod.Radial360,
        ///               (int)UnityEngine.UI.Image.Origin360.Left)
        /// </summary>
        /// <param name="fill"></param>
        /// <param name="fillOrigin"></param>
        /// <param name="fillClockwise"></param>
        /// <param name="fillCenter"></param>
        public void SetFillMode(UnityEngine.UI.Image.FillMethod fill, int fillOrigin, bool fillClockwise = false, bool fillCenter = true)
        {
            if (mStrip != null && mStrip.Graphics != null)
            {
                mStrip.Graphics.SetFillMode(fill, fillOrigin, fillClockwise, fillCenter);
            }
        }

        private void ChangeFillMode(GaugeOrientation Orientation)
        {
            if (mStrip != null && mStrip.Layout != null)
            {
                if (mStrip.Layout.Style == UILayoutStyle.IMAGE_STYLE_BACK_4_CENTER ||
                    mStrip.Layout.Style == UILayoutStyle.IMAGE_STYLE_BACK_4)
                {
                    switch (Orientation)
                    {
                        case GaugeOrientation.BOTTOM_2_TOP:
                            this.SetFillMode(UnityEngine.UI.Image.FillMethod.Vertical,
                                (int)UnityEngine.UI.Image.OriginVertical.Bottom);
                            break;
                        case GaugeOrientation.TOP_2_BOTTOM:
                            this.SetFillMode(UnityEngine.UI.Image.FillMethod.Vertical,
                             (int)UnityEngine.UI.Image.OriginVertical.Top);
                            break;
                        case GaugeOrientation.LEFT_2_RIGHT:
                            this.SetFillMode(UnityEngine.UI.Image.FillMethod.Horizontal,
                          (int)UnityEngine.UI.Image.OriginHorizontal.Left);
                            break;
                        case GaugeOrientation.RIGTH_2_LEFT:
                            this.SetFillMode(UnityEngine.UI.Image.FillMethod.Horizontal,
                          (int)UnityEngine.UI.Image.OriginHorizontal.Right);
                            break;
                    }
                }
            }
        }
        //-----------------------------------------------------------------------------------------------
        protected override void OnStart()
        {
            if (mTextSprite == null)
            {
                if (mUseBitmapFont)
                {
                    mTextSprite = new BitmapTextSprite("bitmap_text");
                }
                else
                {
                    mTextSprite = new TextSprite("bitmap_text");
                }
            }
            base.OnStart();
            this.DoValueChanged();
        }

        protected override void OnUpdate()
        {
            base.OnUpdate();

            if (mStrip.Graphics.IsShowUILayout)
            {
                UIUtils.AdjustGaugeOrientation(Orientation, this, mStrip, ValuePercent);
            }
            else
            {
                mStrip.Position2D = Vector2.zero;
                mStrip.Size2D = this.Size2D;
            }
            if (mTextSprite != null)
            {
                mTextSprite.Size2D = this.Size2D;
            }
        }
        protected override void DecodeEnd(UIEditor.Decoder editor, UIComponentMeta e)
        {
            base.DecodeEnd(editor, e);
            {
                if (!string.IsNullOrEmpty((e as UEGaugeMeta).ImageFont))
                {
                    this.Decode_ImageFont(editor, e as UEGaugeMeta);
                }
                else if (mUseBitmapFont)
                {
                    this.Decode_BitmapText(editor, e as UEGaugeMeta);
                }
                else
                {
                    this.Decode_Text(editor, e as UEGaugeMeta);
                }
            }
            this.Decode_Gauge(editor, e as UEGaugeMeta);

            this.Enable = false;
            this.EnableChildren = false;
        }

        private void Decode_Gauge(UIEditor.Decoder editor, UEGaugeMeta e)
        {
            this.Text = e.text;
            this.mGaugeMaxValue = e.gaugeMax;
            this.mGaugeMinValue = e.gaugeMin;
            this.mGaugeValue = e.gaugeValue;
            this.Orientation = e.render_orientation;
            this.IsShowPercent = e.showPercent;
            UILayout custom_layout_up = editor.CreateLayout(e.custom_layout_up);
            if (custom_layout_up != null)
            {
                mStrip.Layout = custom_layout_up;
                ChangeFillMode(this.Orientation);
            }
            mTextSprite.Text = this.Text;
            mTextSprite.Size2D = this.Size2D;
            mTextSprite.Anchor = e.text_anchor;
            mTextSprite.TextOffset = new Vector2(e.text_offset_x, e.text_offset_y);
        }

        private void Decode_Text(UIEditor.Decoder editor, UETextComponentMeta e)
        {
            var text = new TextSprite("text");
            this.mTextSprite = text;
            this.AddChild(mTextSprite);

            if (!string.IsNullOrEmpty(e.textFontName))
            {
                text.SetTextFont(editor.editor.CreateFont(e.textFontName), this.FontSize, (UnityEngine.FontStyle)e.textFontStyle);
            }
            else
            {
                text.SetTextFont(editor.editor.CreateFont(null), editor.editor.DefaultFont.fontSize, UnityEngine.FontStyle.Normal);
            }
            if (e.textFontSize > 0)
            {
                text.FontSize = e.textFontSize;
                text.Graphics.resizeTextForBestFit = false;
            }
            else
            {
                text.Graphics.resizeTextForBestFit = true;
            }
            text.FontColor = UIUtils.UInt32_ARGB_To_Color(e.textColor);
            if (e.textBorderAlpha > 0)
            {
                Color border_color = UIUtils.UInt32_ARGB_To_Color(e.textBorderColor);
                border_color.a = e.textBorderAlpha / 100f;
                text.AddBorder(border_color, new Vector2(1, -1));
            }
        }
        private void Decode_BitmapText(UIEditor.Decoder editor, UETextComponentMeta e)
        {
            var text = new BitmapTextSprite("bitmap_text");
            this.mTextSprite = text;
            this.AddChild(mTextSprite);

            text.Graphics.Style = e.textFontStyle;
            text.Graphics.FontColor = UIUtils.UInt32_ARGB_To_Color(e.textColor);
            if (e.textFontSize > 0)
            {
                text.FontSize = e.textFontSize;
            }
            if (e.textBorderAlpha > 0)
            {
                Color border_color = UIUtils.UInt32_ARGB_To_Color(e.textBorderColor);
                border_color.a = e.textBorderAlpha / 100f;
                text.Graphics.BorderTime = TextBorderCount.Border;
                text.Graphics.BorderColor = border_color;
            }
        }
        private void Decode_ImageFont(UIEditor.Decoder editor, UETextComponentMeta e)
        {
            var text = new ImageFontSprite("image_font");
            this.mTextSprite = text;
            this.AddChild(mTextSprite);

            editor.editor.ParseImageFont(e.ImageFont, e.text, text.Graphics);

        }

        private void DoTextChanged()
        {
            string text = this.Text;
            if (IsShowPercent)
            {
                text = string.Format("{0}%", ((int)ValuePercent));
                mTextSprite.Text = text;
            }
            else
            {
                mTextSprite.Text = text;
            }
        }
        private void DoValueChanged()
        {
            string text = this.Text;
            if (IsShowPercent)
            {
                text = string.Format("{0}%", ((int)ValuePercent));
                mTextSprite.Text = text;
            }
            else
            {
                mTextSprite.Text = text;
            }
            mStrip.Graphics.SetFillPercent(ValuePercent);

            if (event_ValueChanged != null)
            {
                event_ValueChanged.Invoke(this, mGaugeValue);
            }
        }


        protected override void OnDisposeEvents()
        {
            base.OnDisposeEvents();
            event_ValueChanged = null;
        }

        public delegate void ValueChangedHandler(UEGauge sender, double value);

        [Desc("值改变")]
        public ValueChangedHandler event_ValueChanged;

        [Desc("值改变")]
        public event ValueChangedHandler ValueChanged { add { event_ValueChanged += value; } remove { event_ValueChanged -= value; } }

    }

}