Implemented BrowserView API #371

Author: GregorBiswanger

ElectronNET.API/BrowserView.cs

@@ -0,0 +1,138 @@
+using ElectronNET.API.Entities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API
+{
+    /// <summary>
+    /// A BrowserView can be used to embed additional web content into a BrowserWindow. 
+    /// It is like a child window, except that it is positioned relative to its owning window. 
+    /// It is meant to be an alternative to the webview tag.
+    /// </summary>
+    public class BrowserView
+    {
+        /// <summary>
+        /// Gets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        public int Id { get; internal set; }
+
+        /// <summary>
+        /// Render and control web pages.
+        /// </summary>
+        public WebContents WebContents { get; internal set; }
+
+        /// <summary>
+        /// Whether the view is destroyed.
+        /// </summary>
+        public Task<bool> IsDestroyedAsync
+        {
+            get
+            {
+                return Task.Run<bool>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<bool>();
+
+                    BridgeConnector.Socket.On("browserView-isDestroyed-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("browserView-isDestroyed-reply");
+                        taskCompletionSource.SetResult((bool)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("browserView-isDestroyed", Id);
+
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
+        /// <summary>
+        /// Resizes and moves the view to the supplied bounds relative to the window.
+        /// 
+        /// (experimental)
+        /// </summary>
+        public Rectangle Bounds
+        {
+            get
+            {
+                return Task.Run<Rectangle>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<Rectangle>();
+
+                    BridgeConnector.Socket.On("browserView-getBounds-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("browserView-getBounds-reply");
+                        taskCompletionSource.SetResult((Rectangle)result);
+                    });
+
+                    BridgeConnector.Socket.Emit("browserView-getBounds", Id);
+
+                    return taskCompletionSource.Task;
+                }).Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("browserView-setBounds", Id, JObject.FromObject(value, _jsonSerializer));
+            }
+        }
+
+        internal Action<BrowserView> Destroyed;
+
+        /// <summary>
+        /// BrowserView
+        /// </summary>
+        internal BrowserView(int id) 
+        {
+            Id = id;
+
+            // Workaround: increase the Id so as not to conflict with BrowserWindow id
+            // the backend detect about the value an BrowserView
+            WebContents = new WebContents(id + 1000);
+        }
+
+        /// <summary>
+        /// Force closing the view, the `unload` and `beforeunload` events won't be emitted
+        /// for the web page.After you're done with a view, call this function in order to
+        /// free memory and other resources as soon as possible.
+        /// </summary>
+        public void Destroy()
+        {
+            BridgeConnector.Socket.Emit("browserView-destroy", Id);
+
+            Destroyed?.Invoke(this);
+        }
+
+        /// <summary>
+        /// (experimental)
+        /// </summary>
+        /// <param name="options"></param>
+        public void SetAutoResize(AutoResizeOptions options)
+        {
+            BridgeConnector.Socket.Emit("browserView-setAutoResize", Id, JObject.FromObject(options, _jsonSerializer));
+        }
+
+        /// <summary>
+        /// Color in #aarrggbb or #argb form. The alpha channel is optional.
+        /// 
+        /// (experimental)
+        /// </summary>
+        /// <param name="color">Color in #aarrggbb or #argb form. The alpha channel is optional.</param>
+        public void SetBackgroundColor(string color)
+        {
+            BridgeConnector.Socket.Emit("browserView-setBackgroundColor", Id, color);
+        }
+
+        private JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            NullValueHandling = NullValueHandling.Ignore
+        };
+    }
+}

ElectronNET.API/BrowserWindow.cs

@@ -2305,6 +2305,17 @@ public void SetVibrancy(Vibrancy type)
         /// </summary>
         public WebContents WebContents { get; internal set; }
 
+        /// <summary>
+        /// A BrowserView can be used to embed additional web content into a BrowserWindow. 
+        /// It is like a child window, except that it is positioned relative to its owning window. 
+        /// It is meant to be an alternative to the webview tag.
+        /// </summary>
+        /// <param name="browserView"></param>
+        public void SetBrowserView(BrowserView browserView)
+        {
+            BridgeConnector.Socket.Emit("browserWindow-setBrowserView", Id, browserView.Id);
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/Entities/AutoResizeOptions.cs

@@ -0,0 +1,38 @@
+using System.ComponentModel;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class AutoResizeOptions
+    {
+        /// <summary>
+        /// If `true`, the view's width will grow and shrink together with the window.
+        /// `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Width { get; set; } = false;
+
+        /// <summary>
+        /// If `true`, the view's height will grow and shrink together with the window.
+        /// `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Height { get; set; } = false;
+
+        /// <summary>
+        /// If `true`, the view's x position and width will grow and shrink proportionally
+        /// with the window. `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Horizontal { get; set; } = false;
+
+        /// <summary>
+        /// If `true`, the view's y position and height will grow and shrink proportionally
+        /// with the window. `false` by default.
+        /// </summary>
+        [DefaultValue(false)]
+        public bool Vertical { get; set; } = false;
+    }
+}

ElectronNET.API/Entities/BrowserViewConstructorOptions.cs

@@ -0,0 +1,13 @@
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class BrowserViewConstructorOptions
+    {
+        /// <summary>
+        /// See BrowserWindow.
+        /// </summary>
+        public WebPreferences WebPreferences { get; set; }
+    }
+}

ElectronNET.API/WebContents.cs

@@ -205,7 +205,59 @@ public Task<string> GetUrl()
 
             return taskCompletionSource.Task;
         }
-        
+
+        /// <summary>
+        /// The async method will resolve when the page has finished loading, 
+        /// and rejects if the page fails to load.
+        /// 
+        /// A noop rejection handler is already attached, which avoids unhandled rejection
+        /// errors.
+        ///
+        /// Loads the `url` in the window. The `url` must contain the protocol prefix, e.g.
+        /// the `http://` or `file://`. If the load should bypass http cache then use the
+        /// `pragma` header to achieve it.
+        /// </summary>
+        /// <param name="url"></param>
+        public Task LoadURLAsync(string url)
+        {
+            return LoadURLAsync(url, new LoadURLOptions());
+        }
+
+        /// <summary>
+        /// The async method will resolve when the page has finished loading, 
+        /// and rejects if the page fails to load.
+        /// 
+        /// A noop rejection handler is already attached, which avoids unhandled rejection
+        /// errors.
+        ///
+        /// Loads the `url` in the window. The `url` must contain the protocol prefix, e.g.
+        /// the `http://` or `file://`. If the load should bypass http cache then use the
+        /// `pragma` header to achieve it.
+        /// </summary>
+        /// <param name="url"></param>
+        /// <param name="options"></param>
+        public Task LoadURLAsync(string url, LoadURLOptions options)
+        {
+            var taskCompletionSource = new TaskCompletionSource<object>();
+
+            BridgeConnector.Socket.On("webContents-loadURL-complete" + Id, () =>
+            {
+                BridgeConnector.Socket.Off("webContents-loadURL-complete" + Id);
+                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
+                taskCompletionSource.SetResult(null);
+            });
+
+            BridgeConnector.Socket.On("webContents-loadURL-error" + Id, (error) =>
+            {
+                BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
+                taskCompletionSource.SetException(new InvalidOperationException(error.ToString()));
+            });
+
+            BridgeConnector.Socket.Emit("webContents-loadURL", Id, url, JObject.FromObject(options, _jsonSerializer));
+
+            return taskCompletionSource.Task;
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/WindowManager.cs

@@ -65,6 +65,15 @@ public bool IsQuitOnWindowAllClosed
         public IReadOnlyCollection<BrowserWindow> BrowserWindows { get { return _browserWindows.AsReadOnly(); } }
         private List<BrowserWindow> _browserWindows = new List<BrowserWindow>();
 
+        /// <summary>
+        /// Gets the browser views.
+        /// </summary>
+        /// <value>
+        /// The browser view.
+        /// </value>
+        public IReadOnlyCollection<BrowserView> BrowserViews { get { return _browserViews.AsReadOnly(); } }
+        private List<BrowserView> _browserViews = new List<BrowserView>();
+
         /// <summary>
         /// Creates the window asynchronous.
         /// </summary>
@@ -155,6 +164,51 @@ private bool isWindows10()
             return RuntimeInformation.OSDescription.Contains("Windows 10");
         }
 
+        /// <summary>
+        /// A BrowserView can be used to embed additional web content into a BrowserWindow. 
+        /// It is like a child window, except that it is positioned relative to its owning window. 
+        /// It is meant to be an alternative to the webview tag.
+        /// </summary>
+        /// <returns></returns>
+        public Task<BrowserView> CreateBrowserViewAsync()
+        {
+            return CreateBrowserViewAsync(new BrowserViewConstructorOptions());
+        }
+
+        /// <summary>
+        /// A BrowserView can be used to embed additional web content into a BrowserWindow. 
+        /// It is like a child window, except that it is positioned relative to its owning window. 
+        /// It is meant to be an alternative to the webview tag.
+        /// </summary>
+        /// <param name="options"></param>
+        /// <returns></returns>
+        public Task<BrowserView> CreateBrowserViewAsync(BrowserViewConstructorOptions options)
+        {
+            var taskCompletionSource = new TaskCompletionSource<BrowserView>();
+
+            BridgeConnector.Socket.On("BrowserViewCreated", (id) =>
+            {
+                BridgeConnector.Socket.Off("BrowserViewCreated");
+
+                string browserViewId = id.ToString();
+                BrowserView browserView = new BrowserView(int.Parse(browserViewId));
+                browserView.Destroyed += (b) => _browserViews.Remove(b);
+
+                _browserViews.Add(browserView);
+
+                taskCompletionSource.SetResult(browserView);
+            });
+
+            var ownjsonSerializer = new JsonSerializer()
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                NullValueHandling = NullValueHandling.Ignore
+            };
+            BridgeConnector.Socket.Emit("createBrowserView", JObject.FromObject(options, ownjsonSerializer));
+
+            return taskCompletionSource.Task;
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.CLI/Commands/Actions/DeployEmbeddedElectronFiles.cs

@@ -29,6 +29,7 @@ public static void Do(string tempPath)
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "screen.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "clipboard.js", "api.");
             EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "autoUpdater.js", "api.");
+            EmbeddedFileHelper.DeployEmbeddedFile(hostApiFolder, "browserView.js", "api.");
 
             string splashscreenFolder = Path.Combine(tempPath, "splashscreen");
             if (Directory.Exists(splashscreenFolder) == false)

ElectronNET.CLI/ElectronNET.CLI.csproj

@@ -65,6 +65,7 @@
     <EmbeddedResource Include="..\ElectronNET.Host\api\webContents.js" Link="ElectronHost\api\webContents.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\clipboard.js" Link="ElectronHost\api\clipboard.js" />
     <EmbeddedResource Include="..\ElectronNET.Host\api\autoUpdater.js" Link="ElectronHost\api\autoUpdater.js" />
+    <EmbeddedResource Include="..\ElectronNET.Host\api\browserView.js" Link="ElectronHost\api\browserView.js" />
   </ItemGroup>
 
   <ItemGroup>