public async Task SaveImageDialog(ICanvasDataService canvasData, InkStrokeContainer container)
        {
            var picker = new FileSavePicker();

            picker.FileTypeChoices.Add("JPEG images", new List <string>()
            {
                ".jpg"
            });
            picker.FileTypeChoices.Add("PNG images", new List <string>()
            {
                ".png"
            });
            picker.DefaultFileExtension   = ".jpg";
            picker.SuggestedFileName      = canvasData.Name;
            picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
            var storageFile = await picker.PickSaveFileAsync();

            if (storageFile != null)
            {
                canvasData.FullPath          = storageFile.Path;
                canvasData.FutureAccessToken = StorageApplicationPermissions.FutureAccessList.Add(storageFile);
                var softwareBitmap = await canvasData.SaveToBitmap(container);

                await ImageWriterService.WriteSoftwareBitmapToFile(storageFile, softwareBitmap);
            }
        }
Example #2
0
        private static async Task ProcessSharedImage(IRandomAccessStream stream, ShareOperation operation, string fileName)
        {
            var canvasData = await ImageWriterService.StreamToCanvasData(stream, fileName);

            operation.ReportDataRetrieved();
            NavigateToMain(canvasData);
        }
Example #3
0
        public static async Task OnShareTargetActivated(ShareTargetActivatedEventArgs args)
        {
            var shareOperation = args.ShareOperation;

            shareOperation.ReportStarted();
            if (shareOperation.Data.Contains(StandardDataFormats.StorageItems))
            {
                var items = await shareOperation.Data.GetStorageItemsAsync();

                foreach (var item in items)
                {
                    if (item is StorageFile file)
                    {
                        var canvasData = await ImageWriterService.StorageFileToCanvasData(file);

                        shareOperation.ReportDataRetrieved();
                        NavigateToMain(canvasData);
                    }
                }
            }
            else if (shareOperation.Data.Contains(StandardDataFormats.Bitmap))
            {
                var reference = await shareOperation.Data.GetBitmapAsync();

                using (var stream = await reference.OpenReadAsync())
                {
                    await ProcessSharedImage(
                        stream,
                        shareOperation,
                        ResourceLoader.GetForCurrentView().GetString(NEW_IMAGE_NAME_KEY));
                }
            }
        }
Example #4
0
 public static async Task OnFileActivated(FileActivatedEventArgs args)
 {
     foreach (var f in args.Files)
     {
         if (f is StorageFile storageFile)
         {
             using (var stream = await storageFile.OpenReadAsync())
             {
                 await ImageWriterService.StreamToCanvasData(stream, storageFile.DisplayName);
             }
         }
     }
 }
        public async Task Save(ICanvasDataService canvasData, InkStrokeContainer container)
        {
            if (canvasData.FullPath == null)
            {
                await SaveImageDialog(canvasData, container);
            }
            else
            {
                var softwareBitmap = await canvasData.SaveToBitmap(container);

                var file = await StorageApplicationPermissions.FutureAccessList.GetFileAsync(canvasData.FutureAccessToken);

                await ImageWriterService.WriteSoftwareBitmapToFile(file, softwareBitmap);
            }
        }
        public async Task <ImageCanvasDataService> OpenImageDialog()
        {
            var picker = new FileOpenPicker
            {
                ViewMode = PickerViewMode.Thumbnail,
                SuggestedStartLocation = PickerLocationId.PicturesLibrary
            };

            picker.FileTypeFilter.Add(".jpg");
            picker.FileTypeFilter.Add(".png");

            var file = await picker.PickSingleFileAsync();

            ImageCanvasDataService result = null;

            if (file != null)
            {
                result = await ImageWriterService.StorageFileToCanvasData(file);
            }
            return(result);
        }