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

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

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

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

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

即使我使用System.Windows.Forms.Clipboard或尝试获取并设置DataObject而不是图像也是同样的问题.

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

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

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

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

PNG和DIB都以相同的方式放在剪贴板上:将它们放入DataObjectas中MemoryStream,然后在实际放入时给剪贴板提供"复制"指令.

大多数情况很简单,但DIB更复杂一点.请注意,以下部分包含对我自己的工具集的几个引用.在GetImageData一个可以发现这个答案的BuildImage人可以发现,在这里,和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这里使用的函数基本上只是我GetImageData和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 

因为BitConverter总是要求对系统字节序进行愚蠢的检查,所以我得到了自己的ReadIntFromByteArray并且WriteIntToByteArray在ArrayUtils课堂上:

public static void WriteIntToByteArray(Byte[] data, Int32 startIndex, Int32 bytes, Boolean littleEndian, UInt32 value)
{
    Int32 lastByte = bytes - 1;
    if (data.Length > (8 * index) & 0xFF);
    }
}

public static UInt32 ReadIntFromByteArray(Byte[] data, Int32 startIndex, Int32 bytes, Boolean littleEndian)
{
    Int32 lastByte = bytes - 1;
    if (data.Length