Build out remaining features for WPF

windows/RNViewShot.Net46/RNViewShotModule.cs

             double quality = options["quality"] != null ? options.Value<double>("quality") : 1.0;
             int? width = options["width"] != null ? options.Value<int?>("width") : null;
             int? height = options["height"] != null ? options.Value<int?>("height") : null;
-            string result = options["result"] != null ? options.Value<string>("result") : "file";            
+            string result = options["result"] != null ? options.Value<string>("result") : "file";
+            string path = options["path"] != null ? options.Value<string>("path") : null;
+
+            if (format != "png" && format != "jpg" && format != "jpeg")
+            {
+                promise.Reject(ViewShot.ErrorUnableToSnapshot, "Unsupported image format: " + format + ". Try one of: png | jpg | jpeg");
+                return;
+            }
 
             UIManagerModule uiManager = this._reactContext.GetNativeModule<UIManagerModule>();
-            uiManager.AddUIBlock(new ViewShot(tag, format, quality, width, height, result, promise));
+            uiManager.AddUIBlock(new ViewShot(tag, format, quality, width, height, path, result, promise));
         }
     }
 }

windows/RNViewShot.Net46/ViewShot.cs

 {
     public class ViewShot : IUIBlock
     {
-        private const string ErrorUnableToSnapshot = "E_UNABLE_TO_SNAPSHOT";
+        public const string ErrorUnableToSnapshot = "E_UNABLE_TO_SNAPSHOT";
         private int tag;
         private string extension;
         private double quality;
         private int? width;
         private int? height;
+        private string path;
         private string result;
         private IPromise promise;
 
             double quality,
             int? width,
             int? height,
+            string path,
             string result,
             IPromise promise)
         {
             this.quality = quality;
             this.width = width;
             this.height = height;
+            this.path = path;
             this.result = result;
             this.promise = promise;
         }
                 promise.Reject(ErrorUnableToSnapshot, "No view found with reactTag: " + tag);
                 return;
             }
-            int width = (int)view.ActualWidth;
-            int height = (int)view.ActualHeight;
 
-            RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Default);
-            renderTargetBitmap.Render(view);
+            try
+            {
+                BitmapEncoder image = CaptureView(view);
 
-            BitmapEncoder image;
-            if (extension == "png")
+                if ("file" == result)
+                {
+                    string filePath = GetFilePath();
+                    Stream stream = File.Create(filePath);
+                    image.Save(stream);
+                    promise.Resolve(filePath);
+                    stream.Close();
+                }
+                else if ("base64" == result)
+                {
+                    MemoryStream stream = new MemoryStream();
+                    image.Save(stream);
+                    byte[] imageBytes = stream.ToArray();
+                    string data = Convert.ToBase64String(imageBytes);
+                    promise.Resolve(data);
+                    stream.Close();
+                }
+                else if ("data-uri" == result)
+                {
+                    MemoryStream stream = new MemoryStream();
+                    image.Save(stream);
+                    byte[] imageBytes = stream.ToArray();
+                    string data = Convert.ToBase64String(imageBytes);
+                    data = "data:image/" + extension + ";base64," + data;
+                    promise.Resolve(data);
+                    stream.Close();
+                }
+                else
+                {
+                    promise.Reject(ErrorUnableToSnapshot, "Unsupported result: " + result + ". Try one of: file | base64 | data-uri");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.ToString());
+                promise.Reject(ErrorUnableToSnapshot, "Failed to capture view snapshot");
+            }
+        }
+
+        private BitmapEncoder CaptureView(FrameworkElement view)
+        {
+            int w = (int)view.ActualWidth;
+            int h = (int)view.ActualHeight;
+
+            if (w <= 0 || h <= 0)
             {
-                image = new PngBitmapEncoder();
+                throw new InvalidOperationException("Impossible to snapshot the view: view is invalid");
             }
-            else if (extension == "jpg" || extension == "jpeg")
+
+            RenderTargetBitmap targetBitmap = new RenderTargetBitmap(w, h, 96, 96, PixelFormats.Default);
+            targetBitmap.Render(view);
+
+            BitmapSource bitmap;
+            if (width != null && height != null && (width != w || height != h))
             {
-                image = new JpegBitmapEncoder();
+                double scaleX = (double)width / targetBitmap.PixelWidth;
+                double scaleY = (double)height / targetBitmap.PixelHeight;
+                bitmap = new TransformedBitmap(targetBitmap, new ScaleTransform(scaleX, scaleY));
             }
             else
             {
-                promise.Reject(ErrorUnableToSnapshot, "Unsupported image format: " + extension + ". Try one of: png | jpg | jpeg");
-                return;
+                bitmap = targetBitmap;
             }
 
-            // TODO: Allow setting quality
-            image.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
+            if (bitmap == null)
+            {
+                throw new InvalidOperationException("Impossible to snapshot the view");
+            }
 
-            if ("file" == result)
+            if (extension == "png")
             {
-                // TODO: Allow specifying path
-                string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "testing." + extension);
-                using (Stream fileStream = File.Create(path))
-                {
-                    image.Save(fileStream);
-                }
+                PngBitmapEncoder image = new PngBitmapEncoder();
+                image.Frames.Add(BitmapFrame.Create(bitmap));
+                return image;
             }
-            else if ("base64" == result)
+            else
             {
-                MemoryStream stream = new MemoryStream();
-                image.Save(stream);
-                byte[] imageBytes = stream.ToArray();
-                string data = Convert.ToBase64String(imageBytes);
-                promise.Resolve(data);
-
+                JpegBitmapEncoder image = new JpegBitmapEncoder();
+                image.QualityLevel = (int)(100.0 * quality);
+                image.Frames.Add(BitmapFrame.Create(bitmap));
+                return image;
             }
-            else if ("data-uri" == result)
+        }
+
+        private string GetFilePath()
+        {
+            if (string.IsNullOrEmpty(path)) 
             {
-                MemoryStream stream = new MemoryStream();
-                image.Save(stream);
-                byte[] imageBytes = stream.ToArray();
-                string data = Convert.ToBase64String(imageBytes);
-                data = "data:image/" + extension + ";base64," + data;
-                promise.Resolve(data);
+                string tmpFilePath = Path.GetTempPath();
+                string fileName = Guid.NewGuid().ToString();
+                fileName = Path.ChangeExtension(fileName, extension);
+                return Path.Combine(tmpFilePath, fileName);
             }
             else
             {
-                promise.Reject(ErrorUnableToSnapshot, "Unsupported result: " + result + ". Try one of: file | base64 | data-uri");
+                return path;
             }
         }
     }