Copiar de e para a área de transferência perde a transparência da imagem

Eu tenho tentado copiar uma imagem PNG transparente para área de transferência e preservar sua transparência para colá-lo em um programa específico que o suporte.

Eu já tentei muitas soluções, mas o fundo sempre ficava cinza de uma forma ou de outra.

Então eu tentei copiar a mesma imagem usando o Chrome e colá-lo no programa e funcionou. Ele preservou a transparência. Então eu tentei pegar a imagem da área de transferência que eu tinha copiado usando o Chrome e definir a imagem novamente, esperando que a transparência ainda estivesse lá – mas não, transparência não foi preservada mesmo que eu tirei a imagem da área de transferência e defini-la novamente.

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

Mesmo problema, mesmo se eu usar o System.Windows.Forms.Clipboard ou tente obter e definir o DataObject vez da imagem.

A área de transferência do Windows, por padrão, não oferece suporte à transparência, mas você pode colocar o conteúdo na área de transferência em vários tipos para garantir que a maioria dos aplicativos encontre algum tipo de material que possa usar. Infelizmente, o tipo mais comum (que o próprio Windows parece usar) é muito sujo e não confiável. Eu escrevi uma grande explicação sobre isso aqui .

Eu suponho que você leu isso antes de continuar com a minha resposta aqui, porque contém as informações necessárias para a próxima parte.

Agora, a maneira mais limpa de colocar uma imagem na área de transferência com suporte a transparência é um stream PNG, mas não garante que todos os aplicativos possam colá-la. O Gimp suporta a pasta PNG e, aparentemente, o mesmo acontece com os programas mais recentes do MS Office, mas o Google Chrome, por exemplo, não o faz, e só aceitará o tipo DIB confuso detalhado na resposta a que me vinculei. Por outro lado, o Gimp não aceitará o DIB como tendo transparência, porque seus criadores realmente seguiram as especificações do formato e perceberam que o formato não era confiável (como claramente demonstrado pela pergunta que eu relacionei).

Por causa da bagunça DIB, infelizmente, a melhor coisa a fazer é simplesmente colocá-lo lá em tantos tipos geralmente suportados quanto possível, incluindo PNG, DIB e a imagem normal.

O PNG e o DIB são colocados na área de transferência da mesma maneira: colocando-os no DataObject como MemoryStream e, em seguida, fornecendo à área de transferência a instrução “copy” quando estiver realmente colocando-a.

A maior parte disso é direta, mas o DIB é um pouco mais complexo. Observe que a parte a seguir contém algumas referências aos meus próprios conjuntos de ferramentas. O GetImageData pode ser encontrado nesta resposta , o BuildImage um pode ser encontrado aqui e os ArrayUtils são fornecidos abaixo.

 ///  /// 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; } 

Agora, como para obter uma imagem fora da área de transferência, notei que aparentemente há uma diferença de comportamento entre o .net 3.5 e os posteriores, que parecem realmente usar esse DIB. Dada essa diferença, e considerando a falta de confiabilidade do formato DIB, você deve verificar manualmente todos os tipos, preferencialmente começando com o formato PNG completamente confiável.

Você pode obter o DataObject da área de transferência com este código:

 DataObject retrievedData = Clipboard.GetDataObject() as DataObject; 

A function CloneImage usada aqui é basicamente apenas a combinação dos meus conjuntos de ferramentas BuildImage e BuildImage , garantindo que uma nova imagem seja criada sem nenhum recurso de apoio que possa atrapalhar; Objetos de imagem são conhecidos por causar falhas quando eles são baseados em um Stream que é descartado. Uma versão compactada e otimizada foi publicada aqui, em uma pergunta que vale a pena ler sobre o motivo pelo qual essa clonagem é tão importante.

 ///  /// 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; } } 

Como o BitConverter sempre requer essa verificação burra no endianness do sistema, recebi meus próprios ReadIntFromByteArray e WriteIntToByteArray em uma class ArrayUtils :

 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; } 
    Intereting Posts