ControlWidgetWindow.xaml.cs

using System;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace ScreenLight
{
    public partial class ControlWidgetWindow : Window
    {
        // ============================================================
        // OVERLAY
        // ============================================================

        private readonly RingOverlayWindow
            _overlayWindow;


        // ============================================================
        // STATE
        // ============================================================

        private bool _isExpanded = false;

        private bool _isMouseInside = false;

        private bool _isDragging = false;

        private bool _isHoverPending = false;


        private ScreenEdge _currentEdge =
            ScreenEdge.Right;


        /*
         * Widget'ın bulunduğu kenar üzerindeki
         * merkez konumu.
         *
         * Left / Right:
         * Y koordinatı.
         *
         * Top:
         * X koordinatı.
         */
        private double _dockPosition;


        // ============================================================
        // COLLAPSED SIZE
        // ============================================================

        private const double
            SideCollapsedWidth = 44;

        private const double
            SideCollapsedHeight = 90;


        private const double
            TopCollapsedWidth = 90;

        private const double
            TopCollapsedHeight = 44;


        // ============================================================
        // EXPANDED SIZE
        // ============================================================

        private const double
            ExpandedWidth = 340;

        private const double
            ExpandedHeight = 530;


        // ============================================================
        // CONSTRUCTOR
        // ============================================================

        public ControlWidgetWindow(
            RingOverlayWindow overlayWindow)
        {
            /*
             * Slider ValueChanged event'leri
             * InitializeComponent sırasında tetiklenebilir.
             *
             * Bu yüzden overlay referansını önce atıyoruz.
             */

            _overlayWindow =
                overlayWindow;


            InitializeComponent();


            // ========================================================
            // INITIAL CONTROL VALUES
            // ========================================================

            ThicknessSlider.Value =
                _overlayWindow.LightThickness;


            BrightnessSlider.Value =
                _overlayWindow.Brightness
                * 100;


            TemperatureSlider.Value =
                _overlayWindow.ColorTemperature;


            SoftnessSlider.Value =
                _overlayWindow.Softness
                * 100;


            ToggleLightButton.Content =
                _overlayWindow.IsLightEnabled
                ? "ON"
                : "OFF";


            TemperatureValueText.Text =
                $"{(int)_overlayWindow.ColorTemperature}K";


            SoftnessValueText.Text =
                $"{(int)(_overlayWindow.Softness * 100)}%";


            ThicknessValueText.Text =
                $"{(int)_overlayWindow.LightThickness} px";


            BrightnessValueText.Text =
                $"{(int)(_overlayWindow.Brightness * 100)}%";


            // ========================================================
            // INITIAL WIDGET LOCATION
            // ========================================================

            _currentEdge =
                ScreenEdge.Right;


            _dockPosition =
                SystemParameters
                .PrimaryScreenHeight / 2;


            ApplyCollapsedOrientation();

            PositionCollapsedWindow();

            UpdateArrow();

            UpdateWidgetCorners();
        }


        // ============================================================
        // COLLAPSED ORIENTATION
        // ============================================================

        private void ApplyCollapsedOrientation()
        {
            if (_currentEdge ==
                ScreenEdge.Top)
            {
                /*
                 * Top edge:
                 *
                 * ┌──────────┐
                 * │    ↓     │
                 * └──────────┘
                 */

                Width =
                    TopCollapsedWidth;

                Height =
                    TopCollapsedHeight;
            }
            else
            {
                /*
                 * Left / Right:
                 *
                 * ┌────┐
                 * │ ←  │
                 * └────┘
                 */

                Width =
                    SideCollapsedWidth;

                Height =
                    SideCollapsedHeight;
            }
        }


        // ============================================================
        // COLLAPSED POSITION
        // ============================================================

        private void PositionCollapsedWindow()
        {
            ApplyCollapsedOrientation();


            double screenWidth =
                SystemParameters
                .PrimaryScreenWidth;


            double screenHeight =
                SystemParameters
                .PrimaryScreenHeight;


            switch (_currentEdge)
            {
                // ====================================================
                // LEFT
                // ====================================================

                case ScreenEdge.Left:

                    Left = 0;


                    Top =
                        Clamp(
                            _dockPosition
                            - Height / 2,

                            0,

                            screenHeight
                            - Height
                        );

                    break;


                // ====================================================
                // RIGHT
                // ====================================================

                case ScreenEdge.Right:

                    Left =
                        screenWidth
                        - Width;


                    Top =
                        Clamp(
                            _dockPosition
                            - Height / 2,

                            0,

                            screenHeight
                            - Height
                        );

                    break;


                // ====================================================
                // TOP
                // ====================================================

                case ScreenEdge.Top:

                    Top = 0;


                    Left =
                        Clamp(
                            _dockPosition
                            - Width / 2,

                            0,

                            screenWidth
                            - Width
                        );

                    break;
            }


            UpdateWidgetCorners();
        }


        // ============================================================
        // DRAG
        // ============================================================

        private void
            CollapsedView_MouseLeftButtonDown(
                object sender,
                MouseButtonEventArgs e)
        {
            if (e.LeftButton !=
                MouseButtonState.Pressed)
            {
                return;
            }


            /*
             * Hover ile açılmayı iptal et.
             */

            _isHoverPending = false;

            _isDragging = true;


            e.Handled = true;


            try
            {
                /*
                 * Windows / WPF native dragging.
                 *
                 * Mouse ile pencere arasındaki
                 * takip problemi yaşamamak için
                 * manuel koordinat hesaplamıyoruz.
                 */

                DragMove();
            }
            catch
            {
                /*
                 * Drag sırasında mouse beklenmedik
                 * şekilde bırakılırsa hata almamak için.
                 */
            }
            finally
            {
                _isDragging = false;

                _isHoverPending = false;


                SnapToNearestEdge();
            }
        }


        // ============================================================
        // SNAP TO NEAREST EDGE
        // ============================================================

        private void SnapToNearestEdge()
        {
            double screenWidth =
                SystemParameters
                .PrimaryScreenWidth;


            double centerX =
                Left + Width / 2;


            double centerY =
                Top + Height / 2;


            /*
             * Bottom intentionally unsupported.
             *
             * Only:
             *
             * Left
             * Right
             * Top
             */


            double distanceLeft =
                centerX;


            double distanceRight =
                screenWidth
                - centerX;


            double distanceTop =
                centerY;


            double minimumDistance =
                Math.Min(
                    distanceLeft,

                    Math.Min(
                        distanceRight,
                        distanceTop
                    )
                );


            // ========================================================
            // LEFT
            // ========================================================

            if (minimumDistance ==
                distanceLeft)
            {
                _currentEdge =
                    ScreenEdge.Left;


                _dockPosition =
                    centerY;
            }

            // ========================================================
            // RIGHT
            // ========================================================

            else if (minimumDistance ==
                     distanceRight)
            {
                _currentEdge =
                    ScreenEdge.Right;


                _dockPosition =
                    centerY;
            }

            // ========================================================
            // TOP
            // ========================================================

            else
            {
                _currentEdge =
                    ScreenEdge.Top;


                _dockPosition =
                    centerX;
            }


            PositionCollapsedWindow();

            UpdateArrow();

            UpdateWidgetCorners();
        }


        // ============================================================
        // ARROW
        // ============================================================

        private void UpdateArrow()
        {
            ArrowText.Text =
                _currentEdge switch
                {
                    ScreenEdge.Left =>
                        "→",

                    ScreenEdge.Right =>
                        "←",

                    ScreenEdge.Top =>
                        "↓",

                    _ =>
                        "←"
                };


            UpdateWidgetCorners();
        }


        // ============================================================
        // PREMIUM CORNERS
        // ============================================================

        private void UpdateWidgetCorners()
        {
            if (RootBorder == null)
                return;


            switch (_currentEdge)
            {
                // ====================================================
                // LEFT EDGE
                //
                // Screen edge:
                //
                // │────────╮
                // │   →    │
                // │────────╯
                //
                // Left corners = square
                // Right corners = rounded
                // ====================================================

                case ScreenEdge.Left:

                    RootBorder.CornerRadius =
                        new CornerRadius(
                            0,
                            14,
                            14,
                            0
                        );

                    break;


                // ====================================================
                // RIGHT EDGE
                //
                // ╭────────│
                // │   ←    │
                // ╰────────│
                //
                // Left corners = rounded
                // Right corners = square
                // ====================================================

                case ScreenEdge.Right:

                    RootBorder.CornerRadius =
                        new CornerRadius(
                            14,
                            0,
                            0,
                            14
                        );

                    break;


                // ====================================================
                // TOP EDGE
                //
                // ────────────
                // │     ↓    │
                // ╰──────────╯
                //
                // Top corners = square
                // Bottom corners = rounded
                // ====================================================

                case ScreenEdge.Top:

                    RootBorder.CornerRadius =
                        new CornerRadius(
                            0,
                            0,
                            14,
                            14
                        );

                    break;
            }
        }


        // ============================================================
        // HOVER ENTER
        // ============================================================

        private async void Window_MouseEnter(
            object sender,
            MouseEventArgs e)
        {
            _isMouseInside = true;


            if (_isDragging ||
                _isExpanded)
            {
                return;
            }


            _isHoverPending = true;


            /*
             * Kullanıcı drag yapmak istiyorsa
             * panel hemen açılmasın.
             */

            await Task.Delay(400);


            if (_isHoverPending &&
                _isMouseInside &&
                !_isDragging &&
                !_isExpanded)
            {
                ExpandWindow();
            }
        }


        // ============================================================
        // HOVER LEAVE
        // ============================================================

        private async void Window_MouseLeave(
            object sender,
            MouseEventArgs e)
        {
            _isMouseInside = false;

            _isHoverPending = false;


            if (_isDragging)
                return;


            await Task.Delay(650);


            if (!_isMouseInside &&
                !_isDragging)
            {
                CollapseWindow();
            }
        }


        // ============================================================
        // EXPAND
        // ============================================================

        private void ExpandWindow()
        {
            if (_isExpanded ||
                _isDragging)
            {
                return;
            }


            _isExpanded = true;


            double screenWidth =
                SystemParameters
                .PrimaryScreenWidth;


            double screenHeight =
                SystemParameters
                .PrimaryScreenHeight;


            Width =
                ExpandedWidth;


            Height =
                ExpandedHeight;


            switch (_currentEdge)
            {
                // ====================================================
                // LEFT
                //
                // Opens right.
                // ====================================================

                case ScreenEdge.Left:

                    Left = 0;


                    Top =
                        Clamp(
                            _dockPosition
                            - Height / 2,

                            0,

                            screenHeight
                            - Height
                        );

                    break;


                // ====================================================
                // RIGHT
                //
                // Opens left.
                // ====================================================

                case ScreenEdge.Right:

                    Left =
                        screenWidth
                        - Width;


                    Top =
                        Clamp(
                            _dockPosition
                            - Height / 2,

                            0,

                            screenHeight
                            - Height
                        );

                    break;


                // ====================================================
                // TOP
                //
                // Opens down.
                // ====================================================

                case ScreenEdge.Top:

                    Top = 0;


                    Left =
                        Clamp(
                            _dockPosition
                            - Width / 2,

                            0,

                            screenWidth
                            - Width
                        );

                    break;
            }


            CollapsedView.Visibility =
                Visibility.Collapsed;


            ExpandedView.Visibility =
                Visibility.Visible;


            UpdateWidgetCorners();
        }


        // ============================================================
        // COLLAPSE
        // ============================================================

        private void CollapseWindow()
        {
            if (!_isExpanded)
                return;


            _isExpanded = false;


            ExpandedView.Visibility =
                Visibility.Collapsed;


            CollapsedView.Visibility =
                Visibility.Visible;


            PositionCollapsedWindow();

            UpdateArrow();

            UpdateWidgetCorners();
        }


        // ============================================================
        // BRIGHTNESS
        // ============================================================

        private void
            BrightnessSlider_ValueChanged(
                object sender,
                RoutedPropertyChangedEventArgs<double> e)
        {
            if (_overlayWindow == null)
                return;


            double brightness =
                e.NewValue / 100.0;


            _overlayWindow.Brightness =
                brightness;


            if (BrightnessValueText != null)
            {
                BrightnessValueText.Text =
                    $"{(int)e.NewValue}%";
            }
        }


        // ============================================================
        // TEMPERATURE
        // ============================================================

        private void
            TemperatureSlider_ValueChanged(
                object sender,
                RoutedPropertyChangedEventArgs<double> e)
        {
            if (_overlayWindow == null)
                return;


            _overlayWindow.ColorTemperature =
                e.NewValue;


            if (TemperatureValueText != null)
            {
                TemperatureValueText.Text =
                    $"{(int)e.NewValue}K";
            }
        }


        // ============================================================
        // TEMPERATURE PRESETS
        // ============================================================

        private void TemperaturePreset_Click(
            object sender,
            RoutedEventArgs e)
        {
            if (sender is not Button button)
                return;


            if (button.Tag == null)
                return;


            if (!double.TryParse(
                    button.Tag.ToString(),
                    out double temperature))
            {
                return;
            }


            TemperatureSlider.Value =
                temperature;
        }


        // ============================================================
        // SOFTNESS
        // ============================================================

        private void
            SoftnessSlider_ValueChanged(
                object sender,
                RoutedPropertyChangedEventArgs<double> e)
        {
            if (_overlayWindow == null)
                return;


            double softness =
                e.NewValue / 100.0;


            _overlayWindow.Softness =
                softness;


            if (SoftnessValueText != null)
            {
                SoftnessValueText.Text =
                    $"{(int)e.NewValue}%";
            }
        }


        // ============================================================
        // THICKNESS
        // ============================================================

        private void
            ThicknessSlider_ValueChanged(
                object sender,
                RoutedPropertyChangedEventArgs<double> e)
        {
            if (_overlayWindow == null)
                return;


            _overlayWindow.LightThickness =
                e.NewValue;


            if (ThicknessValueText != null)
            {
                ThicknessValueText.Text =
                    $"{(int)e.NewValue} px";
            }
        }


        // ============================================================
        // LIGHT ON / OFF
        // ============================================================

        private void ToggleLightButton_Click(
            object sender,
            RoutedEventArgs e)
        {
            _overlayWindow.IsLightEnabled =
                !_overlayWindow.IsLightEnabled;


            ToggleLightButton.Content =
                _overlayWindow.IsLightEnabled
                ? "ON"
                : "OFF";
        }


        // ============================================================
        // EXIT APPLICATION
        // ============================================================

        private void CloseApplicationButton_Click(
            object sender,
            RoutedEventArgs e)
        {
            /*
             * Sadece ControlWidgetWindow'u değil,
             * RingOverlayWindow dahil bütün
             * ScreenLight process'ini kapatır.
             */

            Application.Current.Shutdown();
        }


        // ============================================================
        // HELPERS
        // ============================================================

        private static double Clamp(
            double value,
            double minimum,
            double maximum)
        {
            return Math.Max(
                minimum,

                Math.Min(
                    maximum,
                    value
                )
            );
        }
    }


    // ================================================================
    // SUPPORTED SCREEN EDGES
    // ================================================================

    public enum ScreenEdge
    {
        Left,
        Right,
        Top
    }
}