我一直在尝试将透明的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,也会出现相同的问题。
System.Windows.Forms.Clipboard
DataObject
Windows剪贴板默认情况下不支持透明,但是您可以将剪贴板上的内容以多种类型放在一起,以确保大多数应用程序在其中找到可以使用的某种类型。可悲的是,最常见的类型(Windows本身似乎在使用)是一种非常肮脏且不可靠的类型。我写了一个很大的 咆哮 有关解释这里。
我假设您已经阅读了该内容,然后再继续此处的答案,因为它包含了下一部分所需的背景信息。
现在,将图像放在剪贴板上并提供透明性支持的最简单方法是PNG流,但它不能保证所有应用程序都可以粘贴它。Gimp支持PNG粘贴,而较新的MS Office程序显然也支持PNG粘贴,但例如Google Chrome不支持PNG粘贴,并且将仅接受我链接的答案中详述的凌乱的DIB类型。另一方面,Gimp不会接受DIB具有透明度,因为它的创建者实际上遵循了格式的规范,并且意识到格式不可靠(我链接的那个问题清楚地表明了这一点)。
不幸的是,由于DIB混乱,最好的办法就是将其放入尽可能多的受普遍支持的类型中,包括PNG,DIB和常规Image。
PNG和DIB都以相同的方式放置在剪贴板上:将它们放在DataObjectas中MemoryStream,然后在实际放置时为剪贴板提供“复制”指令。
MemoryStream
其中大多数都很简单,但是DIB有点复杂。请注意,以下部分包含一些对我自己的工具集的引用。在GetImageData一个可以发现这个答案的BuildImage人可以发现,在这里,和ArrayUtils那些如下。
GetImageData
BuildImage
ArrayUtils
/// <summary> /// Copies the given image to the clipboard as PNG, DIB and standard Bitmap format. /// </summary> /// <param name="image">Image to put on the clipboard.</param> /// <param name="imageNoTr">Optional specifically nontransparent version of the image to put on the clipboard.</param> /// <param name="data">Clipboard data object to put the image into. Might already contain other stuff. Leave null to create a new one.</param> 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); } } /// <summary> /// 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. /// </summary> /// <param name="image">Image to convert to DIB</param> /// <returns>The image converted to DIB, in bytes.</returns> 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这里使用的功能基本上只是我GetImageData和BuildImage工具集的组合,从而确保创建新映像而没有任何可能弄乱的后备资源;已知图像对象基于时Stream会被丢弃,从而导致崩溃。它的压缩和优化版本已发布在此处,这个问题值得一读,以了解为什么克隆如此重要。
CloneImage
Stream
/// <summary> /// Retrieves an image from the given clipboard data object, in the order PNG, DIB, Bitmap, Image object. /// </summary> /// <param name="retrievedData">The clipboard data.</param> /// <returns>The extracted image, or null if no supported image type was found.</returns> 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总是需要对系统字节序是愚蠢的检查,我有我自己的ReadIntFromByteArray,并WriteIntToByteArray在ArrayUtils类:
BitConverter
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; }