从剪贴板复制到剪贴板会丢失图像透明度

我一直在尝试将透明的PNG图像复制到剪贴板并保留其透明度，以将其粘贴到支持它的特定程序中。

我已经尝试了很多解决方案，但背景总是以这种或那种方式变灰。

所以我尝试使用Chrome复制相同的图像并将其粘贴到程序中并且它有效。 它保持了透明度。 然后我尝试从剪贴板中获取我使用Chrome复制的图像并再次设置图像，期望透明度仍然存在 – 但是，即使我刚从剪贴板中取出图像并设置它，也不会保留透明度再次。

var img = Clipboard.GetImage(); // copied using Chrome and transparency is preserved Clipboard.SetImage(img); // transparency lost 

即使我使用System.Windows.Forms.Clipboard或尝试获取并设置DataObject而不是Image，也会出现同样的问题。

Answer 1

默认情况下，Windows剪贴板不支持透明度，但您可以将多种类型的内容放在剪贴板上，以确保大多数应用程序在其中找到可以使用的某些类型。 可悲的是，最常见的类型（Windows本身似乎使用）是一个非常肮脏和不可靠的类型。 我在这里写了一个很大的咆哮解释。

我会假设你在继续我的答案之前已经阅读过，因为它包含了下一部分所需的背景信息。

现在，将图像放在具有透明度支持的剪贴板上的最简洁方法是PNG流，但它不能保证所有应用程序都可以粘贴它。 Gimp支持PNG粘贴，显然新的MS Office程序也是如此，但谷歌Chrome不会，并且只接受我链接的答案中详述的凌乱的DIB类型。 另一方面，Gimp不会接受DIB具有透明度，因为它的创建者实际上遵循格式的规范，并且意识到格式不可靠（正如我链接的那个问题所清楚地certificate的那样）。

令人遗憾的是，由于DIB的混乱，最好的办法就是尽可能多地将它放在那里，包括PNG，DIB和普通的Image。

PNG和DIB都以相同的方式放在剪贴板上：将它们作为MemoryStream放入DataObject中，然后在实际放入时给剪贴板提供“复制”指令。

大部分都是直截了当的，但DIB更复杂一点。 请注意，以下部分包含对我自己的工具集的几个引用。 BuildImage可以在这个答案中找到，可以在这里找到ArrayUtils ，下面给出了ArrayUtils 。

 /// 
 /// Copies the given image to the clipboard as PNG, DIB and standard Bitmap format. /// 
 /// Image to put on the clipboard. /// Optional specifically nontransparent version of the image to put on the clipboard. /// Clipboard data object to put the image into. Might already contain other stuff. Leave null to create a new one. public static void SetClipboardImage(Bitmap image, Bitmap imageNoTr, DataObject data) { Clipboard.Clear(); if (data == null) data = new DataObject(); if (imageNoTr == null) imageNoTr = image; using (MemoryStream pngMemStream = new MemoryStream()) using (MemoryStream dibMemStream = new MemoryStream()) { // As standard bitmap, without transparency support data.SetData(DataFormats.Bitmap, true, imageNoTr); // As PNG. Gimp will prefer this over the other two. image.Save(pngMemStream, ImageFormat.Png); data.SetData("PNG", false, pngMemStream); // As DIB. This is (wrongly) accepted as ARGB by many applications. Byte[] dibData = ConvertToDib(image); dibMemStream.Write(dibData, 0, dibData.Length); data.SetData(DataFormats.Dib, false, dibMemStream); // The 'copy=true' argument means the MemoryStreams can be safely disposed after the operation. Clipboard.SetDataObject(data, true); } } /// 
 /// Converts the image to Device Independent Bitmap format of type BITFIELDS. /// This is (wrongly) accepted by many applications as containing transparency, /// so I'm abusing it for that. /// 
 /// Image to convert to DIB /// The image converted to DIB, in bytes. public static Byte[] ConvertToDib(Image image) { Byte[] bm32bData; Int32 width = image.Width; Int32 height = image.Height; // Ensure image is 32bppARGB by painting it on a new 32bppARGB image. using (Bitmap bm32b = new Bitmap(image.Width, image.Height, PixelFormat.Format32bppArgb)) { using (Graphics gr = Graphics.FromImage(bm32b)) gr.DrawImage(image, new Rectangle(0, 0, bm32b.Width, bm32b.Height)); // Bitmap format has its lines reversed. bm32b.RotateFlip(RotateFlipType.Rotate180FlipX); Int32 stride; bm32bData = ImageUtils.GetImageData(bm32b, out stride); } // BITMAPINFOHEADER struct for DIB. Int32 hdrSize = 0x28; Byte[] fullImage = new Byte[hdrSize + 12 + bm32bData.Length]; //Int32 biSize; ArrayUtils.WriteIntToByteArray(fullImage, 0x00, 4, true, (UInt32)hdrSize); //Int32 biWidth; ArrayUtils.WriteIntToByteArray(fullImage, 0x04, 4, true, (UInt32)width); //Int32 biHeight; ArrayUtils.WriteIntToByteArray(fullImage, 0x08, 4, true, (UInt32)height); //Int16 biPlanes; ArrayUtils.WriteIntToByteArray(fullImage, 0x0C, 2, true, 1); //Int16 biBitCount; ArrayUtils.WriteIntToByteArray(fullImage, 0x0E, 2, true, 32); //BITMAPCOMPRESSION biCompression = BITMAPCOMPRESSION.BITFIELDS; ArrayUtils.WriteIntToByteArray(fullImage, 0x10, 4, true, 3); //Int32 biSizeImage; ArrayUtils.WriteIntToByteArray(fullImage, 0x14, 4, true, (UInt32)bm32bData.Length); // These are all 0. Since .net clears new arrays, don't bother writing them. //Int32 biXPelsPerMeter = 0; //Int32 biYPelsPerMeter = 0; //Int32 biClrUsed = 0; //Int32 biClrImportant = 0; // The aforementioned "BITFIELDS": colour masks applied to the Int32 pixel value to get the R, G and B values. ArrayUtils.WriteIntToByteArray(fullImage, hdrSize + 0, 4, true, 0x00FF0000); ArrayUtils.WriteIntToByteArray(fullImage, hdrSize + 4, 4, true, 0x0000FF00); ArrayUtils.WriteIntToByteArray(fullImage, hdrSize + 8, 4, true, 0x000000FF); Array.Copy(bm32bData, 0, fullImage, hdrSize + 12, bm32bData.Length); return fullImage; } 

现在，至于从剪贴板中获取图像，我注意到.Net 3.5和后者之间的行为显然存在差异，这似乎实际上使用了DIB。 鉴于这种差异，并且考虑到DIB格式的不可靠性，您需要手动检查所有类型，最好从完全可靠的PNG格式开始。

您可以使用以下代码从剪贴板获取DataObject ：

 DataObject retrievedData = Clipboard.GetDataObject() as DataObject; 

这里使用的CloneImage函数基本上只是我的BuildImage和BuildImage工具集的组合，确保创建一个新的图像，而不会有任何可能混乱的后备资源; 已知图像对象在基于Stream然后被丢弃时会导致崩溃。 它的压缩和优化版本发布在这里，这是一个值得一读的关于为什么这种克隆如此重要的问题的问题。

 /// 
 /// Retrieves an image from the given clipboard data object, in the order PNG, DIB, Bitmap, Image object. /// 
 /// The clipboard data. /// The extracted image, or null if no supported image type was found. public static Bitmap GetClipboardImage(DataObject retrievedData) { Bitmap clipboardimage = null; // Order: try PNG, move on to try 32-bit ARGB DIB, then try the normal Bitmap and Image types. if (retrievedData.GetDataPresent("PNG")) { MemoryStream png_stream = retrievedData.GetData("PNG") as MemoryStream; if (png_stream != null) using (Bitmap bm = new Bitmap(png_stream)) clipboardimage = ImageUtils.CloneImage(bm); } if (clipboardimage == null && retrievedData.GetDataPresent(DataFormats.Dib)) { MemoryStream dib = retrievedData.GetData(DataFormats.Dib) as MemoryStream; if (dib != null) clipboardimage = ImageFromClipboardDib(dib.ToArray()); } if (clipboardimage == null && retrievedData.GetDataPresent(DataFormats.Bitmap)) clipboardimage = new Bitmap(retrievedData.GetData(DataFormats.Bitmap) as Image); if (clipboardimage == null && retrievedData.GetDataPresent(typeof(Image))) clipboardimage = new Bitmap(retrievedData.GetData(typeof(Image)) as Image); return clipboardimage; } public static Bitmap ImageFromClipboardDib(Byte[] dibBytes) { if (dibBytes == null || dibBytes.Length < 4) return null; try { Int32 headerSize = (Int32)ArrayUtils.ReadIntFromByteArray(dibBytes, 0, 4, true); // Only supporting 40-byte DIB from clipboard if (headerSize != 40) return null; Byte[] header = new Byte[40]; Array.Copy(dibBytes, header, 40); Int32 imageIndex = headerSize; Int32 width = (Int32)ArrayUtils.ReadIntFromByteArray(header, 0x04, 4, true); Int32 height = (Int32)ArrayUtils.ReadIntFromByteArray(header, 0x08, 4, true); Int16 planes = (Int16)ArrayUtils.ReadIntFromByteArray(header, 0x0C, 2, true); Int16 bitCount = (Int16)ArrayUtils.ReadIntFromByteArray(header, 0x0E, 2, true); //Compression: 0 = RGB; 3 = BITFIELDS. Int32 compression = (Int32)ArrayUtils.ReadIntFromByteArray(header, 0x10, 4, true); // Not dealing with non-standard formats. if (planes != 1 || (compression != 0 && compression != 3)) return null; PixelFormat fmt; switch (bitCount) { case 32: fmt = PixelFormat.Format32bppRgb; break; case 24: fmt = PixelFormat.Format24bppRgb; break; case 16: fmt = PixelFormat.Format16bppRgb555; break; default: return null; } if (compression == 3) imageIndex += 12; if (dibBytes.Length < imageIndex) return null; Byte[] image = new Byte[dibBytes.Length - imageIndex]; Array.Copy(dibBytes, imageIndex, image, 0, image.Length); // Classic stride: fit within blocks of 4 bytes. Int32 stride = (((((bitCount * width) + 7) / 8) + 3) / 4) * 4; if (compression == 3) { UInt32 redMask = ArrayUtils.ReadIntFromByteArray(dibBytes, headerSize + 0, 4, true); UInt32 greenMask = ArrayUtils.ReadIntFromByteArray(dibBytes, headerSize + 4, 4, true); UInt32 blueMask = ArrayUtils.ReadIntFromByteArray(dibBytes, headerSize + 8, 4, true); // Fix for the undocumented use of 32bppARGB disguised as BITFIELDS. Despite lacking an alpha bit field, // the alpha bytes are still filled in, without any header indication of alpha usage. // Pure 32-bit RGB: check if a switch to ARGB can be made by checking for non-zero alpha. // Admitted, this may give a mess if the alpha bits simply aren't cleared, but why the hell wouldn't it use 24bpp then? if (bitCount == 32 && redMask == 0xFF0000 && greenMask == 0x00FF00 && blueMask == 0x0000FF) { // Stride is always a multiple of 4; no need to take it into account for 32bpp. for (Int32 pix = 3; pix < image.Length; pix += 4) { // 0 can mean transparent, but can also mean the alpha isn't filled in, so only check for non-zero alpha, // which would indicate there is actual data in the alpha bytes. if (image[pix] == 0) continue; fmt = PixelFormat.Format32bppPArgb; break; } } else // Could be supported with a system that parses the colour masks, // but I don't think the clipboard ever uses these anyway. return null; } Bitmap bitmap = ImageUtils.BuildImage(image, width, height, stride, fmt, null, null); // This is bmp; reverse image lines. bitmap.RotateFlip(RotateFlipType.Rotate180FlipX); return bitmap; } catch { return null; } } 

因为BitConverter总是要求对系统字节序进行哑检，所以我在ArrayUtils类中得到了自己的ReadIntFromByteArray和WriteIntToByteArray ：

 public static void WriteIntToByteArray(Byte[] data, Int32 startIndex, Int32 bytes, Boolean littleEndian, UInt32 value) { Int32 lastByte = bytes - 1; if (data.Length < startIndex + bytes) throw new ArgumentOutOfRangeException("startIndex", "Data array is too small to write a " + bytes + "-byte value at offset " + startIndex + "."); for (Int32 index = 0; index < bytes; index++) { Int32 offs = startIndex + (littleEndian ? index : lastByte - index); data[offs] = (Byte)(value >> (8 * index) & 0xFF); } } public static UInt32 ReadIntFromByteArray(Byte[] data, Int32 startIndex, Int32 bytes, Boolean littleEndian) { Int32 lastByte = bytes - 1; if (data.Length < startIndex + bytes) throw new ArgumentOutOfRangeException("startIndex", "Data array is too small to read a " + bytes + "-byte value at offset " + startIndex + "."); UInt32 value = 0; for (Int32 index = 0; index < bytes; index++) { Int32 offs = startIndex + (littleEndian ? index : lastByte - index); value += (UInt32)(data[offs] << (8 * index)); } return value; }