C # Windows Form Transparent Background Image

Question

When I tried with a transparent background, it is not completely transparent. I tried two blocks of code for this problem. At first I tried like this code:

public Form1() { InitializeComponent(); SetStyle(ControlStyles.SupportsTransparentBackColor, true); this.BackColor = Color.Transparent; this.FormBorderStyle = FormBorderStyle.None; //this.WindowState = System.Windows.Forms.FormWindowState.Maximized; } 

it looks like this:

Then I found several different codes and tried this:

  public Form1() { InitializeComponent(); this.TransparencyKey = Color.White; this.BackColor = Color.White; this.FormBorderStyle = FormBorderStyle.None; this.WindowState = System.Windows.Forms.FormWindowState.Maximized; } 

And it looks like this:

You can see the logo with a white frame. I want to show only .png Logo completely transparent. What should I do? How can I do that?

Here is my logo image as .png;

Answer 1

You can use layered Windows

Using a multilayer window can significantly improve the performance and visual effects for a window that has a complex shape, animates its shape, or wishes to use alpha blending effects. The system automatically creates and redraws layered windows and windows of the main applications. As a result, multilayer windows are displayed smoothly, without the flicker characteristic of complex areas of the window. In addition, laminated windows may be partially translucent, i.e. alpha mixed.

Create a layered window in Windows Forms

Here is the code from the MSDN code gallery that demonstrates the creation of layered Windows in Windows Forms. It allows you to create a curly splash screen and move it with the mouse.

Add PerPixelAlphaForm to the project, and then enough to inherit from this form, call it SelectBitmap and pass the png method to create a layered window.

PerPixelAlphaForm.cs

 #region Using directives using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Drawing.Imaging; using System.Runtime.InteropServices; #endregion namespace CSWinFormLayeredWindow { public partial class PerPixelAlphaForm : Form { public PerPixelAlphaForm() { this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; this.ShowInTaskbar = false; this.StartPosition = FormStartPosition.CenterScreen; this.Load += PerPixelAlphaForm_Load; } void PerPixelAlphaForm_Load(object sender, EventArgs e) { this.TopMost = true; } protected override CreateParams CreateParams { get { // Add the layered extended style (WS_EX_LAYERED) to this window. CreateParams createParams = base.CreateParams; if(!DesignMode) createParams.ExStyle |= WS_EX_LAYERED; return createParams; } } /// <summary> /// Let Windows drag this window for us (thinks its hitting the title /// bar of the window) /// </summary> /// <param name="message"></param> protected override void WndProc(ref Message message) { if (message.Msg == WM_NCHITTEST) { // Tell Windows that the user is on the title bar (caption) message.Result = (IntPtr)HTCAPTION; } else { base.WndProc(ref message); } } /// <summary> /// /// </summary> /// <param name="bitmap"></param> public void SelectBitmap(Bitmap bitmap) { SelectBitmap(bitmap, 255); } /// <summary> /// /// </summary> /// <param name="bitmap"> /// /// </param> /// <param name="opacity"> /// Specifies an alpha transparency value to be used on the entire source /// bitmap. The SourceConstantAlpha value is combined with any per-pixel /// alpha values in the source bitmap. The value ranges from 0 to 255. If /// you set SourceConstantAlpha to 0, it is assumed that your image is /// transparent. When you only want to use per-pixel alpha values, set /// the SourceConstantAlpha value to 255 (opaque). /// </param> public void SelectBitmap(Bitmap bitmap, int opacity) { // Does this bitmap contain an alpha channel? if (bitmap.PixelFormat != PixelFormat.Format32bppArgb) { throw new ApplicationException("The bitmap must be 32bpp with alpha-channel."); } // Get device contexts IntPtr screenDc = GetDC(IntPtr.Zero); IntPtr memDc = CreateCompatibleDC(screenDc); IntPtr hBitmap = IntPtr.Zero; IntPtr hOldBitmap = IntPtr.Zero; try { // Get handle to the new bitmap and select it into the current // device context. hBitmap = bitmap.GetHbitmap(Color.FromArgb(0)); hOldBitmap = SelectObject(memDc, hBitmap); // Set parameters for layered window update. Size newSize = new Size(bitmap.Width, bitmap.Height); Point sourceLocation = new Point(0, 0); Point newLocation = new Point(this.Left, this.Top); BLENDFUNCTION blend = new BLENDFUNCTION(); blend.BlendOp = AC_SRC_OVER; blend.BlendFlags = 0; blend.SourceConstantAlpha = (byte)opacity; blend.AlphaFormat = AC_SRC_ALPHA; // Update the window. UpdateLayeredWindow( this.Handle, // Handle to the layered window screenDc, // Handle to the screen DC ref newLocation, // New screen position of the layered window ref newSize, // New size of the layered window memDc, // Handle to the layered window surface DC ref sourceLocation, // Location of the layer in the DC 0, // Color key of the layered window ref blend, // Transparency of the layered window ULW_ALPHA // Use blend as the blend function ); } finally { // Release device context. ReleaseDC(IntPtr.Zero, screenDc); if (hBitmap != IntPtr.Zero) { SelectObject(memDc, hOldBitmap); DeleteObject(hBitmap); } DeleteDC(memDc); } } #region Native Methods and Structures const Int32 WS_EX_LAYERED = 0x80000; const Int32 HTCAPTION = 0x02; const Int32 WM_NCHITTEST = 0x84; const Int32 ULW_ALPHA = 0x02; const byte AC_SRC_OVER = 0x00; const byte AC_SRC_ALPHA = 0x01; [StructLayout(LayoutKind.Sequential)] struct Point { public Int32 x; public Int32 y; public Point(Int32 x, Int32 y) { this.x = x; this.y = y; } } [StructLayout(LayoutKind.Sequential)] struct Size { public Int32 cx; public Int32 cy; public Size(Int32 cx, Int32 cy) { this.cx = cx; this.cy = cy; } } [StructLayout(LayoutKind.Sequential, Pack = 1)] struct ARGB { public byte Blue; public byte Green; public byte Red; public byte Alpha; } [StructLayout(LayoutKind.Sequential, Pack = 1)] struct BLENDFUNCTION { public byte BlendOp; public byte BlendFlags; public byte SourceConstantAlpha; public byte AlphaFormat; } [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref Point pptDst, ref Size psize, IntPtr hdcSrc, ref Point pprSrc, Int32 crKey, ref BLENDFUNCTION pblend, Int32 dwFlags); [DllImport("gdi32.dll", CharSet = CharSet.Auto, SetLastError = true)] static extern IntPtr CreateCompatibleDC(IntPtr hDC); [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] static extern IntPtr GetDC(IntPtr hWnd); [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC); [DllImport("gdi32.dll", CharSet = CharSet.Auto, SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] static extern bool DeleteDC(IntPtr hdc); [DllImport("gdi32.dll", CharSet = CharSet.Auto, SetLastError = true)] static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject); [DllImport("gdi32.dll", CharSet = CharSet.Auto, SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] static extern bool DeleteObject(IntPtr hObject); #endregion } } 

SplashScreen.cs

 public partial class Form4 : CSWinFormLayeredWindow.PerPixelAlphaForm { public Form4() { InitializeComponent(); this.SelectBitmap(Properties.Resources.splash); } } 

Note

The original answer was based on turning off the double buffer and overriding OnPaintBackground and drawing the image without calling the base method. The answer had a known problem; although the form was motionless, it worked well, but if the form moved or the window behind the form changed, the window was not updated. You can see the previous code in revisions. Current editing, based entirely on MSDN code, has no known issues.

Answer 2

You can choose the transparency level for the image by changing the alpha coefficient, which is between 0 and 255. The image can also be a reverse image, no problem

 private static Image ToGrayscale(Image s,int alpha) { Bitmap tImage = new Bitmap(s); for (int x = 0; x < tImage.Width; x++) { for (int y = 0; y < tImage.Height; y++) { Color tCol = tImage.GetPixel(x, y); Color newColor = Color.FromArgb(alpha, tCol.R, tCol.G, tCol.B); tImage.SetPixel(x, y, newColor); } } return tImage; }