internal static async Task <Uri?> GetSharedUriAsync(DataPackageView view)
{
if (view.Contains(StandardDataFormats.Uri))
{
return(await view.GetUriAsync());
}
else if (view.Contains(StandardDataFormats.WebLink))
{
return(await view.GetWebLinkAsync());
}
else if (view.Contains(StandardDataFormats.ApplicationLink))
{
return(await view.GetApplicationLinkAsync());
}
return(null);
}
internal static async Task <NSDraggingItem[]> CreateNativeDragDropData(
DataPackageView data,
Point startPoint)
{
NSDraggingItem draggingItem;
var items = new List <NSDraggingItem>();
double maxFrameDimension = 300.0; // May be adjusted
var defaultFrameRect = new CoreGraphics.CGRect(startPoint.X, startPoint.Y, 100, 30);
/* Note that NSDraggingItems are required by the BeginDraggingSession methods.
* Therefore, that is what is constructed here instead of pasteboard items.
*
* For several types such as NSString or NSImage, they implement the INSPasteboardWriting interface and
* can therefore be used to directly construct an NSDraggingItem.
* However, for other types (such as HTML) the full pasteboard item must be constructed first defining
* both its type and string content.
*
* The dragging frame is used to represent the visual of the item being dragged. This could be a
* preview of the image or sample text. At minimum, macOS requires the DraggingFrame property of the
* NSDraggingItem to be set with a CGRect or the app will crash. It is however better to set both
* the frame bounds and content at the same time with .SetDraggingFrame(). For caveats see:
* https://developer.apple.com/documentation/appkit/nsdraggingitem/1528746-setdraggingframe
*
* Because Uno does not currently support the DragUI, this code only generates a real drag visual
* for images where a visual is already defined. For other types such as text, no visual will be
* generated. In the future, when DragUI and its corresponding image is supported, this can change.
*
*/
if (data?.Contains(StandardDataFormats.Bitmap) ?? false)
{
NSImage?image = null;
using (var stream = (await(await data.GetBitmapAsync()).OpenReadAsync()).AsStream())
{
if (stream != null)
{
using (var ms = new MemoryStream())
{
await stream.CopyToAsync(ms);
ms.Flush();
ms.Position = 0;
image = NSImage.FromStream(ms);
}
}
}
if (image != null)
{
draggingItem = new NSDraggingItem(image);
// For an NSImage, we will use the image itself as the dragging visual.
// The visual should be no larger than the max dimension setting and is therefore scaled.
NSBitmapImageRep rep = new NSBitmapImageRep(image.CGImage);
int width = (int)rep.PixelsWide;
int height = (int)rep.PixelsHigh;
double scale = maxFrameDimension / Math.Max(width, height);
// Dragging frame must be set
draggingItem.SetDraggingFrame(
new CoreGraphics.CGRect(startPoint.X, startPoint.Y, width * scale, height * scale),
image);
items.Add(draggingItem);
}
}
if (data?.Contains(StandardDataFormats.Html) ?? false)
{
var html = await data.GetHtmlFormatAsync();
if (!string.IsNullOrEmpty(html))
{
var pasteboardItem = new NSPasteboardItem();
pasteboardItem.SetStringForType(html, NSPasteboard.NSPasteboardTypeHTML);
draggingItem = new NSDraggingItem(pasteboardItem);
draggingItem.DraggingFrame = defaultFrameRect; // Must be set
items.Add(draggingItem);
}
}
if (data?.Contains(StandardDataFormats.Rtf) ?? false)
{
var rtf = await data.GetRtfAsync();
if (!string.IsNullOrEmpty(rtf))
{
// Use `NSPasteboardTypeRTF` instead of `NSPasteboardTypeRTFD` for max compatibility
var pasteboardItem = new NSPasteboardItem();
pasteboardItem.SetStringForType(rtf, NSPasteboard.NSPasteboardTypeRTF);
draggingItem = new NSDraggingItem(pasteboardItem);
draggingItem.DraggingFrame = defaultFrameRect; // Must be set
items.Add(draggingItem);
}
}
if (data?.Contains(StandardDataFormats.StorageItems) ?? false)
{
var storageItems = await data.GetStorageItemsAsync();
if (storageItems.Count > 0)
{
// Not currently supported
}
}
if (data?.Contains(StandardDataFormats.Text) ?? false)
{
var text = await data.GetTextAsync();
if (!string.IsNullOrEmpty(text))
{
draggingItem = new NSDraggingItem((NSString)text);
draggingItem.DraggingFrame = defaultFrameRect; // Must be set
items.Add(draggingItem);
}
}
if (data != null)
{
var uri = DataPackage.CombineUri(
data.Contains(StandardDataFormats.WebLink) ? (await data.GetWebLinkAsync()).ToString() : null,
data.Contains(StandardDataFormats.ApplicationLink) ? (await data.GetApplicationLinkAsync()).ToString() : null,
data.Contains(StandardDataFormats.Uri) ? (await data.GetUriAsync()).ToString() : null);
if (string.IsNullOrEmpty(uri) == false)
{
draggingItem = new NSDraggingItem(new NSUrl(uri));
draggingItem.DraggingFrame = defaultFrameRect; // Must be set
items.Add(draggingItem);
}
}
return(items.ToArray());
}
private static async Task<ReceivedShareItem> FetchDataFromPackageViewAsync(DataPackageView packageView)
{
var rval = new ReceivedShareItem()
{
Title = packageView.Properties.Title,
Description = packageView.Properties.Description,
PackageFamilyName = packageView.Properties.PackageFamilyName,
ContentSourceWebLink = packageView.Properties.ContentSourceWebLink,
ContentSourceApplicationLink = packageView.Properties.ContentSourceApplicationLink,
LogoBackgroundColor = packageView.Properties.LogoBackgroundColor,
};
if (packageView.Properties.Square30x30Logo != null)
{
using (var logoStream = await packageView.Properties.Square30x30Logo.OpenReadAsync())
{
var logo = new MemoryStream();
await logoStream.AsStreamForRead().CopyToAsync(logo);
logo.Position = 0;
var str = Convert.ToBase64String(logo.ToArray());
//rval.Square30x30LogoBase64 = Convert.ToBase64String(logo.ToArray());
rval.Square30x30Logo = new Models.MemoryStreamBase64Item { Base64String = str };
}
}
if (packageView.Properties.Thumbnail != null)
{
using (var thumbnailStream = await packageView.Properties.Thumbnail.OpenReadAsync())
{
var thumbnail = new MemoryStream();
await thumbnailStream.AsStreamForRead().CopyToAsync(thumbnail);
thumbnail.Position = 0;
var str = Convert.ToBase64String(thumbnail.ToArray());
rval.Thumbnail = new Models.MemoryStreamBase64Item { Base64String = str };
}
}
if (packageView.Contains(StandardDataFormats.WebLink))
{
try
{
var link = new WebLinkShareItem
{
WebLink = await packageView.GetWebLinkAsync()
};
rval.AvialableShareItems.Add(link);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.ApplicationLink))
{
try
{
var sharedApplicationLink = new ApplicationLinkShareItem
{
ApplicationLink = await packageView.GetApplicationLinkAsync()
};
rval.AvialableShareItems.Add(sharedApplicationLink);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetApplicationLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.Text))
{
try
{
var sharedText = new TextShareItem { Text = await packageView.GetTextAsync() };
rval.AvialableShareItems.Add(sharedText);
rval.Text = await packageView.GetTextAsync();
//rval.GetValueContainer(x => x.Text)
// .GetNullObservable()
// .Subscribe(e => sharedText.Text = rval.Text)
// .DisposeWith(rval);
sharedText.GetValueContainer(x => x.Text)
.GetNullObservable()
.Subscribe(e => rval.Text = sharedText.Text)
.DisposeWith(rval);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetTextAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.StorageItems))
{
try
{
var files = await packageView.GetStorageItemsAsync();
var sharedStorageItem = new FilesShareItem
{
StorageFiles = new ObservableCollection<FileItem>()
//StorageItems =
};
foreach (StorageFile sf in files)
{
var guidString = Guid.NewGuid().ToString();
StorageApplicationPermissions.FutureAccessList.AddOrReplace(guidString, sf, sf.Name);
var ts = await sf.GetScaledImageAsThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.VideosView);
var tmbs = new MemoryStream();
await ts.AsStreamForRead().CopyToAsync(tmbs);
var file = new FileItem
{
AccessToken = guidString,
ContentType = sf.ContentType,
FileName = sf.DisplayName,
PossiblePath = sf.Path,
Thumbnail = new Models.MemoryStreamBase64Item(tmbs.ToArray())
};
sharedStorageItem.StorageFiles.Add(file);
}
//StorageApplicationPermissions.FutureAccessList.AddOrReplace()
rval.AvialableShareItems.Add(sharedStorageItem);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetStorageItemsAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
//if (packageView.Contains(dataFormatName))
//{
// try
// {
// this.sharedCustomData = await packageView.GetTextAsync(dataFormatName);
// }
// catch (Exception ex)
// {
// //NotifyUserBackgroundThread("Failed GetTextAsync(" + dataFormatName + ") - " + ex.Message, NotifyType.ErrorMessage);
// }
//}
if (packageView.Contains(StandardDataFormats.Html))
{
var sharedHtmlFormatItem = new HtmlShareItem();
var sharedHtmlFormat = string.Empty;
try
{
sharedHtmlFormat = await packageView.GetHtmlFormatAsync();
//sharedHtmlFormatItem.HtmlFormat = sharedHtmlFormat;
sharedHtmlFormatItem.HtmlFragment = HtmlFormatHelper.GetStaticFragment(sharedHtmlFormat);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetHtmlFormatAsync - " + ex.Message, NotifyType.ErrorMessage);
}
//try
//{
// var sharedResourceMap = await packageView.GetResourceMapAsync();
//}
//catch (Exception ex)
//{
// //NotifyUserBackgroundThread("Failed GetResourceMapAsync - " + ex.Message, NotifyType.ErrorMessage);
//}
//if (packageView.Contains(StandardDataFormats.WebLink))
//{
// try
// {
// sharedHtmlFormatItem.WebLink = await packageView.GetWebLinkAsync();
// }
// catch (Exception ex)
// {
// //NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
// }
//}
rval.AvialableShareItems.Add(sharedHtmlFormatItem);
}
if (packageView.Contains(StandardDataFormats.Bitmap))
{
try
{
var fi = await packageView.GetBitmapAsync();
using (var imgFileStream = await fi.OpenReadAsync())
{
var saveTargetStream = new InMemoryRandomAccessStream();
var bitmapSourceStream = imgFileStream;
await ServiceLocator
.Instance
.Resolve<IImageConvertService>()
.ConverterBitmapToTargetStreamAsync(bitmapSourceStream, saveTargetStream);
saveTargetStream.Seek(0);
var sr = saveTargetStream.GetInputStreamAt(0);
var source = sr.AsStreamForRead();
var ms = new MemoryStream();
await source.CopyToAsync(ms);
var sharedBitmapStreamRef = new DelayRenderedImageShareItem
{
SelectedImage = new Models.MemoryStreamBase64Item(ms.ToArray())
};
rval.AvialableShareItems.Add(sharedBitmapStreamRef);
}
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetBitmapAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
//foreach (var item in rval.AvialableShareItems)
//{
// //item.ContentSourceApplicationLink = rval.ContentSourceApplicationLink;
// //item.ContentSourceWebLink = rval.ContentSourceWebLink;
// //item.DefaultFailedDisplayText = rval.DefaultFailedDisplayText;
// //item.Description = rval.Description;
// //item.Title = rval.Title;
//}
return rval;
}
