Exemple #1
0
 public static BitmapSource LoadBitmap(System.Drawing.Bitmap source)
 {
     handle = source.GetHbitmap();
     bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(handle, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
     DeleteObject(handle);
     return bitmapSource;
 }
 public static BitmapSource LoadBitmap(System.Drawing.Bitmap source)
 {
     var ip = source.GetHbitmap();
     var bs = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(ip, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
     DeleteObject(ip);
     return bs;
 }
Exemple #3
0
        public static BitmapImage Bitmap2BitmapImage(System.Drawing.Bitmap bitmap)
        {
            IntPtr hBitmap = bitmap.GetHbitmap();
            BitmapSource bmpSource;
            BitmapImage bitmapImage = new BitmapImage();

            try
            {
                bmpSource = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                             hBitmap,
                             IntPtr.Zero,
                             Int32Rect.Empty,
                             BitmapSizeOptions.FromEmptyOptions());

                BitmapEncoder enc = new BmpBitmapEncoder();
                MemoryStream memoryStream = new MemoryStream();

                enc.Frames.Add(BitmapFrame.Create(bmpSource));
                enc.Save(memoryStream);

                memoryStream.Position = 0;
                bitmapImage.BeginInit();
                bitmapImage.StreamSource = memoryStream;
                bitmapImage.EndInit();
            }
            finally
            {
                DeleteObject(hBitmap);
            }

            return bitmapImage;
        }
 public static BitmapSource loadBitmap(System.Drawing.Bitmap source)
 {
     return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(source.GetHbitmap(), IntPtr.Zero,
                                                                         Int32Rect.Empty,
                                                                         System.Windows.Media.Imaging
                                                                               .BitmapSizeOptions
                                                                               .FromEmptyOptions());
 }
 /// <summary>
 /// Convert GDI bitmap into a WPF BitmapSource
 /// </summary>
 /// <param name="source"></param>
 /// <param name="width"></param>
 /// <param name="height"></param>
 /// <returns></returns>
 public static BitmapSource ConvertGDI_To_WPF(System.Drawing.Bitmap bmp)
 {
     BitmapSource bms = null;
     if (bmp != null)
     {
         IntPtr h_bm = bmp.GetHbitmap();
         bms = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(h_bm, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
     }
     return bms;
 }
Exemple #6
0
		public static ImageSource ToImageSource(System.Drawing.Bitmap bitmap) {
			var hbitmap = bitmap.GetHbitmap();
			try {
				var imageSource = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hbitmap, IntPtr.Zero, Int32Rect.Empty, System.Windows.Media.Imaging.BitmapSizeOptions.FromWidthAndHeight(bitmap.Width, bitmap.Height));

				return imageSource;
			} finally {
				DeleteObject(hbitmap);
			}
		}
Exemple #7
0
        public static BitmapSource BitmapToBitmapSource(System.Drawing.Bitmap bitmap)
        {
            intPointer = bitmap.GetHbitmap();

            bitmapSource = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(intPointer,
                IntPtr.Zero,
                System.Windows.Int32Rect.Empty,
                System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

            DeleteObject(intPointer);
            return bitmapSource;
        }
        private static BitmapSource ToBitmapSource(System.Drawing.Bitmap source)
        {
            BitmapSource bitSrc = null;

            var hBitmap = source.GetHbitmap();
            bitSrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                hBitmap,
                IntPtr.Zero,
                Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());
            return bitSrc;
        }
        public static ImageSource convertBitmapToBitmapSource(System.Drawing.Bitmap bitmap)
        {
            using (bitmap)
            {
                System.Windows.Media.Imaging.BitmapSource bitmapSource = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    bitmap.GetHbitmap(),
                    IntPtr.Zero,
                    Int32Rect.Empty,
                    System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

                return bitmapSource;
            }
        }
Exemple #10
0
        private void SetImageSource(System.Drawing.Bitmap bmp)
        {
            if (bmp == null)
                return;

            // how to convert a bitmap to an imagesource http://blog.laranjee.com/how-to-convert-winforms-bitmap-to-wpf-imagesource/ 
            // TODO - watch out for memory leaks using system.drawing.bitmaps in managed code, see here http://social.msdn.microsoft.com/Forums/en/csharpgeneral/thread/4e213af5-d546-4cc1-a8f0-462720e5fcde
            // need to call Dispose manually somewhere, or perhaps use a WPF native structure instead of bitmap?

            var hbitmap = bmp.GetHbitmap();
            var imageSource = Imaging.CreateBitmapSourceFromHBitmap(hbitmap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromWidthAndHeight(bmp.Width, bmp.Height));
            image.Source =  imageSource;
        }
        /// <summary>
        /// 从Bitmap创建可供WPF Image控件使用的BitmapSource对象
        /// </summary>
        /// <param name="bitmap"></param>
        /// <returns></returns>
        public static BitmapSource BitmapToImageSource(System.Drawing.Bitmap bitmap)
        {
            BitmapSource destination;

            IntPtr hBitmap = bitmap.GetHbitmap();

            BitmapSizeOptions sizeOptions = BitmapSizeOptions.FromEmptyOptions();

            destination = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, System.Windows.Int32Rect.Empty, sizeOptions);

            destination.Freeze();

            return destination;
        }
Exemple #12
0
        void CamProc_NewTargetPosition(IntPoint Center, System.Drawing.Bitmap image)
        {
            IntPtr hBitMap = image.GetHbitmap();
            BitmapSource bmaps = Imaging.CreateBitmapSourceFromHBitmap(hBitMap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
            bmaps.Freeze();
            Dispatcher.Invoke((Action)(() =>
            {

                if (Center.X > 0)
                {
                    try
                    {

                        prova.Content = String.Format("   Codigo: {0}", Center.X);
                        item.Content = String.Format(" Nº Itens: {0}", Center.Y);
                        TextReader respostas = new StreamReader(@"" + Center.X + ".txt");
                        string R_1 = respostas.ReadLine();
                        string R_2 = respostas.ReadLine();
                        string R_3 = respostas.ReadLine();
                        string R_4 = respostas.ReadLine();
                        string R_5 = respostas.ReadLine();
                        string R_6 = respostas.ReadLine();
                        string R_7 = respostas.ReadLine();
                        string R_8 = respostas.ReadLine();
                        string R_9 = respostas.ReadLine();
                        string R_0 = respostas.ReadLine();
                        item1.Content = String.Format(" Item 01: {0}", R_1);
                        item2.Content = String.Format(" Item 02: {0}", R_2);
                        item3.Content = String.Format(" Item 03: {0}", R_3);
                        item4.Content = String.Format(" Item 04: {0}", R_4);
                        item5.Content = String.Format(" Item 05: {0}", R_5);
                        item6.Content = String.Format(" Item 06: {0}", R_6);
                        item7.Content = String.Format(" Item 07: {0}", R_7);
                        item8.Content = String.Format(" Item 08: {0}", R_8);
                        item9.Content = String.Format(" Item 09: {0}", R_9);
                        item10.Content = String.Format(" Item 10: {0}", R_0);
                        string resps = R_1 + ";" + R_2 + ";" + R_3 + ";" + R_4 + ";" + R_5 + ";" + R_6 + ";" + R_7 + ";" + R_8 + ";" + R_9 + ";" + R_0;

                        refer.Content = String.Format("todas: {0}", resps);
                        conexao((int)Center.X, resps);
                        respostas.Close();
                    }
                    catch { }
                }
                pictureBoxMain.Source = bmaps;
            }), DispatcherPriority.Render, null);
            DeleteObject(hBitMap);
        }
        public static BitmapSource loadBitmap(System.Drawing.Bitmap source)
        {
            IntPtr ip = source.GetHbitmap();
            BitmapSource bs = null;
            try
            {
                bs = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(ip,
                   IntPtr.Zero, Int32Rect.Empty,
                   System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
            }
            finally
            {
                DeleteObject(ip);
            }

            return bs;
        }
        public static BitmapSource ToWPFBitmap(System.Drawing.Bitmap bitmap)
        {
            var hBitmap = bitmap.GetHbitmap();

            BitmapSource source;
            try
            {
                source = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    hBitmap, IntPtr.Zero, Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());
            }
            finally
            {
                DeleteObject(hBitmap);
            }
            return source;
        }
Exemple #15
0
		public TileSet(System.Drawing.Bitmap source, int tileWidth, int tileHeight)
		{
			_source = new WriteableBitmap(Imaging.CreateBitmapSourceFromHBitmap(
				source.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty,
				BitmapSizeOptions.FromWidthAndHeight(source.Width, source.Height)));

			TileWidth = tileWidth;
			TileHeight = tileHeight;
			_tilesPerRow = (int)_source.Width / TileWidth;

			_bytesPerPixel = _source.Format.BitsPerPixel / BITS_PER_BYTE;
			_stride = _source.PixelWidth * _bytesPerPixel;
			_originalPixels = new byte[_stride * _source.PixelHeight];
			_source.CopyPixels(_originalPixels, _stride, 0);

			_tiles = new List<CroppedBitmap>();
			GenerateTiles();
		}
        public static BitmapSource BitmapToBitmapSource(System.Drawing.Bitmap bitmap)
        {
            if (bitmap == null)
                throw new ArgumentNullException("bitmap");

            lock (bitmap)
            {
                IntPtr hBitmap = bitmap.GetHbitmap();

                try
                {
                    return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
                }
                finally
                {
                    DeleteObject(hBitmap);
                }
            }
        }
        public static ImageSource ConvertToImageSource(System.Drawing.Bitmap bmp)
        {
            if (bmp == null)
                return null;

            ImageSource imageSource;
            var hbitmap = bmp.GetHbitmap();
            try
            {
                imageSource = Imaging.CreateBitmapSourceFromHBitmap(hbitmap, IntPtr.Zero, Int32Rect.Empty,
                    BitmapSizeOptions.FromWidthAndHeight(bmp.Width, bmp.Height));
            }
            finally
            {
                DeleteObject(hbitmap);
            }

            return imageSource;
        }
Exemple #18
0
 private static BitmapSource ToBitmapSource(System.Drawing.Bitmap src)
 {
     BitmapSource BitSrc = null;
     var hbmp = src.GetHbitmap();
     try
     {
         BitSrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
              hbmp,
              IntPtr.Zero,
              Int32Rect.Empty,
              BitmapSizeOptions.FromEmptyOptions());
     }
     catch (Win32Exception)
     {
         BitSrc = null;
     }
     finally
     {
         NativeMethods.DeleteObject(hbmp);
     }
     return BitSrc;
 }
Exemple #19
0
        private static BitmapSource toBitmapSource(System.Drawing.Bitmap source)
        {
            var hBitmap = source.GetHbitmap();

            try
            {
                var ret =  System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    hBitmap,
                    IntPtr.Zero,
                    Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());
                return ret;
            }
            catch (Win32Exception)
            {
                return null;
            }
            finally
            {
                DeleteObject(hBitmap);
            }
        }
Exemple #20
0
 /// <summary>
 /// Bitmap文件转化为Image文件
 /// </summary>
 /// <param name="bitmap"></param>
 /// <returns></returns>
 public static ImageSource GetImageSourceFromBitmap(System.Drawing.Bitmap bitmap)
 {
     IntPtr ip = bitmap.GetHbitmap();
     BitmapSource bitmapSource = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(ip, IntPtr.Zero, Int32Rect.Empty, System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
     DeleteObject(ip);
     return bitmapSource;
 }
        public BitmapSource CreateBitmapSourceFromBitmap(System.Drawing.Bitmap bitmap)
        {

            return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                bitmap.GetHbitmap(),
                IntPtr.Zero,
                Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());
        }
Exemple #22
0
        public BitmapSource ToBitmapSource(System.Drawing.Bitmap source)
        {
            BitmapSource bitSrc = null;

            var hBitmap = source.GetHbitmap();

            try
            {
                bitSrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                    hBitmap,
                    IntPtr.Zero,
                    Int32Rect.Empty,
                    BitmapSizeOptions.FromEmptyOptions());
            }
            catch (Win32Exception)
            {
                bitSrc = null;
            }

            return bitSrc;
        }
 public PICTDESCbmp(System.Drawing.Bitmap bitmap) {
     hbitmap = bitmap.GetHbitmap();
     // gpr: What about palettes?
 }
        void processor_NewTargetPosition(System.Drawing.Bitmap image)
        {
            IntPtr hBitMap = image.GetHbitmap();
            BitmapSource bmaps = Imaging.CreateBitmapSourceFromHBitmap(hBitMap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
            bmaps.Freeze();

            Dispatcher.Invoke((Action)(() =>
            {
                pictureBoxMain.Source = bmaps;
            }), DispatcherPriority.Render, null);
        }
 //Bitmap-to-ImageSource converter
 public static ImageSource BitmapToImageSource(System.Drawing.Bitmap bmp)
 {
     IntPtr hBitmap = bmp.GetHbitmap();
     ImageSource wpfBitmap = Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
     bmp.Dispose();
     return wpfBitmap;
 }
 /// <summary>
 /// This is a helper function so you can assign the Icon directly
 /// from a Bitmap, such as one from a resources file.
 /// </summary>
 /// <param name="value"></param>
 protected void SetIconFromBitmap(System.Drawing.Bitmap value)
 {
     IntPtr hBitmap = value.GetHbitmap();
     try
     {
         BitmapSource b = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
             hBitmap,
             IntPtr.Zero,
             Int32Rect.Empty,
             System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
         Icon = b;
     }
     finally
     {
         DeleteObject(hBitmap);
     }
 }
Exemple #27
0
        /// <summary>
        /// FreeImage method
        /// </summary>
        /// <param name="bmp"></param>
        /*
        public static void FI_ConvertSave(Bitmap bmp)
        {
            if (bmp != null)
            {
                using (FreeImageAPI.FreeImageBitmap fiBitmap = FreeImageAPI.FreeImageBitmap.FromHbitmap(bmp.GetHbitmap()))
                {
                    if (fiBitmap.ColorDepth > 24)
                    {
                        fiBitmap.ConvertColorDepth(FreeImageAPI.FREE_IMAGE_COLOR_DEPTH.FICD_08_BPP);
                    }
                    for (int i = 16; i < 256; i++)
                        fiBitmap.Palette.Data[i] = new FreeImageAPI.RGBQUAD(Color.White);

                    FreeImageAPI.Palette pl = new FreeImageAPI.Palette(256);
                    pl.CreateGrayscalePalette();
                    //quantize using the NeuQuant neural-net quantization algorithm
                    fiBitmap.Quantize(FreeImageAPI.FREE_IMAGE_QUANTIZE.FIQ_NNQUANT, 16, pl);

                    fiBitmap.Save("test_FreeImageOutput.png", FreeImageAPI.FREE_IMAGE_FORMAT.FIF_PNG, FreeImageAPI.FREE_IMAGE_SAVE_FLAGS.PNG_Z_BEST_COMPRESSION);
                    //bmp = fiBitmap.ToBitmap();
                    //ms = new MemoryStream();
                    //fiBitmap.Save(ms, FreeImageAPI.FREE_IMAGE_FORMAT.FIF_PNG, FreeImageAPI.FREE_IMAGE_SAVE_FLAGS.PNG_Z_DEFAULT_COMPRESSION);
                }
                bmp.Dispose();
            }
        }
        */
        // From wischik.com
        static Bitmap CopyToBpp(System.Drawing.Bitmap b, int bpp)
        {
            if (bpp != 1 && bpp != 8)
                throw new System.ArgumentException("1 or 8", "bpp");

            // Plan: built into Windows GDI is the ability to convert
            // bitmaps from one format to another. Most of the time, this
            // job is actually done by the graphics hardware accelerator card
            // and so is extremely fast. The rest of the time, the job is done by
            // very fast native code.
            // We will call into this GDI functionality from C#. Our plan:
            // (1) Convert our Bitmap into a GDI hbitmap (ie. copy unmanaged->managed)
            // (2) Create a GDI monochrome hbitmap
            // (3) Use GDI "BitBlt" function to copy from hbitmap into monochrome (as above)
            // (4) Convert the monochrone hbitmap into a Bitmap (ie. copy unmanaged->managed)

            int w = b.Width;
            int h = b.Height;
            IntPtr hbm = b.GetHbitmap(); // this is step (1)
            //
            // Step (2): create the monochrome bitmap.
            // "BITMAPINFO" is an interop-struct which we define below.
            // In GDI terms, it's a BITMAPHEADERINFO followed by an array of two RGBQUADs
            GDI32.BITMAPINFOHEADER bmi = new GDI32.BITMAPINFOHEADER();
            bmi.biSize = 40;  // the size of the BITMAPHEADERINFO struct
            bmi.biWidth = w;
            bmi.biHeight = h;
            bmi.biPlanes = 1; // "planes" are confusing. We always use just 1. Read MSDN for more info.
            bmi.biBitCount = (ushort)bpp; // ie. 1bpp or 8bpp
            bmi.biCompression = (uint)GdiFlags.BI_RGB; // ie. the pixels in our RGBQUAD table are stored as RGBs, not palette indexes
            bmi.biSizeImage = (uint)(((w + 7) & 0xFFFFFFF8) * h / 8);
            bmi.biXPelsPerMeter = 1000000; // not really important
            bmi.biYPelsPerMeter = 1000000; // not really important
            // Now for the colour table.
            uint ncols = (uint)1 << bpp; // 2 colours for 1bpp; 256 colours for 8bpp
            bmi.biClrUsed = ncols;
            bmi.biClrImportant = ncols;
            bmi.cols = new uint[256]; // The structure always has fixed size 256, even if we end up using fewer colours
            if (bpp == 1) { bmi.cols[0] = GDI32.MAKERGB(0, 0, 0); bmi.cols[1] = GDI32.MAKERGB(255, 255, 255); }
            else { for (int i = 0; i < ncols; i++) bmi.cols[i] = GDI32.MAKERGB(i, i, i); }
            // For 8bpp we've created an palette with just greyscale colours.
            // You can set up any palette you want here. Here are some possibilities:
            // greyscale: for (int i=0; i<256; i++) bmi.cols[i]=MAKERGB(i,i,i);
            bmi.biClrUsed = 216; bmi.biClrImportant = 216; int[] colv = new int[6] { 0, 51, 102, 153, 204, 255 };
            for (int i = 0; i < 216; i++)
                bmi.cols[i] = GDI32.MAKERGB(colv[i / 36], colv[(i / 6) % 6], colv[i % 6]);
            // rainbow: bmi.biClrUsed=216; bmi.biClrImportant=216; int[] colv=new int[6]{0,51,102,153,204,255};
            //          for (int i=0; i<216; i++) bmi.cols[i]=GDI32.MAKERGB(colv[i/36],colv[(i/6)%6],colv[i%6]);
            // optimal: a difficult topic: http://en.wikipedia.org/wiki/Color_quantization
            //
            // Now create the indexed bitmap "hbm0"
            IntPtr bits0; // not used for our purposes. It returns a pointer to the raw bits that make up the bitmap.
            IntPtr hbm0 = GDI32.CreateDIBSection(IntPtr.Zero, ref bmi, (uint)GdiFlags.DIB_RGB_COLORS, out bits0, IntPtr.Zero, 0);
            //
            // Step (3): use GDI's BitBlt function to copy from original hbitmap into monocrhome bitmap
            // GDI programming is kind of confusing... nb. The GDI equivalent of "Graphics" is called a "DC".
            IntPtr sdc = USER32.GetDC(IntPtr.Zero);       // First we obtain the DC for the screen
            // Next, create a DC for the original hbitmap
            IntPtr hdc = GDI32.CreateCompatibleDC(sdc);
            GDI32.SelectObject(hdc, hbm);
            // and create a DC for the monochrome hbitmap
            IntPtr hdc0 = GDI32.CreateCompatibleDC(sdc);
            GDI32.SelectObject(hdc0, hbm0);
            // Now we can do the BitBlt:
            GDI32.BitBlt(hdc0, 0, 0, w, h, hdc, 0, 0, TernaryRasterOperations.SRCCOPY);
            // Step (4): convert this monochrome hbitmap back into a Bitmap:
            System.Drawing.Bitmap b0 = System.Drawing.Bitmap.FromHbitmap(hbm0);
            //
            // Finally some cleanup.
            GDI32.DeleteDC(hdc);
            GDI32.DeleteDC(hdc0);
            USER32.ReleaseDC(IntPtr.Zero, sdc);
            GDI32.DeleteObject(hbm);
            GDI32.DeleteObject(hbm0);
            //
            return b0;
        }
Exemple #28
0
        public ImageLBI(System.Drawing.Bitmap bitmap)
            : base(CapturedItemsListController.Instance)
        {
            System.Windows.Media.Imaging.BitmapSource image = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
              bitmap.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty,
              BitmapSizeOptions.FromEmptyOptions());

            this.image = image;
            Tag = new ImageHash(bitmap);

            this.MinHeight = 25;

            double width = image.Width;
            double height = image.Height;
            int scale_to = 200;

            Scale(ref width, ref height, scale_to);

            this.ToolTip = new Image { Source = image, Width = width, Height = height };

            this.Title = "IMAGE #" + counter++ + " (" + controller.ActiveProcess.ProcessName + ")";
        }
 internal Bitmap(System.Drawing.Bitmap bitmap)
 {
     this.hbitmap = bitmap.GetHbitmap();
 }
Exemple #30
0
        void UpdatePPMask(System.Drawing.Bitmap bitmap)
        {
            IntPtr screenDc = Win32.GetDC(IntPtr.Zero);
            IntPtr memDc = Win32.CreateCompatibleDC(screenDc);
            IntPtr hBitmap = IntPtr.Zero;
            IntPtr oldBitmap = IntPtr.Zero;

            try
            {
                hBitmap = bitmap.GetHbitmap(System.Drawing.Color.FromArgb(0));
                oldBitmap = Win32.SelectObject(memDc, hBitmap);

                Win32.Size size = new Win32.Size(bitmap.Width, bitmap.Height);
                Win32.Point pointSource = new Win32.Point(0, 0);
                Win32.Point topPos = new Win32.Point(Left, Top);
                Win32.BLENDFUNCTION blend = new Win32.BLENDFUNCTION();
                blend.BlendOp = Win32.AC_SRC_OVER;
                blend.BlendFlags = 0;
                blend.SourceConstantAlpha = 255;
                blend.AlphaFormat = Win32.AC_SRC_ALPHA;

                Win32.UpdateLayeredWindow(Handle, screenDc, ref topPos, ref size, memDc, ref pointSource, 0, ref blend, Win32.ULW_ALPHA);
            }
            finally
            {
                Win32.ReleaseDC(IntPtr.Zero, screenDc);

                if (hBitmap != IntPtr.Zero)
                {
                    Win32.SelectObject(memDc, oldBitmap);
                    Win32.DeleteObject(hBitmap);
                }

                Win32.DeleteDC(memDc);
            }
        }