carmanager-3/CarManagerV3/Forms/Components/AnimatedProgressBar.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace CarManagerV3
{
    public class AnimatedProgressBar : UserControl
    {
        private Timer animationTimer;
        private float animationPosition = 0f;
        private Color primaryColor = Color.FromArgb(0, 120, 215);
        private Color secondaryColor = Color.FromArgb(100, 180, 255);
        private Color backgroundColor = Color.FromArgb(240, 240, 240);

        public AnimatedProgressBar()
        {
            this.SetStyle(
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.UserPaint |
                ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw,
                true);

            this.Height = 8;

            // Initialize animation timer
            animationTimer = new Timer();
            animationTimer.Interval = 20; // 50 FPS
            animationTimer.Tick += AnimationTimer_Tick;
            animationTimer.Start();
        }

        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            animationPosition += 2f;
            if (animationPosition > this.Width + 100)
            {
                animationPosition = -100;
            }
            this.Invalidate();
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.PixelOffsetMode = PixelOffsetMode.HighQuality;

            // Draw background with rounded corners
            using (GraphicsPath path = GetRoundedRect(ClientRectangle, 4))
            {
                using (SolidBrush bgBrush = new SolidBrush(backgroundColor))
                {
                    g.FillPath(bgBrush, path);
                }
            }

            // Create animated gradient bar
            float barWidth = 100f;
            RectangleF barRect = new RectangleF(animationPosition, 0, barWidth, this.Height);

            if (barRect.Right > 0 && barRect.Left < this.Width)
            {
                using (GraphicsPath barPath = GetRoundedRect(barRect, 4))
                {
                    // Create gradient brush
                    using (LinearGradientBrush gradientBrush = new LinearGradientBrush(
                        barRect,
                        Color.Transparent,
                        Color.Transparent,
                        LinearGradientMode.Horizontal))
                    {
                        ColorBlend colorBlend = new ColorBlend();
                        colorBlend.Colors = new Color[] {
                            Color.FromArgb(0, primaryColor),
                            primaryColor,
                            secondaryColor,
                            primaryColor,
                            Color.FromArgb(0, primaryColor)
                        };
                        colorBlend.Positions = new float[] { 0f, 0.2f, 0.5f, 0.8f, 1f };
                        gradientBrush.InterpolationColors = colorBlend;

                        // Clip to control bounds
                        Region oldClip = g.Clip;
                        using (GraphicsPath clipPath = GetRoundedRect(ClientRectangle, 4))
                        {
                            g.SetClip(clipPath);
                            g.FillPath(gradientBrush, barPath);
                            g.Clip = oldClip;
                        }
                    }
                }
            }

            // Draw subtle border
            using (GraphicsPath borderPath = GetRoundedRect(ClientRectangle, 4))
            {
                using (Pen borderPen = new Pen(Color.FromArgb(220, 220, 220), 1))
                {
                    g.DrawPath(borderPen, borderPath);
                }
            }
        }

        private GraphicsPath GetRoundedRect(RectangleF rect, float radius)
        {
            GraphicsPath path = new GraphicsPath();
            float diameter = radius * 2;

            path.AddArc(rect.X, rect.Y, diameter, diameter, 180, 90);
            path.AddArc(rect.Right - diameter, rect.Y, diameter, diameter, 270, 90);
            path.AddArc(rect.Right - diameter, rect.Bottom - diameter, diameter, diameter, 0, 90);
            path.AddArc(rect.X, rect.Bottom - diameter, diameter, diameter, 90, 90);
            path.CloseFigure();

            return path;
        }

        public void StartAnimation()
        {
            animationTimer.Start();
        }

        public void StopAnimation()
        {
            animationTimer.Stop();
        }

        //protected override void Dispose(bool disposing)
        //{
        //    if (disposing)
        //    {
        //        animationTimer?.Stop();
        //        animationTimer?.Dispose();
        //    }
        //    base.Dispose(disposing);
        //}

        // Properties for customization
        public Color PrimaryColor
        {
            get => primaryColor;
            set
            {
                primaryColor = value;
                this.Invalidate();
            }
        }

        public Color SecondaryColor
        {
            get => secondaryColor;
            set
            {
                secondaryColor = value;
                this.Invalidate();
            }
        }

        public Color ProgressBackColor
        {
            get => backgroundColor;
            set
            {
                backgroundColor = value;
                this.Invalidate();
            }
        }
    }
}