feat: add screenshot options

Author: codebytere

README.md

@@ -139,9 +139,18 @@ console.log(display)
 */
 ```
 
-### `displays.screenshot(id)`
+### `displays.screenshot(id, options)`
 
 * `id` Number - The device ID for the display.
+* `options` Object
+  * `type` String - The representation of the image. Can be 'jpeg', 'png', or 'tiff'. Defaults to 'jpeg'.
+  * `bounds` Object
+    * `x` Number - The x coordinate of the origin of the rectangle.
+    * `y` Number - The y coordinate of the origin of the rectangle.
+    * `width` Number - The width of the rectangle.
+    * `height` Number - The height of the rectangle.
+
+Returns `Buffer` - a Buffer representation of the desired display screenshot.
 
 Takes a screenshot of the display with the specified id.
 
@@ -154,7 +163,14 @@ const path = require('path')
 const { id } = displays.getPrimaryDisplay()
 
 const ssPath = path.resolve(__dirname, 'screenshot.jpg')
-const screenshotData = display.screenshot(id)
+const screenshotData = displays.screenshot(id, {
+  bounds: {
+    x: 100,
+    y: 500,
+    width: 200,
+    height: 200
+  }
+})
 
 // Write out JPEG image as screenshot.jpg in the current directory.
 fs.writeFileSync(ssPath, screenshotData)

displays.mm

@@ -30,6 +30,16 @@
   return obj;
 }
 
+// Converts a bounds object to an NSRect.
+NSRect BoundsObjectToNSRect(Napi::Object bounds) {
+  int64_t x = bounds.Get("x").As<Napi::Number>().Int64Value();
+  int64_t y = bounds.Get("y").As<Napi::Number>().Int64Value();
+  int64_t width = bounds.Get("width").As<Napi::Number>().Int64Value();
+  int64_t height = bounds.Get("height").As<Napi::Number>().Int64Value();
+
+  return NSMakeRect((CGFloat)x, (CGFloat)y, (CGFloat)width, (CGFloat)height);
+}
+
 // Converts an NSColorSpace to an object containing information about the
 // colorSpace.
 Napi::Object NSColorSpaceToObject(Napi::Env env, NSColorSpace *color_space) {
@@ -113,21 +123,41 @@ bool GetIsMonochrome() {
   return displays;
 }
 
+// Takes a screenshot of the specified display.
 Napi::Buffer<uint8_t> Screenshot(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
+
   uint32_t display_id = info[0].As<Napi::Number>().Uint32Value();
+  Napi::Object options = info[1].As<Napi::Object>();
+
+  NSBitmapImageFileType image_type = NSBitmapImageFileTypeJPEG;
+  if (options.Has("type")) {
+    std::string type = options.Get("type").As<Napi::String>().Utf8Value();
+    if (type == "png") {
+      image_type = NSBitmapImageFileTypePNG;
+    } else if (type == "tiff") {
+      image_type = NSBitmapImageFileTypeTIFF;
+    }
+  }
+
+  CGImageRef img_ref;
+  if (options.Has("bounds")) {
+    Napi::Object bounds = options.Get("bounds").As<Napi::Object>();
+    CGRect rect = NSRectToCGRect(BoundsObjectToNSRect(bounds));
+    img_ref = CGDisplayCreateImageForRect(display_id, rect);
+  } else {
+    img_ref = CGDisplayCreateImage(display_id);
+  }
 
-  CGImageRef img_ref = CGDisplayCreateImage(display_id);
   if (!img_ref)
     return Napi::Buffer<uint8_t>::New(env, 0);
 
   std::vector<uint8_t> data;
 
   NSBitmapImageRep *bitmap_rep =
       [[NSBitmapImageRep alloc] initWithCGImage:img_ref];
-  NSData *image_data =
-      [bitmap_rep representationUsingType:NSBitmapImageFileTypeJPEG
-                               properties:@{}];
+  NSData *image_data = [bitmap_rep representationUsingType:image_type
+                                                properties:@{}];
   const uint8 *bytes = (uint8 *)[image_data bytes];
   data.assign(bytes, bytes + [image_data length]);
 

index.js

@@ -8,12 +8,35 @@ function getDisplayFromID(id) {
   return displays.getDisplayFromID.call(this, id)
 }
 
-function screenshot(id) {
+function screenshot(id, options = {}) {
   if (typeof id !== 'number') {
     throw new TypeError(`'id' must be a number`)
   }
 
-  return displays.screenshot.call(this, id)
+  const validTypes = ['jpeg', 'tiff', 'png']
+  if (options.type) {
+    if (typeof options.type !== 'string') {
+      throw new Error(`'type' must be a string`)
+    } else if (!validTypes.includes(options.type)) {
+      throw new Error(`'type' must be one of ${validTypes.join(', ')}`)
+    }
+  }
+
+  if (options.bounds) {
+    if (typeof options.bounds !== 'object') {
+      throw new Error(`'bounds' must be a number`)
+    } else if (!options.bounds.x || typeof options.bounds.x !== 'number') {
+      throw new Error(`'bounds.x' must be a number`)
+    } else if (!options.bounds.y || typeof options.bounds.y !== 'number') {
+      throw new Error(`'bounds.y' must be a number`)
+    } else if (!options.bounds.width || typeof options.bounds.width !== 'number') {
+      throw new Error(`'bounds.width' must be a number`)
+    } else if (!options.bounds.height || typeof options.bounds.height !== 'number') {
+      throw new Error(`'bounds.height' must be a number`)
+    }
+  }
+
+  return displays.screenshot.call(this, id, options)
 }
 
 module.exports = {

test/module.spec.js

@@ -126,6 +126,37 @@ describe('node-system-displays', () => {
       }).to.throw(`'id' must be a number`)
     })
 
+    it('throws an error if options.type is not valid', () => {
+      expect(() => {
+        const { id } = getPrimaryDisplay()
+        screenshot(id, { type: 'bad-type' })
+      }).to.throw(`'type' must be one of jpeg, tiff, png`)
+    })
+
+    it('throws an error if options.bounds are not valid', () => {
+      const { id } = getPrimaryDisplay()
+
+      expect(() => {
+        screenshot(id, { bounds: 'oh no' })
+      }).to.throw(`'bounds' must be a number`)
+
+      expect(() => {
+        screenshot(id, { bounds: { x: 'bad', y: 1, width: 10, height: 10 } })
+      }).to.throw(`'bounds.x' must be a number`)
+
+      expect(() => {
+        screenshot(id, { bounds: { x: 1, y: 'bad', width: 10, height: 10 } })
+      }).to.throw(`'bounds.y' must be a number`)
+
+      expect(() => {
+        screenshot(id, { bounds: { x: 1, y: 1, width: 'bad', height: 10 } })
+      }).to.throw(`'bounds.width' must be a number`)
+
+      expect(() => {
+        screenshot(id, { bounds: { x: 1, y: 1, width: 10, height: 'bad' } })
+      }).to.throw(`'bounds.height' must be a number`)
+    })
+
     it('can write out a screenshot to the current directory', () => {
       const { id } = getPrimaryDisplay()