// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms.Design.Behavior;

namespace System.Windows.Forms.Design;

/// <summary>
///  Contains designer utilities.
/// </summary>
internal static class DesignerUtils
{
    private static Size s_minDragSize = Size.Empty;
    // brush used to draw a 'hover' state over a designer action glyph
    private static SolidBrush s_hoverBrush = new(Color.FromArgb(alpha: 50, SystemColors.Highlight));
    // brush used to draw the resizeable selection borders around controls/components
    private static HatchBrush s_selectionBorderBrush =
        new(HatchStyle.Percent50, SystemColors.ControlDarkDark, SystemColors.ControlDarkDark);
    // Pens and Brushes used via GDI to render our grabhandles
    private static HBRUSH s_grabHandleFillBrushPrimary =
        PInvoke.CreateSolidBrush((COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.Window));
    private static HBRUSH s_grabHandleFillBrush =
        PInvoke.CreateSolidBrush((COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.ControlText));
    private static HPEN s_grabHandlePenPrimary =
        PInvoke.CreatePen(PEN_STYLE.PS_SOLID, cWidth: 1, (COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.ControlText));
    private static HPEN s_grabHandlePen =
        PInvoke.CreatePen(PEN_STYLE.PS_SOLID, cWidth: 1, (COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.Window));

    // The box-like image used as the user is dragging comps from the toolbox
    private static Bitmap? s_boxImage;
    public static int s_boxImageSize = ScaleLogicalToDeviceUnitsX(16);

    // selection border size
    public static int s_selectionBorderSize = ScaleLogicalToDeviceUnitsX(1);
    // Although the selection border is only 1, we actually want a 3 pixel hittestarea
    public static int s_selectionBorderHitArea = ScaleLogicalToDeviceUnitsX(3);

    // We want to make sure that the 1 pixel selectionborder is centered on the handles.
    // The fact that the border is actually 3 pixels wide works like magic. If you draw a picture, then you will see why.
    // grabhandle size (diameter)
    public static int s_handleSize = ScaleLogicalToDeviceUnitsX(7);
    // how much should the grabhandle overlap the control
    public static int s_handleOverlap = ScaleLogicalToDeviceUnitsX(2);
    // we want the selection border to be centered on a grabhandle, so how much do. we need to offset the border from the control to make that happen
    public static int s_selectionBorderOffset = ((s_handleSize - s_selectionBorderSize) / 2) - s_handleOverlap;

    // no-resize handle size (diameter)
    public static int s_noResizeHandleSize = ScaleLogicalToDeviceUnitsX(5);
    // we want the selection border to be centered on a grabhandle, so how much do
    // we need to offset the border from the control to make that happen
    public static int s_noResizeBorderOffset = ((s_noResizeHandleSize - s_selectionBorderSize) / 2);

    // lock handle height
    public static int s_lockHandleHeight = ScaleLogicalToDeviceUnitsX(9);
    // total lock handle width
    public static int s_lockHandleWidth = ScaleLogicalToDeviceUnitsX(7);
    // how much should the lockhandle overlap the control
    public static int s_lockHandleOverlap = ScaleLogicalToDeviceUnitsX(2);
    // we want the selection border to be centered on the no-resize handle, so calculate how many pixels we need
    // to offset the selection border from the control -- since the handle is not square, we need one in each direction
    public static int s_lockedSelectionBorderOffsetY = ((s_lockHandleHeight - s_selectionBorderSize) / 2) - s_lockHandleOverlap;
    public static int s_lockedSelectionBorderOffsetX = ((s_lockHandleWidth - s_selectionBorderSize) / 2) - s_lockHandleOverlap;

    // upper rectangle size (diameter)
    public static int s_lockedHandleSizeUpper = ScaleLogicalToDeviceUnitsX(5);
    // lower rectangle size
    public static int s_lockedHandleHeightLower = ScaleLogicalToDeviceUnitsX(6);
    public static int s_lockedHandleWidthLower = ScaleLogicalToDeviceUnitsX(7);

    // Offset used when drawing the upper rect of a lock handle
    public static int s_lockedHandleUpperOffset = (s_lockedHandleWidthLower - s_lockedHandleSizeUpper) / 2;
    // Offset used when drawing the lower rect of a lock handle
    public static int s_lockedHandleLowerOffset = (s_lockHandleHeight - s_lockedHandleHeightLower);

    public static int s_containerGrabHandleSize = ScaleLogicalToDeviceUnitsX(15);
    // delay for showing snaplines on keyboard movements
    public static int s_snapLineDelay = 1000;

    // min new row/col style size for the table layout panel
    public static int s_minimumStyleSize = 20;
    public static int s_minimumStylePercent = 50;

    // min width/height used to create bitmap to paint control into.
    public static int s_minimumControlBitmapSize = 1;
    // min size for row/col style during a resize drag operation
    public static int s_minimumSizeDrag = 8;
    // min # of rows/cols for the tablelayoutpanel when it is newly created
    public static int s_defaultRowCount = 2;
    public static int s_defaultColumnCount = 2;

    // size of the col/row grab handle glyphs for the table layout panel
    public static int s_resizeGlyphSize = ScaleLogicalToDeviceUnitsX(4);

    // default value for Form padding if it has not been set in the designer (usability study request)
    public static int s_defaultFormPadding = 9;

    // use these value to signify ANY of the right, top, left, center, or bottom alignments with the ContentAlignment enum.
    public const ContentAlignment AnyTopAlignment = ContentAlignment.TopLeft | ContentAlignment.TopCenter | ContentAlignment.TopRight;
    public const ContentAlignment AnyMiddleAlignment = ContentAlignment.MiddleLeft | ContentAlignment.MiddleCenter | ContentAlignment.MiddleRight;

    /// <summary>
    ///  Used when the user clicks and drags a toolbox item onto the documentdesigner - this is the small box that is painted beneath the mouse pointer.
    /// </summary>
    public static Image BoxImage
    {
        get
        {
            if (s_boxImage is null)
            {
                s_boxImage = new Bitmap(s_boxImageSize, s_boxImageSize, PixelFormat.Format32bppPArgb);
                using Graphics g = Graphics.FromImage(s_boxImage);
                g.FillRectangle(new SolidBrush(SystemColors.InactiveBorder), 0, 0, s_boxImageSize, s_boxImageSize);
                g.DrawRectangle(new Pen(SystemColors.ControlDarkDark), 0, 0, s_boxImageSize - 1, s_boxImageSize - 1);
            }

            return s_boxImage;
        }
    }

    /// <summary>
    ///  Used by Designer action glyphs to render a 'mouse hover' state.
    /// </summary>
    public static Brush HoverBrush => s_hoverBrush;

    /// <summary>
    ///  Demand created size used to determine how far the user needs to drag the mouse before a drag operation starts.
    /// </summary>
    public static Size MinDragSize
    {
        get
        {
            if (s_minDragSize == Size.Empty)
            {
                Size minDrag = SystemInformation.DragSize;
                Size minDblClick = SystemInformation.DoubleClickSize;
                s_minDragSize.Width = Math.Max(minDrag.Width, minDblClick.Width);
                s_minDragSize.Height = Math.Max(minDrag.Height, minDblClick.Height);
            }

            return s_minDragSize;
        }
    }

    public static Point LastCursorPoint
    {
        get
        {
            int lastXY = (int)PInvoke.GetMessagePos();
            return new Point(PARAM.SignedLOWORD(lastXY), PARAM.SignedHIWORD(lastXY));
        }
    }

    // Recreate the brushes - behaviorservice calls this when the user preferences changes
    public static void SyncBrushes()
    {
        s_hoverBrush.Dispose();
        s_hoverBrush = new SolidBrush(Color.FromArgb(50, SystemColors.Highlight));

        s_selectionBorderBrush.Dispose();
        s_selectionBorderBrush = new HatchBrush(HatchStyle.Percent50, SystemColors.ControlDarkDark, SystemColors.ControlDarkDark);

        PInvokeCore.DeleteObject(s_grabHandleFillBrushPrimary);
        s_grabHandleFillBrushPrimary = PInvoke.CreateSolidBrush((COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.Window));

        PInvokeCore.DeleteObject(s_grabHandleFillBrush);
        s_grabHandleFillBrush = PInvoke.CreateSolidBrush((COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.ControlText));

        PInvokeCore.DeleteObject(s_grabHandlePenPrimary);
        s_grabHandlePenPrimary = PInvoke.CreatePen(PEN_STYLE.PS_SOLID, cWidth: 1, (COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.ControlText));

        PInvokeCore.DeleteObject(s_grabHandlePen);
        s_grabHandlePen = PInvoke.CreatePen(PEN_STYLE.PS_SOLID, cWidth: 1, (COLORREF)(uint)ColorTranslator.ToWin32(SystemColors.Window));
    }

    /// <summary>
    ///  Draws a ControlDarkDark border around the given image.
    /// </summary>
    private static void DrawDragBorder(Graphics g, Size imageSize, int borderSize, Color backColor)
    {
        Pen pen = SystemPens.ControlDarkDark;
        if (backColor != Color.Empty && backColor.GetBrightness() < .5)
        {
            pen = SystemPens.ControlLight;
        }

        // draw a border w/o the corners connecting
        g.DrawLine(pen, 1, 0, imageSize.Width - 2, 0);
        g.DrawLine(pen, 1, imageSize.Height - 1, imageSize.Width - 2, imageSize.Height - 1);
        g.DrawLine(pen, 0, 1, 0, imageSize.Height - 2);
        g.DrawLine(pen, imageSize.Width - 1, 1, imageSize.Width - 1, imageSize.Height - 2);

        // loop through drawing inner-rects until we get the proper thickness
        for (int i = 1; i < borderSize; i++)
        {
            g.DrawRectangle(pen, i, i, imageSize.Width - (2 + i), imageSize.Height - (2 + i));
        }
    }

    /// <summary>
    ///  Used for drawing the borders around controls that are being resized
    /// </summary>
    public static void DrawResizeBorder(Graphics g, Region resizeBorder, Color backColor)
    {
        Brush brush = SystemBrushes.ControlDarkDark;
        if (backColor != Color.Empty && backColor.GetBrightness() < .5)
        {
            brush = SystemBrushes.ControlLight;
        }

        g.FillRegion(brush, resizeBorder);
    }

    /// <summary>
    ///  Used for drawing the frame when doing a mouse drag
    /// </summary>
    public static void DrawFrame(Graphics g, Region resizeBorder, FrameStyle style, Color backColor)
    {
        Color color = SystemColors.ControlDarkDark;
        if (backColor != Color.Empty && backColor.GetBrightness() < .5)
        {
            color = SystemColors.ControlLight;
        }

        Brush brush = style switch
        {
            FrameStyle.Dashed => new HatchBrush(HatchStyle.Percent50, color, Color.Transparent),
            _ => new SolidBrush(color),
        };
        g.FillRegion(brush, resizeBorder);
        brush.Dispose();
    }

    /// <summary>
    ///  Used for drawing the grab handles around sizeable selected controls and components.
    /// </summary>
    public static void DrawGrabHandle(Graphics graphics, Rectangle bounds, bool isPrimary)
    {
        using DeviceContextHdcScope hDC = new(graphics, applyGraphicsState: false);

        // Set our pen and brush based on primary selection
        using SelectObjectScope brushSelection = new(hDC, isPrimary ? s_grabHandleFillBrushPrimary : s_grabHandleFillBrush);
        using SelectObjectScope penSelection = new(hDC, isPrimary ? s_grabHandlePenPrimary : s_grabHandlePen);

        // Draw our rounded rect grab handle
        PInvoke.RoundRect(hDC, bounds.Left, bounds.Top, bounds.Right, bounds.Bottom, 2, 2);
    }

    /// <summary>
    ///  Used for drawing the no-resize handle for non-resizeable selected controls and components.
    /// </summary>
    public static void DrawNoResizeHandle(Graphics graphics, Rectangle bounds, bool isPrimary)
    {
        using DeviceContextHdcScope hDC = new(graphics, applyGraphicsState: false);

        // Set our pen and brush based on primary selection
        using SelectObjectScope brushSelection = new(hDC, isPrimary ? s_grabHandleFillBrushPrimary : s_grabHandleFillBrush);
        using SelectObjectScope penSelection = new(hDC, s_grabHandlePenPrimary);

        // Draw our rect no-resize handle
        PInvoke.Rectangle(hDC, bounds.Left, bounds.Top, bounds.Right, bounds.Bottom);
    }

    /// <summary>
    ///  Used for drawing the lock handle for locked selected controls and components.
    /// </summary>
    public static void DrawLockedHandle(Graphics graphics, Rectangle bounds, bool isPrimary)
    {
        using DeviceContextHdcScope hDC = new(graphics, applyGraphicsState: false);

        using SelectObjectScope penSelection = new(hDC, s_grabHandlePenPrimary);

        // Upper rect - upper rect is always filled with the primary brush
        using SelectObjectScope brushSelection = new(hDC, s_grabHandleFillBrushPrimary);
        PInvoke.RoundRect(
            hDC,
            bounds.Left + s_lockedHandleUpperOffset,
            bounds.Top, bounds.Left + s_lockedHandleUpperOffset + s_lockedHandleSizeUpper,
            bounds.Top + s_lockedHandleSizeUpper,
            width: 2,
            height: 2);

        // Lower rect - its fillbrush depends on the primary selection
        PInvoke.SelectObject(hDC, isPrimary ? s_grabHandleFillBrushPrimary : s_grabHandleFillBrush);
        PInvoke.Rectangle(hDC, bounds.Left, bounds.Top + s_lockedHandleLowerOffset, bounds.Right, bounds.Bottom);
    }

    /// <summary>
    ///  Uses the lockedBorderBrush to draw a 'locked' border on the given Graphics at the specified bounds.
    /// </summary>
    public static void DrawSelectionBorder(Graphics graphics, Rectangle bounds)
    {
        graphics.FillRectangle(s_selectionBorderBrush, bounds);
    }

    /// <summary>
    ///  Used to generate an image that represents the given control.
    ///  First, this method will call the 'GenerateSnapShotWithWM_PRINT' method on the control.
    ///  If we believe that this method did not return us a valid image
    ///  (caused by some comctl/ax controls not properly responding to a wm_print)
    ///  then we will attempt to do a bitblt of the control instead.
    /// </summary>
    public static void GenerateSnapShot(Control control, out Bitmap image, int borderSize, double opacity, Color backColor)
    {
        // GenerateSnapShot will return a boolean value indicating if the control returned an image or not...
        if (!GenerateSnapShotWithWM_PRINT(control, out image))
        {
            // here, we failed to get the image on wmprint - so try bitblt
            GenerateSnapShotWithBitBlt(control, out image);
            // if we still failed - we'll just fall though, put up a border around an empty area and call it good enough
        }

        // set the opacity
        if (opacity is < 1.0 and > 0.0)
        {
            // make this semi-transparent
            SetImageAlpha(image, opacity);
        }

        // draw a drag border around this thing
        if (borderSize > 0)
        {
            using Graphics g = Graphics.FromImage(image);
            DrawDragBorder(g, image.Size, borderSize, backColor);
        }
    }

    /// <summary>
    ///  Retrieves the width and height of a selection border grab handle. Designers may need this to properly position their user interfaces.
    /// </summary>
    public static Size GetAdornmentDimensions(AdornmentType adornmentType) => adornmentType switch
    {
        AdornmentType.GrabHandle => new Size(s_handleSize, s_handleSize),
        AdornmentType.ContainerSelector or AdornmentType.Maximum => new Size(s_containerGrabHandleSize, s_containerGrabHandleSize),
        _ => new Size(0, 0),
    };

    public static bool UseSnapLines(IServiceProvider provider)
    {
        ArgumentNullException.ThrowIfNull(provider);
        object? optionValue = null;
        if (provider.TryGetService(out DesignerOptionService? options))
        {
            PropertyDescriptor? snaplinesProp = options.Options.Properties["UseSnapLines"];
            if (snaplinesProp is not null)
            {
                optionValue = snaplinesProp.GetValue(null);
            }
        }

        if (optionValue is not bool useSnapLines)
        {
            useSnapLines = true;
        }

        return useSnapLines;
    }

    public static object? GetOptionValue(IServiceProvider? provider, string name)
    {
        if (provider.TryGetService(out DesignerOptionService? designerOptionService))
        {
            PropertyDescriptor? prop = designerOptionService.Options.Properties[name];
            return prop?.GetValue(null);
        }

        if (provider.TryGetService(out IDesignerOptionService? optionService))
        {
            return optionService.GetOptionValue("WindowsFormsDesigner\\General", name);
        }

        return null;
    }

    /// <summary>
    ///  Uses BitBlt to geta snapshot of the control
    /// </summary>
    public static void GenerateSnapShotWithBitBlt(Control control, out Bitmap image)
    {
        // Get the DC's and create our image
        using GetDcScope controlDC = new((HWND)control.Handle);
        image = new Bitmap(
            Math.Max(control.Width, s_minimumControlBitmapSize),
            Math.Max(control.Height, s_minimumControlBitmapSize),
            PixelFormat.Format32bppPArgb);

        using Graphics gDest = Graphics.FromImage(image);

        if (control.BackColor == Color.Transparent)
        {
            gDest.Clear(SystemColors.Control);
        }

        using DeviceContextHdcScope destDC = new(gDest, applyGraphicsState: false);

        // Perform our bitblit operation to push the image into the dest bitmap
        PInvokeCore.BitBlt(
            destDC,
            x: 0,
            y: 0,
            image.Width,
            image.Height,
            controlDC,
            x1: 0,
            y1: 0,
            ROP_CODE.SRCCOPY);
    }

    /// <summary>
    ///  Uses WM_PRINT to get a snapshot of the control.  This method will return true if the control properly responded to the wm_print message.
    /// </summary>
    public static bool GenerateSnapShotWithWM_PRINT(Control control, out Bitmap image)
    {
        image = new Bitmap(
            Math.Max(control.Width, s_minimumControlBitmapSize),
            Math.Max(control.Height, s_minimumControlBitmapSize),
            PixelFormat.Format32bppPArgb);

        // Have to do this BEFORE we set the testcolor.
        if (control.BackColor == Color.Transparent)
        {
            using Graphics g = Graphics.FromImage(image);
            g.Clear(SystemColors.Control);
        }

        // To validate that the control responded to the wm_print message, we pre-populate the bitmap with a
        //  colored center pixel.  We assume that the control _did not_ respond to wm_print if these center pixel
        //  is still this value.

        Color testColor = Color.FromArgb(255, 252, 186, 238);
        image.SetPixel(image.Width / 2, image.Height / 2, testColor);
        using (Graphics g = Graphics.FromImage(image))
        {
            IntPtr hDc = g.GetHdc();
            PInvoke.SendMessage(
                control,
                PInvoke.WM_PRINT,
                (WPARAM)hDc,
                (LPARAM)(uint)(PInvoke.PRF_CHILDREN | PInvoke.PRF_CLIENT | PInvoke.PRF_ERASEBKGND | PInvoke.PRF_NONCLIENT));
            g.ReleaseHdc(hDc);
        }

        // Now check to see if our center pixel was cleared, if not then our WM_PRINT failed
        if (image.GetPixel(image.Width / 2, image.Height / 2).Equals(testColor))
        {
            return false;
        }

        return true;
    }

    /// <summary>
    ///  Used by the Glyphs and ComponentTray to determine the Top, Left, Right, Bottom and Body bound rects related to their original bounds and bordersize.
    /// </summary>
    public static Rectangle GetBoundsForSelectionType(Rectangle originalBounds, SelectionBorderGlyphType type, int borderSize) =>
        type switch
        {
            SelectionBorderGlyphType.Top => new Rectangle(originalBounds.Left - borderSize, originalBounds.Top - borderSize, originalBounds.Width + 2 * borderSize, borderSize),
            SelectionBorderGlyphType.Bottom => new Rectangle(originalBounds.Left - borderSize, originalBounds.Bottom, originalBounds.Width + 2 * borderSize, borderSize),
            SelectionBorderGlyphType.Left => new Rectangle(originalBounds.Left - borderSize, originalBounds.Top - borderSize, borderSize, originalBounds.Height + 2 * borderSize),
            SelectionBorderGlyphType.Right => new Rectangle(originalBounds.Right, originalBounds.Top - borderSize, borderSize, originalBounds.Height + 2 * borderSize),
            SelectionBorderGlyphType.Body => originalBounds,
            _ => Rectangle.Empty
        };

    /// <summary>
    ///  Used by the Glyphs and ComponentTray to determine the Top, Left, Right, Bottom and Body bound rects related to their original bounds and bordersize.
    ///  Offset - how many pixels between the border glyph and the control
    /// </summary>
    private static Rectangle GetBoundsForSelectionType(Rectangle originalBounds, SelectionBorderGlyphType type, int bordersize, int offset)
    {
        Rectangle bounds = GetBoundsForSelectionType(originalBounds, type, bordersize);
        if (offset != 0)
        {
            switch (type)
            {
                case SelectionBorderGlyphType.Top:
                    bounds.Offset(-offset, -offset);
                    bounds.Width += 2 * offset;
                    break;
                case SelectionBorderGlyphType.Bottom:
                    bounds.Offset(-offset, offset);
                    bounds.Width += 2 * offset;
                    break;
                case SelectionBorderGlyphType.Left:
                    bounds.Offset(-offset, -offset);
                    bounds.Height += 2 * offset;
                    break;
                case SelectionBorderGlyphType.Right:
                    bounds.Offset(offset, -offset);
                    bounds.Height += 2 * offset;
                    break;
                case SelectionBorderGlyphType.Body:
                    bounds = originalBounds;
                    break;
            }
        }

        return bounds;
    }

    /// <summary>
    ///  Used by the Glyphs and ComponentTray to determine the Top, Left, Right, Bottom and Body bound rects related to their original bounds and bordersize.
    /// </summary>
    public static Rectangle GetBoundsForSelectionType(Rectangle originalBounds, SelectionBorderGlyphType type)
    {
        return GetBoundsForSelectionType(originalBounds, type, s_selectionBorderSize, s_selectionBorderOffset);
    }

    public static Rectangle GetBoundsForNoResizeSelectionType(Rectangle originalBounds, SelectionBorderGlyphType type)
    {
        return GetBoundsForSelectionType(originalBounds, type, s_selectionBorderSize, s_noResizeBorderOffset);
    }

    /// <summary>
    ///  Identifies where the text baseline for our control which should be based on bounds, padding, font, and textalignment.
    /// </summary>
    public static unsafe int GetTextBaseline(Control ctrl, ContentAlignment alignment)
    {
        // determine the actual client area we are working in (w/padding)
        Rectangle face = ctrl.ClientRectangle;

        using Graphics g = ctrl.CreateGraphics();
        using DeviceContextHdcScope dc = new(g, applyGraphicsState: false);
        using ObjectScope hFont = new(ctrl.Font.ToHFONT());
        using SelectObjectScope hFontOld = new(dc, hFont);

        TEXTMETRICW metrics = default;
        PInvoke.GetTextMetrics(dc, &metrics);

        // get the font metrics via gdi
        // Add the font ascent to the baseline
        int fontAscent = metrics.tmAscent + 1;
        int fontHeight = metrics.tmHeight;

        // Now add it all up
        if ((alignment & AnyTopAlignment) != 0)
        {
            return face.Top + fontAscent;
        }
        else if ((alignment & AnyMiddleAlignment) != 0)
        {
            return face.Top + (face.Height / 2) - (fontHeight / 2) + fontAscent;
        }
        else
        {
            return face.Bottom - fontHeight + fontAscent;
        }
    }

    /// <summary>
    ///  Called by the ParentControlDesigner when creating a new control - this will update the
    ///  new control's bounds with the proper toolbox/snapline information that has been stored
    ///  off. If the ParentControlDesigner is so, we need to offset for that. This is because
    ///  all snapline stuff is done using a LTR coordinate system
    /// </summary>
    public static Rectangle GetBoundsFromToolboxSnapDragDropInfo(ToolboxSnapDragDropEventArgs e, Rectangle originalBounds, bool isMirrored)
    {
        Rectangle newBounds = originalBounds;

        // this should always be the case 'cause we don't
        // create 'e' unless we have an offset
        if (e.Offset != Point.Empty)
        {
            // snap either up or down depending on offset
            if ((e.SnapDirections & ToolboxSnapDragDropEventArgs.SnapDirection.Top) != 0)
            {
                newBounds.Y += e.Offset.Y; // snap to top - so move up our bounds
            }
            else if ((e.SnapDirections & ToolboxSnapDragDropEventArgs.SnapDirection.Bottom) != 0)
            {
                newBounds.Y = originalBounds.Y - originalBounds.Height + e.Offset.Y;
            }

            // snap either left or right depending on offset
            if (!isMirrored)
            {
                if ((e.SnapDirections & ToolboxSnapDragDropEventArgs.SnapDirection.Left) != 0)
                {
                    newBounds.X += e.Offset.X; // snap to left-
                }
                else if ((e.SnapDirections & ToolboxSnapDragDropEventArgs.SnapDirection.Right) != 0)
                {
                    newBounds.X = originalBounds.X - originalBounds.Width + e.Offset.X;
                }
            }
            else
            {
                // ParentControlDesigner is RTL, that means that the origin is upper-right, not upper-left
                if ((e.SnapDirections & ToolboxSnapDragDropEventArgs.SnapDirection.Left) != 0)
                {
                    // e.Offset.X is negative when we snap to left
                    newBounds.X = originalBounds.X - originalBounds.Width - e.Offset.X;
                }
                else if ((e.SnapDirections & ToolboxSnapDragDropEventArgs.SnapDirection.Right) != 0)
                {
                    // e.Offset.X is positive when we snap to right
                    newBounds.X -= e.Offset.X;
                }
            }
        }

        return newBounds;
    }

    /// <summary>
    ///  Determine a unique site name for a component, starting from a base name.
    ///  Return value should be passed into the Container.Add() method.
    ///  If null is returned, this just means "let container generate a default name based on component type".
    /// </summary>
    public static string? GetUniqueSiteName(IDesignerHost host, string? name)
    {
        // Item has no explicit name, so let host generate a type-based name instead
        if (string.IsNullOrEmpty(name))
        {
            return null;
        }

        // Get the name creation service from the designer host
        ArgumentNullException.ThrowIfNull(host);
        if (!host.TryGetService(out INameCreationService? nameCreationService))
        {
            return null;
        }

        // See if desired name is already in use
        object? existingComponent = host.Container.Components[name];
        if (existingComponent is null)
        {
            // Name is not in use - but make sure that it contains valid characters before using it!
            return nameCreationService.IsValidName(name) ? name : null;
        }
        else
        {
            // Name is in use (and therefore basically valid), so start appending numbers
            string nameN = name;
            for (int i = 1; !nameCreationService.IsValidName(nameN); ++i)
            {
                nameN = $"{name}{i}";
            }

            return nameN;
        }
    }

    /// <summary>
    ///  Applies the given opacity to the image
    /// </summary>
    private static unsafe void SetImageAlpha(Bitmap b, double opacity)
    {
        if (opacity == 1.0)
        {
            return;
        }

        Span<byte> alphaValues = stackalloc byte[256];
        // precompute all the possible alpha values into an array so we don't do multiplications in the loop
        for (int i = 0; i < alphaValues.Length; i++)
        {
            alphaValues[i] = (byte)(i * opacity);
        }

        // lock the data in ARGB format.
        //
        BitmapData data = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
        try
        {
            // compute the number of pixels that we're modifying.
            int pixels = data.Height * data.Width;
            int* pPixels = (int*)data.Scan0;

            // have the compiler figure out where to stop for us
            // by doing the pointer math
            byte* maxAddr = (byte*)(pPixels + pixels);

            // now run through the pixels only modifying the A byte
            for (byte* addr = (byte*)(pPixels) + 3; addr < maxAddr; addr += 4)
            {
                // the new value is just an index into our precomputed value array from above.
                *addr = alphaValues[*addr];
            }
        }
        finally
        {
            // now, apply the data back to the bitmap.
            b.UnlockBits(data);
        }
    }

    /// <summary>
    ///  This method removes types that are generics from the input collection
    /// </summary>
    [return: NotNullIfNotNull(nameof(types))]
    public static ICollection? FilterGenericTypes(ICollection? types)
    {
        if (types is null || types.Count == 0)
        {
            return types;
        }

        // now we get each Type and add it to the destination collection if its not a generic
        List<Type> final = new(types.Count);
        foreach (Type t in types)
        {
            if (!t.ContainsGenericParameters)
            {
                final.Add(t);
            }
        }

        return final;
    }

    /// <summary>
    ///  Checks the given container, substituting any nested container with its owning container.
    ///  Ensures that a SplitterPanel in a SplitContainer returns the same container as other form components,
    ///  since SplitContainer sites its two SplitterPanels inside a nested container.
    /// </summary>
    public static IContainer? CheckForNestedContainer(IContainer? container)
    {
        if (container is NestedContainer nestedContainer)
        {
            return nestedContainer.Owner.Site?.Container;
        }
        else
        {
            return container;
        }
    }

    /// <summary>
    ///  Used to create copies of the objects that we are dragging in a drag operation
    /// </summary>
    public static List<IComponent>? CopyDragObjects(IReadOnlyList<IComponent> objects, IServiceProvider svcProvider)
    {
        if (objects is null || svcProvider is null)
        {
            Debug.Fail("Invalid parameter passed to DesignerUtils.CopyObjects.");
            return null;
        }

        Cursor? oldCursor = Cursor.Current;
        try
        {
            Cursor.Current = Cursors.WaitCursor;
            ComponentSerializationService? css = svcProvider.GetService<ComponentSerializationService>();
            IDesignerHost? host = svcProvider.GetService<IDesignerHost>();
            Debug.Assert(css is not null, "No component serialization service -- we cannot copy the objects");
            Debug.Assert(host is not null, "No host -- we cannot copy the objects");
            if (css is not null && host is not null)
            {
                SerializationStore store = css.CreateStore();
                // Get all the objects, meaning we want the children too
                ICollection copyObjects = GetCopySelection(objects, host);

                // The serialization service does not (yet) handle serializing collections
                foreach (IComponent comp in copyObjects)
                {
                    css.Serialize(store, comp);
                }

                store.Close();
                copyObjects = css.Deserialize(store);

                // Now, copyObjects contains a flattened list of all the controls contained in the original drag objects,
                // that's not what we want to return. We only want to return the root drag objects,
                // so that the caller gets an identical copy - identical in terms of objects.Count
                List<IComponent> newObjects = new(objects.Count);
                foreach (IComponent comp in copyObjects)
                {
                    if (comp is Control { Parent: null })
                    {
                        newObjects.Add(comp);
                    }
                    else if (comp is ToolStripItem item && item.GetCurrentParent() is null)
                    { // this happens when we are dragging a toolstripitem
                        newObjects.Add(comp);
                    }
                }

                Debug.Assert(newObjects.Count == objects.Count, "Why is the count of the copied objects not the same?");
                return newObjects;
            }
        }
        finally
        {
            Cursor.Current = oldCursor;
        }

        return null;
    }

    private static List<IComponent> GetCopySelection(IReadOnlyList<IComponent> objects, IDesignerHost host)
    {
        List<IComponent> copySelection = [];
        foreach (IComponent comp in objects)
        {
            copySelection.Add(comp);
            GetAssociatedComponents(comp, host, copySelection);
        }

        return copySelection;
    }

    internal static void GetAssociatedComponents(IComponent component, IDesignerHost? host, List<IComponent> list)
    {
        if (host?.GetDesigner(component) is not ComponentDesigner designer)
        {
            return;
        }

        foreach (IComponent childComp in designer.AssociatedComponents)
        {
            if (childComp.Site is not null)
            {
                list.Add(childComp);
                GetAssociatedComponents(childComp, host, list);
            }
        }
    }

    private static int ScaleLogicalToDeviceUnitsX(int unit) => ScaleHelper.ScaleToInitialSystemDpi(unit);

    private static uint TreeView_GetExtendedStyle(HWND handle)
        => (uint)PInvoke.SendMessage(handle, PInvoke.TVM_GETEXTENDEDSTYLE);

    /// <summary>
    ///  Modify a WinForms TreeView control to use the new Explorer style theme
    /// </summary>
    /// <param name="treeView">The tree view control to modify</param>
    public static void ApplyTreeViewThemeStyles(TreeView treeView)
    {
        ArgumentNullException.ThrowIfNull(treeView);

        treeView.HotTracking = true;
        treeView.ShowLines = false;
        HWND hwnd = (HWND)treeView.Handle;
        PInvoke.SetWindowTheme(hwnd, "Explorer", pszSubIdList: null);
        uint exstyle = TreeView_GetExtendedStyle(hwnd);
        exstyle |= PInvoke.TVS_EX_DOUBLEBUFFER | PInvoke.TVS_EX_FADEINOUTEXPANDOS;
        PInvoke.SendMessage(treeView, PInvoke.TVM_SETEXTENDEDSTYLE, 0, (nint)exstyle);
    }

    /// <summary>
    ///  Modify a WinForms ListView control to use the new Explorer style theme
    /// </summary>
    /// <param name="listView">The list view control to modify</param>
    public static void ApplyListViewThemeStyles(ListView listView)
    {
        ArgumentNullException.ThrowIfNull(listView);

        HWND hwnd = (HWND)listView.Handle;
        PInvoke.SetWindowTheme(hwnd, "Explorer", null);
        PInvoke.SendMessage(
            listView,
            PInvoke.LVM_SETEXTENDEDLISTVIEWSTYLE,
            (WPARAM)PInvoke.LVS_EX_DOUBLEBUFFER,
            (LPARAM)PInvoke.LVS_EX_DOUBLEBUFFER);
    }
}
