internal IntPtr CreateHalftoneHBRUSH()
        {
            short[] array = new short[8];
            for (int i = 0; i < 8; i++)
            {
                array[i] = (short)(21845 << (i & 1));
            }
            IntPtr intPtr = SafeNativeMethods.CreateBitmap(8, 8, 1, 1, array);

            NativeMethods.LOGBRUSH lOGBRUSH = new NativeMethods.LOGBRUSH();
            lOGBRUSH.lbColor = ColorTranslator.ToWin32(Color.Black);
            lOGBRUSH.lbStyle = 3;
            lOGBRUSH.lbHatch = intPtr;
            IntPtr result = SafeNativeMethods.CreateBrushIndirect(lOGBRUSH);

            SafeNativeMethods.DeleteObject(new HandleRef(null, intPtr));
            return(result);
        }
            internal MetafileDCWrapper(IntPtr hOriginalDC, Size size)
            {
                Debug.Assert(Gdi32.GetObjectType(hOriginalDC) == Gdi32.ObjectType.OBJ_ENHMETADC,
                             "Why wrap a non-Enhanced MetaFile DC?");

                if (size.Width < 0 || size.Height < 0)
                {
                    throw new ArgumentException(SR.ControlMetaFileDCWrapperSizeInvalid, nameof(size));
                }

                _hMetafileDC = hOriginalDC;
                _destRect    = new RECT(0, 0, size.Width, size.Height);
                HDC          = Gdi32.CreateCompatibleDC(IntPtr.Zero);

                int planes    = Gdi32.GetDeviceCaps(HDC, Gdi32.DeviceCapability.PLANES);
                int bitsPixel = Gdi32.GetDeviceCaps(HDC, Gdi32.DeviceCapability.BITSPIXEL);

                _hBitmap      = SafeNativeMethods.CreateBitmap(size.Width, size.Height, planes, bitsPixel, IntPtr.Zero);
                _hOriginalBmp = Gdi32.SelectObject(HDC, _hBitmap);
            }
            internal MetafileDCWrapper(HandleRef hOriginalDC, Size size)
            {
                Debug.Assert(UnsafeNativeMethods.GetObjectType(hOriginalDC) == NativeMethods.OBJ_ENHMETADC,
                             "Why wrap a non-Enhanced MetaFile DC?");

                // Security fix: make sure the size has non-negative width and height.
                if (size.Width < 0 || size.Height < 0)
                {
                    throw new ArgumentException(nameof(size), SR.ControlMetaFileDCWrapperSizeInvalid);
                }

                _hMetafileDC = hOriginalDC;
                _destRect    = new Interop.RECT(0, 0, size.Width, size.Height);
                HDC          = Interop.Gdi32.CreateCompatibleDC(IntPtr.Zero);

                int planes    = Interop.Gdi32.GetDeviceCaps(HDC, Interop.Gdi32.DeviceCapability.PLANES);
                int bitsPixel = Interop.Gdi32.GetDeviceCaps(HDC, Interop.Gdi32.DeviceCapability.BITSPIXEL);

                _hBitmap      = SafeNativeMethods.CreateBitmap(size.Width, size.Height, planes, bitsPixel, IntPtr.Zero);
                _hOriginalBmp = Interop.Gdi32.SelectObject(HDC, _hBitmap);
            }
            // ported form VB6 (Ctls\PortUtil\StdCtl.cpp:6176)
            private unsafe bool DICopy(IntPtr hdcDest, IntPtr hdcSrc, RECT rect, bool bStretch)
            {
                long i;

                // Get the bitmap from the DC by selecting in a 1x1 pixel temp bitmap
                IntPtr hNullBitmap = SafeNativeMethods.CreateBitmap(1, 1, 1, 1, IntPtr.Zero);

                if (hNullBitmap == IntPtr.Zero)
                {
                    return(false);
                }

                try
                {
                    IntPtr hBitmap = Gdi32.SelectObject(hdcSrc, hNullBitmap);
                    if (hBitmap == IntPtr.Zero)
                    {
                        return(false);
                    }

                    // Restore original bitmap
                    Gdi32.SelectObject(hdcSrc, hBitmap);

                    if (!Gdi32.GetObjectW(hBitmap, out Gdi32.BITMAP bmp))
                    {
                        return(false);
                    }

                    NativeMethods.BITMAPINFO_FLAT lpbmi = new NativeMethods.BITMAPINFO_FLAT
                    {
                        bmiHeader_biSize          = Marshal.SizeOf <NativeMethods.BITMAPINFOHEADER>(),
                        bmiHeader_biWidth         = bmp.bmWidth,
                        bmiHeader_biHeight        = bmp.bmHeight,
                        bmiHeader_biPlanes        = 1,
                        bmiHeader_biBitCount      = (short)bmp.bmBitsPixel,
                        bmiHeader_biCompression   = NativeMethods.BI_RGB,
                        bmiHeader_biSizeImage     = 0,           //Not needed since using BI_RGB
                        bmiHeader_biXPelsPerMeter = 0,
                        bmiHeader_biYPelsPerMeter = 0,
                        bmiHeader_biClrUsed       = 0,
                        bmiHeader_biClrImportant  = 0,
                        bmiColors = new byte[NativeMethods.BITMAPINFO_MAX_COLORSIZE * 4]
                    };

                    // Include the palette for 256 color bitmaps
                    long iColors = 1 << (bmp.bmBitsPixel * bmp.bmPlanes);
                    if (iColors <= 256)
                    {
                        byte[] aj = new byte[Marshal.SizeOf <NativeMethods.PALETTEENTRY>() * 256];
                        SafeNativeMethods.GetSystemPaletteEntries(hdcSrc, 0, (int)iColors, aj);

                        fixed(byte *pcolors = lpbmi.bmiColors)
                        {
                            fixed(byte *ppal = aj)
                            {
                                NativeMethods.RGBQUAD *     prgb = (NativeMethods.RGBQUAD *)pcolors;
                                NativeMethods.PALETTEENTRY *lppe = (NativeMethods.PALETTEENTRY *)ppal;

                                // Convert the palette entries to RGB quad entries
                                for (i = 0; i < (int)iColors; i++)
                                {
                                    prgb[i].rgbRed   = lppe[i].peRed;
                                    prgb[i].rgbBlue  = lppe[i].peBlue;
                                    prgb[i].rgbGreen = lppe[i].peGreen;
                                }
                            }
                        }
                    }

                    // Allocate memory to hold the bitmap bits
                    long   bitsPerScanLine  = bmp.bmBitsPixel * (long)bmp.bmWidth;
                    long   bytesPerScanLine = (bitsPerScanLine + 7) / 8;
                    long   totalBytesReqd   = bytesPerScanLine * bmp.bmHeight;
                    byte[] lpBits           = new byte[totalBytesReqd];

                    // Get the bitmap bits
                    int diRet = SafeNativeMethods.GetDIBits(hdcSrc, hBitmap, 0, bmp.bmHeight, lpBits,
                                                            ref lpbmi, NativeMethods.DIB_RGB_COLORS);
                    if (diRet == 0)
                    {
                        return(false);
                    }

                    // Set the destination coordiates depending on whether stretch-to-fit was chosen
                    int xDest, yDest, cxDest, cyDest;
                    if (bStretch)
                    {
                        xDest  = rect.left;
                        yDest  = rect.top;
                        cxDest = rect.right - rect.left;
                        cyDest = rect.bottom - rect.top;
                    }
                    else
                    {
                        xDest  = rect.left;
                        yDest  = rect.top;
                        cxDest = bmp.bmWidth;
                        cyDest = bmp.bmHeight;
                    }

                    // Paint the bitmap
                    int iRet = SafeNativeMethods.StretchDIBits(hdcDest,
                                                               xDest, yDest, cxDest, cyDest, 0, 0, bmp.bmWidth, bmp.bmHeight,
                                                               lpBits, ref lpbmi, NativeMethods.DIB_RGB_COLORS, NativeMethods.SRCCOPY);

                    if (iRet == NativeMethods.GDI_ERROR)
                    {
                        return(false);
                    }
                }
                finally
                {
                    Gdi32.DeleteObject(hNullBitmap);
                }

                return(true);
            }