implement the API Demo-App complete. Implement the Clipboard-, Screen- and WebContents-API. Fix some bugs. Edit the Readme.

ElectronNET.API/Clipboard.cs

@@ -0,0 +1,240 @@
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Perform copy and paste operations on the system clipboard.
+    /// </summary>
+    public sealed class Clipboard
+    {
+        private static Clipboard _clipboard;
+
+        internal Clipboard() { }
+
+        internal static Clipboard Instance
+        {
+            get
+            {
+                if (_clipboard == null)
+                {
+                    _clipboard = new Clipboard();
+                }
+
+                return _clipboard;
+            }
+        }
+
+        /// <summary>
+        /// Read the content in the clipboard as plain text.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns>The content in the clipboard as plain text.</returns>
+        public Task<string> ReadTextAsync(string type = "")
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+
+            BridgeConnector.Socket.On("clipboard-readText-Completed", (text) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-readText-Completed");
+
+                taskCompletionSource.SetResult(text.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-readText", type);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes the text into the clipboard as plain text.
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="type"></param>
+        public void WriteText(string text, string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-writeText", text, type);
+        }
+
+        /// <summary>
+        /// The content in the clipboard as markup.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public Task<string> ReadHTMLAsync(string type = "")
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+
+            BridgeConnector.Socket.On("clipboard-readHTML-Completed", (text) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-readHTML-Completed");
+
+                taskCompletionSource.SetResult(text.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-readHTML", type);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes markup to the clipboard.
+        /// </summary>
+        /// <param name="markup"></param>
+        /// <param name="type"></param>
+        public void WriteHTML(string markup, string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-writeHTML", markup, type);
+        }
+
+        /// <summary>
+        /// The content in the clipboard as RTF.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public Task<string> ReadRTFAsync(string type = "")
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+
+            BridgeConnector.Socket.On("clipboard-readRTF-Completed", (text) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-readRTF-Completed");
+
+                taskCompletionSource.SetResult(text.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-readRTF", type);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes the text into the clipboard in RTF.
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="type"></param>
+        public void WriteRTF(string text, string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-writeHTML", text, type);
+        }
+
+        /// <summary>
+        /// Returns an Object containing title and url keys representing 
+        /// the bookmark in the clipboard. The title and url values will 
+        /// be empty strings when the bookmark is unavailable.
+        /// </summary>
+        /// <returns></returns>
+        public Task<ReadBookmark> ReadBookmarkAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<ReadBookmark>();
+
+            BridgeConnector.Socket.On("clipboard-readBookmark-Completed", (bookmark) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-readBookmark-Completed");
+
+                taskCompletionSource.SetResult(((JObject)bookmark).ToObject<ReadBookmark>());
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-readBookmark");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes the title and url into the clipboard as a bookmark.
+        /// 
+        /// Note: Most apps on Windows don’t support pasting bookmarks
+        /// into them so you can use clipboard.write to write both a 
+        /// bookmark and fallback text to the clipboard.
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="url"></param>
+        /// <param name="type"></param>
+        public void WriteBookmark(string title, string url, string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-writeBookmark", title, url, type);
+        }
+
+        /// <summary>
+        /// macOS: The text on the find pasteboard. This method uses synchronous IPC
+        /// when called from the renderer process. The cached value is reread from the
+        /// find pasteboard whenever the application is activated.
+        /// </summary>
+        /// <returns></returns>
+        public Task<string> ReadFindTextAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<string>();
+
+            BridgeConnector.Socket.On("clipboard-readFindText-Completed", (text) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-readFindText-Completed");
+
+                taskCompletionSource.SetResult(text.ToString());
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-readFindText");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// macOS: Writes the text into the find pasteboard as plain text. This method uses 
+        /// synchronous IPC when called from the renderer process.
+        /// </summary>
+        /// <param name="text"></param>
+        public void WriteFindText(string text)
+        {
+            BridgeConnector.Socket.Emit("clipboard-writeFindText", text);
+        }
+
+        /// <summary>
+        /// Clears the clipboard content.
+        /// </summary>
+        /// <param name="type"></param>
+        public void Clear(string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-clear", type);
+        }
+
+        /// <summary>
+        /// An array of supported formats for the clipboard type.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public Task<string[]> AvailableFormatsAsync(string type = "")
+        {
+            var taskCompletionSource = new TaskCompletionSource<string[]>();
+
+            BridgeConnector.Socket.On("clipboard-availableFormats-Completed", (formats) =>
+            {
+                BridgeConnector.Socket.Off("clipboard-availableFormats-Completed");
+
+                taskCompletionSource.SetResult(((JArray)formats).ToObject<string[]>());
+            });
+
+            BridgeConnector.Socket.Emit("clipboard-availableFormats", type);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Writes data to the clipboard.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="type"></param>
+        public void Write(Data data, string type = "")
+        {
+            BridgeConnector.Socket.Emit("clipboard-write", JObject.FromObject(data, _jsonSerializer), type);
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore,
+            DefaultValueHandling = DefaultValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/Electron.cs

@@ -46,5 +46,15 @@
         /// Manage files and URLs using their default applications.
         /// </summary>
         public static Shell Shell { get { return Shell.Instance; } }
+
+        /// <summary>
+        /// Retrieve information about screen size, displays, cursor position, etc.
+        /// </summary>
+        public static Screen Screen { get { return Screen.Instance; } }
+
+        /// <summary>
+        /// Perform copy and paste operations on the system clipboard.
+        /// </summary>
+        public static Clipboard Clipboard { get { return Clipboard.Instance; } }
     }
 }

ElectronNET.API/Entities/Data.cs

@@ -0,0 +1,14 @@
+namespace ElectronNET.API.Entities
+{
+    public class Data
+    {
+        public string Text { get; set; }
+        public string Html { get; set; }
+        public string Rtf { get; set; }
+
+        /// <summary>
+        /// The title of the url at text.
+        /// </summary>
+        public string Bookmark { get; set; }
+    }
+}

ElectronNET.API/Entities/Display.cs

@@ -0,0 +1,50 @@
+using Newtonsoft.Json;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class Display
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public Rectangle Bounds { get; set; }
+
+        /// <summary>
+        /// Unique identifier associated with the display.
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Can be 0, 90, 180, 270, represents screen rotation in clock-wise degrees.
+        /// </summary>
+        public int Rotation { get; set; }
+
+        /// <summary>
+        /// Output device's pixel scale factor.
+        /// </summary>
+        public int ScaleFactor { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public Size Size { get; set; }
+
+        /// <summary>
+        /// Can be available, unavailable, unknown.
+        /// </summary>
+        public string TouchSupport { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public Rectangle WorkArea { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public Size WorkAreaSize { get; set; }
+    }
+}

ElectronNET.API/Entities/Point.cs

@@ -0,0 +1,8 @@
+namespace ElectronNET.API.Entities
+{
+    public class Point
+    {
+        public int X { get; set; }
+        public int Y { get; set; }
+    }
+}

ElectronNET.API/Entities/PrintToPDFOptions.cs

@@ -0,0 +1,32 @@
+namespace ElectronNET.API.Entities
+{
+    public class PrintToPDFOptions
+    {
+        /// <summary>
+        /// Specifies the type of margins to use. Uses 0 for default margin, 1 for no
+        /// margin, and 2 for minimum margin.
+        /// </summary>
+        public int MarginsType { get; set; }
+
+        /// <summary>
+        /// Specify page size of the generated PDF. Can be A3, A4, A5, Legal, Letter,
+        /// Tabloid or an Object containing height and width in microns.
+        /// </summary>
+        public string PageSize { get; set; }
+
+        /// <summary>
+        /// Whether to print CSS backgrounds.
+        /// </summary>
+        public bool PrintBackground { get; set; }
+
+        /// <summary>
+        /// Whether to print selection only.
+        /// </summary>
+        public bool PrintSelectionOnly { get; set; }
+
+        /// <summary>
+        /// true for landscape, false for portrait.
+        /// </summary>
+        public bool Landscape { get; set; }
+    }
+}

ElectronNET.API/Entities/ReadBookmark.cs

@@ -0,0 +1,8 @@
+namespace ElectronNET.API.Entities
+{
+    public class ReadBookmark
+    {
+        public string Title { get; set; }
+        public string Url { get; set; }
+    }
+}

ElectronNET.API/Entities/Size.cs

@@ -1,9 +1,18 @@
 namespace ElectronNET.API.Entities
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public class Size
     {
+        /// <summary>
+        /// 
+        /// </summary>
         public int Width { get; set; }
 
+        /// <summary>
+        /// 
+        /// </summary>
         public int Height { get; set; }
     }
 }

ElectronNET.API/Extensions/MenuItemExtensions.cs

@@ -17,7 +17,7 @@ namespace ElectronNET.API.Extensions
                     AddMenuItemsId(menuItem.Submenu);
                 }
 
-                if (string.IsNullOrEmpty(menuItem.Id))
+                if (string.IsNullOrEmpty(menuItem.Id) && menuItem.Click != null)
                 {
                     menuItem.Id = Guid.NewGuid().ToString();
                 }

ElectronNET.API/IpcMain.cs

@@ -2,6 +2,9 @@
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ElectronNET.API
 {
@@ -36,7 +39,35 @@ namespace ElectronNET.API
         public void On(string channel, Action<object> listener)
         {
             BridgeConnector.Socket.Emit("registerIpcMainChannel", channel);
-            BridgeConnector.Socket.On(channel, listener);
+            BridgeConnector.Socket.On(channel, (args) => 
+            {
+                List<object> objectArray = FormatArguments(args);
+
+                if(objectArray.Count == 1)
+                {
+                    listener(objectArray.First());
+                }
+                else
+                {
+                    listener(objectArray);
+                }
+            });
+        }
+
+        private List<object> FormatArguments(object args)
+        {
+            List<object> objectArray = ((JArray)args).ToObject<object[]>().ToList();
+
+            for (int index = 0; index < objectArray.Count; index++)
+            {
+                var item = objectArray[index];
+                if (item == null)
+                {
+                    objectArray.Remove(item);
+                }
+            }
+
+            return objectArray;
         }
 
         /// <summary>
@@ -52,8 +83,18 @@ namespace ElectronNET.API
         {
             BridgeConnector.Socket.Emit("registerSyncIpcMainChannel", channel);
             BridgeConnector.Socket.On(channel, (args) => {
-                var result = listener(args);
+                List<object> objectArray = FormatArguments(args);
+                object parameter;
+                if (objectArray.Count == 1)
+                {
+                    parameter = objectArray.First();
+                }
+                else
+                {
+                    parameter = objectArray;
+                }
 
+                var result = listener(parameter);
                 BridgeConnector.Socket.Emit(channel + "Sync", result);
             });
         }
@@ -67,7 +108,19 @@ namespace ElectronNET.API
         public void Once(string channel, Action<object> listener)
         {
             BridgeConnector.Socket.Emit("registerOnceIpcMainChannel", channel);
-            BridgeConnector.Socket.On(channel, listener);
+            BridgeConnector.Socket.On(channel, (args) =>
+            {
+                List<object> objectArray = FormatArguments(args);
+
+                if (objectArray.Count == 1)
+                {
+                    listener(objectArray.First());
+                }
+                else
+                {
+                    listener(objectArray);
+                }
+            });
         }
 
         /// <summary>
@@ -90,7 +143,32 @@ namespace ElectronNET.API
         /// <param name="data">Arguments data.</param>
         public void Send(BrowserWindow browserWindow, string channel, params object[] data)
         {
-            BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, data);
+            List<JObject> jobjects = new List<JObject>();
+            List<JArray> jarrays = new List<JArray>();
+            List<Object> objects = new List<Object>();
+
+            foreach (var parameterObject in data)
+            {
+                if(parameterObject.GetType().IsArray || parameterObject.GetType().IsGenericType && parameterObject is IEnumerable)
+                {
+                    jarrays.Add(JArray.FromObject(parameterObject, _jsonSerializer));
+                } else if(parameterObject.GetType().IsClass && !parameterObject.GetType().IsPrimitive && !(parameterObject is string))
+                {
+                    jobjects.Add(JObject.FromObject(parameterObject, _jsonSerializer));
+                } else if(parameterObject.GetType().IsPrimitive || (parameterObject is string))
+                {
+                    objects.Add(parameterObject);
+                }
+            }
+
+            if(jobjects.Count > 0 || jarrays.Count > 0)
+            {
+                BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, jarrays.ToArray(), jobjects.ToArray(), objects.ToArray());
+            }
+            else
+            {
+                BridgeConnector.Socket.Emit("sendToIpcRenderer", JObject.FromObject(browserWindow, _jsonSerializer), channel, data);
+            }
         }
 
         private JsonSerializer _jsonSerializer = new JsonSerializer()

ElectronNET.API/Screen.cs

@@ -0,0 +1,243 @@
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// Retrieve information about screen size, displays, cursor position, etc.
+    /// </summary>
+    public sealed class Screen
+    {
+        /// <summary>
+        /// Emitted when an new Display has been added.
+        /// </summary>
+        public event Action<Display> OnDisplayAdded
+        {
+            add
+            {
+                if (_onDisplayAdded == null)
+                {
+                    BridgeConnector.Socket.On("screen-display-added-event" + GetHashCode(), (display) =>
+                    {
+                        _onDisplayAdded(((JObject)display).ToObject<Display>());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-screen-display-added", GetHashCode());
+                }
+                _onDisplayAdded += value;
+            }
+            remove
+            {
+                _onDisplayAdded -= value;
+            }
+        }
+
+        private event Action<Display> _onDisplayAdded;
+
+        /// <summary>
+        /// Emitted when oldDisplay has been removed.
+        /// </summary>
+        public event Action<Display> OnDisplayRemoved
+        {
+            add
+            {
+                if (_onDisplayRemoved == null)
+                {
+                    BridgeConnector.Socket.On("screen-display-removed-event" + GetHashCode(), (display) =>
+                    {
+                        _onDisplayRemoved(((JObject)display).ToObject<Display>());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-screen-display-removed", GetHashCode());
+                }
+                _onDisplayRemoved += value;
+            }
+            remove
+            {
+                _onDisplayRemoved -= value;
+            }
+        }
+
+        private event Action<Display> _onDisplayRemoved;
+
+        /// <summary>
+        /// Emitted when one or more metrics change in a display. 
+        /// The changedMetrics is an array of strings that describe the changes. 
+        /// Possible changes are bounds, workArea, scaleFactor and rotation.
+        /// </summary>
+        public event Action<Display, string[]> OnDisplayMetricsChanged
+        {
+            add
+            {
+                if (_onDisplayMetricsChanged == null)
+                {
+                    BridgeConnector.Socket.On("screen-display-metrics-changed-event" + GetHashCode(), (args) =>
+                    {
+                        var display = ((JArray)args).First.ToObject<Display>();
+                        var metrics = ((JArray)args).Last.ToObject<string[]>();
+
+                        _onDisplayMetricsChanged(display, metrics);
+                    });
+
+                    BridgeConnector.Socket.Emit("register-screen-display-metrics-changed", GetHashCode());
+                }
+                _onDisplayMetricsChanged += value;
+            }
+            remove
+            {
+                _onDisplayMetricsChanged -= value;
+            }
+        }
+
+        private event Action<Display, string[]> _onDisplayMetricsChanged;
+
+        private static Screen _screen;
+
+        internal Screen() { }
+
+        internal static Screen Instance
+        {
+            get
+            {
+                if (_screen == null)
+                {
+                    _screen = new Screen();
+                }
+
+                return _screen;
+            }
+        }
+
+        /// <summary>
+        /// The current absolute position of the mouse pointer.
+        /// </summary>
+        /// <returns></returns>
+        public Task<Point> GetCursorScreenPointAsync() 
+        {
+            var taskCompletionSource = new TaskCompletionSource<Point>();
+
+            BridgeConnector.Socket.On("screen-getCursorScreenPointCompleted", (point) =>
+            {
+                BridgeConnector.Socket.Off("screen-getCursorScreenPointCompleted");
+
+                taskCompletionSource.SetResult(((JObject)point).ToObject<Point>());
+            });
+
+            BridgeConnector.Socket.Emit("screen-getCursorScreenPoint");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// macOS: The height of the menu bar in pixels.
+        /// </summary>
+        /// <returns>The height of the menu bar in pixels.</returns>
+        public Task<int> GetMenuBarHeightAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<int>();
+
+            BridgeConnector.Socket.On("screen-getMenuBarHeightCompleted", (height) =>
+            {
+                BridgeConnector.Socket.Off("screen-getMenuBarHeightCompleted");
+
+                taskCompletionSource.SetResult(int.Parse(height.ToString()));
+            });
+
+            BridgeConnector.Socket.Emit("screen-getMenuBarHeight");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// The primary display.
+        /// </summary>
+        /// <returns></returns>
+        public Task<Display> GetPrimaryDisplayAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<Display>();
+
+            BridgeConnector.Socket.On("screen-getPrimaryDisplayCompleted", (display) =>
+            {
+                BridgeConnector.Socket.Off("screen-getPrimaryDisplayCompleted");
+
+                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
+            });
+
+            BridgeConnector.Socket.Emit("screen-getPrimaryDisplay");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// An array of displays that are currently available.
+        /// </summary>
+        /// <returns>An array of displays that are currently available.</returns>
+        public Task<Display[]> GetAllDisplaysAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<Display[]>();
+
+            BridgeConnector.Socket.On("screen-getAllDisplaysCompleted", (displays) =>
+            {
+                BridgeConnector.Socket.Off("screen-getAllDisplaysCompleted");
+
+                taskCompletionSource.SetResult(((JArray)displays).ToObject<Display[]>());
+            });
+
+            BridgeConnector.Socket.Emit("screen-getAllDisplays");
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// The display nearest the specified point.
+        /// </summary>
+        /// <returns>The display nearest the specified point.</returns>
+        public Task<Display> GetDisplayNearestPointAsync(Point point)
+        {
+            var taskCompletionSource = new TaskCompletionSource<Display>();
+
+            BridgeConnector.Socket.On("screen-getDisplayNearestPointCompleted", (display) =>
+            {
+                BridgeConnector.Socket.Off("screen-getDisplayNearestPointCompleted");
+
+                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
+            });
+
+            BridgeConnector.Socket.Emit("screen-getDisplayNearestPoint", JObject.FromObject(point, _jsonSerializer));
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// The display that most closely intersects the provided bounds.
+        /// </summary>
+        /// <param name="rectangle"></param>
+        /// <returns>The display that most closely intersects the provided bounds.</returns>
+        public Task<Display> GetDisplayMatchingAsync(Rectangle rectangle)
+        {
+            var taskCompletionSource = new TaskCompletionSource<Display>();
+
+            BridgeConnector.Socket.On("screen-getDisplayMatching", (display) =>
+            {
+                BridgeConnector.Socket.Off("screen-getDisplayMatching");
+
+                taskCompletionSource.SetResult(((JObject)display).ToObject<Display>());
+            });
+
+            BridgeConnector.Socket.Emit("screen-getDisplayMatching", JObject.FromObject(rectangle, _jsonSerializer));
+
+            return taskCompletionSource.Task;
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore,
+            DefaultValueHandling = DefaultValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/WebContents.cs

@@ -4,6 +4,7 @@ using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 using System;
 using System.Diagnostics;
+using System.Threading.Tasks;
 
 namespace ElectronNET.API
 {
@@ -89,6 +90,37 @@ namespace ElectronNET.API
             BridgeConnector.Socket.Emit("webContentsOpenDevTools", Id, JObject.FromObject(openDevToolsOptions, _jsonSerializer));
         }
 
+        /// <summary>
+        /// Prints window's web page as PDF with Chromium's preview printing custom
+        /// settings.The landscape will be ignored if @page CSS at-rule is used in the web page. 
+        /// By default, an empty options will be regarded as: Use page-break-before: always; 
+        /// CSS style to force to print to a new page.
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="options"></param>
+        /// <returns>success</returns>
+        public Task<bool> PrintToPDFAsync(string path, PrintToPDFOptions options = null)
+        {
+            var taskCompletionSource = new TaskCompletionSource<bool>();
+
+            BridgeConnector.Socket.On("webContents-printToPDF-completed", (success) =>
+            {
+                BridgeConnector.Socket.Off("webContents-printToPDF-completed");
+                taskCompletionSource.SetResult((bool)success);
+            });
+
+            if(options == null)
+            {
+                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, "", path);
+            }
+            else
+            {
+                BridgeConnector.Socket.Emit("webContents-printToPDF", Id, JObject.FromObject(options, _jsonSerializer), path);
+            }
+
+            return taskCompletionSource.Task;
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),