using System.Windows;
using System.Windows.Controls;

namespace Sicentury.Core.UserControls
{
    [TemplateVisualState(Name = "Large", GroupName = "SizeStates")]
    [TemplateVisualState(Name = "Small", GroupName = "SizeStates")]
    [TemplateVisualState(Name = "Inactive", GroupName = "ActiveStates")]
    [TemplateVisualState(Name = "Active", GroupName = "ActiveStates")]
    public class CirclePointRingLoading : Control
    {
        // Token: 0x17000001 RID: 1
        // (get) Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
        // (set) Token: 0x06000002 RID: 2 RVA: 0x00002072 File Offset: 0x00000272
        public double BindableWidth
        {
            get => (double)base.GetValue(CirclePointRingLoading.BindableWidthProperty);
            private set => base.SetValue(CirclePointRingLoading.BindableWidthProperty, value);
        }

        // Token: 0x06000003 RID: 3 RVA: 0x00002088 File Offset: 0x00000288
        private static void BindableWidthCallback(DependencyObject dependencyObject,
            DependencyPropertyChangedEventArgs e)
        {
            var circlePointRingLoading = dependencyObject as CirclePointRingLoading;
            var flag = circlePointRingLoading == null;
            if (!flag)
            {
                circlePointRingLoading.SetEllipseDiameter((double)e.NewValue);
                circlePointRingLoading.SetEllipseOffset((double)e.NewValue);
                circlePointRingLoading.SetMaxSideLength((double)e.NewValue);
            }
        }

        // Token: 0x06000004 RID: 4 RVA: 0x000020E0 File Offset: 0x000002E0
        private void SetEllipseDiameter(double width)
        {
            this.EllipseDiameter = width / 8.0;
        }

        // Token: 0x06000005 RID: 5 RVA: 0x000020F5 File Offset: 0x000002F5
        private void SetEllipseOffset(double width)
        {
            this.EllipseOffset = new Thickness(0.0, width / 2.0, 0.0, 0.0);
        }

        // Token: 0x06000006 RID: 6 RVA: 0x0000212A File Offset: 0x0000032A
        private void SetMaxSideLength(double width)
        {
            this.MaxSideLength = ((width <= 20.0) ? 20.0 : width);
        }

        // Token: 0x17000002 RID: 2
        // (get) Token: 0x06000007 RID: 7 RVA: 0x0000214C File Offset: 0x0000034C
        // (set) Token: 0x06000008 RID: 8 RVA: 0x0000216E File Offset: 0x0000036E
        public bool IsActive
        {
            get => (bool)base.GetValue(CirclePointRingLoading.IsActiveProperty);
            set => base.SetValue(CirclePointRingLoading.IsActiveProperty, value);
        }

        // Token: 0x06000009 RID: 9 RVA: 0x00002184 File Offset: 0x00000384
        private static void IsActiveChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var circlePointRingLoading = sender as CirclePointRingLoading;
            var flag = circlePointRingLoading == null;
            if (!flag)
            {
                circlePointRingLoading.UpdateActiveState();
            }
        }

        // Token: 0x0600000A RID: 10 RVA: 0x000021AC File Offset: 0x000003AC
        private void UpdateActiveState()
        {
            var isActive = this.IsActive;
            if (isActive)
            {
                VisualStateManager.GoToState(this, this.StateActive, true);
            }
            else
            {
                VisualStateManager.GoToState(this, this.StateInActive, true);
            }
        }

        // Token: 0x17000003 RID: 3
        // (get) Token: 0x0600000B RID: 11 RVA: 0x000021E4 File Offset: 0x000003E4
        // (set) Token: 0x0600000C RID: 12 RVA: 0x00002206 File Offset: 0x00000406
        public bool IsLarge
        {
            get => (bool)base.GetValue(CirclePointRingLoading.IsLargeProperty);
            set => base.SetValue(CirclePointRingLoading.IsLargeProperty, value);
        }

        // Token: 0x0600000D RID: 13 RVA: 0x0000221C File Offset: 0x0000041C
        private static void IsLargeChangedCallback(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var circlePointRingLoading = sender as CirclePointRingLoading;
            var flag = circlePointRingLoading == null;
            if (!flag)
            {
                circlePointRingLoading.UpdateLargeState();
            }
        }

        // Token: 0x0600000E RID: 14 RVA: 0x00002244 File Offset: 0x00000444
        private void UpdateLargeState()
        {
            var isLarge = this.IsLarge;
            if (isLarge)
            {
                VisualStateManager.GoToState(this, this.StateLarge, true);
            }
            else
            {
                VisualStateManager.GoToState(this, this.StateSmall, true);
            }
        }

        // Token: 0x17000004 RID: 4
        // (get) Token: 0x0600000F RID: 15 RVA: 0x0000227C File Offset: 0x0000047C
        // (set) Token: 0x06000010 RID: 16 RVA: 0x0000229E File Offset: 0x0000049E
        public double MaxSideLength
        {
            get => (double)base.GetValue(CirclePointRingLoading.MaxSideLengthProperty);
            set => base.SetValue(CirclePointRingLoading.MaxSideLengthProperty, value);
        }

        // Token: 0x17000005 RID: 5
        // (get) Token: 0x06000011 RID: 17 RVA: 0x000022B4 File Offset: 0x000004B4
        // (set) Token: 0x06000012 RID: 18 RVA: 0x000022D6 File Offset: 0x000004D6
        public double EllipseDiameter
        {
            get => (double)base.GetValue(CirclePointRingLoading.EllipseDiameterProperty);
            set => base.SetValue(CirclePointRingLoading.EllipseDiameterProperty, value);
        }

        // Token: 0x17000006 RID: 6
        // (get) Token: 0x06000013 RID: 19 RVA: 0x000022EC File Offset: 0x000004EC
        // (set) Token: 0x06000014 RID: 20 RVA: 0x0000230E File Offset: 0x0000050E
        public Thickness EllipseOffset
        {
            get => (Thickness)base.GetValue(CirclePointRingLoading.EllipseOffsetProperty);
            set => base.SetValue(CirclePointRingLoading.EllipseOffsetProperty, value);
        }

        // Token: 0x06000015 RID: 21 RVA: 0x00002324 File Offset: 0x00000524
        public CirclePointRingLoading()
        {


            base.SizeChanged += new SizeChangedEventHandler((object argument0, SizeChangedEventArgs argument1) =>
                this.BindableWidth = base.ActualWidth);
        }

        // Token: 0x06000016 RID: 22 RVA: 0x00002378 File Offset: 0x00000578
        static CirclePointRingLoading()
        {
            FrameworkElement.DefaultStyleKeyProperty.OverrideMetadata(typeof(CirclePointRingLoading),
                new FrameworkPropertyMetadata(typeof(CirclePointRingLoading)));
            UIElement.VisibilityProperty.OverrideMetadata(typeof(CirclePointRingLoading), new FrameworkPropertyMetadata(
                delegate (DependencyObject ringObject, DependencyPropertyChangedEventArgs e)
                {
                    var flag = e.NewValue != e.OldValue;
                    if (flag)
                    {
                        var circlePointRingLoading = (CirclePointRingLoading)ringObject;
                        var flag2 = (Visibility)e.NewValue > Visibility.Visible;
                        if (flag2)
                        {
                            circlePointRingLoading.SetCurrentValue(CirclePointRingLoading.IsActiveProperty, false);
                        }
                        else
                        {
                            circlePointRingLoading.IsActive = true;
                        }
                    }
                }));
        }

        // Token: 0x06000017 RID: 23 RVA: 0x00002531 File Offset: 0x00000731
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            this.UpdateLargeState();
            this.UpdateActiveState();
        }

        // Token: 0x04000001 RID: 1
        private string StateActive = "Active";

        // Token: 0x04000002 RID: 2
        private string StateInActive = "InActive";

        // Token: 0x04000003 RID: 3
        private string StateLarge = "Large";

        // Token: 0x04000004 RID: 4
        private string StateSmall = "Small";

        // Token: 0x04000005 RID: 5
        public static readonly DependencyProperty BindableWidthProperty = DependencyProperty.Register("BindableWidth",
            typeof(double), typeof(CirclePointRingLoading),
            new PropertyMetadata(0.0, new PropertyChangedCallback(CirclePointRingLoading.BindableWidthCallback)));

        // Token: 0x04000006 RID: 6
        public static readonly DependencyProperty IsActiveProperty = DependencyProperty.Register("IsActive",
            typeof(bool), typeof(CirclePointRingLoading),
            new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,
                new PropertyChangedCallback(CirclePointRingLoading.IsActiveChanged)));

        // Token: 0x04000007 RID: 7
        public static readonly DependencyProperty IsLargeProperty = DependencyProperty.Register("IsLarge", typeof(bool),
            typeof(CirclePointRingLoading),
            new PropertyMetadata(true, new PropertyChangedCallback(CirclePointRingLoading.IsLargeChangedCallback)));

        // Token: 0x04000008 RID: 8
        public static readonly DependencyProperty MaxSideLengthProperty = DependencyProperty.Register("MaxSideLength",
            typeof(double), typeof(CirclePointRingLoading), new PropertyMetadata(0.0));

        // Token: 0x04000009 RID: 9
        public static readonly DependencyProperty EllipseDiameterProperty =
            DependencyProperty.Register("EllipseDiameter", typeof(double), typeof(CirclePointRingLoading),
                new PropertyMetadata(0.0));

        // Token: 0x0400000A RID: 10
        public static readonly DependencyProperty EllipseOffsetProperty = DependencyProperty.Register("EllipseOffset",
            typeof(Thickness), typeof(CirclePointRingLoading), new PropertyMetadata(default(Thickness)));
    }
}
