Win32 | Android | Browser - Support reading images from clipboard

samples/ControlCatalog/Pages/ClipboardPage.xaml

@@ -6,6 +6,7 @@
 
     <Button Click="CopyText" Content="Copy text to clipboard" />
     <Button Click="PasteText" Content="Paste text from clipboard" />
+    <Button Click="PasteImage" Content="Paste image from clipboard" />
     <Button Click="CopyFiles" Content="Copy files to clipboard" />
     <Button Click="PasteFiles" Content="Paste files from clipboard" />
     <Button Click="CopyBinaryData" Content="Copy bytes to clipboard" />
@@ -20,5 +21,9 @@
              MinHeight="100"
              AcceptsReturn="True"
              Watermark="Text to copy of file names per line" />
+    <Viewbox Width="420" Height="360">
+      <Image x:Name="ClipboardImage"
+      />
+    </Viewbox>
   </StackPanel>
 </UserControl>

samples/ControlCatalog/Pages/ClipboardPage.xaml.cs

@@ -10,6 +10,7 @@
 using Avalonia.Interactivity;
 using Avalonia.Markup.Xaml;
 using Avalonia.Media;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 
@@ -34,6 +35,7 @@ public ClipboardPage()
         }
 
         private TextBox ClipboardContent => this.Get<TextBox>("ClipboardContent");
+        private Image ClipboardImage => this.Get<Image>("ClipboardImage");
 
         private void InitializeComponent()
         {
@@ -54,6 +56,20 @@ private async void PasteText(object? sender, RoutedEventArgs args)
             }
         }
 
+        private async void PasteImage(object? sender, RoutedEventArgs args)
+        {
+            if (TopLevel.GetTopLevel(this)?.Clipboard is { } clipboard)
+            {
+                using var data = await clipboard.TryGetDataAsync();
+                Bitmap? source = null;
+                if (data != null)
+                {
+                    source = await data!.TryGetValueAsync(DataFormat.Image);
+                }
+                ClipboardImage.Source = source;
+            }
+        }
+
         private async void CopyFiles(object? sender, RoutedEventArgs args)
         {
             if (TopLevel.GetTopLevel(this)?.Clipboard is { } clipboard)

src/Android/Avalonia.Android/Platform/ClipDataItemToDataTransferItemWrapper.cs

@@ -1,9 +1,10 @@
-using System;
+using System.IO;
 using Android.App;
 using Android.Content;
 using Avalonia.Android.Platform.Storage;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
+using Avalonia.Media.Imaging;
 
 namespace Avalonia.Android.Platform;
 
@@ -26,16 +27,58 @@ protected override DataFormat[] ProvideFormats()
         if (DataFormat.Text.Equals(format))
             return _item.CoerceToText(_owner.Context);
 
-        if (DataFormat.File.Equals(format))
-        {
-            return _item.Uri is { Scheme: "file" or "content" } fileUri && _owner.Context is Activity activity ?
-                AndroidStorageItem.CreateItem(activity, fileUri) :
-                null;
-        }
-
         if (format is DataFormat<string>)
             return TryGetAsString();
 
+        var file = item.Uri is { Scheme: "file" or "content" } fileUri && _owner.Context is Activity activity ?
+                AndroidStorageFile.CreateItem(activity, fileUri) :
+                null;
+
+        if(file != null)
+        {
+            if (DataFormat.File.Equals(format))
+            {
+                return file;
+            }
+
+            try
+            {
+                if (DataFormat.Image.Equals(format))
+                {
+                    Bitmap? image = null;
+
+                    if (file is AndroidStorageFile storageFile)
+                    {
+                        using var stream = storageFile.OpenReadAsync().Result;
+
+                        if (stream != null)
+                        {
+                            image = new Bitmap(stream);
+                        }
+                    }
+
+                    return image;
+                }
+
+                if (format is DataFormat<byte[]>)
+                {
+                    if (file is AndroidStorageFile storageFile)
+                    {
+                        using var stream = storageFile.OpenReadAsync().Result;
+
+                        using var mem = new MemoryStream();
+                        stream.CopyTo(mem);
+                        return mem.ToArray();
+                    }
+                }
+            }
+            finally
+            {
+
+                file?.Dispose();
+            }
+        }
+
         return null;
     }
 

src/Android/Avalonia.Android/Platform/ClipDataToDataTransferWrapper.cs

@@ -1,4 +1,5 @@
-using Android.Content;
+using System.Linq;
+using Android.Content;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 
@@ -26,6 +27,11 @@ protected override DataFormat[] ProvideFormats()
         for (var i = 0; i < count; ++i)
             formats[i] = AndroidDataFormatHelper.MimeTypeToDataFormat(clipDescription.GetMimeType(i)!);
 
+        if (formats.Any(x => x?.Identifier.StartsWith("image/", System.StringComparison.OrdinalIgnoreCase) == true))
+        {
+            formats = [.. formats, DataFormat.Image];
+        }
+
         return formats;
     }
 

src/Avalonia.Base/Input/DataFormat.cs

@@ -1,4 +1,5 @@
 using System;
+using Avalonia.Media.Imaging;
 using Avalonia.Metadata;
 using Avalonia.Platform.Storage;
 using Avalonia.Utilities;
@@ -32,6 +33,12 @@ private protected DataFormat(DataFormatKind kind, string identifier)
     /// </summary>
     public static DataFormat<string> Text { get; } = CreateUniversalFormat<string>("Text");
 
+    /// <summary>
+    /// Gets a data format representing a bitmap.
+    /// Its data type is <see cref="Bitmap"/>.
+    /// </summary>
+    public static DataFormat<Bitmap> Image { get; } = CreateUniversalFormat<Bitmap>("Image");
+
     /// <summary>
     /// Gets a data format representing a single file.
     /// Its data type is <see cref="IStorageItem"/>.

src/Browser/Avalonia.Browser/BrowserClipboardDataTransferItem.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Runtime.InteropServices.JavaScript;
 using System.Threading.Tasks;
 using Avalonia.Browser.Interop;
@@ -22,8 +23,24 @@ protected override DataFormat[] ProvideFormats()
 
     protected override async Task<object?> TryGetRawCoreAsync(DataFormat format)
     {
-        var formatString = BrowserDataFormatHelper.ToBrowserFormat(format);
-        var value = await InputHelper.TryGetReadableDataItemValueAsync(_readableDataItem, formatString).ConfigureAwait(false);
+        string formatString = "";
+
+        if (DataFormat.Image.Equals(format))
+        {
+            var formats = Formats;
+            var imageFormat = formats.FirstOrDefault(x => x.Identifier == "image/png");
+            if (imageFormat == null)
+                imageFormat = formats.FirstOrDefault(x => x.Identifier is "image/jpg" or "image/jpeg");
+            if (imageFormat == null)
+                imageFormat = formats.FirstOrDefault(x => x.Identifier == "image/bmp");
+
+            formatString = imageFormat?.Identifier ?? "";
+        }
+        else
+            formatString = BrowserDataFormatHelper.ToBrowserFormat(format);
+
+        var value = await InputHelper.TryGetReadableDataItemValueAsync(_readableDataItem, formatString)
+            .ConfigureAwait(false);
         return BrowserDataTransferHelper.TryGetValue(value, format);
     }
 

src/Browser/Avalonia.Browser/BrowserDataFormatHelper.cs

@@ -7,6 +7,7 @@ internal static class BrowserDataFormatHelper
 {
     private const string FormatTextPlain = "text/plain";
     private const string FormatFiles = "Files";
+    private const string FormatImage = "Image";
     private const string AppPrefix = "application/avn-fmt.";
 
     public static DataFormat ToDataFormat(string formatString)
@@ -29,6 +30,9 @@ public static string ToBrowserFormat(DataFormat format)
         if (DataFormat.File.Equals(format))
             return FormatFiles;
 
+        if (DataFormat.Image.Equals(format))
+            return FormatImage;
+
         return format.ToSystemName(AppPrefix);
     }
 }

src/Browser/Avalonia.Browser/BrowserDataTransferHelper.cs

@@ -1,8 +1,10 @@
-using System.Runtime.InteropServices.JavaScript;
+using System.IO;
+using System.Runtime.InteropServices.JavaScript;
 using System.Text;
 using Avalonia.Browser.Interop;
 using Avalonia.Browser.Storage;
 using Avalonia.Input;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform.Storage;
 
 namespace Avalonia.Browser;
@@ -13,8 +15,17 @@ public static DataFormat[] GetReadableItemFormats(JSObject readableDataItem /* J
     {
         var formatStrings = InputHelper.GetReadableDataItemFormats(readableDataItem);
         var formats = new DataFormat[formatStrings.Length];
+        var hasSupportedImage = false;
         for (var i = 0; i < formatStrings.Length; ++i)
-            formats[i] = BrowserDataFormatHelper.ToDataFormat(formatStrings[i]);
+        {
+            var formatString = formatStrings[i];
+            hasSupportedImage = formatString is "image/png" or "image/jpeg" or "image/bmp" or "image/jpeg";
+            formats[i] = BrowserDataFormatHelper.ToDataFormat(formatString);
+        }
+
+        if (hasSupportedImage)
+            formats = [..formats, DataFormat.Image];
+
         return formats;
     }
 
@@ -47,6 +58,17 @@ public static DataFormat[] GetReadableItemFormats(JSObject readableDataItem /* J
             };
         }
 
+        if (DataFormat.Image.Equals(format))
+        {
+            if (data is byte[] bytes)
+            {
+                using var stream = new MemoryStream(bytes);
+                return new Bitmap(stream);
+            }
+
+            return null;
+        }
+
         if (format is DataFormat<byte[]>)
         {
             return data switch

src/Windows/Avalonia.Win32/ClipboardFormatRegistry.cs

@@ -1,8 +1,8 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using Avalonia.Input;
-using Avalonia.Win32.Interop;
 using Avalonia.Utilities;
+using Avalonia.Win32.Interop;
 
 namespace Avalonia.Win32
 {
@@ -52,6 +52,17 @@ public static ushort GetFormatId(DataFormat format)
         {
             lock (s_formats)
             {
+                if (DataFormat.Image.Equals(format))
+                {
+                    var imageFormat = s_formats.Find(x => x.Format.Identifier == "image/png");
+                    if (imageFormat.Format == null)
+                        imageFormat = s_formats.Find(x => x.Format.Identifier == "image/jpg" || x.Format.Identifier == "image/jpeg");
+                    if (imageFormat.Format == null)
+                        imageFormat = s_formats.Find(x => x.Format.Identifier == "image/bmp");
+
+                    return imageFormat.Id;
+                }
+
                 for (var i = 0; i < s_formats.Count; ++i)
                 {
                     if (s_formats[i].Format.Equals(format))

src/Windows/Avalonia.Win32/OleDataObjectHelper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
@@ -8,9 +9,9 @@
 using Avalonia.Platform.Storage;
 using Avalonia.Platform.Storage.FileIO;
 using Avalonia.Utilities;
+using static Avalonia.Win32.Interop.UnmanagedMethods;
 using FORMATETC = Avalonia.Win32.Interop.UnmanagedMethods.FORMATETC;
 using STGMEDIUM = Avalonia.Win32.Interop.UnmanagedMethods.STGMEDIUM;
-using static Avalonia.Win32.Interop.UnmanagedMethods;
 
 namespace Avalonia.Win32;
 
@@ -69,6 +70,14 @@ public static FORMATETC ToFormatEtc(this DataFormat format)
                 .ToArray();
         }
 
+        if(DataFormat.Image.Equals(format))
+        {
+            var data = ReadBytesFromHGlobal(hGlobal);
+            using var stream = new MemoryStream(data);
+
+            return new Avalonia.Media.Imaging.Bitmap(stream);
+        }
+
         if (format is DataFormat<string>)
             return ReadStringFromHGlobal(hGlobal);
 

src/Windows/Avalonia.Win32/OleDataObjectToDataTransferWrapper.cs

@@ -32,6 +32,35 @@ protected override DataFormat[] ProvideFormats()
         while (Next(enumFormat) is { } format)
             formats.Add(format);
 
+        DataFormat? bmpImageFormat = null;
+        DataFormat? pngImageFormat = null;
+        DataFormat? jpegImageFormat = null;
+
+        foreach (var format in formats)
+        {
+            if (format.Identifier == "image/png")
+            {
+                pngImageFormat = format;
+            }
+
+            if (format.Identifier == "image/jpg" || format.Identifier == "image/jpeg")
+            {
+                jpegImageFormat = format;
+            }
+
+            if (format.Identifier == "image/bmp")
+            {
+                bmpImageFormat = format;
+            }
+        }
+
+        var hasSupportedFormat = (pngImageFormat ?? jpegImageFormat ?? bmpImageFormat ?? null) != null;
+
+        if (hasSupportedFormat)
+        {
+            formats.Add(DataFormat.Image);
+        }
+
         return formats.ToArray();
 
         static unsafe DataFormat? Next(IEnumFORMATETC enumFormat)