Comment puis-je copier et coller des images de manière fiable et transparente dans différentes applications ?

Copier-coller fiable d'images transparentes dans différentes applications

Vous avez peut-être rencontré un problème où lorsque vous copiez et collez une image, la transparence ne reste pas cohérente entre les différents programmes. Bien que Chrome puisse préserver la transparence, celle-ci peut être perdue lorsqu'une image est définie à l'aide de l'objet Presse-papiers du système.

Limitation du presse-papiers

Le Presse-papiers Windows ne prend pas en charge nativement la transparence des images. Cependant, vous pouvez exploiter plusieurs types de données pour augmenter la compatibilité entre les applications.

Diffusion PNG : meilleure option de compatibilité

Le streaming PNG est le moyen le plus fiable de maintenir la transparence des images du presse-papiers. Collez l'image PNG dans GIMP ou dans des programmes MS Office plus récents et la transparence sera préservée.

Formats multiples, compatibilité plus large

Pour garantir la compatibilité avec davantage d'applications, il est recommandé d'inclure plusieurs formats d'image pris en charge dans le presse-papiers, tels que PNG, Device Independent Bitmap (DIB) et bitmap standard.

Exemple de code

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())
    {
        data.SetData(DataFormats.Bitmap, true, imageNoTr); // 设置标准位图（无透明度）
        image.Save(pngMemStream, ImageFormat.Png);
        data.SetData("PNG", false, pngMemStream); // 设置PNG流（GIMP和较新MS Office兼容）
        Byte[] dibData = ConvertToDib(image);
        dibMemStream.Write(dibData, 0, dibData.Length);
        data.SetData(DataFormats.Dib, false, dibMemStream); // 设置DIB格式（处理错误解释透明度的应用）
        Clipboard.SetDataObject(data, true);
    }
}

public static Byte[] ConvertToDib(Image 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));
        bm32b.RotateFlip(RotateFlipType.Rotate180FlipX);
        Int32 stride;
        Byte[] bm32bData = ImageUtils.GetImageData(bm32b, out stride);
        Int32 hdrSize = 0x28;
        Byte[] fullImage = new Byte[hdrSize + 12 + bm32bData.Length];
        ArrayUtils.WriteIntToByteArray(fullImage, 0x00, 4, true, (UInt32)hdrSize);
        ArrayUtils.WriteIntToByteArray(fullImage, 0x04, 4, true, (UInt32)image.Width);
        ArrayUtils.WriteIntToByteArray(fullImage, 0x08, 4, true, (UInt32)image.Height);
        ArrayUtils.WriteIntToByteArray(fullImage, 0x0C, 2, true, 1);
        ArrayUtils.WriteIntToByteArray(fullImage, 0x0E, 2, true, 32);
        ArrayUtils.WriteIntToByteArray(fullImage, 0x10, 4, true, 3);
        ArrayUtils.WriteIntToByteArray(fullImage, 0x14, 4, true, (UInt32)bm32bData.Length);
        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;
    }
}

Extraire l'image du presse-papiers

Pour extraire une image du presse-papier, vous devez vérifier les différents formats supportés, en privilégiant le PNG pour garantir une fiabilité maximale :

public static Bitmap GetClipboardImage(DataObject retrievedData)
{
    if (retrievedData.GetDataPresent("PNG", false))
    {
        MemoryStream png_stream = retrievedData.GetData("PNG", false) as MemoryStream;
        if (png_stream != null)
            using (Bitmap bm = new Bitmap(png_stream))
                return ImageUtils.CloneImage(bm);
    }
    else if (retrievedData.GetDataPresent(DataFormats.Dib, false))
    {
        MemoryStream dib = retrievedData.GetData(DataFormats.Dib, false) as MemoryStream;
        if (dib != null)
            return ImageFromClipboardDib(dib.ToArray());
    }
    else if (retrievedData.GetDataPresent(DataFormats.Bitmap))
        return new Bitmap(retrievedData.GetData(DataFormats.Bitmap) as Image);
    else if (retrievedData.GetDataPresent(typeof(Image)))
        return new Bitmap(retrievedData.GetData(typeof(Image)) as Image);
    return null;
}

public static Bitmap ImageFromClipboardDib(Byte[] dibBytes)
{
    if (dibBytes == null || dibBytes.Length < 4 || dibBytes.Length < (Int32)ArrayUtils.ReadIntFromByteArray(dibBytes, 0, 4, true))
        return null;
    Int32 width = (Int32)ArrayUtils.ReadIntFromByteArray(dibBytes, 0x04, 4, true);
    Int32 height = (Int32)ArrayUtils.ReadIntFromByteArray(dibBytes, 0x08, 4, true);
    Int16 planes = (Int16)ArrayUtils.ReadIntFromByteArray(dibBytes, 0x0C, 2, true);
    Int16 bitCount = (Int16)ArrayUtils.ReadIntFromByteArray(dibBytes, 0x0E, 2, true);
    Int32 compression = (Int32)ArrayUtils.ReadIntFromByteArray(dibBytes, 0x10, 4, true);
    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;
    }
    Int32 stride = (((((bitCount * width) + 7) / 8) + 3) / 4) * 4;
    Int32 imageIndex = 40 + (compression == 3 ? 12 : 0);
    if (dibBytes.Length < imageIndex) return null;
    Byte[] image = new Byte[dibBytes.Length - imageIndex];
    Array.Copy(dibBytes, imageIndex, image, 0, image.Length);
    Bitmap bitmap = ImageUtils.BuildImage(image, width, height, stride, fmt, null, null);

    // ... (ImageFromClipboardDib function continues,  requires ImageUtils.BuildImage implementation) ...
}

(Remarque : ImageUtils.GetImageData, ImageUtils.CloneImage et ImageUtils.BuildImage dans l'extrait de code ci-dessus doivent être implémentés par vous-même en fonction de la situation réelle.) Ces fonctions sont responsables du traitement de l'image données et la création de bitmaps. L'implémentation de cette partie dépend de la bibliothèque de traitement d'image que vous utilisez et de l'environnement spécifique de la plateforme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!